Add cost estimationAdd dollar cost estimation across 4 models

.gitignore

@@ -2,3 +2,4 @@ node_modules/
 context.md
 **/.DS_Store
 .claude/settings.local.json
+

README.md

@@ -98,6 +98,23 @@ Mimir auto-detected `src/auth.ts` and `src/middleware/auth.ts` from your repo 
 
 ---
 
+## Cost Estimation
+
+Example output:
+
+```text
+Dollar cost: ~$0.0330 (sonnet) | ~$0.0088 (haiku) | ~$0.0007 (gemini) | ~$0.0225 (gpt-4o)
+```
+
+Cost is computed from estimated input tokens, assuming output tokens = 2x input tokens, using these per-million-token rates:
+
+- Claude Sonnet: $3 input / $15 output
+- Claude Haiku: $0.80 input / $4 output
+- Gemini Flash: $0.075 input / $0.30 output
+- GPT-4o: $2.50 input / $10 output
+
+---
+
 ## Commands
 
 | Command | Description |
@@ -345,3 +362,5 @@ Designed and built using **[Claude Code](https://claude.ai/code)** — Anthropic
 ## License
 
 MIT © 2026 [Marco Barlera](https://github.com/marcobarlera)
+
+

scripts/config-show.js

@@ -23,4 +23,8 @@ function main() {
   process.stdout.write(`${LINE}\n\n`);
 }
 
-main();
+if (require.main === module) {
+  main();
+}
+
+module.exports = { main };

scripts/estimate.js

@@ -9,6 +9,7 @@ const { appendHistory }                                = require('./lib/history'
 const { estimateContextOverhead, autoDetectFiles }     = require('./lib/context');
 const { estimateCacheSavings }                         = require('./lib/cache');
 const { estimateTaskTurns, projectAtTurn }             = require('./lib/turns');
+const { estimateAllModelCosts }                        = require('./lib/cost');
 
 const LINE = '━'.repeat(35);
 const SEP  = '─'.repeat(35);
@@ -40,7 +41,7 @@ function parseArgs(argv) {
   const clean = [];
   let i = 0;
   while (i < argv.length) {
-    if (argv[i] === '--git-diff' || argv[i] === '--no-auto') { i++;    continue; }
+    if (argv[i] === '--git-diff' || argv[i] === '--no-auto') { i++; continue; }
     if (argv[i] === '--turns')                               { i += 2; continue; }
     if (argv[i] === '--output')                              { i += 2; continue; }
     clean.push(argv[i]);
@@ -101,7 +102,6 @@ async function main() {
   const method     = taskResult.method;
   const ctx        = estimateContextOverhead(cfg, { turns, cwd });
 
-  // Explicit files
   const fileResults = [];
   let fileTotal     = 0;
   for (const fp of filePaths) {
@@ -115,15 +115,13 @@ async function main() {
     }
   }
 
-  // Auto-detected files (only when no explicit --files and not --no-auto)
   let autoFiles   = [];
   let autoTotal   = 0;
   if (!noAuto) {
     autoFiles = autoDetectFiles(task, cwd);
     autoTotal = autoFiles.reduce((s, f) => s + f.tokens, 0);
   }
 
-  // Git diff
   let diffTokens = 0;
   if (useGitDiff) {
     const diff = getGitDiff();
@@ -140,6 +138,7 @@ async function main() {
   const turnEst          = estimateTaskTurns(task);
   const projectedTokens  = projectAtTurn(totalTokens, ctx.tokensPerTurn, turnEst.turns);
   const projectedRisk    = classifyRisk(projectedTokens, cfg, task);
+  const costInfo         = estimateAllModelCosts(totalTokens);
 
   if (outputJson) {
     const allFiles = [
@@ -155,6 +154,7 @@ async function main() {
       suggestedModel: modelLine,
       headroomPct:    headroom,
       method,
+      costInfo,
       files:          allFiles,
       cache:          cacheInfo,
       projection:     { turns: turnEst.turns, category: turnEst.category, tokens: projectedTokens, risk: projectedRisk.level },
@@ -166,7 +166,6 @@ async function main() {
   process.stdout.write(`\n⚡ MIMIR PREFLIGHT\n`);
   process.stdout.write(`${LINE}\n`);
 
-  // — Baseline section —
   process.stdout.write(`  Baseline:\n`);
   row('  System overhead:', `~${ctx.systemOverhead.toLocaleString()}  (prompt + Claude UI)`);
   for (const h of ctx.hookScripts) {
@@ -186,7 +185,6 @@ async function main() {
     row(`  Conversation (${turns} turns):`, `~${ctx.conversationTokens.toLocaleString()}  (${tptLabel})`);
   }
 
-  // — Task section —
   process.stdout.write(`\n  This task:\n`);
   row(`  Task (${method}):`, fmt(method, taskResult.tokens));
 
@@ -208,14 +206,19 @@ async function main() {
 
   if (useGitDiff) row('  Git diff:', `~${diffTokens.toLocaleString()}`);
 
-  // — Totals —
   process.stdout.write(`\n  ${SEP}\n`);
   row('Task tokens:', `~${taskSpecific.toLocaleString()}`);
   row('Total context:', `~${totalTokens.toLocaleString()}`);
 
   process.stdout.write(`\n`);
   process.stdout.write(`  Risk:                 ${risk.level} ${risk.emoji}\n`);
   process.stdout.write(`  Suggested model:      ${modelLine}\n`);
+  if (costInfo) {
+    const costLine = costInfo
+      .map((c) => `~$${c.totalCost.toFixed(4)} (${c.label})`)
+      .join(' | ');
+    process.stdout.write(`  Dollar cost:          ${costLine}\n`);
+  }
   process.stdout.write(`  Context headroom:     ${headroom}%\n`);
   if (cacheInfo) {
     process.stdout.write(`  Prompt cache:         ~${cacheInfo.cacheableTokens.toLocaleString()} tok stable (${cacheInfo.cacheablePct}%) → ~${cacheInfo.costReductionPct}% cost/turn if cached\n`);
@@ -238,4 +241,8 @@ async function main() {
   }
 }
 
-main().catch(err => { process.stderr.write(`Error: ${err.message}\n`); process.exit(1); });
+if (require.main === module) {
+  main().catch(err => { process.stderr.write(`Error: ${err.message}\n`); process.exit(1); });
+}
+
+module.exports = { parseArgs, main };

scripts/history-show.js

@@ -91,4 +91,8 @@ function main() {
   process.stdout.write(`${LINE}\n\n`);
 }
 
-main();
+if (require.main === module) {
+  main();
+}
+
+module.exports = { main, printStats, escapeCsv };

scripts/lib/cost.js

@@ -0,0 +1,63 @@
+const MODEL_PRICING = {
+  'sonnet-4-6':   { input: 3.00,  output: 15.00 },
+  'haiku-4-5':    { input: 0.80,  output: 4.00 },
+  'gemini-flash': { input: 0.075, output: 0.30 },
+  'gpt-4o':       { input: 2.50,  output: 10.00 },
+};
+
+const MODEL_LABELS = {
+  'sonnet-4-6': 'sonnet',
+  'haiku-4-5': 'haiku',
+  'gemini-flash': 'gemini',
+  'gpt-4o': 'gpt-4o',
+};
+
+function normalizeModelId(model) {
+  if (!model) return null;
+  const raw = String(model).toLowerCase();
+  if (raw.includes('sonnet-4-6') || raw.includes('sonnet 4.6')) return 'sonnet-4-6';
+  if (raw.includes('haiku-4-5') || raw.includes('haiku 4.5')) return 'haiku-4-5';
+  if (raw.includes('gemini-flash') || raw.includes('gemini flash')) return 'gemini-flash';
+  if (raw.includes('gpt-4o') || raw.includes('gpt 4o')) return 'gpt-4o';
+  return null;
+}
+
+function estimateModelCost(model, inputTokens) {
+  const modelId = normalizeModelId(model);
+  const pricing = modelId ? MODEL_PRICING[modelId] : null;
+  if (!pricing || !Number.isFinite(inputTokens) || inputTokens < 0) return null;
+
+  const outputTokens = inputTokens * 2;
+  const inputCost = (inputTokens / 1_000_000) * pricing.input;
+  const outputCost = (outputTokens / 1_000_000) * pricing.output;
+  return {
+    modelId,
+    inputTokens,
+    outputTokens,
+    inputCost,
+    outputCost,
+    totalCost: inputCost + outputCost,
+  };
+}
+
+function estimateAllModelCosts(inputTokens) {
+  if (!Number.isFinite(inputTokens) || inputTokens < 0) return null;
+  return Object.keys(MODEL_PRICING).map((modelId) => {
+    const pricing = MODEL_PRICING[modelId];
+    const outputTokens = inputTokens * 2;
+    const inputCost = (inputTokens / 1_000_000) * pricing.input;
+    const outputCost = (outputTokens / 1_000_000) * pricing.output;
+    return {
+      modelId,
+      label: MODEL_LABELS[modelId] || modelId,
+      inputTokens,
+      outputTokens,
+      inputCost,
+      outputCost,
+      totalCost: inputCost + outputCost,
+    };
+  });
+}
+
+module.exports = { MODEL_PRICING, MODEL_LABELS, normalizeModelId, estimateModelCost, estimateAllModelCosts };
+

scripts/split.js

@@ -159,7 +159,11 @@ async function main() {
   process.stdout.write(`${LINE}\n\n`);
 }
 
-main().catch((err) => {
-  process.stderr.write(`Error: ${err.message}\n`);
-  process.exit(1);
-});
+if (require.main === module) {
+  main().catch((err) => {
+    process.stderr.write(`Error: ${err.message}\n`);
+    process.exit(1);
+  });
+}
+
+module.exports = { parseArgs, detectSplitPoints, main };

tests/config-show.test.js

@@ -1,13 +1,32 @@
 const assert = require('assert');
 const path   = require('path');
-const { execSync } = require('child_process');
 
-const script = path.resolve(__dirname, '..', 'scripts', 'config-show.js');
+async function runConfigShow(cwd) {
+  const originalArgv = process.argv;
+  const originalCwd = process.cwd();
+  const originalWrite = process.stdout.write;
+  let stdout = '';
 
+  process.argv = [process.execPath, 'scripts/config-show.js'];
+  process.stdout.write = (chunk) => { stdout += chunk; return true; };
+  process.chdir(cwd);
+
+  try {
+    delete require.cache[require.resolve('../scripts/config-show.js')];
+    require('../scripts/config-show.js').main();
+  } finally {
+    process.argv = originalArgv;
+    process.stdout.write = originalWrite;
+    process.chdir(originalCwd);
+    delete require.cache[require.resolve('../scripts/config-show.js')];
+  }
+
+  return stdout;
+}
+
+void (async () => {
 // Default config (no .mimir.json in /tmp)
-const out1 = execSync(`node "${script}"`, {
-  cwd: '/tmp',
-}).toString();
+const out1 = await runConfigShow('/tmp');
 
 assert.match(out1, /MIMIR CONFIG/,          'missing header');
 assert.match(out1, /Source/,                'missing source line');
@@ -19,3 +38,4 @@ assert.match(out1, /Default model/,         'missing default model');
 assert.match(out1, /200[,.]000/,            'should show 200k default context window');
 
 console.log('✅ config-show.test.js passed');
+})().catch(err => { throw err; });

tests/cost.test.js

@@ -0,0 +1,29 @@
+const assert = require('assert');
+const { MODEL_PRICING, normalizeModelId, estimateModelCost, estimateAllModelCosts } = require('../scripts/lib/cost');
+
+assert.strictEqual(MODEL_PRICING['sonnet-4-6'].input, 3);
+assert.strictEqual(MODEL_PRICING['haiku-4-5'].output, 4);
+assert.strictEqual(MODEL_PRICING['gemini-flash'].input, 0.075);
+assert.strictEqual(MODEL_PRICING['gpt-4o'].output, 10);
+
+assert.strictEqual(normalizeModelId('Sonnet 4.6'), 'sonnet-4-6');
+assert.strictEqual(normalizeModelId('claude-sonnet-4-6'), 'sonnet-4-6');
+assert.strictEqual(normalizeModelId('Haiku 4.5'), 'haiku-4-5');
+assert.strictEqual(normalizeModelId('gemini flash'), 'gemini-flash');
+assert.strictEqual(normalizeModelId('gpt-4o'), 'gpt-4o');
+
+const cost = estimateModelCost('Sonnet 4.6', 1000);
+assert.ok(cost, 'expected a cost result');
+assert.strictEqual(cost.modelId, 'sonnet-4-6');
+assert.strictEqual(cost.outputTokens, 2000);
+assert.strictEqual(cost.totalCost, 0.033);
+
+assert.strictEqual(estimateModelCost('unknown', 1000), null);
+
+const all = estimateAllModelCosts(1000);
+assert.ok(Array.isArray(all), 'expected all model costs array');
+assert.strictEqual(all.length, 4);
+assert.strictEqual(all[0].label, 'sonnet');
+assert.strictEqual(all[1].label, 'haiku');
+
+console.log('✅ cost.test.js passed');