@hasna/terminal 0.7.1 → 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);
@@ -151,10 +169,30 @@ if (args[0] === "exec") {
         }
     }
     catch (e) {
-        // Command failed — show error output
+        // Command failed — parse error output for structured diagnosis
         const stderr = e.stderr?.toString() ?? "";
         const stdout = e.stdout?.toString() ?? "";
-        console.log(stripNoise(stripAnsi(stdout + stderr)).cleaned);
+        const errorOutput = stripNoise(stripAnsi(stdout + stderr)).cleaned;
+        // Try structured error parsing
+        const { errorParser } = await import("./parsers/errors.js");
+        if (errorOutput.length > 200 && errorParser.detect(actualCmd, errorOutput)) {
+            const info = errorParser.parse(actualCmd, errorOutput);
+            if (jsonMode) {
+                console.log(JSON.stringify({ exitCode: e.status ?? 1, error: info }));
+            }
+            else {
+                console.log(`Error: ${info.type}`);
+                console.log(`  ${info.message}`);
+                if (info.file)
+                    console.log(`  File: ${info.file}${info.line ? `:${info.line}` : ""}`);
+                if (info.suggestion)
+                    console.log(`  Fix: ${info.suggestion}`);
+            }
+        }
+        else {
+            // Short error or no parser match — pass through cleaned
+            console.log(errorOutput);
+        }
         process.exit(e.status ?? 1);
     }
     process.exit(0);

package/dist/parsers/git.js

@@ -7,6 +7,19 @@ export const gitLogParser = {
     parse(_command, output) {
         const entries = [];
         const lines = output.split("\n");
+        // Detect oneline format: "abc1234 commit message"
+        const firstLine = lines[0]?.trim() ?? "";
+        const isOneline = /^[a-f0-9]{7,12}\s+/.test(firstLine) && !firstLine.startsWith("commit ");
+        if (isOneline) {
+            for (const line of lines) {
+                const match = line.trim().match(/^([a-f0-9]{7,12})\s+(.+)$/);
+                if (match) {
+                    entries.push({ hash: match[1], author: "", date: "", message: match[2] });
+                }
+            }
+            return entries;
+        }
+        // Verbose format
         let hash = "", author = "", date = "", message = [];
         for (const line of lines) {
             const commitMatch = line.match(/^commit\s+([a-f0-9]+)/);

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.1",
+  "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);
@@ -155,10 +171,27 @@ if (args[0] === "exec") {
       console.error(`[open-terminal] saved ${savedTokens} tokens (noise filter)`);
     }
   } catch (e: any) {
-    // Command failed — show error output
+    // Command failed — parse error output for structured diagnosis
     const stderr = e.stderr?.toString() ?? "";
     const stdout = e.stdout?.toString() ?? "";
-    console.log(stripNoise(stripAnsi(stdout + stderr)).cleaned);
+    const errorOutput = stripNoise(stripAnsi(stdout + stderr)).cleaned;
+
+    // Try structured error parsing
+    const { errorParser } = await import("./parsers/errors.js");
+    if (errorOutput.length > 200 && errorParser.detect(actualCmd, errorOutput)) {
+      const info = errorParser.parse(actualCmd, errorOutput);
+      if (jsonMode) {
+        console.log(JSON.stringify({ exitCode: e.status ?? 1, error: info }));
+      } else {
+        console.log(`Error: ${info.type}`);
+        console.log(`  ${info.message}`);
+        if (info.file) console.log(`  File: ${info.file}${info.line ? `:${info.line}` : ""}`);
+        if (info.suggestion) console.log(`  Fix: ${info.suggestion}`);
+      }
+    } else {
+      // Short error or no parser match — pass through cleaned
+      console.log(errorOutput);
+    }
     process.exit(e.status ?? 1);
   }
   process.exit(0);

package/src/parsers/git.ts

@@ -13,6 +13,21 @@ export const gitLogParser: Parser<GitLogEntry[]> = {
     const entries: GitLogEntry[] = [];
     const lines = output.split("\n");
 
+    // Detect oneline format: "abc1234 commit message"
+    const firstLine = lines[0]?.trim() ?? "";
+    const isOneline = /^[a-f0-9]{7,12}\s+/.test(firstLine) && !firstLine.startsWith("commit ");
+
+    if (isOneline) {
+      for (const line of lines) {
+        const match = line.trim().match(/^([a-f0-9]{7,12})\s+(.+)$/);
+        if (match) {
+          entries.push({ hash: match[1], author: "", date: "", message: match[2] });
+        }
+      }
+      return entries;
+    }
+
+    // Verbose format
     let hash = "", author = "", date = "", message: string[] = [];
 
     for (const line of lines) {

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");
+}