@hasna/terminal 2.3.1 → 3.0.1

package/dist/tool-profiles.js

@@ -0,0 +1,129 @@
+// Tool profiles — config-driven AI enhancement for specific command categories
+// Profiles are loaded from ~/.terminal/profiles/ (user-customizable)
+// Each profile tells the AI how to handle a specific tool's output
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+const PROFILES_DIR = join(process.env.HOME ?? "~", ".terminal", "profiles");
+/** Built-in profiles — sensible defaults, user can override */
+const BUILTIN_PROFILES = [
+    {
+        name: "git",
+        detect: "^git\\b",
+        hints: {
+            compress: "For git output: show branch, file counts, insertions/deletions summary. Collapse individual diffs to file-level stats.",
+            errors: "Git errors often include a suggested fix (e.g., 'did you mean X?'). Extract the suggestion.",
+            success: "Clean working tree, successful push/pull, merge complete.",
+        },
+        output: { preservePatterns: ["conflict", "CONFLICT", "fatal", "error", "diverged"] },
+    },
+    {
+        name: "test",
+        detect: "\\b(bun|npm|yarn|pnpm)\\s+(test|run\\s+test)|\\bpytest\\b|\\bcargo\\s+test\\b|\\bgo\\s+test\\b",
+        hints: {
+            compress: "For test output: show pass/fail counts FIRST, then list ONLY failing test names with error snippets. Skip passing tests entirely.",
+            errors: "Test failures have: test name, expected vs actual, stack trace. Extract all three.",
+            success: "All tests passing = one line: '✓ N tests pass, 0 fail'",
+        },
+        output: { preservePatterns: ["FAIL", "fail", "Error", "✗", "expected", "received"] },
+    },
+    {
+        name: "build",
+        detect: "\\b(tsc|bun\\s+run\\s+build|npm\\s+run\\s+build|cargo\\s+build|go\\s+build|make)\\b",
+        hints: {
+            compress: "For build output: if success with no errors, say '✓ Build succeeded'. If errors, list each error with file:line and message.",
+            errors: "Build errors have file:line:column format. Group by file.",
+            success: "Empty output or exit 0 = build succeeded.",
+        },
+    },
+    {
+        name: "lint",
+        detect: "\\b(eslint|biome|ruff|clippy|golangci-lint|prettier|tsc\\s+--noEmit)\\b",
+        hints: {
+            compress: "For lint output: group violations by rule name, show count per rule, one example per rule. Skip clean files.",
+            errors: "Lint violations: file:line rule-name message. Group by rule.",
+        },
+        output: { maxLines: 100 },
+    },
+    {
+        name: "install",
+        detect: "\\b(npm\\s+install|bun\\s+install|yarn|pip\\s+install|cargo\\s+build|go\\s+mod)\\b",
+        hints: {
+            compress: "For install output: show only errors and final summary (packages added/removed/updated). Strip progress bars, funding notices, deprecation warnings.",
+        },
+        output: { stripPatterns: ["npm warn", "packages are looking for funding", "run `npm fund`"] },
+    },
+    {
+        name: "find",
+        detect: "^find\\b",
+        hints: {
+            compress: "For find output: if >50 results, group by top-level directory with counts. Show first 10 results as examples.",
+        },
+    },
+    {
+        name: "docker",
+        detect: "\\b(docker|kubectl|helm)\\b",
+        hints: {
+            compress: "For container output: show container status, image, ports. Strip pull progress and layer hashes.",
+            errors: "Docker errors: extract the error message after 'Error response from daemon:'",
+        },
+    },
+];
+/** Load user profiles from ~/.terminal/profiles/ */
+function loadUserProfiles() {
+    if (!existsSync(PROFILES_DIR))
+        return [];
+    const profiles = [];
+    try {
+        for (const file of readdirSync(PROFILES_DIR)) {
+            if (!file.endsWith(".json"))
+                continue;
+            try {
+                const content = JSON.parse(readFileSync(join(PROFILES_DIR, file), "utf8"));
+                if (content.name && content.detect)
+                    profiles.push(content);
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return profiles;
+}
+/** Get all profiles — user profiles override builtins by name (cached 30s) */
+let _cachedProfiles = null;
+let _cachedProfilesAt = 0;
+export function getProfiles() {
+    const now = Date.now();
+    if (_cachedProfiles && now - _cachedProfilesAt < 30_000)
+        return _cachedProfiles;
+    const user = loadUserProfiles();
+    const userNames = new Set(user.map(p => p.name));
+    const builtins = BUILTIN_PROFILES.filter(p => !userNames.has(p.name));
+    _cachedProfiles = [...user, ...builtins];
+    _cachedProfilesAt = now;
+    return _cachedProfiles;
+}
+/** Find the matching profile for a command */
+export function matchProfile(command) {
+    for (const profile of getProfiles()) {
+        try {
+            if (new RegExp(profile.detect).test(command))
+                return profile;
+        }
+        catch { }
+    }
+    return null;
+}
+/** Format profile hints for injection into AI prompt */
+export function formatProfileHints(command) {
+    const profile = matchProfile(command);
+    if (!profile)
+        return "";
+    const lines = [`TOOL PROFILE (${profile.name}):`];
+    if (profile.hints.compress)
+        lines.push(`  Compression: ${profile.hints.compress}`);
+    if (profile.hints.errors)
+        lines.push(`  Errors: ${profile.hints.errors}`);
+    if (profile.hints.success)
+        lines.push(`  Success: ${profile.hints.success}`);
+    return lines.join("\n");
+}

package/dist/tree.js

@@ -0,0 +1,94 @@
+// Tree compression — convert flat file paths to compact tree representation
+import { readdirSync, statSync } from "fs";
+import { join, basename } from "path";
+import { DEFAULT_EXCLUDE_DIRS } from "./search/filters.js";
+/** Build a tree from a directory */
+export function buildTree(dirPath, options = {}) {
+    const { maxDepth = 2, includeHidden = false, depth = 0 } = options;
+    const name = basename(dirPath) || dirPath;
+    const node = { name, type: "dir", children: [], fileCount: 0 };
+    if (depth >= maxDepth) {
+        // Count files without listing them
+        try {
+            const entries = readdirSync(dirPath);
+            node.fileCount = entries.length;
+            node.children = undefined; // don't expand
+        }
+        catch {
+            node.fileCount = 0;
+        }
+        return node;
+    }
+    try {
+        const entries = readdirSync(dirPath);
+        for (const entry of entries) {
+            if (!includeHidden && entry.startsWith("."))
+                continue;
+            if (DEFAULT_EXCLUDE_DIRS.includes(entry)) {
+                // Show as collapsed with count
+                try {
+                    const subPath = join(dirPath, entry);
+                    const subStat = statSync(subPath);
+                    if (subStat.isDirectory()) {
+                        node.children.push({ name: entry, type: "dir", fileCount: -1 }); // -1 = hidden
+                        continue;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            const fullPath = join(dirPath, entry);
+            try {
+                const stat = statSync(fullPath);
+                if (stat.isDirectory()) {
+                    node.children.push(buildTree(fullPath, { maxDepth, includeHidden, depth: depth + 1 }));
+                }
+                else {
+                    node.children.push({ name: entry, type: "file", size: stat.size });
+                    node.fileCount++;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch { }
+    return node;
+}
+/** Render tree as compact string (for agents — minimum tokens) */
+export function compactTree(node, indent = 0) {
+    const pad = "  ".repeat(indent);
+    if (node.type === "file")
+        return `${pad}${node.name}`;
+    if (node.fileCount === -1)
+        return `${pad}${node.name}/ (hidden)`;
+    if (!node.children || node.children.length === 0)
+        return `${pad}${node.name}/ (empty)`;
+    if (!node.children.some(c => c.children)) {
+        // Leaf directory — compact single line
+        const files = node.children.filter(c => c.type === "file").map(c => c.name);
+        const dirs = node.children.filter(c => c.type === "dir");
+        const parts = [];
+        if (files.length <= 5) {
+            parts.push(...files);
+        }
+        else {
+            parts.push(`${files.length} files`);
+        }
+        for (const d of dirs) {
+            parts.push(`${d.name}/${d.fileCount != null ? ` (${d.fileCount === -1 ? "hidden" : d.fileCount + " files"})` : ""}`);
+        }
+        return `${pad}${node.name}/ [${parts.join(", ")}]`;
+    }
+    const lines = [`${pad}${node.name}/`];
+    for (const child of node.children) {
+        lines.push(compactTree(child, indent + 1));
+    }
+    return lines.join("\n");
+}
+/** Render tree as JSON (for MCP) */
+export function treeToJson(node) {
+    return node;
+}

package/dist/usage-cache.js

@@ -0,0 +1,65 @@
+// Usage learning cache — zero-cost repeated queries
+// After 3 identical prompt→command mappings, cache locally
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { createHash } from "crypto";
+const DIR = join(homedir(), ".terminal");
+const CACHE_FILE = join(DIR, "learned.json");
+function ensureDir() {
+    if (!existsSync(DIR))
+        mkdirSync(DIR, { recursive: true });
+}
+function hash(s) {
+    return createHash("md5").update(s).digest("hex").slice(0, 12);
+}
+function cacheKey(prompt) {
+    const projectHash = hash(process.cwd());
+    const promptHash = hash(prompt.toLowerCase().trim());
+    return `${projectHash}:${promptHash}`;
+}
+function loadCache() {
+    ensureDir();
+    if (!existsSync(CACHE_FILE))
+        return {};
+    try {
+        return JSON.parse(readFileSync(CACHE_FILE, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function saveCache(cache) {
+    ensureDir();
+    writeFileSync(CACHE_FILE, JSON.stringify(cache));
+}
+/** Check if we have a learned command for this prompt (3+ identical mappings) */
+export function getLearned(prompt) {
+    const key = cacheKey(prompt);
+    const cache = loadCache();
+    const entry = cache[key];
+    if (entry && entry.count >= 3)
+        return entry.command;
+    return null;
+}
+/** Record a prompt→command mapping */
+export function recordMapping(prompt, command) {
+    const key = cacheKey(prompt);
+    const cache = loadCache();
+    const existing = cache[key];
+    if (existing && existing.command === command) {
+        existing.count++;
+        existing.lastUsed = Date.now();
+    }
+    else {
+        cache[key] = { command, count: 1, lastUsed: Date.now() };
+    }
+    saveCache(cache);
+}
+/** Get cache stats */
+export function learnedStats() {
+    const cache = loadCache();
+    const entries = Object.keys(cache).length;
+    const cached = Object.values(cache).filter(e => e.count >= 3).length;
+    return { entries, cached };
+}

package/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@hasna/terminal",
-  "version": "2.3.1",
+  "version": "3.0.1",
   "description": "Smart terminal wrapper for AI agents and humans — structured output, token compression, MCP server, natural language",
   "type": "module",
+  "files": [
+    "dist/**",
+    "src/**",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
   "bin": {
     "t": "dist/cli.js",
     "terminal": "dist/cli.js"

package/src/ai.ts

@@ -26,16 +26,25 @@ const MODEL_DEFAULTS: Record<string, { fast: string; smart: string }> = {
   anthropic: { fast: "claude-haiku-4-5-20251001",       smart: "claude-sonnet-4-6" },
 };
 
-/** Load user model overrides from ~/.terminal/config.json */
+/** Load user model overrides from ~/.terminal/config.json (cached 30s) */
+let _modelOverrides: Record<string, { fast?: string; smart?: string }> | null = null;
+let _modelOverridesAt = 0;
+
 function loadModelOverrides(): Record<string, { fast?: string; smart?: string }> {
+  const now = Date.now();
+  if (_modelOverrides && now - _modelOverridesAt < 30_000) return _modelOverrides;
   try {
     const configPath = join(process.env.HOME ?? "~", ".terminal", "config.json");
     if (existsSync(configPath)) {
       const config = JSON.parse(readFileSync(configPath, "utf8"));
-      return config.models ?? {};
+      _modelOverrides = config.models ?? {};
+      _modelOverridesAt = now;
+      return _modelOverrides!;
     }
   } catch {}
-  return {};
+  _modelOverrides = {};
+  _modelOverridesAt = now;
+  return _modelOverrides;
 }
 
 /** Model routing per provider — config-driven with defaults */
@@ -148,6 +157,8 @@ function detectProjectContext(): string {
 // ── system prompt ─────────────────────────────────────────────────────────────
 
 function buildSystemPrompt(perms: Permissions, sessionEntries: SessionEntry[], currentPrompt?: string): string {
+  const nl = currentPrompt?.toLowerCase() ?? "";
+
   const restrictions: string[] = [];
   if (!perms.destructive)
     restrictions.push("- NEVER generate commands that delete, remove, or overwrite files/data");
@@ -178,7 +189,6 @@ function buildSystemPrompt(perms: Permissions, sessionEntries: SessionEntry[], c
 
   const projectContext = detectProjectContext();
 
-  // Inject safety hints for the command being generated (AI sees what's risky)
   const safetyBlock = sessionEntries.length > 0
     ? (() => {
         const lastCmd = sessionEntries[sessionEntries.length - 1]?.cmd;
@@ -190,70 +200,32 @@ function buildSystemPrompt(perms: Permissions, sessionEntries: SessionEntry[], c
       })()
     : "";
 
+  // ── Conditional sections (only included when relevant) ──
+  const wantsStructure = /\b(function|class|interface|export|symbol|structure|hierarchy|outline)\b/i.test(nl);
+  const astBlock = wantsStructure ? `\nAST-POWERED QUERIES: For code STRUCTURE questions, use "terminal symbols" instead of grep. It uses AST parsing for TypeScript, Python, Go, Rust.` : "";
+
+  const wantsMultiple = /\b(and|both|also|plus|as well)\b/i.test(nl);
+  const compoundBlock = wantsMultiple ? `\nCOMPOUND QUESTIONS: Prefer ONE command that captures all info. NEVER split into separate expensive commands.` : "";
+
+  const wantsAnalysis = /\b(quality|lint|coverage|complexity|unused|dead code|security|audit|scan|dependency)\b/i.test(nl);
+  const blockedAltBlock = wantsAnalysis ? `\nBLOCKED ALTERNATIVES: If your preferred command needs installing packages, try READ-ONLY alternatives (grep, cat, wc, awk). NEVER give up on analysis questions.` : "";
+
   return `You are a terminal assistant. Output ONLY the exact shell command — no explanation, no markdown, no backticks.
-The user describes what they want in plain English. You translate to the exact shell command.
 
 RULES:
-- SIMPLICITY FIRST: Use the simplest command that works. Prefer grep | sort | head over 10-pipe chains. Complex pipelines are OK when needed, but NEVER pass file:line output to wc or xargs without cleaning it first.
-- ALWAYS use grep -rn (with -r) when searching directories. NEVER use grep without -r on src/ or any directory.
-- When user refers to items from previous output, use the EXACT names shown (e.g., "feature/auth" not "auth", "open-skills" not "open_skills")
-- When user says "the largest/smallest/first/second", look at the previous output to identify the correct item
-- When user says "them all" or "combine them", refer to items from the most recent command output
-- For "show who changed each line" use git blame, for "show remote urls" use git remote -v
-- For text search in code, use grep -rn, NOT nm or objdump (those are for compiled binaries)
-- On macOS: for memory use vm_stat or top -l 1, for disk use df -h, for processes use ps aux
-- macOS uses BSD tools, NOT GNU. Use: du -d 1 (not --max-depth), ls (not ls --color), sort -r (not sort --reverse), ps aux (not ps --sort)
-- NEVER use grep -P (PCRE). macOS grep has NO -P flag. Use grep -E for extended regex, or sed/awk for complex extraction.
-- NEVER invent commands that don't exist. Stick to standard Unix/macOS commands.
-- NEVER install packages (npx, npm install, pip install, brew install). This is a READ-ONLY terminal.
-- NEVER modify source code (sed -i, codemod, awk with redirect). Only observe, never change.
-- Search src/ directory, NOT dist/ or node_modules/ for code queries.
-- Use exact file paths from the project context below. Do NOT guess paths.
-- For "what would break if I deleted X": use grep -rn "from.*X\\|import.*X\\|require.*X" src/ to find all importers.
-- For "find where X is defined": use grep -rn "export.*function X\\|export.*class X\\|export.*const X" src/
-- For "show me the code of function X": if you know the file, use grep -A 30 "function X" src/file.ts. If not, use grep -rn -A 30 "function X" src/ --include="*.ts"
-- ALWAYS use grep -rn (recursive) when searching directories. NEVER use grep without -r on a directory — it will fail.
-- For conceptual questions about what code does: use cat on the relevant file, the AI summary will explain it.
-- For DESTRUCTIVE requests (delete, remove, install, push): output BLOCKED: <reason>. NEVER try to execute destructive commands.
-
-AST-POWERED QUERIES: For code STRUCTURE questions, use the built-in AST tool instead of grep:
-- "find all exported functions" → terminal symbols src/ (lists all functions, classes, interfaces with line numbers)
-- "show all interfaces" → terminal symbols src/ | grep interface
-- "what does file X export" → terminal symbols src/file.ts
-- "show me the class hierarchy" → terminal symbols src/
-The "terminal symbols" command uses AST parsing (not regex) — it understands TypeScript, Python, Go, Rust code structure.
-For TEXT search (TODO, string matches, imports) → use grep as normal.
-
-COMPOUND QUESTIONS: For questions asking multiple things, prefer ONE command that captures all info. Extract multiple answers from a single output.
-- "how many tests and do they pass" → bun test (extract count AND pass/fail from output)
-- "what files changed and how many lines" → git log --stat -3 (shows files AND line counts)
-- "what version of node and bun" → node -v && bun -v (only use && for trivial non-failing commands)
-NEVER split into separate test runs or expensive commands chained with &&.
-
-BLOCKED ALTERNATIVES: If your preferred command would require installing packages (npx, npm install), ALWAYS try a READ-ONLY alternative:
-- Code quality analysis → grep -rn "TODO\\|FIXME\\|HACK\\|XXX" src/
-- Linting → check if "lint" or "typecheck" exists in package.json scripts, run that
-- Security scan → grep -rn "eval\\|exec\\|spawn\\|password\\|secret" src/
-- Dependency audit → cat package.json | grep -A 50 dependencies
-- Test coverage → bun test --coverage (or npm run test:coverage if available)
-NEVER give up. NEVER output BLOCKED for analysis questions. Always try a grep/find/cat/wc/awk read-only alternative.
-- Cyclomatic complexity → grep -rn "if\\|else\\|for\\|while\\|switch\\|case\\|catch\\|&&\\|||" src/ --include="*.ts" | wc -l
-- Unused exports → grep -rn "export function\|export const\|export class" src/ --include="*.ts" | sed 's/.*export [a-z]* //' | sed 's/[(<:].*//' | sort -u
-- Dead code → for each exported name, grep -rn "name" src/ --include="*.ts" | wc -l (if only 1 match = unused)
-- Dependency graph → grep -rn "from " src/ --include="*.ts" | sed 's/:.*from "/→/' | sed 's/".*//' | sort -u
-- Most parameters → grep -rn "function " src/ --include="*.ts" | awk -F'[()]' '{print gsub(/,/,",",$2)+1, $0}' | sort -nr | head -10
-ALWAYS try a heuristic shell approach before giving up. NEVER say BLOCKED for analysis questions.
-
-SEMANTIC MAPPING: When the user references a concept, search the file tree for RELATED terms:
-- Look at directory names: src/agent/ likely contains "agentic" code
-- Look at file names: lazy-executor.ts likely handles "lazy mode"
-- When uncertain: grep -rn "keyword" src/ --include="*.ts" -l (list matching files)
-
-ACTION vs CONCEPTUAL: If the prompt starts with "run", "execute", "check", "test", "build", "show output of" — ALWAYS generate an executable command. NEVER read README for action requests. Only read docs for "explain why", "what does X mean", "how was X designed".
-
-EXISTENCE CHECKS: If the prompt starts with "is there", "does this have", "do we have", "does X exist" — NEVER run/start/launch anything. Use ls, find, or test -d to CHECK existence. These are READ-ONLY questions.
-
-MONOREPO: If the project context says "MONOREPO", search packages/ or apps/ NOT src/. Use: grep -rn "pattern" packages/ --include="*.ts". For specific packages, use packages/PKGNAME/src/.
+- SIMPLICITY FIRST: Use the simplest command. Prefer grep | sort | head over 10-pipe chains.
+- ALWAYS use grep -rn when searching directories. NEVER grep without -r on a directory.
+- When user refers to items from previous output, use EXACT names shown.
+- For text search use grep -rn, NOT nm or objdump.
+- macOS/BSD tools: du -d 1 (not --max-depth), NEVER grep -P, use grep -E for extended regex.
+- NEVER invent commands. Stick to standard Unix/macOS.
+- NEVER install packages. READ-ONLY terminal.
+- NEVER modify source code. Only observe.
+- Search src/ not dist/ or node_modules/.
+- Use exact file paths from project context. Do NOT guess paths.
+- For DESTRUCTIVE requests: output BLOCKED: <reason>.
+- ACTION vs CONCEPTUAL: "run/test/build/check" → executable command. "explain/what does X mean" → read docs.
+- EXISTENCE CHECKS: "is there/does X exist" → use ls/find/test, NEVER run/launch.${astBlock}${compoundBlock}${blockedAltBlock}
 cwd: ${process.cwd()}
 shell: zsh / macOS${projectContext}${safetyBlock}${restrictionBlock}${contextBlock}${currentPrompt ? loadCorrectionHints(currentPrompt) : ""}`;
 }
@@ -280,11 +252,11 @@ export async function translateToCommand(
   let text: string;
 
   if (onToken) {
-    text = await provider.stream(nl, { model, maxTokens: 256, system }, {
+    text = await provider.stream(nl, { model, maxTokens: 256, temperature: 0, stop: ["\n"], system }, {
       onToken: (partial) => onToken(partial),
     });
   } else {
-    text = await provider.complete(nl, { model, maxTokens: 256, system });
+    text = await provider.complete(nl, { model, maxTokens: 256, temperature: 0, stop: ["\n"], system });
   }
 
   if (text.startsWith("BLOCKED:")) throw new Error(text);
@@ -334,6 +306,7 @@ export async function explainCommand(command: string): Promise<string> {
   return provider.complete(command, {
     model: routing.fast,
     maxTokens: 128,
+    temperature: 0,
     system: "Explain what this shell command does in one plain English sentence. No markdown, no code blocks.",
   });
 }
@@ -345,37 +318,34 @@ export async function fixCommand(
   failedCommand: string,
   errorOutput: string,
   perms: Permissions,
-  sessionEntries: SessionEntry[]
+  _sessionEntries: SessionEntry[]
 ): Promise<string> {
   const provider = getProvider();
   const routing = pickModel(originalNl);
+
+  // Lightweight fix prompt — no full project context, just rules + restrictions
+  const restrictions: string[] = [];
+  if (!perms.destructive) restrictions.push("- NEVER delete/remove/overwrite files");
+  if (!perms.network) restrictions.push("- NEVER make network requests");
+  if (!perms.install) restrictions.push("- NEVER install packages");
+
+  const fixSystem = `You are a terminal assistant. Output ONLY the corrected shell command — no explanation.
+macOS/BSD tools. NEVER use grep -P. Use grep -E for extended regex.
+NEVER install packages. READ-ONLY terminal.
+cwd: ${process.cwd()}${restrictions.length > 0 ? `\nRESTRICTIONS:\n${restrictions.join("\n")}` : ""}`;
+
   const text = await provider.complete(
-    `I wanted to: ${originalNl}\nI ran: ${failedCommand}\nError:\n${errorOutput}\n\nGive me the corrected command only.`,
+    `I wanted to: ${originalNl}\nI ran: ${failedCommand}\nError:\n${errorOutput.slice(0, 2000)}\n\nGive me the corrected command only.`,
     {
-      model: routing.smart, // always use smart model for fixes
+      model: routing.smart,
       maxTokens: 256,
-      system: buildSystemPrompt(perms, sessionEntries, originalNl),
+      temperature: 0,
+      stop: ["\n"],
+      system: fixSystem,
     }
   );
   if (text.startsWith("BLOCKED:")) throw new Error(text);
-  return text;
+  return text.trim();
 }
 
-// ── summarize output (for MCP/agent use) ──────────────────────────────────────
-
-export async function summarizeOutput(
-  command: string,
-  output: string,
-  maxTokens: number = 200
-): Promise<string> {
-  const provider = getProvider();
-  const routing = pickModel("summarize");
-  return provider.complete(
-    `Command: ${command}\nOutput:\n${output}\n\nSummarize this output concisely for an AI agent. Focus on: status, key results, errors. Be terse.`,
-    {
-      model: routing.fast,
-      maxTokens,
-      system: "You summarize command output for AI agents. Be extremely concise. Return structured info. No prose.",
-    }
-  );
-}
+// summarizeOutput() removed — all output processing goes through processOutput() in output-processor.ts

package/src/cache.ts

@@ -20,12 +20,13 @@ function persistCache() {
   try { writeFileSync(CACHE_FILE, JSON.stringify(mem)); } catch {}
 }
 
-/** Normalize a natural language query for cache lookup */
+/** Normalize a natural language query for cache lookup.
+ *  Keeps . / - _ which are meaningful in file paths and shell context. */
 export function normalizeNl(nl: string): string {
   return nl
     .toLowerCase()
     .trim()
-    .replace(/[^a-z0-9\s]/g, "")   // strip punctuation
+    .replace(/[^a-z0-9\s.\/_-]/g, "")   // keep meaningful shell chars
     .replace(/\s+/g, " ");
 }
 

package/src/cli.tsx

@@ -446,7 +446,7 @@ else if (args.length > 0) {
   const { rewriteCommand } = await import("./command-rewriter.js");
   const { shouldBeLazy, toLazy } = await import("./lazy-executor.js");
   const { saveOutput, formatOutputHint } = await import("./output-store.js");
-  const { parseOutput, estimateTokens } = await import("./parsers/index.js");
+  const { estimateTokens } = await import("./tokens.js");
   const { recordSaving, recordUsage } = await import("./economy.js");
   const { isTestOutput, trackTests, formatWatchResult } = await import("./test-watchlist.js");
   const { detectLoop } = await import("./loop-detector.js");

package/src/compression.ts

@@ -1,19 +1,18 @@
 // Token compression engine — reduces CLI output to fit within token budgets
+// No regex parsing — just ANSI stripping, deduplication, and smart truncation.
+// All intelligent output processing goes through AI via processOutput().
 
-import { parseOutput, estimateTokens, tokenSavings } from "./parsers/index.js";
+import { estimateTokens } from "./tokens.js";
 
 export interface CompressOptions {
   /** Max tokens for the output (default: unlimited) */
   maxTokens?: number;
-  /** Output format */
-  format?: "text" | "json" | "summary";
   /** Strip ANSI escape codes (default: true) */
   stripAnsi?: boolean;
 }
 
 export interface CompressedOutput {
   content: string;
-  format: "text" | "json" | "summary";
   originalTokens: number;
   compressedTokens: number;
   tokensSaved: number;
@@ -36,7 +35,6 @@ function deduplicateLines(lines: string[]): string[] {
 
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
-    // Extract a "pattern" — the line without numbers, paths, specific identifiers
     const pattern = line.replace(/[0-9]+/g, "N").replace(/\/\S+/g, "/PATH").replace(/\s+/g, " ").trim();
 
     if (pattern === repeatPattern) {
@@ -45,7 +43,6 @@ function deduplicateLines(lines: string[]): string[] {
       if (repeatCount > 2) {
         result.push(`  ... (${repeatCount} similar lines)`);
       } else if (repeatCount > 0) {
-        // Push the skipped lines back
         for (let j = i - repeatCount; j < i; j++) {
           result.push(lines[j]);
         }
@@ -67,14 +64,13 @@ function deduplicateLines(lines: string[]): string[] {
   return result;
 }
 
-/** Smart truncation: keep first N + last M lines */
+/** Smart truncation: keep first 60% + last 40% of lines */
 function smartTruncate(text: string, maxTokens: number): string {
   const lines = text.split("\n");
   const currentTokens = estimateTokens(text);
 
   if (currentTokens <= maxTokens) return text;
 
-  // Keep proportional first/last, with first getting more
   const targetLines = Math.floor((maxTokens * lines.length) / currentTokens);
   const firstCount = Math.ceil(targetLines * 0.6);
   const lastCount = Math.floor(targetLines * 0.4);
@@ -88,42 +84,20 @@ function smartTruncate(text: string, maxTokens: number): string {
   return [...first, `\n--- ${hiddenCount} lines hidden ---\n`, ...last].join("\n");
 }
 
-/** Compress command output to fit within a token budget */
+/** Compress command output — ANSI strip, dedup, truncate. No parsing. */
 export function compress(command: string, output: string, options: CompressOptions = {}): CompressedOutput {
-  const { maxTokens, format = "text", stripAnsi: doStrip = true } = options;
+  const { maxTokens, stripAnsi: doStrip = true } = options;
   const originalTokens = estimateTokens(output);
 
   // Step 1: Strip ANSI codes
   let text = doStrip ? stripAnsi(output) : output;
 
-  // Step 2: Try structured parsing (format=json or when it saves tokens)
-  if (format === "json" || format === "summary") {
-    const parsed = parseOutput(command, text);
-    if (parsed) {
-      const json = JSON.stringify(parsed.data, null, format === "summary" ? 0 : 2);
-      const savings = tokenSavings(output, parsed.data);
-      const compressedTokens = estimateTokens(json);
-
-      // ONLY use JSON if it actually saves tokens (never return larger output)
-      if (savings.saved > 0 && (!maxTokens || compressedTokens <= maxTokens)) {
-        return {
-          content: json,
-          format: "json",
-          originalTokens,
-          compressedTokens,
-          tokensSaved: savings.saved,
-          savingsPercent: savings.percent,
-        };
-      }
-    }
-  }
-
-  // Step 3: Deduplicate similar lines
+  // Step 2: Deduplicate similar lines
   const lines = text.split("\n");
   const deduped = deduplicateLines(lines);
   text = deduped.join("\n");
 
-  // Step 4: Smart truncation if over budget
+  // Step 3: Smart truncation if over budget
   if (maxTokens) {
     text = smartTruncate(text, maxTokens);
   }
@@ -131,7 +105,6 @@ export function compress(command: string, output: string, options: CompressOptio
   const compressedTokens = estimateTokens(text);
   return {
     content: text,
-    format: "text",
     originalTokens,
     compressedTokens,
     tokensSaved: Math.max(0, originalTokens - compressedTokens),