cc-model-selector 1.0.0

package/cli.mjs

@@ -0,0 +1,334 @@
+#!/usr/bin/env node
+
+// cc-model-selector — Task complexity → Claude model recommendation
+// Zero dependencies. Helps Claude Code users pick the right model.
+//
+// Shows: model pricing, task decision matrix, session-based cost analysis
+//
+// Usage:
+//   npx cc-model-selector           # interactive decision guide
+//   npx cc-model-selector --task "write unit tests"   # instant recommendation
+//   npx cc-model-selector --analyze  # analyze your session history
+//   npx cc-model-selector --json    # machine-readable output
+
+import { readdir, stat } from 'node:fs/promises';
+import { createReadStream } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { createInterface } from 'node:readline';
+import { createRequire } from 'node:module';
+
+const PROJECTS_DIR = join(homedir(), '.claude', 'projects');
+
+// Claude model pricing ($ per million tokens, as of 2025)
+// Used for API-equivalent burn rate calculation
+const MODELS = {
+  'claude-haiku-4-5': {
+    label: 'Haiku 4.5',
+    input:  0.80,
+    output: 4.00,
+    cache_write: 1.00,
+    cache_read:  0.08,
+    tier: 1,
+    desc: 'Fastest, cheapest. Simple edits, lookups, formatting.',
+  },
+  'claude-sonnet-4-6': {
+    label: 'Sonnet 4.6',
+    input:  3.00,
+    output: 15.00,
+    cache_write: 3.75,
+    cache_read:  0.30,
+    tier: 2,
+    desc: 'Balanced. Most tasks. Default for autonomous agents.',
+  },
+  'claude-opus-4-6': {
+    label: 'Opus 4.6',
+    input:  15.00,
+    output: 75.00,
+    cache_write: 18.75,
+    cache_read:   1.50,
+    tier: 3,
+    desc: 'Most capable. Architecture, complex bugs, creative work.',
+  },
+};
+
+// Task complexity → model decision matrix
+const TASK_RULES = [
+  {
+    keywords: ['fix typo', 'format', 'rename', 'comment', 'docstring', 'readme', 'changelog', 'lint'],
+    model: 'claude-haiku-4-5',
+    reason: 'Simple edit — no reasoning needed',
+  },
+  {
+    keywords: ['unit test', 'test', 'mock', 'fixture', 'migration', 'crud', 'boilerplate', 'scaffold'],
+    model: 'claude-sonnet-4-6',
+    reason: 'Structured but routine — Sonnet handles reliably',
+  },
+  {
+    keywords: ['refactor', 'implement', 'feature', 'api', 'integrate', 'debug', 'bug', 'fix'],
+    model: 'claude-sonnet-4-6',
+    reason: 'Mid-complexity coding — Sonnet default',
+  },
+  {
+    keywords: ['architecture', 'design', 'system', 'complex', 'optimize', 'performance', 'security', 'algorithm'],
+    model: 'claude-opus-4-6',
+    reason: 'High-stakes reasoning — Opus recommended',
+  },
+  {
+    keywords: ['review', 'analyze', 'explain', 'understand', 'research', 'strategy', 'plan'],
+    model: 'claude-opus-4-6',
+    reason: 'Deep analysis — Opus excels at nuanced judgment',
+  },
+];
+
+const C = {
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+  red: '\x1b[31m', green: '\x1b[32m', yellow: '\x1b[33m',
+  blue: '\x1b[34m', cyan: '\x1b[36m', magenta: '\x1b[35m',
+};
+
+function pad(s, len, right = false) {
+  const t = String(s);
+  const p = ' '.repeat(Math.max(0, len - t.length));
+  return right ? p + t : t + p;
+}
+
+// ── Model recommendation for a task description ──────────────────────────────
+function recommendModel(taskDesc) {
+  if (!taskDesc) return null;
+  const lower = taskDesc.toLowerCase();
+  for (const rule of TASK_RULES) {
+    if (rule.keywords.some(k => lower.includes(k))) {
+      return { modelId: rule.model, reason: rule.reason, model: MODELS[rule.model] };
+    }
+  }
+  // Default: Sonnet
+  return {
+    modelId: 'claude-sonnet-4-6',
+    reason: 'No specific pattern matched — Sonnet is a safe default',
+    model: MODELS['claude-sonnet-4-6'],
+  };
+}
+
+// ── Session analysis ──────────────────────────────────────────────────────────
+function tokenCost(u, modelId) {
+  const m = MODELS[modelId] || MODELS['claude-sonnet-4-6'];
+  if (!u) return 0;
+  return (
+    (u.input_tokens || 0) * m.input / 1e6 +
+    (u.output_tokens || 0) * m.output / 1e6 +
+    (u.cache_creation_input_tokens || 0) * m.cache_write / 1e6 +
+    (u.cache_read_input_tokens || 0) * m.cache_read / 1e6
+  );
+}
+
+async function analyzeSession(filePath) {
+  const rl = createInterface({ input: createReadStream(filePath), crlfDelay: Infinity });
+  const result = { sonnetCost: 0, opusCost: 0, haikuCost: 0, totalMessages: 0, modelIds: new Set() };
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    let obj;
+    try { obj = JSON.parse(line); } catch { continue; }
+    if (obj.type !== 'assistant') continue;
+    const usage = obj.message?.usage || obj.usage;
+    if (!usage) continue;
+    const modelId = obj.message?.model || obj.model || 'claude-sonnet-4-6';
+    result.modelIds.add(modelId);
+    result.totalMessages++;
+    const cost = tokenCost(usage, modelId);
+    if (modelId.includes('opus')) result.opusCost += cost;
+    else if (modelId.includes('haiku')) result.haikuCost += cost;
+    else result.sonnetCost += cost;
+  }
+  return result;
+}
+
+async function collectSessionAnalysis() {
+  const totals = { sonnetCost: 0, opusCost: 0, haikuCost: 0, totalMessages: 0, modelIds: new Set() };
+  const cutoff = Date.now() - 30 * 24 * 60 * 60 * 1000;
+  try {
+    const projects = await readdir(PROJECTS_DIR);
+    for (const proj of projects) {
+      const dir = join(PROJECTS_DIR, proj);
+      let files;
+      try { files = await readdir(dir); } catch { continue; }
+      for (const f of files) {
+        if (!f.endsWith('.jsonl')) continue;
+        const fp = join(dir, f);
+        try {
+          const s = await stat(fp);
+          if (s.size < 100 || s.mtimeMs < cutoff) continue;
+        } catch { continue; }
+        const r = await analyzeSession(fp);
+        totals.sonnetCost += r.sonnetCost;
+        totals.opusCost += r.opusCost;
+        totals.haikuCost += r.haikuCost;
+        totals.totalMessages += r.totalMessages;
+        r.modelIds.forEach(id => totals.modelIds.add(id));
+      }
+    }
+  } catch {}
+  return totals;
+}
+
+// ── Render ────────────────────────────────────────────────────────────────────
+function renderPricingTable() {
+  const lines = [];
+  lines.push(`  ${C.dim}Model pricing (API-equivalent, $ per 1M tokens)${C.reset}`);
+  lines.push(`  ${C.dim}${'Model'.padEnd(14)} ${'Input'.padStart(8)} ${'Output'.padStart(8)} ${'CacheR'.padStart(8)}  Use when${C.reset}`);
+  lines.push('  ' + C.dim + '─'.repeat(70) + C.reset);
+  for (const [id, m] of Object.entries(MODELS)) {
+    const col = m.tier === 1 ? C.green : m.tier === 2 ? C.cyan : C.yellow;
+    lines.push(
+      `  ${col}${pad(m.label, 14)}${C.reset}` +
+      ` ${pad('$'+m.input.toFixed(2), 8, true)}` +
+      ` ${pad('$'+m.output.toFixed(2), 8, true)}` +
+      ` ${pad('$'+m.cache_read.toFixed(2), 8, true)}` +
+      `  ${C.dim}${m.desc}${C.reset}`
+    );
+  }
+  return lines;
+}
+
+function renderDecisionMatrix() {
+  const lines = [];
+  lines.push(`  ${C.dim}Task → Model decision matrix${C.reset}`);
+  lines.push('  ' + C.dim + '─'.repeat(60) + C.reset);
+
+  const byModel = {};
+  for (const rule of TASK_RULES) {
+    if (!byModel[rule.model]) byModel[rule.model] = [];
+    byModel[rule.model].push(...rule.keywords.slice(0, 3));
+  }
+  for (const [modelId, keywords] of Object.entries(byModel)) {
+    const m = MODELS[modelId];
+    const col = m.tier === 1 ? C.green : m.tier === 2 ? C.cyan : C.yellow;
+    lines.push(`  ${col}${m.label}${C.reset}  ${keywords.slice(0, 5).join(', ')}${keywords.length > 5 ? ', ...' : ''}`);
+  }
+  return lines;
+}
+
+function renderCostMultipliers() {
+  const base = MODELS['claude-sonnet-4-6'];
+  const lines = [];
+  lines.push(`  ${C.dim}Cost multiplier vs Sonnet${C.reset}`);
+  for (const [id, m] of Object.entries(MODELS)) {
+    const inputMult = (m.input / base.input).toFixed(1) + 'x';
+    const outputMult = (m.output / base.output).toFixed(1) + 'x';
+    const col = m.tier === 1 ? C.green : m.tier === 2 ? C.cyan : C.yellow;
+    lines.push(`  ${col}${pad(m.label, 14)}${C.reset}  input ${pad(inputMult, 6, true)}  output ${pad(outputMult, 6, true)}`);
+  }
+  return lines;
+}
+
+function renderAnalysis(totals) {
+  const lines = [];
+  const total = totals.sonnetCost + totals.opusCost + totals.haikuCost;
+  const W = 52;
+
+  lines.push(`  ${C.dim}Your model usage (last 30 days)${C.reset}`);
+  lines.push('  ' + C.dim + '─'.repeat(W) + C.reset);
+
+  if (total === 0) {
+    lines.push(`  ${C.dim}No session data found in ${PROJECTS_DIR}${C.reset}`);
+    return lines;
+  }
+
+  const fmtCost = (n) => '$' + n.toFixed(3);
+  const fmtPct = (n) => (n * 100).toFixed(0) + '%';
+
+  lines.push(`  Total (API-equiv)     ${pad(fmtCost(total), 10, true)}`);
+  if (totals.sonnetCost > 0) lines.push(`  Sonnet               ${pad(fmtCost(totals.sonnetCost), 10, true)}  ${pad(fmtPct(totals.sonnetCost/total), 5, true)}`);
+  if (totals.opusCost > 0) lines.push(`  Opus                 ${pad(fmtCost(totals.opusCost), 10, true)}  ${pad(fmtPct(totals.opusCost/total), 5, true)}  ${C.yellow}← expensive${C.reset}`);
+  if (totals.haikuCost > 0) lines.push(`  Haiku                ${pad(fmtCost(totals.haikuCost), 10, true)}  ${pad(fmtPct(totals.haikuCost/total), 5, true)}  ${C.green}← cheapest${C.reset}`);
+  lines.push('');
+
+  // Savings suggestion
+  if (totals.opusCost > 0) {
+    const savings = totals.opusCost * 0.4; // if 40% of Opus tasks could use Sonnet
+    lines.push(`  ${C.yellow}Savings opportunity:${C.reset}`);
+    lines.push(`  If 40% of Opus tasks used Sonnet instead:`);
+    lines.push(`  ~${fmtCost(savings)} API-equivalent savings over 30d`);
+    lines.push(`  ${C.dim}(Useful for autonomous agents with mixed task types)${C.reset}`);
+  } else if (totals.sonnetCost > 0 && totals.haikuCost === 0) {
+    const potentialSavings = totals.sonnetCost * 0.2 * (3.0 / 0.8 - 1) * 0.8 / 3.0;
+    // rough: 20% of Sonnet tasks could be Haiku, Haiku is ~3.75x cheaper on input
+    lines.push(`  ${C.cyan}Optimization note:${C.reset}`);
+    lines.push(`  All sessions used Sonnet. Consider Haiku for simple tasks.`);
+    lines.push(`  Potential savings: ~${fmtCost(potentialSavings)}/30d if 20% migrate to Haiku`);
+  }
+
+  return lines;
+}
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+const args = process.argv.slice(2);
+const taskIdx = args.indexOf('--task');
+const taskDesc = taskIdx >= 0 ? args.slice(taskIdx + 1).join(' ') : null;
+const doAnalyze = args.includes('--analyze');
+const jsonMode = args.includes('--json');
+
+(async () => {
+  if (taskDesc) {
+    // Single recommendation
+    const rec = recommendModel(taskDesc);
+    if (jsonMode) {
+      console.log(JSON.stringify({ task: taskDesc, recommended: rec.modelId, reason: rec.reason, model: rec.model }));
+      return;
+    }
+    console.log('');
+    console.log(`  ${C.dim}Task:${C.reset} ${taskDesc}`);
+    const col = rec.model.tier === 1 ? C.green : rec.model.tier === 2 ? C.cyan : C.yellow;
+    console.log(`  ${C.bold}Recommended:${C.reset} ${col}${rec.model.label}${C.reset}`);
+    console.log(`  ${C.dim}Reason:${C.reset} ${rec.reason}`);
+    console.log(`  ${C.dim}Desc:${C.reset} ${rec.model.desc}`);
+    console.log('');
+    return;
+  }
+
+  const W = 52;
+  const div = C.dim + '─'.repeat(W) + C.reset;
+  const lines = [];
+
+  lines.push('');
+  lines.push(`  ${C.bold}cc-model-selector${C.reset}  ${C.dim}Task → Claude model guide${C.reset}`);
+  lines.push('  ' + div);
+  lines.push('');
+
+  // Pricing table
+  lines.push(...renderPricingTable());
+  lines.push('');
+
+  // Cost multipliers
+  lines.push(...renderCostMultipliers());
+  lines.push('');
+
+  // Decision matrix
+  lines.push(...renderDecisionMatrix());
+  lines.push('');
+
+  lines.push('  ' + div);
+  lines.push(`  ${C.dim}Usage:${C.reset}`);
+  lines.push(`  ${C.cyan}npx cc-model-selector --task "refactor auth module"${C.reset}`);
+  lines.push(`  ${C.cyan}npx cc-model-selector --analyze${C.reset}  ${C.dim}# analyze your 30d session history${C.reset}`);
+  lines.push('');
+
+  if (doAnalyze) {
+    process.stdout.write(C.dim + '  Analyzing sessions...\r' + C.reset);
+    const totals = await collectSessionAnalysis();
+    process.stdout.write(' '.repeat(40) + '\r');
+    lines.push(...renderAnalysis(totals));
+    lines.push('');
+  }
+
+  if (jsonMode) {
+    const out = {
+      models: Object.fromEntries(Object.entries(MODELS).map(([k, v]) => [k, v])),
+      decision_matrix: TASK_RULES,
+    };
+    console.log(JSON.stringify(out, null, 2));
+    return;
+  }
+
+  console.log(lines.join('\n'));
+})();

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "cc-model-selector",
+  "version": "1.0.0",
+  "description": "Task complexity → Claude model recommendation for Claude Code users",
+  "type": "module",
+  "bin": {
+    "cc-model-selector": "cli.mjs"
+  },
+  "scripts": {
+    "start": "node cli.mjs"
+  },
+  "keywords": ["claude", "claude-code", "ai", "model", "sonnet", "opus", "haiku", "cost", "optimization"],
+  "author": "yurukusa",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yurukusa/cc-model-selector"
+  }
+}