@hasna/terminal 0.7.2 → 0.7.3

package/dist/cli.js

@@ -82,6 +82,7 @@ if (args[0] === "exec") {
     const { shouldBeLazy, toLazy, getSlice } = await import("./lazy-executor.js");
     const { parseOutput, estimateTokens } = await import("./parsers/index.js");
     const { recordSaving, recordUsage } = await import("./economy.js");
+    const { isTestOutput, trackTests, formatWatchResult } = await import("./test-watchlist.js");
     // Rewrite command if possible
     const rw = rewriteCommand(command);
     const actualCmd = rw.changed ? rw.rewritten : command;
@@ -123,6 +124,23 @@ if (args[0] === "exec") {
                 console.error(`[open-terminal] showing ${slice.lines.length}/${slice.total}, ${slice.total - (offset ?? 0) - slice.lines.length} remaining`);
             process.exit(0);
         }
+        // Test output detection — use watchlist for structured test tracking
+        if (isTestOutput(clean)) {
+            const result = trackTests(process.cwd(), clean);
+            const formatted = formatWatchResult(result);
+            const savedTokens = rawTokens - estimateTokens(formatted);
+            if (savedTokens > 20)
+                recordSaving("structured", savedTokens);
+            if (jsonMode) {
+                console.log(JSON.stringify({ exitCode: 0, type: "test-results", ...result, duration: Date.now() - start }));
+            }
+            else {
+                console.log(formatted);
+            }
+            if (savedTokens > 10)
+                console.error(`[open-terminal] test watchlist: saved ${savedTokens} tokens`);
+            process.exit(0);
+        }
         // Lazy mode for huge output (threshold 200, skip cat/summary commands)
         if (shouldBeLazy(clean, actualCmd)) {
             const lazy = toLazy(clean, actualCmd);

package/dist/test-watchlist.js

@@ -0,0 +1,127 @@
+// Test focus tracker — tracks test status across runs, only reports changes
+// Instead of showing "248 passed, 2 failed" every time, shows:
+// "auth.login: FIXED, auth.logout: STILL FAILING, 246 unchanged"
+// Per-cwd watchlist
+const watchlists = new Map();
+/** Extract test names and status from test runner output (any runner) */
+function extractTests(output) {
+    const tests = [];
+    const lines = output.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // PASS/FAIL with test name: "PASS src/auth.test.ts" or "✓ login works" or "✗ logout fails"
+        const passMatch = line.match(/(?:PASS|✓|✔|✅)\s+(.+)/);
+        if (passMatch) {
+            tests.push({ name: passMatch[1].trim(), status: "pass" });
+            continue;
+        }
+        const failMatch = line.match(/(?:FAIL|✗|✕|❌|×)\s+(.+)/);
+        if (failMatch) {
+            // Capture error from next few lines
+            const errorLines = [];
+            for (let j = i + 1; j < Math.min(i + 5, lines.length); j++) {
+                if (lines[j].match(/(?:PASS|FAIL|✓|✗|✔|✕|Tests:|^\s*$)/))
+                    break;
+                errorLines.push(lines[j].trim());
+            }
+            tests.push({ name: failMatch[1].trim(), status: "fail", error: errorLines.join(" ").slice(0, 200) });
+            continue;
+        }
+        // Jest/vitest style: "  ● test name" for failures
+        const jestFail = line.match(/^\s*●\s+(.+)/);
+        if (jestFail) {
+            tests.push({ name: jestFail[1].trim(), status: "fail" });
+            continue;
+        }
+    }
+    return tests;
+}
+/** Detect if output looks like test runner output */
+export function isTestOutput(output) {
+    const markers = /(?:Tests?:|PASS|FAIL|✓|✗|passed|failed|\d+\s+pass|\d+\s+fail)/i;
+    const lines = output.split("\n");
+    return lines.filter(l => markers.test(l)).length >= 2;
+}
+/** Track test results and return only changes */
+export function trackTests(cwd, output) {
+    const current = extractTests(output);
+    const prev = watchlists.get(cwd);
+    // Count totals from raw output (more reliable than extracted tests)
+    let totalPassed = 0, totalFailed = 0;
+    const summaryMatch = output.match(/(\d+)\s+pass/i);
+    const failMatch = output.match(/(\d+)\s+fail/i);
+    if (summaryMatch)
+        totalPassed = parseInt(summaryMatch[1]);
+    if (failMatch)
+        totalFailed = parseInt(failMatch[1]);
+    // Fallback to extracted counts
+    if (totalPassed === 0)
+        totalPassed = current.filter(t => t.status === "pass").length;
+    if (totalFailed === 0)
+        totalFailed = current.filter(t => t.status === "fail").length;
+    // Store current for next comparison
+    const currentMap = new Map();
+    for (const t of current)
+        currentMap.set(t.name, t);
+    watchlists.set(cwd, currentMap);
+    // First run — no comparison possible
+    if (!prev) {
+        return {
+            changed: [],
+            newTests: current.filter(t => t.status === "fail"), // only show failures on first run
+            totalPassed,
+            totalFailed,
+            unchangedCount: 0,
+            firstRun: true,
+        };
+    }
+    // Compare with previous
+    const changed = [];
+    const newTests = [];
+    let unchangedCount = 0;
+    for (const [name, test] of currentMap) {
+        const prevTest = prev.get(name);
+        if (!prevTest) {
+            newTests.push(test);
+        }
+        else if (prevTest.status !== test.status) {
+            changed.push({ name, from: prevTest.status, to: test.status, error: test.error });
+        }
+        else {
+            unchangedCount++;
+        }
+    }
+    return { changed, newTests, totalPassed, totalFailed, unchangedCount, firstRun: false };
+}
+/** Format watchlist result for display */
+export function formatWatchResult(result) {
+    const lines = [];
+    if (result.firstRun) {
+        lines.push(`${result.totalPassed} passed, ${result.totalFailed} failed`);
+        if (result.newTests.length > 0) {
+            for (const t of result.newTests) {
+                lines.push(`  ✗ ${t.name}${t.error ? `: ${t.error}` : ""}`);
+            }
+        }
+        return lines.join("\n");
+    }
+    // Status changes
+    for (const c of result.changed) {
+        if (c.to === "pass")
+            lines.push(`  ✓ FIXED: ${c.name}`);
+        else
+            lines.push(`  ✗ BROKE: ${c.name}${c.error ? ` — ${c.error}` : ""}`);
+    }
+    // New failures
+    for (const t of result.newTests.filter(t => t.status === "fail")) {
+        lines.push(`  ✗ NEW FAIL: ${t.name}${t.error ? ` — ${t.error}` : ""}`);
+    }
+    // Summary
+    if (result.changed.length === 0 && result.newTests.filter(t => t.status === "fail").length === 0) {
+        lines.push(`✓ ${result.totalPassed} passed, ${result.totalFailed} failed (no changes)`);
+    }
+    else {
+        lines.push(`${result.totalPassed} passed, ${result.totalFailed} failed, ${result.unchangedCount} unchanged`);
+    }
+    return lines.join("\n");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/terminal",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "Smart terminal wrapper for AI agents and humans — structured output, token compression, MCP server, natural language",
   "type": "module",
   "bin": {

package/src/cli.tsx

@@ -86,6 +86,7 @@ if (args[0] === "exec") {
   const { shouldBeLazy, toLazy, getSlice } = await import("./lazy-executor.js");
   const { parseOutput, estimateTokens } = await import("./parsers/index.js");
   const { recordSaving, recordUsage } = await import("./economy.js");
+  const { isTestOutput, trackTests, formatWatchResult } = await import("./test-watchlist.js");
 
   // Rewrite command if possible
   const rw = rewriteCommand(command);
@@ -127,6 +128,21 @@ if (args[0] === "exec") {
       process.exit(0);
     }
 
+    // Test output detection — use watchlist for structured test tracking
+    if (isTestOutput(clean)) {
+      const result = trackTests(process.cwd(), clean);
+      const formatted = formatWatchResult(result);
+      const savedTokens = rawTokens - estimateTokens(formatted);
+      if (savedTokens > 20) recordSaving("structured", savedTokens);
+      if (jsonMode) {
+        console.log(JSON.stringify({ exitCode: 0, type: "test-results", ...result, duration: Date.now() - start }));
+      } else {
+        console.log(formatted);
+      }
+      if (savedTokens > 10) console.error(`[open-terminal] test watchlist: saved ${savedTokens} tokens`);
+      process.exit(0);
+    }
+
     // Lazy mode for huge output (threshold 200, skip cat/summary commands)
     if (shouldBeLazy(clean, actualCmd)) {
       const lazy = toLazy(clean, actualCmd);

package/src/test-watchlist.ts

@@ -0,0 +1,156 @@
+// Test focus tracker — tracks test status across runs, only reports changes
+// Instead of showing "248 passed, 2 failed" every time, shows:
+// "auth.login: FIXED, auth.logout: STILL FAILING, 246 unchanged"
+
+export interface TestStatus {
+  name: string;
+  status: "pass" | "fail";
+  error?: string;
+}
+
+export interface TestWatchResult {
+  /** Tests that changed status since last run */
+  changed: { name: string; from: "pass" | "fail"; to: "pass" | "fail"; error?: string }[];
+  /** New tests not seen before */
+  newTests: TestStatus[];
+  /** Summary counts */
+  totalPassed: number;
+  totalFailed: number;
+  unchangedCount: number;
+  /** Whether this is the first run (no previous data) */
+  firstRun: boolean;
+}
+
+// Per-cwd watchlist
+const watchlists = new Map<string, Map<string, TestStatus>>();
+
+/** Extract test names and status from test runner output (any runner) */
+function extractTests(output: string): TestStatus[] {
+  const tests: TestStatus[] = [];
+  const lines = output.split("\n");
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // PASS/FAIL with test name: "PASS src/auth.test.ts" or "✓ login works" or "✗ logout fails"
+    const passMatch = line.match(/(?:PASS|✓|✔|✅)\s+(.+)/);
+    if (passMatch) {
+      tests.push({ name: passMatch[1].trim(), status: "pass" });
+      continue;
+    }
+
+    const failMatch = line.match(/(?:FAIL|✗|✕|❌|×)\s+(.+)/);
+    if (failMatch) {
+      // Capture error from next few lines
+      const errorLines: string[] = [];
+      for (let j = i + 1; j < Math.min(i + 5, lines.length); j++) {
+        if (lines[j].match(/(?:PASS|FAIL|✓|✗|✔|✕|Tests:|^\s*$)/)) break;
+        errorLines.push(lines[j].trim());
+      }
+      tests.push({ name: failMatch[1].trim(), status: "fail", error: errorLines.join(" ").slice(0, 200) });
+      continue;
+    }
+
+    // Jest/vitest style: "  ● test name" for failures
+    const jestFail = line.match(/^\s*●\s+(.+)/);
+    if (jestFail) {
+      tests.push({ name: jestFail[1].trim(), status: "fail" });
+      continue;
+    }
+  }
+
+  return tests;
+}
+
+/** Detect if output looks like test runner output */
+export function isTestOutput(output: string): boolean {
+  const markers = /(?:Tests?:|PASS|FAIL|✓|✗|passed|failed|\d+\s+pass|\d+\s+fail)/i;
+  const lines = output.split("\n");
+  return lines.filter(l => markers.test(l)).length >= 2;
+}
+
+/** Track test results and return only changes */
+export function trackTests(cwd: string, output: string): TestWatchResult {
+  const current = extractTests(output);
+  const prev = watchlists.get(cwd);
+
+  // Count totals from raw output (more reliable than extracted tests)
+  let totalPassed = 0, totalFailed = 0;
+  const summaryMatch = output.match(/(\d+)\s+pass/i);
+  const failMatch = output.match(/(\d+)\s+fail/i);
+  if (summaryMatch) totalPassed = parseInt(summaryMatch[1]);
+  if (failMatch) totalFailed = parseInt(failMatch[1]);
+  // Fallback to extracted counts
+  if (totalPassed === 0) totalPassed = current.filter(t => t.status === "pass").length;
+  if (totalFailed === 0) totalFailed = current.filter(t => t.status === "fail").length;
+
+  // Store current for next comparison
+  const currentMap = new Map<string, TestStatus>();
+  for (const t of current) currentMap.set(t.name, t);
+  watchlists.set(cwd, currentMap);
+
+  // First run — no comparison possible
+  if (!prev) {
+    return {
+      changed: [],
+      newTests: current.filter(t => t.status === "fail"), // only show failures on first run
+      totalPassed,
+      totalFailed,
+      unchangedCount: 0,
+      firstRun: true,
+    };
+  }
+
+  // Compare with previous
+  const changed: TestWatchResult["changed"] = [];
+  const newTests: TestStatus[] = [];
+  let unchangedCount = 0;
+
+  for (const [name, test] of currentMap) {
+    const prevTest = prev.get(name);
+    if (!prevTest) {
+      newTests.push(test);
+    } else if (prevTest.status !== test.status) {
+      changed.push({ name, from: prevTest.status, to: test.status, error: test.error });
+    } else {
+      unchangedCount++;
+    }
+  }
+
+  return { changed, newTests, totalPassed, totalFailed, unchangedCount, firstRun: false };
+}
+
+/** Format watchlist result for display */
+export function formatWatchResult(result: TestWatchResult): string {
+  const lines: string[] = [];
+
+  if (result.firstRun) {
+    lines.push(`${result.totalPassed} passed, ${result.totalFailed} failed`);
+    if (result.newTests.length > 0) {
+      for (const t of result.newTests) {
+        lines.push(`  ✗ ${t.name}${t.error ? `: ${t.error}` : ""}`);
+      }
+    }
+    return lines.join("\n");
+  }
+
+  // Status changes
+  for (const c of result.changed) {
+    if (c.to === "pass") lines.push(`  ✓ FIXED: ${c.name}`);
+    else lines.push(`  ✗ BROKE: ${c.name}${c.error ? ` — ${c.error}` : ""}`);
+  }
+
+  // New failures
+  for (const t of result.newTests.filter(t => t.status === "fail")) {
+    lines.push(`  ✗ NEW FAIL: ${t.name}${t.error ? ` — ${t.error}` : ""}`);
+  }
+
+  // Summary
+  if (result.changed.length === 0 && result.newTests.filter(t => t.status === "fail").length === 0) {
+    lines.push(`✓ ${result.totalPassed} passed, ${result.totalFailed} failed (no changes)`);
+  } else {
+    lines.push(`${result.totalPassed} passed, ${result.totalFailed} failed, ${result.unchangedCount} unchanged`);
+  }
+
+  return lines.join("\n");
+}