@hasna/terminal 0.5.2 → 0.6.0

package/src/output-processor.ts

@@ -12,10 +12,18 @@ export interface ProcessedOutput {
   full: string;
   /** Structured JSON if the AI could extract it */
   structured?: Record<string, unknown>;
-  /** How many tokens were saved */
+  /** How many tokens were saved (net, after subtracting AI cost) */
   tokensSaved: number;
+  /** Tokens used by the AI summarization call */
+  aiTokensUsed: number;
   /** Whether AI processing was used (vs passthrough) */
   aiProcessed: boolean;
+  /** Cost of the AI call in USD (Cerebras pricing) */
+  aiCostUsd: number;
+  /** Value of tokens saved in USD (at Claude Sonnet rates) */
+  savingsValueUsd: number;
+  /** Net ROI: savings minus AI cost */
+  netSavingsUsd: number;
 }
 
 const MIN_LINES_TO_PROCESS = 15;
@@ -53,7 +61,11 @@ export async function processOutput(
       summary: output,
       full: output,
       tokensSaved: 0,
+      aiTokensUsed: 0,
       aiProcessed: false,
+      aiCostUsd: 0,
+      savingsValueUsd: 0,
+      netSavingsUsd: 0,
     };
   }
 
@@ -94,12 +106,34 @@ export async function processOutput(
       }
     } catch { /* not JSON, that's fine */ }
 
+    // Cost calculation
+    // AI input: system prompt (~200 tokens) + command + output sent to AI
+    const aiInputTokens = estimateTokens(SUMMARIZE_PROMPT) + estimateTokens(toSummarize) + 20;
+    const aiOutputTokens = summaryTokens;
+    const aiTokensUsed = aiInputTokens + aiOutputTokens;
+
+    // Cerebras qwen-3-235b pricing: $0.60/M input, $1.20/M output
+    const aiCostUsd = (aiInputTokens * 0.60 + aiOutputTokens * 1.20) / 1_000_000;
+
+    // Value of tokens saved (at Claude Sonnet $3/M input — what the agent would pay)
+    const savingsValueUsd = (saved * 3.0) / 1_000_000;
+    const netSavingsUsd = savingsValueUsd - aiCostUsd;
+
+    // Only record savings if net positive (AI cost < token savings value)
+    if (netSavingsUsd > 0 && saved > 0) {
+      recordSaving("compressed", saved);
+    }
+
     return {
       summary,
       full: output,
       structured,
       tokensSaved: saved,
+      aiTokensUsed,
       aiProcessed: true,
+      aiCostUsd,
+      savingsValueUsd,
+      netSavingsUsd,
     };
   } catch {
     // AI unavailable — fall back to simple truncation
@@ -111,7 +145,11 @@ export async function processOutput(
       summary: fallback,
       full: output,
       tokensSaved: Math.max(0, estimateTokens(output) - estimateTokens(fallback)),
+      aiTokensUsed: 0,
       aiProcessed: false,
+      aiCostUsd: 0,
+      savingsValueUsd: 0,
+      netSavingsUsd: 0,
     };
   }
 }

package/src/search/semantic.ts

@@ -37,6 +37,40 @@ export function extractSymbolsFromFile(filePath: string): CodeSymbol[] {
   return extractSymbols(filePath);
 }
 
+/** Extract the complete code block for a symbol by name */
+export function extractBlock(filePath: string, symbolName: string): { code: string; startLine: number; endLine: number } | null {
+  if (!existsSync(filePath)) return null;
+  const content = readFileSync(filePath, "utf8");
+  const lines = content.split("\n");
+  const symbols = extractSymbols(filePath);
+
+  const symbol = symbols.find(s => s.name === symbolName && s.kind !== "import");
+  if (!symbol) return null;
+
+  const startLine = symbol.line - 1; // 0-indexed
+  let braceDepth = 0;
+  let foundOpen = false;
+  let endLine = startLine;
+
+  for (let i = startLine; i < lines.length; i++) {
+    const line = lines[i];
+    for (const ch of line) {
+      if (ch === "{") { braceDepth++; foundOpen = true; }
+      if (ch === "}") { braceDepth--; }
+    }
+    endLine = i;
+    if (foundOpen && braceDepth <= 0) break;
+    // For single-line arrow functions without braces
+    if (i === startLine && !line.includes("{") && line.includes("=>")) break;
+  }
+
+  return {
+    code: lines.slice(startLine, endLine + 1).join("\n"),
+    startLine: startLine + 1, // 1-indexed
+    endLine: endLine + 1,
+  };
+}
+
 function extractSymbols(filePath: string): CodeSymbol[] {
   if (!existsSync(filePath)) return [];
   const content = readFileSync(filePath, "utf8");
@@ -50,7 +84,7 @@ function extractSymbols(filePath: string): CodeSymbol[] {
     const isExported = line.trimStart().startsWith("export");
 
     // Functions: export function X(...) or export const X = (...) =>
-    const funcMatch = line.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/);
+    const funcMatch = line.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/);
     if (funcMatch) {
       const prevLine = i > 0 ? lines[i - 1] : "";
       const doc = prevLine.trim().startsWith("/**") || prevLine.trim().startsWith("//")

package/dist/compression.test.js

@@ -1,42 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { compress, stripAnsi } from "./compression.js";
-describe("stripAnsi", () => {
-    it("removes ANSI escape codes", () => {
-        expect(stripAnsi("\x1b[31mred\x1b[0m")).toBe("red");
-        expect(stripAnsi("\x1b[1;32mbold green\x1b[0m")).toBe("bold green");
-    });
-    it("leaves clean text unchanged", () => {
-        expect(stripAnsi("hello world")).toBe("hello world");
-    });
-});
-describe("compress", () => {
-    it("strips ANSI by default", () => {
-        const result = compress("ls", "\x1b[32mfile.ts\x1b[0m");
-        expect(result.content).not.toContain("\x1b");
-    });
-    it("uses structured parser when format=json", () => {
-        const output = `total 16
--rw-r--r--  1 user staff  450 Mar 10 09:00 package.json
-drwxr-xr-x  5 user staff  160 Mar 10 09:00 src`;
-        const result = compress("ls -la", output, { format: "json" });
-        // Parser may or may not save tokens on small input, just check it parsed
-        expect(result.content).toBeTruthy();
-        const parsed = JSON.parse(result.content);
-        expect(Array.isArray(parsed)).toBe(true);
-    });
-    it("respects maxTokens budget", () => {
-        const longOutput = Array.from({ length: 100 }, (_, i) => `Line ${i}: some output text here`).join("\n");
-        const result = compress("some-command", longOutput, { maxTokens: 50 });
-        expect(result.compressedTokens).toBeLessThanOrEqual(60); // allow some slack
-    });
-    it("deduplicates similar lines", () => {
-        const output = Array.from({ length: 20 }, (_, i) => `Compiling module ${i}...`).join("\n");
-        const result = compress("build", output);
-        expect(result.compressedTokens).toBeLessThan(result.originalTokens);
-    });
-    it("tracks savings on large output", () => {
-        const output = Array.from({ length: 100 }, (_, i) => `Line ${i}: some long output text here that takes tokens`).join("\n");
-        const result = compress("cmd", output, { maxTokens: 50 });
-        expect(result.compressedTokens).toBeLessThan(result.originalTokens);
-    });
-});

package/dist/diff-cache.test.js

@@ -1,27 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { diffOutput, clearDiffCache } from "./diff-cache.js";
-describe("diffOutput", () => {
-    it("returns first run with no previous", () => {
-        clearDiffCache();
-        const result = diffOutput("npm test", "/tmp", "PASS\n5 passed");
-        expect(result.hasPrevious).toBe(false);
-        expect(result.diffSummary).toBe("first run");
-        expect(result.tokensSaved).toBe(0);
-    });
-    it("detects identical output", () => {
-        clearDiffCache();
-        diffOutput("npm test", "/tmp/id", "PASS\n5 passed");
-        const result = diffOutput("npm test", "/tmp/id", "PASS\n5 passed");
-        expect(result.unchanged).toBe(true);
-        expect(result.diffSummary).toBe("identical to previous run");
-    });
-    it("computes diff for changed output", () => {
-        clearDiffCache();
-        diffOutput("npm test", "/tmp/diff", "PASS test1\nPASS test2\nFAIL test3");
-        const result = diffOutput("npm test", "/tmp/diff", "PASS test1\nPASS test2\nPASS test3");
-        expect(result.hasPrevious).toBe(true);
-        expect(result.unchanged).toBe(false);
-        expect(result.added).toContain("PASS test3");
-        expect(result.removed).toContain("FAIL test3");
-    });
-});

package/dist/economy.test.js

@@ -1,13 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { formatTokens } from "./economy.js";
-describe("formatTokens", () => {
-    it("formats small numbers", () => {
-        expect(formatTokens(42)).toBe("42");
-    });
-    it("formats thousands", () => {
-        expect(formatTokens(1500)).toBe("1.5K");
-    });
-    it("formats millions", () => {
-        expect(formatTokens(2500000)).toBe("2.5M");
-    });
-});

package/dist/parsers/parsers.test.js

@@ -1,136 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { parseOutput, tokenSavings, estimateTokens } from "./index.js";
-describe("parseOutput", () => {
-    it("parses ls -la output", () => {
-        const output = `total 32
-drwxr-xr-x  5 user staff  160 Mar 10 09:00 src
--rw-r--r--  1 user staff  450 Mar 10 09:00 package.json
-lrwxr-xr-x  1 user staff   20 Mar 10 09:00 link -> target`;
-        const result = parseOutput("ls -la", output);
-        expect(result).not.toBeNull();
-        expect(result.parser).toBe("ls");
-        const data = result.data;
-        expect(data.length).toBe(3);
-        expect(data[0].name).toBe("src");
-        expect(data[0].type).toBe("dir");
-        expect(data[1].name).toBe("package.json");
-        expect(data[1].type).toBe("file");
-        expect(data[2].type).toBe("symlink");
-    });
-    it("parses find output and filters node_modules", () => {
-        const output = `./src/lib/webhooks.ts
-./node_modules/@types/node/async_hooks.d.ts
-./node_modules/@types/node/perf_hooks.d.ts
-./dist/lib/webhooks.d.ts
-./src/routes/api.ts`;
-        const result = parseOutput("find . -name '*hooks*' -type f", output);
-        expect(result).not.toBeNull();
-        expect(result.parser).toBe("find");
-        const data = result.data;
-        expect(data.source.length).toBe(2); // webhooks.ts and api.ts
-        expect(data.filtered.length).toBeGreaterThan(0);
-        expect(data.filtered.find((f) => f.reason === "node_modules")?.count).toBe(2);
-    });
-    it("parses test output (jest style)", () => {
-        const output = `PASS src/auth.test.ts
-FAIL src/db.test.ts
-  ✗ should connect to database
-    Error: Connection refused
-Tests: 5 passed, 1 failed, 1 skipped, 7 total
-Time: 3.2s`;
-        const result = parseOutput("npm test", output);
-        expect(result).not.toBeNull();
-        expect(result.parser).toBe("test");
-        const data = result.data;
-        expect(data.passed).toBe(5);
-        expect(data.failed).toBe(1);
-        expect(data.skipped).toBe(1);
-        expect(data.total).toBe(7);
-    });
-    it("parses git status", () => {
-        const output = `On branch main
-Changes to be committed:
-  new file:   src/mcp/server.ts
-  modified:   src/ai.ts
-
-Changes not staged for commit:
-  modified:   package.json
-
-Untracked files:
-  src/tree.ts`;
-        const result = parseOutput("git status", output);
-        expect(result).not.toBeNull();
-        expect(result.parser).toBe("git-status");
-        const data = result.data;
-        expect(data.branch).toBe("main");
-        expect(data.staged.length).toBe(2);
-        expect(data.unstaged.length).toBe(1);
-        expect(data.untracked.length).toBe(1);
-    });
-    it("parses git log", () => {
-        const output = `commit af19ce3456789
-Author: Andrei Hasna <andrei@hasna.com>
-Date:   Sat Mar 15 10:00:00 2026
-
-    feat: add MCP server
-
-commit 3963db5123456
-Author: Andrei Hasna <andrei@hasna.com>
-Date:   Fri Mar 14 09:00:00 2026
-
-    feat: tabs and browse mode`;
-        const result = parseOutput("git log", output);
-        expect(result).not.toBeNull();
-        expect(result.parser).toBe("git-log");
-        const data = result.data;
-        expect(data.length).toBe(2);
-        expect(data[0].hash).toBe("af19ce34");
-        expect(data[0].message).toBe("feat: add MCP server");
-    });
-    it("parses npm install output", () => {
-        const output = `added 47 packages in 3.2s
-2 vulnerabilities found`;
-        const result = parseOutput("npm install", output);
-        expect(result).not.toBeNull();
-        expect(result.parser).toBe("npm-install");
-        const data = result.data;
-        expect(data.installed).toBe(47);
-        expect(data.duration).toBe("3.2s");
-        expect(data.vulnerabilities).toBe(2);
-    });
-    it("parses build output", () => {
-        const output = `Compiling...
-1 warning
-Found 0 errors
-Done in 2.5s`;
-        const result = parseOutput("npm run build", output);
-        expect(result).not.toBeNull();
-        expect(result.parser).toBe("build");
-        const data = result.data;
-        expect(data.status).toBe("success");
-        expect(data.warnings).toBe(1);
-    });
-    it("detects errors", () => {
-        const output = `Error: EADDRINUSE: address already in use :3000`;
-        const result = parseOutput("node server.js", output);
-        expect(result).not.toBeNull();
-        expect(result.parser).toBe("error");
-        const data = result.data;
-        expect(data.type).toBe("port_in_use");
-    });
-});
-describe("estimateTokens", () => {
-    it("estimates roughly 4 chars per token", () => {
-        expect(estimateTokens("hello world")).toBe(3); // 11 chars / 4 = 2.75 → 3
-    });
-});
-describe("tokenSavings", () => {
-    it("calculates savings correctly", () => {
-        const raw = "a".repeat(400); // 100 tokens
-        const parsed = { status: "ok" };
-        const result = tokenSavings(raw, parsed);
-        expect(result.rawTokens).toBe(100);
-        expect(result.saved).toBeGreaterThan(0);
-        expect(result.percent).toBeGreaterThan(0);
-    });
-});

package/dist/providers/providers.test.js

@@ -1,14 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { availableProviders, resetProvider } from "./index.js";
-describe("providers", () => {
-    it("lists available providers", () => {
-        const providers = availableProviders();
-        expect(providers.length).toBe(2);
-        expect(providers[0].name).toBe("cerebras");
-        expect(providers[1].name).toBe("anthropic");
-    });
-    it("resetProvider clears cache", () => {
-        // Should not throw
-        resetProvider();
-    });
-});

package/dist/recipes/recipes.test.js

@@ -1,36 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { genId, substituteVariables, extractVariables } from "./model.js";
-describe("genId", () => {
-    it("generates unique ids", () => {
-        const a = genId();
-        const b = genId();
-        expect(a).not.toBe(b);
-        expect(a.length).toBe(8);
-    });
-});
-describe("substituteVariables", () => {
-    it("replaces {var} placeholders", () => {
-        expect(substituteVariables("kill -9 {pid}", { pid: "1234" })).toBe("kill -9 1234");
-    });
-    it("replaces multiple variables", () => {
-        expect(substituteVariables("curl {host}:{port}", { host: "localhost", port: "3000" }))
-            .toBe("curl localhost:3000");
-    });
-    it("replaces all occurrences of same variable", () => {
-        expect(substituteVariables("{x} and {x}", { x: "y" })).toBe("y and y");
-    });
-    it("leaves unmatched vars alone", () => {
-        expect(substituteVariables("{a} {b}", { a: "1" })).toBe("1 {b}");
-    });
-});
-describe("extractVariables", () => {
-    it("extracts variable names from command", () => {
-        expect(extractVariables("lsof -i :{port} -t | xargs kill")).toEqual(["port"]);
-    });
-    it("deduplicates", () => {
-        expect(extractVariables("{x} {x} {y}")).toEqual(["x", "y"]);
-    });
-    it("returns empty for no variables", () => {
-        expect(extractVariables("ls -la")).toEqual([]);
-    });
-});

package/dist/search/search.test.js

@@ -1,22 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { isSourceFile, isExcludedDir, relevanceScore } from "./filters.js";
-describe("filters", () => {
-    it("identifies source files", () => {
-        expect(isSourceFile("src/app.ts")).toBe(true);
-        expect(isSourceFile("index.tsx")).toBe(true);
-        expect(isSourceFile("main.py")).toBe(true);
-        expect(isSourceFile("image.png")).toBe(false);
-        expect(isSourceFile("binary")).toBe(false);
-    });
-    it("identifies excluded directories", () => {
-        expect(isExcludedDir("./node_modules/foo/bar.js")).toBe(true);
-        expect(isExcludedDir("./dist/index.js")).toBe(true);
-        expect(isExcludedDir("./.git/config")).toBe(true);
-        expect(isExcludedDir("./src/lib/utils.ts")).toBe(false);
-    });
-    it("scores source files highest", () => {
-        expect(relevanceScore("src/app.ts")).toBe(10);
-        expect(relevanceScore("./node_modules/foo.js")).toBe(0);
-        expect(relevanceScore("binary")).toBe(3);
-    });
-});