claude-monitor/dist/core/plans.js

Real-time terminal monitoring tool for Claude AI token usage

const PLAN_LIMITS = {
    pro: {
        tokenLimit: 19_000,
        costLimit: 18.0,
        messageLimit: 250,
        displayName: 'Pro',
    },
    max5: {
        tokenLimit: 88_000,
        costLimit: 35.0,
        messageLimit: 1_000,
        displayName: 'Max5',
    },
    max20: {
        tokenLimit: 220_000,
        costLimit: 140.0,
        messageLimit: 2_000,
        displayName: 'Max20',
    },
    custom: {
        tokenLimit: 44_000,
        costLimit: 50.0,
        messageLimit: 250,
        displayName: 'Custom',
    },
};
const DEFAULTS = {
    tokenLimit: PLAN_LIMITS.pro.tokenLimit,
    costLimit: PLAN_LIMITS.custom.costLimit,
    messageLimit: PLAN_LIMITS.pro.messageLimit,
};
export class Plans {
    static DEFAULT_TOKEN_LIMIT = DEFAULTS.tokenLimit;
    static DEFAULT_COST_LIMIT = DEFAULTS.costLimit;
    static DEFAULT_MESSAGE_LIMIT = DEFAULTS.messageLimit;
    static COMMON_TOKEN_LIMITS = [19_000, 88_000, 220_000, 880_000];
    static LIMIT_DETECTION_THRESHOLD = 0.95;
    static buildPlan(planType) {
        const limits = PLAN_LIMITS[planType];
        return {
            name: limits.displayName,
            tokenLimit: limits.tokenLimit,
            messageLimit: limits.messageLimit,
            description: `${limits.displayName} plan with ${this.formatTokenLimit(limits.tokenLimit)} tokens and ${limits.messageLimit} messages per session`,
        };
    }
    static formatTokenLimit(limit) {
        if (limit >= 1_000) {
            return `${limit / 1_000}k`;
        }
        return limit.toString();
    }
    static getAllPlans() {
        return Object.entries(PLAN_LIMITS).reduce((acc, [key]) => {
            const planType = key;
            acc[planType] = this.buildPlan(planType);
            return acc;
        }, {});
    }
    static getPlan(planType) {
        return this.buildPlan(planType);
    }
    static getPlanByName(name) {
        const normalizedName = name.toLowerCase();
        if (normalizedName in PLAN_LIMITS) {
            return this.getPlan(normalizedName);
        }
        return null;
    }
    static async getTokenLimit(plan, blocks) {
        const planConfig = this.getPlanByName(plan);
        if (!planConfig) {
            return this.DEFAULT_TOKEN_LIMIT;
        }
        if (plan === 'custom' && blocks && blocks.length > 0) {
            const { calculateP90Limit } = await import('./p90-calculator.js');
            return calculateP90Limit(blocks);
        }
        return planConfig.tokenLimit;
    }
    static getCostLimit(plan) {
        const planType = plan.toLowerCase();
        if (planType in PLAN_LIMITS) {
            return PLAN_LIMITS[planType].costLimit;
        }
        return this.DEFAULT_COST_LIMIT;
    }
    static getMessageLimit(plan) {
        const planType = plan.toLowerCase();
        if (planType in PLAN_LIMITS) {
            return PLAN_LIMITS[planType].messageLimit;
        }
        return this.DEFAULT_MESSAGE_LIMIT;
    }
    static isValidPlan(plan) {
        return this.getPlanByName(plan) !== null;
    }
}
export const TOKEN_LIMITS = Object.entries(PLAN_LIMITS).reduce((acc, [key, limits]) => {
    if (key !== 'custom') {
        acc[key] = limits.tokenLimit;
    }
    return acc;
}, {});
export const COST_LIMITS = Object.entries(PLAN_LIMITS).reduce((acc, [key, limits]) => {
    if (key !== 'custom') {
        acc[key] = limits.costLimit;
    }
    return acc;
}, {});
export const DEFAULT_TOKEN_LIMIT = Plans.DEFAULT_TOKEN_LIMIT;
export const DEFAULT_COST_LIMIT = Plans.DEFAULT_COST_LIMIT;
export const COMMON_TOKEN_LIMITS = Plans.COMMON_TOKEN_LIMITS;
export const LIMIT_DETECTION_THRESHOLD = Plans.LIMIT_DETECTION_THRESHOLD;
export async function getTokenLimit(plan, blocks) {
    return Plans.getTokenLimit(plan, blocks);
}
export function getCostLimit(plan) {
    return Plans.getCostLimit(plan);
}
//# sourceMappingURL=plans.js.map