@hasna/terminal 2.3.1 → 3.0.1

package/benchmarks/benchmark.mjs

@@ -1,115 +0,0 @@
-#!/usr/bin/env bun
-// Reproducible benchmark: measures token savings across real commands
-// Run: bun benchmarks/benchmark.mjs
-
-import { compress, stripAnsi } from "../dist/compression.js";
-import { parseOutput, estimateTokens, tokenSavings } from "../dist/parsers/index.js";
-import { searchContent } from "../dist/search/index.js";
-import { diffOutput, clearDiffCache } from "../dist/diff-cache.js";
-import { smartDisplay } from "../dist/smart-display.js";
-import { stripNoise } from "../dist/noise-filter.js";
-import { rewriteCommand } from "../dist/command-rewriter.js";
-import { execSync } from "child_process";
-
-const cwd = process.cwd();
-const run = (cmd) => { try { return execSync(cmd, { encoding: "utf8", cwd, maxBuffer: 10*1024*1024 }).trim(); } catch(e) { return e.stdout?.trim() ?? ""; } };
-
-let totalRaw = 0, totalSaved = 0;
-const rows = [];
-
-function track(name, rawText, compressedText) {
-  const raw = estimateTokens(rawText);
-  const comp = estimateTokens(compressedText);
-  const saved = Math.max(0, raw - comp);
-  totalRaw += raw;
-  totalSaved += saved;
-  rows.push({ name, raw, comp, saved, pct: raw > 0 ? Math.round(saved/raw*100) : 0 });
-}
-
-console.log("open-terminal benchmark — measuring real token savings\n");
-
-// 1. Noise filter on npm install-like output
-const npmSim = "added 847 packages in 12s\n\n143 packages are looking for funding\n  run `npm fund` for details\n\nfound 0 vulnerabilities\n";
-const npmClean = stripNoise(npmSim).cleaned;
-track("npm install (noise filter)", npmSim, npmClean);
-
-// 2. Command rewriting
-const rwTests = [
-  ["find . -name '*.ts' | grep -v node_modules", "find pipe→filter"],
-  ["cat package.json | grep name", "cat pipe→grep"],
-  ["git log", "git log→oneline"],
-  ["npm ls", "npm ls→depth0"],
-];
-for (const [cmd, label] of rwTests) {
-  const rw = rewriteCommand(cmd);
-  if (rw.changed) {
-    const rawOut = run(cmd) || cmd;
-    const rwOut = run(rw.rewritten) || rw.rewritten;
-    track(`rewrite: ${label}`, rawOut, rwOut);
-  }
-}
-
-// 3. Structured parsing
-const gitStatus = run("git status");
-const gsParsed = parseOutput("git status", gitStatus);
-if (gsParsed) track("git status (structured)", gitStatus, JSON.stringify(gsParsed.data));
-
-const gitLog = run("git log -15");
-const glParsed = parseOutput("git log -15", gitLog);
-if (glParsed) track("git log -15 (structured)", gitLog, JSON.stringify(glParsed.data));
-
-// 4. Token budget compression
-const bigLs = run("ls -laR src/");
-const c1 = compress("ls -laR src/", bigLs, { maxTokens: 150 });
-track("ls -laR src/ (budget 150)", bigLs, c1.content);
-
-// 5. Search overflow guard
-const rawGrep = run("grep -rn export src/ | head -200");
-const search = await searchContent("export", cwd, { maxResults: 10 });
-track("grep export (overflow guard)", rawGrep, JSON.stringify(search));
-
-// 6. Smart display on paths
-const findPng = run("find . -name '*.png' -not -path '*/node_modules/*' 2>/dev/null | head -50");
-if (findPng) {
-  const display = smartDisplay(findPng.split("\n"));
-  track("find *.png (smart display)", findPng, display.join("\n"));
-}
-
-// 7. Diff caching (identical re-run)
-clearDiffCache();
-const testOut = run("bun test 2>&1");
-diffOutput("bun test", cwd, testOut);
-const d2 = diffOutput("bun test", cwd, testOut);
-track("bun test (identical re-run)", testOut, d2.diffSummary);
-
-// 8. Diff caching (fuzzy — simulated 95% similar)
-clearDiffCache();
-const testA = "PASS test1\nPASS test2\nPASS test3\nPASS test4\nPASS test5\nPASS test6\nPASS test7\nPASS test8\nPASS test9\nFAIL test10\nTests: 9 passed, 1 failed";
-const testB = "PASS test1\nPASS test2\nPASS test3\nPASS test4\nPASS test5\nPASS test6\nPASS test7\nPASS test8\nPASS test9\nPASS test10\nTests: 10 passed, 0 failed";
-diffOutput("test", "/tmp", testA);
-const fuzzyDiff = diffOutput("test", "/tmp", testB);
-track("test (fuzzy diff, 1 change)", testA, fuzzyDiff.added.join("\n") + "\n" + fuzzyDiff.removed.join("\n"));
-
-// 9. Budget compression on large ls
-const bigLs2 = run("ls -laR . 2>/dev/null | head -300");
-const c2 = compress("ls -laR .", bigLs2, { maxTokens: 100 });
-track("ls -laR . (budget 100, 300 lines)", bigLs2, c2.content);
-
-// Print results
-console.log("┌─────────────────────────────────────────────┬──────┬──────┬───────┬──────┐");
-console.log("│ Scenario                                    │  Raw │ Comp │ Saved │    % │");
-console.log("├─────────────────────────────────────────────┼──────┼──────┼───────┼──────┤");
-for (const r of rows) {
-  console.log("│ " + r.name.padEnd(43) + " │ " + String(r.raw).padStart(4) + " │ " + String(r.comp).padStart(4) + " │ " + String(r.saved).padStart(5) + " │ " + (r.pct + "%").padStart(4) + " │");
-}
-console.log("├─────────────────────────────────────────────┼──────┼──────┼───────┼──────┤");
-const pct = Math.round(totalSaved/totalRaw*100);
-console.log("│ " + "TOTAL".padEnd(43) + " │ " + String(totalRaw).padStart(4) + " │ " + String(totalRaw-totalSaved).padStart(4) + " │ " + String(totalSaved).padStart(5) + " │ " + (pct + "%").padStart(4) + " │");
-console.log("└─────────────────────────────────────────────┴──────┴──────┴───────┴──────┘");
-
-// Cost analysis
-const sonnetRate = 3.0;
-const cerebrasInputRate = 0.60;
-const savingsUsd = totalSaved * sonnetRate / 1_000_000;
-console.log(`\nAt Claude Sonnet $3/M: ${totalSaved} tokens saved = $${savingsUsd.toFixed(6)}`);
-console.log(`At 500 commands/day: ~$${(savingsUsd * 50).toFixed(2)}/day, $${(savingsUsd * 50 * 30).toFixed(0)}/month saved`);

package/src/compression.test.ts

@@ -1,49 +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 skip JSON if it's larger than raw — just check it returned something
-    expect(result.content).toBeTruthy();
-    expect(result.compressedTokens).toBeGreaterThan(0);
-  });
-
-  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/src/output-router.ts

@@ -1,56 +0,0 @@
-// Output intelligence router — auto-detect command type and optimize output
-
-import { parseOutput, estimateTokens } from "./parsers/index.js";
-import { compress, stripAnsi } from "./compression.js";
-import { recordSaving } from "./economy.js";
-
-export interface RouterResult {
-  raw: string;
-  structured?: unknown;
-  compressed?: string;
-  parser?: string;
-  tokensSaved: number;
-  format: "raw" | "json" | "compressed";
-}
-
-/** Route command output through the best optimization path */
-export function routeOutput(command: string, output: string, maxTokens?: number): RouterResult {
-  const clean = stripAnsi(output);
-  const rawTokens = estimateTokens(clean);
-
-  // Try structured parsing first
-  const parsed = parseOutput(command, clean);
-  if (parsed) {
-    const json = JSON.stringify(parsed.data);
-    const jsonTokens = estimateTokens(json);
-    const saved = rawTokens - jsonTokens;
-
-    if (saved > 0) {
-      recordSaving("structured", saved);
-      return {
-        raw: clean,
-        structured: parsed.data,
-        parser: parsed.parser,
-        tokensSaved: saved,
-        format: "json",
-      };
-    }
-  }
-
-  // Try compression if structured didn't save enough
-  if (maxTokens || rawTokens > 200) {
-    const compressed = compress(command, clean, { maxTokens, format: "text" });
-    if (compressed.tokensSaved > 0) {
-      recordSaving("compressed", compressed.tokensSaved);
-      return {
-        raw: clean,
-        compressed: compressed.content,
-        tokensSaved: compressed.tokensSaved,
-        format: "compressed",
-      };
-    }
-  }
-
-  // Return raw if no optimization helps
-  return { raw: clean, tokensSaved: 0, format: "raw" };
-}

package/src/parsers/base.ts

@@ -1,72 +0,0 @@
-// Base types for output parsers
-
-export interface Parser<T = unknown> {
-  /** Name of this parser */
-  readonly name: string;
-
-  /** Test if this parser can handle the given command/output */
-  detect(command: string, output: string): boolean;
-
-  /** Parse the output into structured data */
-  parse(command: string, output: string): T;
-}
-
-export interface FileEntry {
-  name: string;
-  type: "file" | "dir" | "symlink" | "other";
-  size?: number;
-  modified?: string;
-  permissions?: string;
-}
-
-export interface TestResult {
-  passed: number;
-  failed: number;
-  skipped: number;
-  total: number;
-  duration?: string;
-  failures: { test: string; error: string }[];
-}
-
-export interface GitLogEntry {
-  hash: string;
-  author: string;
-  date: string;
-  message: string;
-}
-
-export interface GitStatus {
-  branch: string;
-  staged: string[];
-  unstaged: string[];
-  untracked: string[];
-}
-
-export interface BuildResult {
-  status: "success" | "failure";
-  warnings: number;
-  errors: number;
-  duration?: string;
-  output?: string;
-}
-
-export interface NpmInstallResult {
-  installed: number;
-  duration?: string;
-  vulnerabilities: number;
-}
-
-export interface ErrorInfo {
-  type: string;
-  message: string;
-  file?: string;
-  line?: number;
-  suggestion?: string;
-}
-
-export interface SearchResult {
-  total: number;
-  source: FileEntry[];
-  other: FileEntry[];
-  filtered: { count: number; reason: string }[];
-}

package/src/parsers/build.ts

@@ -1,73 +0,0 @@
-// Parser for build output (npm/bun/pnpm build, tsc, webpack, vite, etc.)
-
-import type { Parser, BuildResult, NpmInstallResult } from "./base.js";
-
-export const buildParser: Parser<BuildResult> = {
-  name: "build",
-
-  detect(command: string, output: string): boolean {
-    if (/\b(npm|bun|pnpm|yarn)\s+(run\s+)?build\b/.test(command)) return true;
-    if (/\btsc\b/.test(command)) return true;
-    if (/\b(webpack|vite|esbuild|rollup|turbo)\b/.test(command)) return true;
-    return /\b(compiled|bundled|built)\b/i.test(output) && /\b(success|error|warning)\b/i.test(output);
-  },
-
-  parse(_command: string, output: string): BuildResult {
-    const lines = output.split("\n");
-    let warnings = 0, errors = 0, duration: string | undefined;
-
-    // Count warnings and errors
-    for (const line of lines) {
-      if (/\bwarning\b/i.test(line)) warnings++;
-      if (/\berror\b/i.test(line) && !/0 errors/.test(line)) errors++;
-    }
-
-    // Specific patterns
-    const tscErrors = output.match(/Found (\d+) error/);
-    if (tscErrors) errors = parseInt(tscErrors[1]);
-
-    const warningCount = output.match(/(\d+)\s+warning/);
-    if (warningCount) warnings = parseInt(warningCount[1]);
-
-    // Duration
-    const timeMatch = output.match(/(?:in|took)\s+([\d.]+\s*(?:s|ms|m))/i) ||
-      output.match(/Done in ([\d.]+s)/);
-    if (timeMatch) duration = timeMatch[1];
-
-    const status: "success" | "failure" = errors > 0 ? "failure" : "success";
-
-    return { status, warnings, errors, duration };
-  },
-};
-
-export const npmInstallParser: Parser<NpmInstallResult> = {
-  name: "npm-install",
-
-  detect(command: string, _output: string): boolean {
-    return /\b(npm|bun|pnpm|yarn)\s+(install|add|i)\b/.test(command);
-  },
-
-  parse(_command: string, output: string): NpmInstallResult {
-    let installed = 0, vulnerabilities = 0, duration: string | undefined;
-
-    // npm: added 47 packages in 3.2s
-    const npmMatch = output.match(/added\s+(\d+)\s+packages?\s+in\s+([\d.]+s)/);
-    if (npmMatch) {
-      installed = parseInt(npmMatch[1]);
-      duration = npmMatch[2];
-    }
-
-    // bun: 47 packages installed [1.2s]
-    const bunMatch = output.match(/(\d+)\s+packages?\s+installed.*?\[([\d.]+[ms]*s)\]/);
-    if (!npmMatch && bunMatch) {
-      installed = parseInt(bunMatch[1]);
-      duration = bunMatch[2];
-    }
-
-    // Vulnerabilities
-    const vulnMatch = output.match(/(\d+)\s+vulnerabilit/);
-    if (vulnMatch) vulnerabilities = parseInt(vulnMatch[1]);
-
-    return { installed, vulnerabilities, duration };
-  },
-};

package/src/parsers/errors.ts

@@ -1,107 +0,0 @@
-// Parser for common error patterns
-
-import type { Parser, ErrorInfo } from "./base.js";
-
-const ERROR_PATTERNS: { type: string; pattern: RegExp; extract: (m: RegExpMatchArray, output: string) => ErrorInfo }[] = [
-  {
-    type: "port_in_use",
-    pattern: /EADDRINUSE.*?(?::(\d+))|port\s+(\d+)\s+(?:is\s+)?(?:already\s+)?in\s+use/i,
-    extract: (m) => ({
-      type: "port_in_use",
-      message: m[0],
-      suggestion: `Kill the process: lsof -i :${m[1] ?? m[2]} -t | xargs kill`,
-    }),
-  },
-  {
-    type: "file_not_found",
-    pattern: /ENOENT.*?'([^']+)'|No such file or directory:\s*(.+)/,
-    extract: (m) => ({
-      type: "file_not_found",
-      message: m[0],
-      file: m[1] ?? m[2]?.trim(),
-      suggestion: "Check the file path exists",
-    }),
-  },
-  {
-    type: "permission_denied",
-    pattern: /EACCES.*?'([^']+)'|Permission denied:\s*(.+)/,
-    extract: (m) => ({
-      type: "permission_denied",
-      message: m[0],
-      file: m[1] ?? m[2]?.trim(),
-      suggestion: "Check file permissions or run with sudo",
-    }),
-  },
-  {
-    type: "command_not_found",
-    pattern: /command not found:\s*(\S+)|(\S+):\s*not found/,
-    extract: (m) => ({
-      type: "command_not_found",
-      message: m[0],
-      suggestion: `Install ${m[1] ?? m[2]} or check your PATH`,
-    }),
-  },
-  {
-    type: "dependency_missing",
-    pattern: /Cannot find module\s+'([^']+)'|Module not found.*?'([^']+)'/,
-    extract: (m) => ({
-      type: "dependency_missing",
-      message: m[0],
-      suggestion: `Install: npm install ${m[1] ?? m[2]}`,
-    }),
-  },
-  {
-    type: "syntax_error",
-    pattern: /SyntaxError:\s*(.+)|error TS\d+:\s*(.+)/,
-    extract: (m, output) => {
-      const fileMatch = output.match(/(\S+\.\w+):(\d+)/);
-      return {
-        type: "syntax_error",
-        message: m[1] ?? m[2] ?? m[0],
-        file: fileMatch?.[1],
-        line: fileMatch ? parseInt(fileMatch[2]) : undefined,
-        suggestion: "Fix the syntax error in the referenced file",
-      };
-    },
-  },
-  {
-    type: "out_of_memory",
-    pattern: /ENOMEM|JavaScript heap out of memory|Killed/,
-    extract: (m) => ({
-      type: "out_of_memory",
-      message: m[0],
-      suggestion: "Increase memory: NODE_OPTIONS=--max-old-space-size=4096",
-    }),
-  },
-  {
-    type: "network_error",
-    pattern: /ECONNREFUSED|ENOTFOUND|ETIMEDOUT|fetch failed/,
-    extract: (m) => ({
-      type: "network_error",
-      message: m[0],
-      suggestion: "Check network connection and target URL/host",
-    }),
-  },
-];
-
-export const errorParser: Parser<ErrorInfo> = {
-  name: "error",
-
-  detect(_command: string, output: string): boolean {
-    return ERROR_PATTERNS.some(({ pattern }) => pattern.test(output));
-  },
-
-  parse(_command: string, output: string): ErrorInfo {
-    for (const { pattern, extract } of ERROR_PATTERNS) {
-      const match = output.match(pattern);
-      if (match) return extract(match, output);
-    }
-
-    // Generic error fallback
-    const errorLine = output.split("\n").find(l => /error/i.test(l));
-    return {
-      type: "unknown",
-      message: errorLine?.trim() ?? "Unknown error",
-    };
-  },
-};

package/src/parsers/files.ts

@@ -1,91 +0,0 @@
-// Parser for file listing output (ls -la, find, etc.)
-
-import type { Parser, FileEntry, SearchResult } from "./base.js";
-
-const NODE_MODULES_RE = /node_modules/;
-const DIST_RE = /\b(dist|build|\.next|__pycache__|coverage|\.git)\b/;
-const SOURCE_EXTS = /\.(ts|tsx|js|jsx|py|go|rs|java|rb|sh|c|cpp|h|css|scss|html|vue|svelte|md|json|yaml|yml|toml)$/;
-
-export const lsParser: Parser<FileEntry[]> = {
-  name: "ls",
-
-  detect(command: string, output: string): boolean {
-    return /^\s*(ls|ll|la)\b/.test(command) && output.includes(" ");
-  },
-
-  parse(_command: string, output: string): FileEntry[] {
-    const lines = output.split("\n").filter(l => l.trim());
-    const entries: FileEntry[] = [];
-
-    for (const line of lines) {
-      // ls -la format: drwxr-xr-x  5 user group 160 Mar 10 09:00 dirname
-      const match = line.match(/^([dlcbps-])([rwxsStT-]{9})\s+\d+\s+\S+\s+\S+\s+(\d+)\s+(\w+\s+\d+\s+[\d:]+)\s+(.+)$/);
-      if (match) {
-        const typeChar = match[1];
-        entries.push({
-          name: match[5],
-          type: typeChar === "d" ? "dir" : typeChar === "l" ? "symlink" : "file",
-          size: parseInt(match[3]),
-          modified: match[4],
-          permissions: match[1] + match[2],
-        });
-      } else if (line.trim() && !line.startsWith("total ")) {
-        // Simple ls output — just filenames
-        entries.push({ name: line.trim(), type: "file" });
-      }
-    }
-
-    return entries;
-  },
-};
-
-export const findParser: Parser<SearchResult> = {
-  name: "find",
-
-  detect(command: string, _output: string): boolean {
-    return /^\s*(find|fd)\b/.test(command);
-  },
-
-  parse(_command: string, output: string): SearchResult {
-    const lines = output.split("\n").filter(l => l.trim());
-    const source: FileEntry[] = [];
-    const other: FileEntry[] = [];
-    let nodeModulesCount = 0;
-    let distCount = 0;
-
-    for (const line of lines) {
-      const path = line.trim();
-      if (!path) continue;
-
-      if (NODE_MODULES_RE.test(path)) {
-        nodeModulesCount++;
-        continue;
-      }
-
-      if (DIST_RE.test(path)) {
-        distCount++;
-        continue;
-      }
-
-      const name = path.split("/").pop() ?? path;
-      const entry: FileEntry = { name: path, type: SOURCE_EXTS.test(name) ? "file" : "other" };
-
-      if (SOURCE_EXTS.test(name)) {
-        source.push(entry);
-      } else {
-        other.push(entry);
-      }
-    }
-
-    const filtered: { count: number; reason: string }[] = [];
-    if (nodeModulesCount > 0) filtered.push({ count: nodeModulesCount, reason: "node_modules" });
-    if (distCount > 0) filtered.push({ count: distCount, reason: "dist/build" });
-
-    return {
-      total: lines.length,
-      source,
-      other,
-      filtered,
-    };
-  },
-};

package/src/parsers/git.ts

@@ -1,101 +0,0 @@
-// Parsers for git output (log, status, diff)
-
-import type { Parser, GitLogEntry, GitStatus } from "./base.js";
-
-export const gitLogParser: Parser<GitLogEntry[]> = {
-  name: "git-log",
-
-  detect(command: string, _output: string): boolean {
-    return /\bgit\s+log\b/.test(command);
-  },
-
-  parse(_command: string, output: string): 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) {
-      const commitMatch = line.match(/^commit\s+([a-f0-9]+)/);
-      if (commitMatch) {
-        if (hash) {
-          entries.push({ hash: hash.slice(0, 8), author, date, message: message.join(" ").trim() });
-        }
-        hash = commitMatch[1];
-        author = ""; date = ""; message = [];
-        continue;
-      }
-
-      const authorMatch = line.match(/^Author:\s+(.+)/);
-      if (authorMatch) { author = authorMatch[1]; continue; }
-
-      const dateMatch = line.match(/^Date:\s+(.+)/);
-      if (dateMatch) { date = dateMatch[1].trim(); continue; }
-
-      if (line.startsWith("    ")) {
-        message.push(line.trim());
-      }
-    }
-
-    if (hash) {
-      entries.push({ hash: hash.slice(0, 8), author, date, message: message.join(" ").trim() });
-    }
-
-    return entries;
-  },
-};
-
-export const gitStatusParser: Parser<GitStatus> = {
-  name: "git-status",
-
-  detect(command: string, _output: string): boolean {
-    return /\bgit\s+status\b/.test(command);
-  },
-
-  parse(_command: string, output: string): GitStatus {
-    const lines = output.split("\n");
-    let branch = "";
-    const staged: string[] = [];
-    const unstaged: string[] = [];
-    const untracked: string[] = [];
-
-    const branchMatch = output.match(/On branch\s+(\S+)/);
-    if (branchMatch) branch = branchMatch[1];
-
-    let section = "";
-    for (const line of lines) {
-      if (line.includes("Changes to be committed")) { section = "staged"; continue; }
-      if (line.includes("Changes not staged")) { section = "unstaged"; continue; }
-      if (line.includes("Untracked files")) { section = "untracked"; continue; }
-
-      const fileMatch = line.match(/^\s+(?:new file|modified|deleted|renamed):\s+(.+)/);
-      if (fileMatch) {
-        if (section === "staged") staged.push(fileMatch[1].trim());
-        else if (section === "unstaged") unstaged.push(fileMatch[1].trim());
-        continue;
-      }
-
-      // Untracked files are just indented filenames
-      if (section === "untracked" && line.match(/^\s+\S/) && !line.includes("(use ")) {
-        untracked.push(line.trim());
-      }
-    }
-
-    return { branch, staged, unstaged, untracked };
-  },
-};