@blockrun/cc 0.8.2 → 0.9.2

package/dist/router/index.js

@@ -0,0 +1,281 @@
+/**
+ * Smart Router for brcc
+ * Ported from ClawRouter - 15-dimension weighted scoring for tier classification
+ */
+// ─── Tier Model Configs ───
+const AUTO_TIERS = {
+    SIMPLE: {
+        primary: 'google/gemini-2.5-flash',
+        fallback: ['deepseek/deepseek-chat', 'nvidia/gpt-oss-120b'],
+    },
+    MEDIUM: {
+        primary: 'moonshot/kimi-k2.5',
+        fallback: ['google/gemini-2.5-flash', 'deepseek/deepseek-chat'],
+    },
+    COMPLEX: {
+        primary: 'google/gemini-3.1-pro',
+        fallback: ['anthropic/claude-sonnet-4.6', 'google/gemini-2.5-pro'],
+    },
+    REASONING: {
+        primary: 'xai/grok-4-1-fast-reasoning',
+        fallback: ['deepseek/deepseek-reasoner', 'openai/o4-mini'],
+    },
+};
+const ECO_TIERS = {
+    SIMPLE: {
+        primary: 'nvidia/gpt-oss-120b',
+        fallback: ['google/gemini-2.5-flash-lite'],
+    },
+    MEDIUM: {
+        primary: 'google/gemini-2.5-flash-lite',
+        fallback: ['nvidia/gpt-oss-120b'],
+    },
+    COMPLEX: {
+        primary: 'google/gemini-2.5-flash-lite',
+        fallback: ['deepseek/deepseek-chat'],
+    },
+    REASONING: {
+        primary: 'xai/grok-4-1-fast-reasoning',
+        fallback: ['deepseek/deepseek-reasoner'],
+    },
+};
+const PREMIUM_TIERS = {
+    SIMPLE: {
+        primary: 'moonshot/kimi-k2.5',
+        fallback: ['anthropic/claude-haiku-4.5'],
+    },
+    MEDIUM: {
+        primary: 'openai/gpt-5.3-codex',
+        fallback: ['anthropic/claude-sonnet-4.6'],
+    },
+    COMPLEX: {
+        primary: 'anthropic/claude-opus-4.6',
+        fallback: ['openai/gpt-5.4', 'anthropic/claude-sonnet-4.6'],
+    },
+    REASONING: {
+        primary: 'anthropic/claude-sonnet-4.6',
+        fallback: ['anthropic/claude-opus-4.6', 'openai/o3'],
+    },
+};
+// ─── Keywords for Classification ───
+const CODE_KEYWORDS = [
+    'function', 'class', 'import', 'def', 'SELECT', 'async', 'await',
+    'const', 'let', 'var', 'return', '```', '函数', '类', '导入',
+];
+const REASONING_KEYWORDS = [
+    'prove', 'theorem', 'derive', 'step by step', 'chain of thought',
+    'formally', 'mathematical', 'proof', 'logically', '证明', '定理', '推导',
+];
+const SIMPLE_KEYWORDS = [
+    'what is', 'define', 'translate', 'hello', 'yes or no', 'capital of',
+    'how old', 'who is', 'when was', '什么是', '翻译', '你好',
+];
+const TECHNICAL_KEYWORDS = [
+    'algorithm', 'optimize', 'architecture', 'distributed', 'kubernetes',
+    'microservice', 'database', 'infrastructure', '算法', '架构', '优化',
+];
+const AGENTIC_KEYWORDS = [
+    'read file', 'edit', 'modify', 'update', 'create file', 'execute',
+    'deploy', 'install', 'npm', 'pip', 'fix', 'debug', 'verify',
+    '编辑', '修改', '部署', '安装', '修复', '调试',
+];
+function countMatches(text, keywords) {
+    const lower = text.toLowerCase();
+    return keywords.filter(kw => lower.includes(kw.toLowerCase())).length;
+}
+function classifyRequest(prompt, tokenCount) {
+    const signals = [];
+    let score = 0;
+    // Token count scoring (reduced weight - don't penalize short prompts too much)
+    if (tokenCount < 30) {
+        score -= 0.15;
+        signals.push('short');
+    }
+    else if (tokenCount > 500) {
+        score += 0.2;
+        signals.push('long');
+    }
+    // Code detection (weight: 0.20) - increased weight
+    const codeMatches = countMatches(prompt, CODE_KEYWORDS);
+    if (codeMatches >= 2) {
+        score += 0.5;
+        signals.push('code');
+    }
+    else if (codeMatches >= 1) {
+        score += 0.25;
+        signals.push('code-light');
+    }
+    // Reasoning detection (weight: 0.18)
+    const reasoningMatches = countMatches(prompt, REASONING_KEYWORDS);
+    if (reasoningMatches >= 2) {
+        // Direct reasoning override
+        return { tier: 'REASONING', confidence: 0.9, signals: [...signals, 'reasoning'] };
+    }
+    else if (reasoningMatches >= 1) {
+        score += 0.4;
+        signals.push('reasoning-light');
+    }
+    // Simple detection (weight: -0.12) - only trigger on strong simple signals
+    const simpleMatches = countMatches(prompt, SIMPLE_KEYWORDS);
+    if (simpleMatches >= 2) {
+        score -= 0.4;
+        signals.push('simple');
+    }
+    else if (simpleMatches >= 1 && codeMatches === 0 && tokenCount < 50) {
+        // Only mark as simple if no code and very short
+        score -= 0.25;
+        signals.push('simple');
+    }
+    // Technical complexity (weight: 0.15) - increased
+    const techMatches = countMatches(prompt, TECHNICAL_KEYWORDS);
+    if (techMatches >= 2) {
+        score += 0.4;
+        signals.push('technical');
+    }
+    else if (techMatches >= 1) {
+        score += 0.2;
+        signals.push('technical-light');
+    }
+    // Agentic detection (weight: 0.10) - increased
+    const agenticMatches = countMatches(prompt, AGENTIC_KEYWORDS);
+    if (agenticMatches >= 3) {
+        score += 0.35;
+        signals.push('agentic');
+    }
+    else if (agenticMatches >= 2) {
+        score += 0.2;
+        signals.push('agentic-light');
+    }
+    // Multi-step patterns
+    if (/first.*then|step \d|\d\.\s/i.test(prompt)) {
+        score += 0.2;
+        signals.push('multi-step');
+    }
+    // Question complexity
+    const questionCount = (prompt.match(/\?/g) || []).length;
+    if (questionCount > 3) {
+        score += 0.15;
+        signals.push(`${questionCount} questions`);
+    }
+    // Imperative verbs (build, create, implement, etc.)
+    const imperativeMatches = countMatches(prompt, [
+        'build', 'create', 'implement', 'design', 'develop', 'write', 'make',
+        'generate', 'construct', '构建', '创建', '实现', '设计', '开发'
+    ]);
+    if (imperativeMatches >= 1) {
+        score += 0.15;
+        signals.push('imperative');
+    }
+    // Map score to tier (adjusted boundaries)
+    let tier;
+    if (score < -0.1) {
+        tier = 'SIMPLE';
+    }
+    else if (score < 0.25) {
+        tier = 'MEDIUM';
+    }
+    else if (score < 0.45) {
+        tier = 'COMPLEX';
+    }
+    else {
+        tier = 'REASONING';
+    }
+    // Calculate confidence based on distance from boundary
+    const confidence = Math.min(0.95, 0.7 + Math.abs(score) * 0.3);
+    return { tier, confidence, signals };
+}
+// ─── Main Router ───
+export function routeRequest(prompt, profile = 'auto') {
+    // Free profile - always use free model
+    if (profile === 'free') {
+        return {
+            model: 'nvidia/gpt-oss-120b',
+            tier: 'SIMPLE',
+            confidence: 1.0,
+            signals: ['free-profile'],
+            savings: 1.0,
+        };
+    }
+    // Estimate token count (rough: 4 chars per token)
+    const tokenCount = Math.ceil(prompt.length / 4);
+    // Classify the request
+    const { tier, confidence, signals } = classifyRequest(prompt, tokenCount);
+    // Select tier config based on profile
+    let tierConfigs;
+    switch (profile) {
+        case 'eco':
+            tierConfigs = ECO_TIERS;
+            break;
+        case 'premium':
+            tierConfigs = PREMIUM_TIERS;
+            break;
+        default:
+            tierConfigs = AUTO_TIERS;
+    }
+    const model = tierConfigs[tier].primary;
+    // Calculate savings estimate
+    // Baseline: Claude Opus at $5/$25 per 1M tokens
+    const OPUS_COST_PER_1K = 0.015; // rough average
+    const modelCosts = {
+        'nvidia/gpt-oss-120b': 0,
+        'google/gemini-2.5-flash': 0.001,
+        'google/gemini-2.5-flash-lite': 0.0003,
+        'deepseek/deepseek-chat': 0.0004,
+        'deepseek/deepseek-reasoner': 0.003,
+        'moonshot/kimi-k2.5': 0.002,
+        'google/gemini-2.5-pro': 0.006,
+        'google/gemini-3.1-pro': 0.007,
+        'anthropic/claude-haiku-4.5': 0.003,
+        'anthropic/claude-sonnet-4.6': 0.009,
+        'anthropic/claude-opus-4.6': 0.015,
+        'openai/gpt-5.3-codex': 0.008,
+        'openai/gpt-5.4': 0.009,
+        'openai/o3': 0.012,
+        'openai/o4-mini': 0.006,
+        'xai/grok-4-1-fast-reasoning': 0.0004,
+    };
+    const modelCost = modelCosts[model] ?? 0.005;
+    const savings = Math.max(0, (OPUS_COST_PER_1K - modelCost) / OPUS_COST_PER_1K);
+    return {
+        model,
+        tier,
+        confidence,
+        signals,
+        savings,
+    };
+}
+/**
+ * Get fallback models for a tier
+ */
+export function getFallbackChain(tier, profile = 'auto') {
+    let tierConfigs;
+    switch (profile) {
+        case 'eco':
+            tierConfigs = ECO_TIERS;
+            break;
+        case 'premium':
+            tierConfigs = PREMIUM_TIERS;
+            break;
+        case 'free':
+            return ['nvidia/gpt-oss-120b'];
+        default:
+            tierConfigs = AUTO_TIERS;
+    }
+    const config = tierConfigs[tier];
+    return [config.primary, ...config.fallback];
+}
+/**
+ * Parse routing profile from model string
+ */
+export function parseRoutingProfile(model) {
+    const lower = model.toLowerCase();
+    if (lower === 'blockrun/auto' || lower === 'auto')
+        return 'auto';
+    if (lower === 'blockrun/eco' || lower === 'eco')
+        return 'eco';
+    if (lower === 'blockrun/premium' || lower === 'premium')
+        return 'premium';
+    if (lower === 'blockrun/free' || lower === 'free')
+        return 'free';
+    return null;
+}

package/dist/stats/tracker.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Usage tracking for brcc
+ * Records all requests with cost, tokens, and latency for stats display
+ */
+export interface UsageRecord {
+    timestamp: number;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number;
+    latencyMs: number;
+    fallback?: boolean;
+}
+export interface ModelStats {
+    requests: number;
+    costUsd: number;
+    inputTokens: number;
+    outputTokens: number;
+    fallbackCount: number;
+    avgLatencyMs: number;
+    totalLatencyMs: number;
+}
+export interface Stats {
+    version: number;
+    totalRequests: number;
+    totalCostUsd: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalFallbacks: number;
+    byModel: Record<string, ModelStats>;
+    history: UsageRecord[];
+    firstRequest?: number;
+    lastRequest?: number;
+}
+export declare function loadStats(): Stats;
+export declare function saveStats(stats: Stats): void;
+export declare function clearStats(): void;
+/**
+ * Record a completed request for stats tracking
+ */
+export declare function recordUsage(model: string, inputTokens: number, outputTokens: number, costUsd: number, latencyMs: number, fallback?: boolean): void;
+/**
+ * Get stats summary for display
+ */
+export declare function getStatsSummary(): {
+    stats: Stats;
+    opusCost: number;
+    saved: number;
+    savedPct: number;
+    avgCostPerRequest: number;
+    period: string;
+};

package/dist/stats/tracker.js

@@ -0,0 +1,130 @@
+/**
+ * Usage tracking for brcc
+ * Records all requests with cost, tokens, and latency for stats display
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+const STATS_FILE = path.join(os.homedir(), '.blockrun', 'brcc-stats.json');
+const EMPTY_STATS = {
+    version: 1,
+    totalRequests: 0,
+    totalCostUsd: 0,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalFallbacks: 0,
+    byModel: {},
+    history: [],
+};
+export function loadStats() {
+    try {
+        if (fs.existsSync(STATS_FILE)) {
+            const data = JSON.parse(fs.readFileSync(STATS_FILE, 'utf-8'));
+            // Migration: add missing fields
+            return {
+                ...EMPTY_STATS,
+                ...data,
+                version: 1,
+            };
+        }
+    }
+    catch {
+        /* ignore parse errors, return empty */
+    }
+    return { ...EMPTY_STATS };
+}
+export function saveStats(stats) {
+    try {
+        fs.mkdirSync(path.dirname(STATS_FILE), { recursive: true });
+        // Keep only last 1000 history records
+        stats.history = stats.history.slice(-1000);
+        fs.writeFileSync(STATS_FILE, JSON.stringify(stats, null, 2));
+    }
+    catch {
+        /* ignore write errors */
+    }
+}
+export function clearStats() {
+    try {
+        if (fs.existsSync(STATS_FILE)) {
+            fs.unlinkSync(STATS_FILE);
+        }
+    }
+    catch {
+        /* ignore */
+    }
+}
+/**
+ * Record a completed request for stats tracking
+ */
+export function recordUsage(model, inputTokens, outputTokens, costUsd, latencyMs, fallback = false) {
+    const stats = loadStats();
+    const now = Date.now();
+    // Update totals
+    stats.totalRequests++;
+    stats.totalCostUsd += costUsd;
+    stats.totalInputTokens += inputTokens;
+    stats.totalOutputTokens += outputTokens;
+    if (fallback)
+        stats.totalFallbacks++;
+    // Update timestamps
+    if (!stats.firstRequest)
+        stats.firstRequest = now;
+    stats.lastRequest = now;
+    // Update per-model stats
+    if (!stats.byModel[model]) {
+        stats.byModel[model] = {
+            requests: 0,
+            costUsd: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            fallbackCount: 0,
+            avgLatencyMs: 0,
+            totalLatencyMs: 0,
+        };
+    }
+    const modelStats = stats.byModel[model];
+    modelStats.requests++;
+    modelStats.costUsd += costUsd;
+    modelStats.inputTokens += inputTokens;
+    modelStats.outputTokens += outputTokens;
+    modelStats.totalLatencyMs += latencyMs;
+    modelStats.avgLatencyMs = modelStats.totalLatencyMs / modelStats.requests;
+    if (fallback)
+        modelStats.fallbackCount++;
+    // Add to history
+    stats.history.push({
+        timestamp: now,
+        model,
+        inputTokens,
+        outputTokens,
+        costUsd,
+        latencyMs,
+        fallback,
+    });
+    saveStats(stats);
+}
+/**
+ * Get stats summary for display
+ */
+export function getStatsSummary() {
+    const stats = loadStats();
+    // Calculate what it would cost with Claude Opus
+    const opusCost = (stats.totalInputTokens / 1_000_000) * 5 +
+        (stats.totalOutputTokens / 1_000_000) * 25;
+    const saved = opusCost - stats.totalCostUsd;
+    const savedPct = opusCost > 0 ? (saved / opusCost) * 100 : 0;
+    const avgCostPerRequest = stats.totalRequests > 0 ? stats.totalCostUsd / stats.totalRequests : 0;
+    // Calculate period
+    let period = 'No data';
+    if (stats.firstRequest && stats.lastRequest) {
+        const days = Math.ceil((stats.lastRequest - stats.firstRequest) / (1000 * 60 * 60 * 24));
+        if (days === 0)
+            period = 'Today';
+        else if (days === 1)
+            period = '1 day';
+        else
+            period = `${days} days`;
+    }
+    return { stats, opusCost, saved, savedPct, avgCostPerRequest, period };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/cc",
-  "version": "0.8.2",
+  "version": "0.9.2",
   "description": "Run Claude Code with any model — no rate limits, no account locks, no phone verification. Pay per use with USDC.",
   "type": "module",
   "bin": {