@hasna/terminal 0.3.0 → 0.4.0

package/src/search/semantic.ts

@@ -0,0 +1,267 @@
+// Semantic code search — AST-powered search that understands code structure
+// Instead of raw grep, searches by meaning: "find auth functions" → login(), verifyToken()
+
+import { spawn } from "child_process";
+import { readFileSync, existsSync } from "fs";
+import { join, extname } from "path";
+
+export interface CodeSymbol {
+  name: string;
+  kind: "function" | "class" | "interface" | "type" | "variable" | "export" | "import" | "component" | "hook";
+  file: string;
+  line: number;
+  signature?: string;  // e.g., "function login(email: string, password: string): Promise<User>"
+  exported: boolean;
+  doc?: string;        // JSDoc comment if present
+}
+
+export interface SemanticSearchResult {
+  query: string;
+  symbols: CodeSymbol[];
+  totalFiles: number;
+  tokensSaved?: number;
+}
+
+function exec(command: string, cwd: string): Promise<string> {
+  return new Promise((resolve) => {
+    const proc = spawn("/bin/zsh", ["-c", command], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let out = "";
+    proc.stdout?.on("data", (d: Buffer) => { out += d.toString(); });
+    proc.stderr?.on("data", (d: Buffer) => { /* ignore */ });
+    proc.on("close", () => resolve(out));
+  });
+}
+
+/** Extract code symbols from a TypeScript/JavaScript file using regex-based parsing */
+function extractSymbols(filePath: string): CodeSymbol[] {
+  if (!existsSync(filePath)) return [];
+  const content = readFileSync(filePath, "utf8");
+  const lines = content.split("\n");
+  const symbols: CodeSymbol[] = [];
+  const file = filePath;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+    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*\(([^)]*)\)/);
+    if (funcMatch) {
+      const prevLine = i > 0 ? lines[i - 1] : "";
+      const doc = prevLine.trim().startsWith("/**") || prevLine.trim().startsWith("//")
+        ? prevLine.trim().replace(/^\/\*\*\s*|\s*\*\/$/g, "").replace(/^\/\/\s*/, "")
+        : undefined;
+      symbols.push({
+        name: funcMatch[1], kind: "function", file, line: lineNum,
+        signature: line.trim().replace(/\{.*$/, "").trim(),
+        exported: isExported, doc,
+      });
+      continue;
+    }
+
+    // Arrow functions: export const X = (...) =>
+    const arrowMatch = line.match(/(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?\(([^)]*)\)\s*(?::\s*\w[^=]*)?\s*=>/);
+    if (arrowMatch) {
+      // Detect React hooks
+      const isHook = arrowMatch[1].startsWith("use");
+      const isComponent = /^[A-Z]/.test(arrowMatch[1]);
+      symbols.push({
+        name: arrowMatch[1],
+        kind: isHook ? "hook" : isComponent ? "component" : "function",
+        file, line: lineNum,
+        signature: line.trim().replace(/\{.*$/, "").replace(/=>.*$/, "=>").trim(),
+        exported: isExported,
+      });
+      continue;
+    }
+
+    // Classes
+    const classMatch = line.match(/(?:export\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?/);
+    if (classMatch) {
+      symbols.push({
+        name: classMatch[1], kind: "class", file, line: lineNum,
+        signature: line.trim().replace(/\{.*$/, "").trim(),
+        exported: isExported,
+      });
+      continue;
+    }
+
+    // Interfaces
+    const ifaceMatch = line.match(/(?:export\s+)?interface\s+(\w+)/);
+    if (ifaceMatch) {
+      symbols.push({
+        name: ifaceMatch[1], kind: "interface", file, line: lineNum,
+        signature: line.trim().replace(/\{.*$/, "").trim(),
+        exported: isExported,
+      });
+      continue;
+    }
+
+    // Type aliases
+    const typeMatch = line.match(/(?:export\s+)?type\s+(\w+)\s*=/);
+    if (typeMatch) {
+      symbols.push({
+        name: typeMatch[1], kind: "type", file, line: lineNum,
+        signature: line.trim(),
+        exported: isExported,
+      });
+      continue;
+    }
+
+    // Imports (for dependency tracking)
+    const importMatch = line.match(/import\s+(?:\{([^}]+)\}|(\w+))\s+from\s+['"]([^'"]+)['"]/);
+    if (importMatch) {
+      const names = importMatch[1]
+        ? importMatch[1].split(",").map(s => s.trim().split(" as ")[0].trim())
+        : [importMatch[2]];
+      for (const name of names) {
+        if (name) {
+          symbols.push({
+            name, kind: "import", file, line: lineNum,
+            signature: `from '${importMatch[3]}'`,
+            exported: false,
+          });
+        }
+      }
+      continue;
+    }
+
+    // Exported constants/variables
+    const constMatch = line.match(/export\s+const\s+(\w+)\s*[=:]/);
+    if (constMatch && !arrowMatch) {
+      symbols.push({
+        name: constMatch[1], kind: "variable", file, line: lineNum,
+        signature: line.trim().slice(0, 80),
+        exported: true,
+      });
+    }
+  }
+
+  return symbols;
+}
+
+/** Find all source files in a directory */
+async function findSourceFiles(cwd: string, maxFiles: number = 200): Promise<string[]> {
+  const excludes = ["node_modules", ".git", "dist", "build", ".next", "coverage", "__pycache__"];
+  const excludeArgs = excludes.map(d => `-not -path '*/${d}/*'`).join(" ");
+  const extensions = "\\( -name '*.ts' -o -name '*.tsx' -o -name '*.js' -o -name '*.jsx' \\)";
+  const cmd = `find . ${extensions} ${excludeArgs} -type f 2>/dev/null | head -${maxFiles}`;
+  const output = await exec(cmd, cwd);
+  return output.split("\n").filter(l => l.trim()).map(l => join(cwd, l.trim()));
+}
+
+/** Semantic search: find symbols matching a natural language query */
+export async function semanticSearch(
+  query: string,
+  cwd: string,
+  options: { kinds?: CodeSymbol["kind"][]; exportedOnly?: boolean; maxResults?: number } = {}
+): Promise<SemanticSearchResult> {
+  const { kinds, exportedOnly = false, maxResults = 30 } = options;
+
+  // Find all source files
+  const files = await findSourceFiles(cwd);
+
+  // Extract symbols from all files
+  let allSymbols: CodeSymbol[] = [];
+  for (const file of files) {
+    try {
+      allSymbols.push(...extractSymbols(file));
+    } catch { /* skip unreadable files */ }
+  }
+
+  // Filter by kind
+  if (kinds) {
+    allSymbols = allSymbols.filter(s => kinds.includes(s.kind));
+  }
+
+  // Filter by exported
+  if (exportedOnly) {
+    allSymbols = allSymbols.filter(s => s.exported);
+  }
+
+  // Score each symbol against the query
+  const queryLower = query.toLowerCase();
+  const queryWords = queryLower.split(/\s+/).filter(w => w.length > 2);
+
+  const scored = allSymbols.map(symbol => {
+    let score = 0;
+    const nameLower = symbol.name.toLowerCase();
+    const sigLower = (symbol.signature ?? "").toLowerCase();
+    const fileLower = symbol.file.toLowerCase();
+
+    // Exact name match
+    if (queryWords.some(w => nameLower === w)) score += 10;
+
+    // Name contains query word
+    if (queryWords.some(w => nameLower.includes(w))) score += 5;
+
+    // Signature contains query word
+    if (queryWords.some(w => sigLower.includes(w))) score += 3;
+
+    // File path contains query word
+    if (queryWords.some(w => fileLower.includes(w))) score += 2;
+
+    // Doc contains query word
+    if (symbol.doc && queryWords.some(w => symbol.doc!.toLowerCase().includes(w))) score += 4;
+
+    // Boost exported symbols
+    if (symbol.exported) score += 1;
+
+    // Boost functions/classes over imports
+    if (symbol.kind === "function" || symbol.kind === "class") score += 1;
+
+    // Semantic matching for common patterns
+    if (queryLower.includes("component") && symbol.kind === "component") score += 5;
+    if (queryLower.includes("hook") && symbol.kind === "hook") score += 5;
+    if (queryLower.includes("type") && (symbol.kind === "type" || symbol.kind === "interface")) score += 5;
+    if (queryLower.includes("import") && symbol.kind === "import") score += 5;
+    if (queryLower.includes("class") && symbol.kind === "class") score += 5;
+
+    return { symbol, score };
+  });
+
+  // Sort by score, filter zero scores
+  const results = scored
+    .filter(s => s.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, maxResults)
+    .map(s => s.symbol);
+
+  // Make file paths relative
+  for (const r of results) {
+    if (r.file.startsWith(cwd)) {
+      r.file = "." + r.file.slice(cwd.length);
+    }
+  }
+
+  // Estimate token savings
+  const rawGrep = await exec(`grep -rn '${queryWords[0] ?? query}' . --include='*.ts' --include='*.tsx' 2>/dev/null | head -100`, cwd);
+  const rawTokens = Math.ceil(rawGrep.length / 4);
+  const resultTokens = Math.ceil(JSON.stringify(results).length / 4);
+
+  return {
+    query,
+    symbols: results,
+    totalFiles: files.length,
+    tokensSaved: Math.max(0, rawTokens - resultTokens),
+  };
+}
+
+/** Quick helper: find all exported functions */
+export async function findExports(cwd: string): Promise<CodeSymbol[]> {
+  const result = await semanticSearch("export", cwd, { exportedOnly: true, maxResults: 100 });
+  return result.symbols;
+}
+
+/** Quick helper: find all React components */
+export async function findComponents(cwd: string): Promise<CodeSymbol[]> {
+  const result = await semanticSearch("component", cwd, { kinds: ["component"], maxResults: 50 });
+  return result.symbols;
+}
+
+/** Quick helper: find all hooks */
+export async function findHooks(cwd: string): Promise<CodeSymbol[]> {
+  const result = await semanticSearch("hook", cwd, { kinds: ["hook"], maxResults: 50 });
+  return result.symbols;
+}

package/src/smart-display.test.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect } from "bun:test";
+import { smartDisplay } from "./smart-display.js";
+
+describe("smartDisplay", () => {
+  it("passes through short output unchanged", () => {
+    const lines = ["file1.txt", "file2.txt", "file3.txt"];
+    expect(smartDisplay(lines)).toEqual(lines);
+  });
+
+  it("collapses node_modules paths", () => {
+    const lines = [
+      "./src/app.ts",
+      "./node_modules/foo/index.js",
+      "./node_modules/bar/index.js",
+      "./node_modules/baz/index.js",
+      "./node_modules/qux/index.js",
+      "./node_modules/quux/index.js",
+      "./tests/app.test.ts",
+    ];
+    const result = smartDisplay(lines);
+    expect(result.length).toBeLessThanOrEqual(lines.length);
+    expect(result.some(l => l.includes("node_modules/") && l.includes("matches"))).toBe(true);
+  });
+
+  it("groups files by directory", () => {
+    const lines = [
+      "./src/components/Button.tsx",
+      "./src/components/Modal.tsx",
+      "./src/components/Input.tsx",
+      "./src/components/Select.tsx",
+      "./src/components/Table.tsx",
+      "./src/lib/utils.ts",
+    ];
+    const result = smartDisplay(lines);
+    expect(result.length).toBeLessThan(lines.length);
+  });
+
+  it("detects duplicate filenames across directories", () => {
+    const lines = [
+      "./open-testers/node_modules/zod/.github/logo.png",
+      "./open-attachments/node_modules/zod/.github/logo.png",
+      "./open-terminal/node_modules/zod/.github/logo.png",
+      "./open-emails/node_modules/zod/.github/logo.png",
+      "./src/app.ts",
+      "./tests/app.test.ts",
+    ];
+    const result = smartDisplay(lines);
+    // Should collapse the 4 identical logo.png into one entry
+    expect(result.length).toBeLessThan(lines.length);
+  });
+
+  it("collapses timestamp-like patterns", () => {
+    const lines = [
+      "./screenshots/page-2026-03-09T05-43-19-525Z.png",
+      "./screenshots/page-2026-03-09T05-43-30-441Z.png",
+      "./screenshots/page-2026-03-09T05-48-20-401Z.png",
+      "./screenshots/page-2026-03-09T05-58-25-884Z.png",
+      "./screenshots/page-2026-03-10T05-30-07-086Z.png",
+      "./screenshots/page-2026-03-10T05-32-31-790Z.png",
+      "./screenshots/page-2026-03-10T13-37-04-963Z.png",
+    ];
+    const result = smartDisplay(lines);
+    expect(result.length).toBeLessThan(lines.length);
+    // Should show pattern like page-*.png ×7
+    expect(result.some(l => l.includes("×"))).toBe(true);
+  });
+
+  it("handles the exact user example", () => {
+    const lines = [
+      "./open-testers/node_modules/playwright-core/lib/server/chromium/appIcon.png",
+      "./open-testers/node_modules/zod-to-json-schema/.github/CR_logotype-full-color.png",
+      "./open-attachments/node_modules/zod-to-json-schema/.github/CR_logotype-full-color.png",
+      "./open-attachments/dashboard/src/assets/hero.png",
+      "./open-terminal/node_modules/zod-to-json-schema/.github/CR_logotype-full-color.png",
+      "./open-emails/node_modules/zod-to-json-schema/.github/CR_logotype-full-color.png",
+      "./open-todos/node_modules/zod-to-json-schema/.github/CR_logotype-full-color.png",
+      "./open-todos/.playwright-mcp/page-2026-03-09T05-43-19-525Z.png",
+      "./open-todos/.playwright-mcp/page-2026-03-09T05-43-30-441Z.png",
+      "./open-todos/.playwright-mcp/page-2026-03-09T06-01-53-897Z.png",
+      "./open-todos/.playwright-mcp/page-2026-03-09T05-58-25-884Z.png",
+      "./open-todos/.playwright-mcp/page-2026-03-10T05-30-07-086Z.png",
+      "./open-todos/.playwright-mcp/page-2026-03-09T08-38-38-240Z.png",
+      "./open-todos/.playwright-mcp/page-2026-03-10T13-37-04-963Z.png",
+      "./open-todos/.playwright-mcp/page-2026-03-09T05-40-31-213Z.png",
+      "./open-todos/.playwright-mcp/page-2026-03-10T05-32-31-790Z.png",
+      "./open-todos/.playwright-mcp/page-2026-03-09T08-38-26-591Z.png",
+      "./open-todos/.playwright-mcp/page-2026-03-09T05-48-20-401Z.png",
+      "./open-todos/.playwright-mcp/page-2026-03-09T08-38-16-511Z.png",
+      "./open-todos/.playwright-mcp/page-2026-03-09T05-34-10-009Z.png",
+    ];
+    const result = smartDisplay(lines);
+    console.log("User example output:");
+    for (const line of result) console.log(line);
+    console.log(`\nCompressed: ${lines.length} → ${result.length} lines`);
+    expect(result.length).toBeLessThan(lines.length);
+  });
+});

package/src/smart-display.ts

@@ -0,0 +1,300 @@
+// Smart output display — compress repetitive output into grouped patterns
+
+import { dirname, basename } from "path";
+
+interface GroupedEntry {
+  type: "single" | "pattern" | "duplicate" | "collapsed";
+  display: string;
+}
+
+/** Detect if lines look like file paths */
+function looksLikePaths(lines: string[]): boolean {
+  if (lines.length < 3) return false;
+  const pathLike = lines.filter(l => l.trim().match(/^\.?\//) || l.trim().includes("/"));
+  return pathLike.length > lines.length * 0.6;
+}
+
+/** Find the varying part between similar strings and create a glob pattern */
+function findPattern(items: string[]): string | null {
+  if (items.length < 2) return null;
+  const first = items[0];
+  const last = items[items.length - 1];
+
+  // Find common prefix
+  let prefixLen = 0;
+  while (prefixLen < first.length && prefixLen < last.length && first[prefixLen] === last[prefixLen]) {
+    prefixLen++;
+  }
+
+  // Find common suffix
+  let suffixLen = 0;
+  while (
+    suffixLen < first.length - prefixLen &&
+    suffixLen < last.length - prefixLen &&
+    first[first.length - 1 - suffixLen] === last[last.length - 1 - suffixLen]
+  ) {
+    suffixLen++;
+  }
+
+  const prefix = first.slice(0, prefixLen);
+  const suffix = suffixLen > 0 ? first.slice(-suffixLen) : "";
+
+  if (prefix.length + suffix.length < first.length * 0.3) return null; // too different
+
+  return `${prefix}*${suffix}`;
+}
+
+/** Group file paths by directory */
+function groupByDir(paths: string[]): Map<string, string[]> {
+  const groups = new Map<string, string[]>();
+  for (const p of paths) {
+    const dir = dirname(p.trim());
+    const file = basename(p.trim());
+    if (!groups.has(dir)) groups.set(dir, []);
+    groups.get(dir)!.push(file);
+  }
+  return groups;
+}
+
+/** Detect duplicate filenames across directories */
+function findDuplicates(paths: string[]): Map<string, string[]> {
+  const byName = new Map<string, string[]>();
+  for (const p of paths) {
+    const file = basename(p.trim());
+    if (!byName.has(file)) byName.set(file, []);
+    byName.get(file)!.push(dirname(p.trim()));
+  }
+  // Only return files that appear in 2+ dirs
+  const dupes = new Map<string, string[]>();
+  for (const [file, dirs] of byName) {
+    if (dirs.length >= 2) dupes.set(file, dirs);
+  }
+  return dupes;
+}
+
+/** Collapse node_modules paths */
+function collapseNodeModules(paths: string[]): { nodeModulesPaths: string[]; otherPaths: string[] } {
+  const nodeModulesPaths: string[] = [];
+  const otherPaths: string[] = [];
+  for (const p of paths) {
+    if (p.includes("node_modules")) {
+      nodeModulesPaths.push(p);
+    } else {
+      otherPaths.push(p);
+    }
+  }
+  return { nodeModulesPaths, otherPaths };
+}
+
+/** Smart display: compress file path output into grouped patterns */
+export function smartDisplay(lines: string[]): string[] {
+  if (lines.length <= 5) return lines;
+
+  // Try ls -la table compression first
+  const lsCompressed = compressLsTable(lines);
+  if (lsCompressed) return lsCompressed;
+
+  if (!looksLikePaths(lines)) return compressGeneric(lines);
+
+  const paths = lines.map(l => l.trim()).filter(l => l);
+  const result: string[] = [];
+
+  // Step 1: Separate node_modules
+  const { nodeModulesPaths, otherPaths } = collapseNodeModules(paths);
+
+  // Step 2: Find duplicates in non-node_modules paths
+  const dupes = findDuplicates(otherPaths);
+  const handledPaths = new Set<string>();
+
+  // Show duplicates first
+  for (const [file, dirs] of dupes) {
+    if (dirs.length >= 3) {
+      result.push(`  **/${file}  ×${dirs.length}`);
+      result.push(`    ${dirs.slice(0, 5).join(", ")}${dirs.length > 5 ? ` +${dirs.length - 5} more` : ""}`);
+      for (const d of dirs) {
+        handledPaths.add(`${d}/${file}`);
+      }
+    }
+  }
+
+  // Step 3: Group remaining by directory
+  const remaining = otherPaths.filter(p => !handledPaths.has(p.trim()));
+  const dirGroups = groupByDir(remaining);
+
+  for (const [dir, files] of dirGroups) {
+    if (files.length === 1) {
+      result.push(`  ${dir}/${files[0]}`);
+    } else if (files.length <= 3) {
+      result.push(`  ${dir}/`);
+      for (const f of files) result.push(`    ${f}`);
+    } else {
+      // Try to find a pattern
+      const sorted = files.sort();
+      const pattern = findPattern(sorted);
+      if (pattern) {
+        const dateRange = collapseDateRange(sorted);
+        const rangeStr = dateRange ? ` (${dateRange})` : "";
+        result.push(`  ${dir}/${pattern}  ×${files.length}${rangeStr}`);
+      } else {
+        result.push(`  ${dir}/ (${files.length} files)`);
+        // Show first 2 + count
+        result.push(`    ${sorted[0]}, ${sorted[1]}${files.length > 2 ? `, +${files.length - 2} more` : ""}`);
+      }
+    }
+  }
+
+  // Step 4: Collapsed node_modules summary
+  if (nodeModulesPaths.length > 0) {
+    if (nodeModulesPaths.length <= 2) {
+      for (const p of nodeModulesPaths) result.push(`  ${p}`);
+    } else {
+      // Group node_modules by package name
+      const nmGroups = new Map<string, number>();
+      for (const p of nodeModulesPaths) {
+        // Extract package name from path: ./X/node_modules/PKG/...
+        const match = p.match(/node_modules\/(@[^/]+\/[^/]+|[^/]+)/);
+        const pkg = match ? match[1] : "other";
+        nmGroups.set(pkg, (nmGroups.get(pkg) ?? 0) + 1);
+      }
+      result.push(`  node_modules/ (${nodeModulesPaths.length} matches)`);
+      const topPkgs = [...nmGroups.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3);
+      for (const [pkg, count] of topPkgs) {
+        result.push(`    ${pkg}  ×${count}`);
+      }
+      if (nmGroups.size > 3) {
+        result.push(`    +${nmGroups.size - 3} more packages`);
+      }
+    }
+  }
+
+  return result;
+}
+
+/** Detect date range in timestamps and collapse */
+function collapseDateRange(files: string[]): string | null {
+  const timestamps: Date[] = [];
+  for (const f of files) {
+    const match = f.match(/(\d{4})-(\d{2})-(\d{2})T?(\d{2})?/);
+    if (match) {
+      const [, y, m, d, h] = match;
+      timestamps.push(new Date(`${y}-${m}-${d}T${h ?? "00"}:00:00`));
+    }
+  }
+  if (timestamps.length < 2) return null;
+  timestamps.sort((a, b) => a.getTime() - b.getTime());
+  const first = timestamps[0];
+  const last = timestamps[timestamps.length - 1];
+  const fmt = (d: Date) => `${d.getMonth() + 1}/${d.getDate()}`;
+  if (first.toDateString() === last.toDateString()) {
+    return `${fmt(first)}`;
+  }
+  return `${fmt(first)}–${fmt(last)}`;
+}
+
+/** Detect and compress ls -la style table output */
+function compressLsTable(lines: string[]): string[] | null {
+  // Detect ls -la format: permissions size date name
+  const lsPattern = /^[dlcbps-][rwxsStT-]{9}\s+\d+\s+\S+\s+\S+\s+\S+\s+\w+\s+\d+\s+[\d:]+\s+.+$/;
+  const isLsOutput = lines.filter(l => lsPattern.test(l.trim())).length > lines.length * 0.5;
+  if (!isLsOutput) return null;
+
+  const result: string[] = [];
+  const dirs: string[] = [];
+  const files: { name: string; size: string }[] = [];
+  let totalSize = 0;
+
+  for (const line of lines) {
+    const match = line.trim().match(/^([dlcbps-])[rwxsStT-]{9}\s+\d+\s+\S+\s+\S+\s+(\S+)\s+\w+\s+\d+\s+[\d:]+\s+(.+)$/);
+    if (!match) {
+      if (line.trim().startsWith("total ")) continue;
+      result.push(line);
+      continue;
+    }
+
+    const [, type, sizeStr, name] = match;
+    const size = parseInt(sizeStr) || 0;
+    totalSize += size;
+
+    if (type === "d") {
+      dirs.push(name);
+    } else {
+      files.push({ name, size: formatSize(size) });
+    }
+  }
+
+  // Compact display
+  if (dirs.length > 0) {
+    result.push(`  📁 ${dirs.join("  ")}${dirs.length > 5 ? ` (+${dirs.length - 5} more)` : ""}`);
+  }
+  if (files.length <= 8) {
+    for (const f of files) {
+      result.push(`  ${f.size.padStart(6)}  ${f.name}`);
+    }
+  } else {
+    // Show top 5 by size + count
+    const sorted = files.sort((a, b) => parseSize(b.size) - parseSize(a.size));
+    for (const f of sorted.slice(0, 5)) {
+      result.push(`  ${f.size.padStart(6)}  ${f.name}`);
+    }
+    result.push(`  ... +${files.length - 5} more files (${formatSize(totalSize)} total)`);
+  }
+
+  return result;
+}
+
+function formatSize(bytes: number): string {
+  if (bytes >= 1_000_000) return `${(bytes / 1_000_000).toFixed(1)}M`;
+  if (bytes >= 1_000) return `${(bytes / 1_000).toFixed(1)}K`;
+  return `${bytes}B`;
+}
+
+function parseSize(s: string): number {
+  const match = s.match(/([\d.]+)([BKMG])?/);
+  if (!match) return 0;
+  const n = parseFloat(match[1]);
+  const unit = match[2];
+  if (unit === "K") return n * 1000;
+  if (unit === "M") return n * 1000000;
+  if (unit === "G") return n * 1000000000;
+  return n;
+}
+
+/** Compress non-path generic output by deduplicating similar lines */
+function compressGeneric(lines: string[]): string[] {
+  if (lines.length <= 10) return lines;
+
+  const result: string[] = [];
+  let repeatCount = 0;
+  let lastPattern = "";
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    // Normalize: remove numbers, timestamps, hashes for pattern matching
+    const pattern = line
+      .replace(/\d{4}-\d{2}-\d{2}T[\d:.-]+Z?/g, "TIMESTAMP")
+      .replace(/\b[0-9a-f]{7,40}\b/g, "HASH")
+      .replace(/\b\d+\b/g, "N")
+      .trim();
+
+    if (pattern === lastPattern && i > 0) {
+      repeatCount++;
+    } else {
+      if (repeatCount > 1) {
+        result.push(`  ... ×${repeatCount} similar`);
+      } else if (repeatCount === 1) {
+        result.push(lines[i - 1]);
+      }
+      result.push(line);
+      lastPattern = pattern;
+      repeatCount = 0;
+    }
+  }
+
+  if (repeatCount > 1) {
+    result.push(`  ... ×${repeatCount} similar`);
+  } else if (repeatCount === 1) {
+    result.push(lines[lines.length - 1]);
+  }
+
+  return result;
+}