@cjhyy/code-shell-core 0.5.0-rc.0

package/dist/cost-tracker.js

@@ -0,0 +1,314 @@
+/**
+ * Cost tracker — tracks token usage and calculates estimated costs.
+ */
+import { NOOP_COLORIZER } from "./colorizer.js";
+import { findOpenRouterModel } from "./data/openrouter-models.js";
+function pricing(input, output) {
+    // Default cache pricing: read = 10% of input, write = 125% of input
+    return { input, output, cacheRead: input * 0.1, cacheWrite: input * 1.25 };
+}
+const MODEL_PRICING = {
+    // Anthropic (per 1M tokens, USD)
+    "claude-opus-4.6": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+    "claude-opus-4-6": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 }, // alias
+    "claude-opus-4.5": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+    "claude-opus-4.1": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+    "claude-opus-4": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+    "claude-sonnet-4.6": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+    "claude-sonnet-4-6": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 }, // alias
+    "claude-sonnet-4.5": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+    "claude-sonnet-4": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+    "claude-3.7-sonnet": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+    "claude-3-7-sonnet": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+    "claude-3.5-haiku": { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 },
+    "claude-haiku-4.5": { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
+    "claude-haiku-4-5": { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 }, // alias
+    // OpenAI
+    "gpt-5.4": pricing(5, 20),
+    "gpt-5.4-mini": pricing(1.5, 6),
+    "gpt-5.4-pro": pricing(10, 40),
+    "gpt-5": pricing(5, 20),
+    "gpt-4o": pricing(2.5, 10),
+    "gpt-4o-mini": pricing(0.15, 0.6),
+    "gpt-4.1": pricing(2, 8),
+    "gpt-4.1-mini": pricing(0.4, 1.6),
+    "o4-mini": pricing(1.1, 4.4),
+    "o3": pricing(10, 40),
+    "o3-mini": pricing(1.1, 4.4),
+    // Google
+    "gemini-2.5-pro": pricing(1.25, 10),
+    "gemini-2.5-pro-preview": pricing(1.25, 10),
+    "gemini-2.5-flash": pricing(0.15, 0.6),
+    "gemini-3.1-pro-preview": pricing(2, 10),
+    "gemini-3-flash-preview": pricing(0.15, 0.6),
+    "gemini-2.0-flash": pricing(0.1, 0.4),
+    // DeepSeek
+    "deepseek-v4-flash": pricing(0.126, 0.252),
+    "deepseek-v4-pro": pricing(0.5, 2),
+    "deepseek-v3.2": pricing(0.14, 0.28),
+    "deepseek-chat": pricing(0.14, 0.28),
+    "deepseek-r1": pricing(0.55, 2.19),
+    "deepseek-reasoner": pricing(0.55, 2.19),
+    // Qwen
+    "qwen3-coder": pricing(0.3, 0.6),
+    "qwen3-235b-a22b": pricing(0.3, 1.2),
+    "qwen3-30b-a3b": pricing(0.1, 0.3),
+    "qwen3-max": pricing(0.5, 2),
+    // Meta
+    "llama-4-maverick": pricing(0.2, 0.8),
+    "llama-4-scout": pricing(0.15, 0.4),
+    // Mistral
+    "devstral-medium": pricing(0.5, 1.5),
+    "mistral-large": pricing(2, 6),
+    "devstral-small": pricing(0.1, 0.3),
+};
+// Default fallback pricing
+const DEFAULT_PRICING = pricing(3, 15);
+/** Build a ModelPricing from an OpenRouter snapshot entry. */
+function openRouterPricing(hit) {
+    const input = hit.inputPricePerMillion;
+    const output = hit.outputPricePerMillion;
+    return {
+        pricing: {
+            input,
+            output,
+            // Snapshot doesn't carry cache pricing; use the same heuristic as pricing() helper
+            cacheRead: input * 0.1,
+            cacheWrite: input * 1.25,
+        },
+        known: true,
+    };
+}
+/**
+ * Resolve pricing for a model. Lookup order:
+ *   1. OpenRouter snapshot (by full ID like "deepseek/deepseek-v4-flash")
+ *   2. OpenRouter snapshot (by short name like "deepseek-v4-flash" → tries common vendors)
+ *   3. MODEL_PRICING by canonical name (strips provider prefix)
+ *   4. MODEL_PRICING by raw name
+ *   5. DEFAULT_PRICING fallback
+ *
+ * Returns { pricing, source } so callers can flag unknown-model warnings
+ * accurately (the snapshot path counts as known even if MODEL_PRICING misses).
+ */
+function lookupPricing(model) {
+    // Try OpenRouter snapshot lookup for models with vendor/ prefix
+    if (model.includes("/")) {
+        const hit = findOpenRouterModel(model);
+        if (hit && (hit.inputPricePerMillion > 0 || hit.outputPricePerMillion > 0)) {
+            return openRouterPricing(hit);
+        }
+    }
+    // Also try OpenRouter for short names (e.g. "deepseek-v4-flash" → "deepseek/deepseek-v4-flash")
+    // by matching on the model part after the slash
+    const orHit = findOpenRouterModel(`deepseek/${model}`) ??
+        findOpenRouterModel(`openai/${model}`) ??
+        findOpenRouterModel(`anthropic/${model}`);
+    if (orHit && (orHit.inputPricePerMillion > 0 || orHit.outputPricePerMillion > 0)) {
+        return openRouterPricing(orHit);
+    }
+    const canonical = getCanonicalName(model);
+    const hit = MODEL_PRICING[canonical] ?? MODEL_PRICING[model];
+    if (hit)
+        return { pricing: hit, known: true };
+    return { pricing: DEFAULT_PRICING, known: false };
+}
+/** Normalize model names: strip provider prefix and version suffixes for consistent grouping. */
+function getCanonicalName(model) {
+    // "anthropic/claude-opus-4-6" → "claude-opus-4-6"
+    const slashIdx = model.lastIndexOf("/");
+    const base = slashIdx >= 0 ? model.slice(slashIdx + 1) : model;
+    // Strip date suffixes like "-20250301"
+    return base.replace(/-\d{8}$/, "");
+}
+export class CostTracker {
+    records = [];
+    sessionStart = Date.now();
+    _hasUnknownModel = false;
+    record(model, promptTokens, completionTokens, isSubAgent = false, cacheReadTokens = 0, cacheWriteTokens = 0) {
+        const canonical = getCanonicalName(model);
+        if (!lookupPricing(model).known && !lookupPricing(canonical).known) {
+            this._hasUnknownModel = true;
+        }
+        this.records.push({
+            model: canonical,
+            promptTokens,
+            completionTokens,
+            cacheReadTokens,
+            cacheWriteTokens,
+            totalTokens: promptTokens + completionTokens,
+            timestamp: Date.now(),
+            isSubAgent,
+        });
+    }
+    getTotalTokens() {
+        let prompt = 0;
+        let completion = 0;
+        for (const r of this.records) {
+            prompt += r.promptTokens;
+            completion += r.completionTokens;
+        }
+        return { prompt, completion, total: prompt + completion };
+    }
+    getEstimatedCost() {
+        let totalCost = 0;
+        for (const r of this.records) {
+            const { pricing: p } = lookupPricing(r.model);
+            // promptTokens includes cache tokens — subtract them to avoid double billing
+            const uncachedInput = Math.max(0, r.promptTokens - r.cacheReadTokens - r.cacheWriteTokens);
+            totalCost += (uncachedInput / 1_000_000) * p.input;
+            totalCost += (r.completionTokens / 1_000_000) * p.output;
+            totalCost += (r.cacheReadTokens / 1_000_000) * p.cacheRead;
+            totalCost += (r.cacheWriteTokens / 1_000_000) * p.cacheWrite;
+        }
+        return totalCost;
+    }
+    getRequestCount() {
+        return this.records.length;
+    }
+    getSessionDuration() {
+        return Date.now() - this.sessionStart;
+    }
+    /** Estimate cost for a specific set of tokens without recording them. */
+    estimateForTokens(model, promptTokens, completionTokens, cacheReadTokens = 0, cacheWriteTokens = 0) {
+        const { pricing: p } = lookupPricing(model);
+        const uncachedInput = Math.max(0, promptTokens - cacheReadTokens - cacheWriteTokens);
+        return ((uncachedInput / 1_000_000) * p.input +
+            (completionTokens / 1_000_000) * p.output +
+            (cacheReadTokens / 1_000_000) * p.cacheRead +
+            (cacheWriteTokens / 1_000_000) * p.cacheWrite);
+    }
+    /**
+     * Get total cache token counts.
+     */
+    getCacheTokens() {
+        let cacheRead = 0;
+        let cacheWrite = 0;
+        for (const r of this.records) {
+            cacheRead += r.cacheReadTokens;
+            cacheWrite += r.cacheWriteTokens;
+        }
+        return { cacheRead, cacheWrite };
+    }
+    /**
+     * Format a styled cost summary for terminal display.
+     */
+    formatSummary(c = NOOP_COLORIZER) {
+        const tokens = this.getTotalTokens();
+        const cache = this.getCacheTokens();
+        const cost = this.getEstimatedCost();
+        const requests = this.getRequestCount();
+        const duration = this.getSessionDuration();
+        const lines = [];
+        lines.push(`  ${c.boldCyan("Cost Summary")}`);
+        lines.push(c.dim("  ─".repeat(25)));
+        lines.push(`    ${c.dim("Requests:")}      ${c.white(String(requests))}`);
+        lines.push(`    ${c.dim("Input tokens:")}  ${c.white(formatNumber(tokens.prompt))}`);
+        lines.push(`    ${c.dim("Output tokens:")} ${c.white(formatNumber(tokens.completion))}`);
+        if (cache.cacheRead > 0 || cache.cacheWrite > 0) {
+            lines.push(`    ${c.dim("Cache read:")}    ${c.white(formatNumber(cache.cacheRead))}`);
+            lines.push(`    ${c.dim("Cache write:")}   ${c.white(formatNumber(cache.cacheWrite))}`);
+        }
+        lines.push(`    ${c.dim("Total cost:")}    ${c.green(formatCost(cost))}`);
+        lines.push(`    ${c.dim("Duration:")}      ${c.white(formatDuration(duration))}`);
+        // Per-model breakdown (always show)
+        const modelMap = new Map();
+        for (const r of this.records) {
+            const existing = modelMap.get(r.model) ?? { prompt: 0, completion: 0, cacheRead: 0, cacheWrite: 0, count: 0 };
+            existing.prompt += r.promptTokens;
+            existing.completion += r.completionTokens;
+            existing.cacheRead += r.cacheReadTokens;
+            existing.cacheWrite += r.cacheWriteTokens;
+            existing.count++;
+            modelMap.set(r.model, existing);
+        }
+        if (modelMap.size >= 1) {
+            lines.push("");
+            lines.push(`    ${c.dim("By model:")}`);
+            for (const [model, stats] of modelMap) {
+                const { pricing: p } = lookupPricing(model);
+                const uncachedInput = Math.max(0, stats.prompt - stats.cacheRead - stats.cacheWrite);
+                const modelCost = (uncachedInput / 1_000_000) * p.input +
+                    (stats.completion / 1_000_000) * p.output +
+                    (stats.cacheRead / 1_000_000) * p.cacheRead +
+                    (stats.cacheWrite / 1_000_000) * p.cacheWrite;
+                const tokenDetail = `${formatNumber(stats.prompt)} in, ${formatNumber(stats.completion)} out` +
+                    (stats.cacheRead > 0 ? `, ${formatNumber(stats.cacheRead)} cache` : "");
+                lines.push(`      ${c.dim(model)} — ${tokenDetail}, ${formatCost(modelCost)} (${stats.count} reqs)`);
+            }
+        }
+        if (this._hasUnknownModel) {
+            lines.push("");
+            lines.push(c.dim("    (costs may be inaccurate due to usage of unknown models)"));
+        }
+        return lines.join("\n");
+    }
+    /**
+     * Format a compact one-line cost display for the prompt footer.
+     */
+    formatCompact(c = NOOP_COLORIZER) {
+        const tokens = this.getTotalTokens();
+        const cost = this.getEstimatedCost();
+        return c.dim(`tokens: ${formatNumber(tokens.total)} | cost: ${formatCost(cost)}`);
+    }
+    reset() {
+        this.records = [];
+        this.sessionStart = Date.now();
+    }
+    /** Serialize cost state for session persistence. */
+    serialize() {
+        const tokens = this.getTotalTokens();
+        return {
+            records: this.records,
+            sessionStart: this.sessionStart,
+            totalPromptTokens: tokens.prompt,
+            totalCompletionTokens: tokens.completion,
+            estimatedCost: this.getEstimatedCost(),
+        };
+    }
+    /** Restore cost state from a previous session. */
+    restore(state) {
+        this.records = state.records ?? [];
+        this.sessionStart = state.sessionStart ?? Date.now();
+    }
+}
+function formatCost(cost) {
+    if (cost >= 0.5)
+        return `$${Math.round(cost * 100) / 100}`;
+    if (cost >= 0.01)
+        return `$${cost.toFixed(4)}`;
+    if (cost > 0)
+        return `$${cost.toFixed(6)}`;
+    return "$0.00";
+}
+function formatNumber(n) {
+    if (n >= 1_000_000)
+        return (n / 1_000_000).toFixed(1) + "M";
+    if (n >= 1_000)
+        return (n / 1_000).toFixed(1) + "K";
+    return String(n);
+}
+function formatDuration(ms) {
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    const rs = s % 60;
+    if (m < 60)
+        return `${m}m ${rs}s`;
+    const h = Math.floor(m / 60);
+    const rm = m % 60;
+    return `${h}h ${rm}m`;
+}
+// Singleton for the current session
+export const costTracker = new CostTracker();
+/**
+ * Wire the LLM base-class usage hook into the singleton cost tracker.
+ * Called once from main.ts so every LLM call (REPL, run, arena, sub-agents)
+ * records into a single tracker without each call site having to remember.
+ */
+export async function installCostTracking() {
+    const { LLMClientBase } = await import("./llm/client-base.js");
+    LLMClientBase.onUsage = (model, usage) => {
+        costTracker.record(model, usage.promptTokens, usage.completionTokens, false, usage.cacheReadTokens ?? 0, usage.cacheCreationTokens ?? 0);
+    };
+}

package/dist/cron/scheduler.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Cron scheduler — schedule and manage recurring agent tasks.
+ *
+ * Supports simple cron-like intervals. Each job runs the Engine
+ * with a predefined prompt on schedule.
+ */
+export interface CronJob {
+    id: string;
+    name: string;
+    schedule: string;
+    prompt: string;
+    enabled: boolean;
+    lastRun?: number;
+    nextRun?: number;
+    runCount: number;
+    createdAt: number;
+}
+declare class CronScheduler {
+    private jobs;
+    private timers;
+    private nextId;
+    private onExecute?;
+    setExecutor(fn: (job: CronJob) => Promise<void>): void;
+    create(name: string, schedule: string, prompt: string): CronJob;
+    delete(id: string): boolean;
+    list(): CronJob[];
+    get(id: string): CronJob | undefined;
+    pause(id: string): boolean;
+    resume(id: string): boolean;
+    stopAll(): void;
+    private startTimer;
+}
+export declare const cronScheduler: CronScheduler;
+export {};

package/dist/cron/scheduler.js

@@ -0,0 +1,115 @@
+/**
+ * Cron scheduler — schedule and manage recurring agent tasks.
+ *
+ * Supports simple cron-like intervals. Each job runs the Engine
+ * with a predefined prompt on schedule.
+ */
+class CronScheduler {
+    jobs = new Map();
+    timers = new Map();
+    nextId = 1;
+    onExecute;
+    setExecutor(fn) {
+        this.onExecute = fn;
+    }
+    create(name, schedule, prompt) {
+        const id = String(this.nextId++);
+        const intervalMs = parseSchedule(schedule);
+        const job = {
+            id,
+            name,
+            schedule,
+            prompt,
+            enabled: true,
+            nextRun: Date.now() + intervalMs,
+            runCount: 0,
+            createdAt: Date.now(),
+        };
+        this.jobs.set(id, job);
+        this.startTimer(job, intervalMs);
+        return job;
+    }
+    delete(id) {
+        const timer = this.timers.get(id);
+        if (timer) {
+            clearInterval(timer);
+            this.timers.delete(id);
+        }
+        return this.jobs.delete(id);
+    }
+    list() {
+        return [...this.jobs.values()];
+    }
+    get(id) {
+        return this.jobs.get(id);
+    }
+    pause(id) {
+        const job = this.jobs.get(id);
+        if (!job)
+            return false;
+        job.enabled = false;
+        const timer = this.timers.get(id);
+        if (timer) {
+            clearInterval(timer);
+            this.timers.delete(id);
+        }
+        return true;
+    }
+    resume(id) {
+        const job = this.jobs.get(id);
+        if (!job)
+            return false;
+        job.enabled = true;
+        const intervalMs = parseSchedule(job.schedule);
+        this.startTimer(job, intervalMs);
+        return true;
+    }
+    stopAll() {
+        for (const timer of this.timers.values()) {
+            clearInterval(timer);
+        }
+        this.timers.clear();
+    }
+    startTimer(job, intervalMs) {
+        if (this.timers.has(job.id)) {
+            clearInterval(this.timers.get(job.id));
+        }
+        const timer = setInterval(async () => {
+            if (!job.enabled)
+                return;
+            job.lastRun = Date.now();
+            job.runCount++;
+            job.nextRun = Date.now() + intervalMs;
+            try {
+                await this.onExecute?.(job);
+            }
+            catch {
+                // Job execution failed — continue scheduling
+            }
+        }, intervalMs);
+        this.timers.set(job.id, timer);
+    }
+}
+/**
+ * Parse a schedule string into milliseconds.
+ * Supports: "30s", "5m", "1h", "1d", or raw milliseconds.
+ */
+function parseSchedule(schedule) {
+    const match = schedule.match(/^(\d+)(s|m|h|d)$/);
+    if (match) {
+        const value = parseInt(match[1], 10);
+        switch (match[2]) {
+            case "s": return value * 1000;
+            case "m": return value * 60 * 1000;
+            case "h": return value * 60 * 60 * 1000;
+            case "d": return value * 24 * 60 * 60 * 1000;
+        }
+    }
+    // Try raw number (milliseconds)
+    const ms = parseInt(schedule, 10);
+    if (!isNaN(ms) && ms > 0)
+        return ms;
+    // Default: 10 minutes
+    return 10 * 60 * 1000;
+}
+export const cronScheduler = new CronScheduler();

package/dist/data/deepseek-models.json

@@ -0,0 +1,46 @@
+{
+  "fetchedAt": "2026-05-14",
+  "source": "https://api-docs.deepseek.com/quick_start/pricing",
+  "count": 4,
+  "models": [
+    {
+      "id": "deepseek-v4-pro",
+      "name": "DeepSeek V4 Pro",
+      "contextLength": 1000000,
+      "maxOutputTokens": 384000,
+      "inputPricePerMillion": 1.74,
+      "outputPricePerMillion": 3.48,
+      "modalities": ["text"],
+      "thinking": true
+    },
+    {
+      "id": "deepseek-v4-flash",
+      "name": "DeepSeek V4 Flash",
+      "contextLength": 1000000,
+      "maxOutputTokens": 384000,
+      "inputPricePerMillion": 0.14,
+      "outputPricePerMillion": 0.28,
+      "modalities": ["text"],
+      "thinking": true
+    },
+    {
+      "id": "deepseek-chat",
+      "name": "DeepSeek Chat (legacy, deprecating)",
+      "contextLength": 128000,
+      "maxOutputTokens": 8192,
+      "inputPricePerMillion": 0.14,
+      "outputPricePerMillion": 0.28,
+      "modalities": ["text"]
+    },
+    {
+      "id": "deepseek-reasoner",
+      "name": "DeepSeek Reasoner (legacy, deprecating)",
+      "contextLength": 128000,
+      "maxOutputTokens": 8192,
+      "inputPricePerMillion": 0.14,
+      "outputPricePerMillion": 0.28,
+      "modalities": ["text"],
+      "thinking": true
+    }
+  ]
+}

package/dist/data/gemini-models.json

@@ -0,0 +1,67 @@
+{
+  "fetchedAt": "2026-05-15",
+  "source": "https://ai.google.dev/gemini-api/docs/models + https://ai.google.dev/gemini-api/docs/gemini-3",
+  "count": 6,
+  "models": [
+    {
+      "id": "gemini-3.1-pro-preview",
+      "name": "Gemini 3.1 Pro (preview)",
+      "contextLength": 1048576,
+      "maxOutputTokens": 65536,
+      "modalities": ["text", "image", "audio", "video"],
+      "thinking": true
+    },
+    {
+      "id": "gemini-3-pro-preview",
+      "name": "Gemini 3 Pro (preview)",
+      "contextLength": 1048576,
+      "maxOutputTokens": 65536,
+      "modalities": ["text", "image", "audio", "video"],
+      "thinking": true
+    },
+    {
+      "id": "gemini-3.1-flash-lite",
+      "name": "Gemini 3.1 Flash-Lite",
+      "contextLength": 1048576,
+      "maxOutputTokens": 65536,
+      "modalities": ["text", "image", "audio", "video"],
+      "thinking": true
+    },
+    {
+      "id": "gemini-3-flash-preview",
+      "name": "Gemini 3 Flash (preview)",
+      "contextLength": 1048576,
+      "maxOutputTokens": 65536,
+      "modalities": ["text", "image", "audio", "video"],
+      "thinking": true
+    },
+    {
+      "id": "gemini-2.5-pro",
+      "name": "Gemini 2.5 Pro",
+      "contextLength": 1048576,
+      "maxOutputTokens": 65536,
+      "inputPricePerMillion": 1.25,
+      "outputPricePerMillion": 10.0,
+      "modalities": ["text", "image", "audio", "video"],
+      "thinking": true
+    },
+    {
+      "id": "gemini-2.5-flash",
+      "name": "Gemini 2.5 Flash",
+      "contextLength": 1000000,
+      "maxOutputTokens": 65536,
+      "inputPricePerMillion": 0.3,
+      "outputPricePerMillion": 2.5,
+      "modalities": ["text", "image", "audio", "video"],
+      "thinking": true
+    },
+    {
+      "id": "gemini-2.5-flash-lite",
+      "name": "Gemini 2.5 Flash-Lite",
+      "contextLength": 1000000,
+      "maxOutputTokens": 65536,
+      "modalities": ["text", "image", "audio", "video"],
+      "thinking": true
+    }
+  ]
+}