@hasna/terminal 2.3.0 → 2.3.1

package/dist/cli.js

@@ -361,17 +361,52 @@ else if (args[0] === "repo") {
 else if (args[0] === "symbols" && args[1]) {
     const { extractSymbolsFromFile } = await import("./search/semantic.js");
     const { resolve } = await import("path");
-    const filePath = resolve(args[1]);
-    const symbols = extractSymbolsFromFile(filePath);
-    if (symbols.length === 0) {
-        console.log("No symbols found.");
+    const { statSync, readdirSync } = await import("fs");
+    const target = resolve(args[1]);
+    const filter = args[2]; // optional: grep-like filter on symbol name
+    // Support directories — recurse and extract symbols from all source files
+    const files = [];
+    try {
+        if (statSync(target).isDirectory()) {
+            const walk = (dir) => {
+                for (const entry of readdirSync(dir, { withFileTypes: true })) {
+                    if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist")
+                        continue;
+                    const full = resolve(dir, entry.name);
+                    if (entry.isDirectory())
+                        walk(full);
+                    else if (/\.(ts|tsx|py|go|rs)$/.test(entry.name) && !/\.(test|spec)\.\w+$/.test(entry.name))
+                        files.push(full);
+                }
+            };
+            walk(target);
+        }
+        else {
+            files.push(target);
+        }
     }
-    else {
-        for (const s of symbols) {
+    catch {
+        files.push(target);
+    }
+    let totalSymbols = 0;
+    for (const file of files) {
+        const symbols = extractSymbolsFromFile(file);
+        const filtered = filter ? symbols.filter(s => s.name.toLowerCase().includes(filter.toLowerCase()) || s.kind.toLowerCase().includes(filter.toLowerCase())) : symbols;
+        if (filtered.length === 0)
+            continue;
+        const relPath = file.replace(process.cwd() + "/", "");
+        if (files.length > 1)
+            console.log(`\n${relPath}:`);
+        for (const s of filtered) {
             const exp = s.exported ? "⬡" : "·";
             console.log(`  ${exp} ${s.kind.padEnd(10)} L${String(s.line).padStart(4)}  ${s.name}`);
         }
+        totalSymbols += filtered.length;
     }
+    if (totalSymbols === 0)
+        console.log("No symbols found.");
+    else if (files.length > 1)
+        console.log(`\n${totalSymbols} symbols across ${files.length} files`);
 }
 // ── History command ──────────────────────────────────────────────────────────
 else if (args[0] === "history") {
@@ -621,7 +656,7 @@ else if (args.length > 0) {
     catch (e) {
         // Empty result (grep exit 1 = no matches) — not a real error
         const errStdout = e.stdout?.toString() ?? "";
-        const errStderr = e.stderr?.toString() ?? "";
+        let errStderr = e.stderr?.toString() ?? "";
         if (e.status === 1 && !errStdout.trim() && !errStderr.trim()) {
             // Empty result — retry with broader scope before giving up
             if (!actualCmd.includes("#(broadened)")) {
@@ -643,24 +678,37 @@ else if (args.length > 0) {
             console.log(`No results found for: ${prompt}`);
             process.exit(0);
         }
-        // Auto-retry: if command failed (exit 2+), ask AI for a simpler alternative
-        if (e.status >= 2 && !actualCmd.includes("(retry)")) {
-            try {
-                const retryCmd = await translateToCommand(`${prompt} (The previous command failed with: ${errStderr.slice(0, 200)}. Try a SIMPLER approach. Use basic commands only.)`, perms, []);
-                if (retryCmd && !isIrreversible(retryCmd) && !checkPermissions(retryCmd, perms)) {
-                    console.error(`[open-terminal] retrying: $ ${retryCmd}`);
-                    const retryResult = execSync(retryCmd + " #(retry)", { encoding: "utf8", maxBuffer: 10 * 1024 * 1024, cwd: process.cwd() });
+        // 3-retry learning loop: each attempt learns from the previous failure
+        if (e.status >= 2) {
+            const retryStrategies = [
+                // Attempt 2: inject error context
+                `${prompt} (Command "${actualCmd}" failed with: ${errStderr.slice(0, 300)}. Fix this specific error. Keep the approach but correct the issue.)`,
+                // Attempt 3: inject corrections + force simplicity
+                `${prompt} (TWO commands already failed for this query. Use the ABSOLUTE SIMPLEST approach: basic grep -rn, find, wc -l, cat. No awk, no xargs, no subshells. Must work on macOS BSD.)`,
+            ];
+            for (let attempt = 0; attempt < retryStrategies.length; attempt++) {
+                try {
+                    const retryCmd = await translateToCommand(retryStrategies[attempt], perms, []);
+                    if (!retryCmd || retryCmd === actualCmd || isIrreversible(retryCmd) || checkPermissions(retryCmd, perms))
+                        continue;
+                    console.error(`[open-terminal] retry ${attempt + 2}/3: $ ${retryCmd}`);
+                    const retryResult = execSync(retryCmd + ` #(retry${attempt + 2})`, { encoding: "utf8", maxBuffer: 10 * 1024 * 1024, cwd: process.cwd() });
                     const retryClean = stripNoise(stripAnsi(retryResult)).cleaned;
                     if (retryClean.length > 5) {
-                        // Record the correction so we learn from it
+                        // Record correction — AI learns for next time
                         recordCorrection(prompt, actualCmd, errStderr.slice(0, 500), retryCmd, true);
                         const processed = await processOutput(retryCmd, retryClean, prompt);
                         console.log(processed.aiProcessed ? processed.summary : retryClean);
                         process.exit(0);
                     }
                 }
+                catch (retryErr) {
+                    // This attempt also failed — record it and try next strategy
+                    const retryStderr = retryErr.stderr?.toString() ?? "";
+                    errStderr = retryStderr; // update for next attempt's context
+                    continue;
+                }
             }
-            catch { /* retry also failed, fall through */ }
         }
         // Combine stdout+stderr and try AI answer framing (for audit/lint/test commands)
         const combined = errStderr && errStdout.includes(errStderr.trim()) ? errStdout : errStdout + errStderr;

package/package.json

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

package/src/ai.ts

@@ -216,6 +216,14 @@ RULES:
 - 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)

package/src/cli.tsx

@@ -335,15 +335,43 @@ else if (args[0] === "repo") {
 else if (args[0] === "symbols" && args[1]) {
   const { extractSymbolsFromFile } = await import("./search/semantic.js");
   const { resolve } = await import("path");
-  const filePath = resolve(args[1]);
-  const symbols = extractSymbolsFromFile(filePath);
-  if (symbols.length === 0) { console.log("No symbols found."); }
-  else {
-    for (const s of symbols) {
+  const { statSync, readdirSync } = await import("fs");
+  const target = resolve(args[1]);
+  const filter = args[2]; // optional: grep-like filter on symbol name
+
+  // Support directories — recurse and extract symbols from all source files
+  const files: string[] = [];
+  try {
+    if (statSync(target).isDirectory()) {
+      const walk = (dir: string) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+          if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist") continue;
+          const full = resolve(dir, entry.name);
+          if (entry.isDirectory()) walk(full);
+          else if (/\.(ts|tsx|py|go|rs)$/.test(entry.name) && !/\.(test|spec)\.\w+$/.test(entry.name)) files.push(full);
+        }
+      };
+      walk(target);
+    } else {
+      files.push(target);
+    }
+  } catch { files.push(target); }
+
+  let totalSymbols = 0;
+  for (const file of files) {
+    const symbols = extractSymbolsFromFile(file);
+    const filtered = filter ? symbols.filter(s => s.name.toLowerCase().includes(filter.toLowerCase()) || s.kind.toLowerCase().includes(filter.toLowerCase())) : symbols;
+    if (filtered.length === 0) continue;
+    const relPath = file.replace(process.cwd() + "/", "");
+    if (files.length > 1) console.log(`\n${relPath}:`);
+    for (const s of filtered) {
       const exp = s.exported ? "⬡" : "·";
       console.log(`  ${exp} ${s.kind.padEnd(10)} L${String(s.line).padStart(4)}  ${s.name}`);
     }
+    totalSymbols += filtered.length;
   }
+  if (totalSymbols === 0) console.log("No symbols found.");
+  else if (files.length > 1) console.log(`\n${totalSymbols} symbols across ${files.length} files`);
 }
 
 // ── History command ──────────────────────────────────────────────────────────
@@ -603,7 +631,7 @@ else if (args.length > 0) {
   } catch (e: any) {
     // Empty result (grep exit 1 = no matches) — not a real error
     const errStdout = e.stdout?.toString() ?? "";
-    const errStderr = e.stderr?.toString() ?? "";
+    let errStderr = e.stderr?.toString() ?? "";
     if (e.status === 1 && !errStdout.trim() && !errStderr.trim()) {
       // Empty result — retry with broader scope before giving up
       if (!actualCmd.includes("#(broadened)")) {
@@ -628,26 +656,37 @@ else if (args.length > 0) {
       process.exit(0);
     }
 
-    // Auto-retry: if command failed (exit 2+), ask AI for a simpler alternative
-    if (e.status >= 2 && !actualCmd.includes("(retry)")) {
-      try {
-        const retryCmd = await translateToCommand(
-          `${prompt} (The previous command failed with: ${errStderr.slice(0, 200)}. Try a SIMPLER approach. Use basic commands only.)`,
-          perms, []
-        );
-        if (retryCmd && !isIrreversible(retryCmd) && !checkPermissions(retryCmd, perms)) {
-          console.error(`[open-terminal] retrying: $ ${retryCmd}`);
-          const retryResult = execSync(retryCmd + " #(retry)", { encoding: "utf8", maxBuffer: 10 * 1024 * 1024, cwd: process.cwd() });
+    // 3-retry learning loop: each attempt learns from the previous failure
+    if (e.status >= 2) {
+      const retryStrategies = [
+        // Attempt 2: inject error context
+        `${prompt} (Command "${actualCmd}" failed with: ${errStderr.slice(0, 300)}. Fix this specific error. Keep the approach but correct the issue.)`,
+        // Attempt 3: inject corrections + force simplicity
+        `${prompt} (TWO commands already failed for this query. Use the ABSOLUTE SIMPLEST approach: basic grep -rn, find, wc -l, cat. No awk, no xargs, no subshells. Must work on macOS BSD.)`,
+      ];
+
+      for (let attempt = 0; attempt < retryStrategies.length; attempt++) {
+        try {
+          const retryCmd = await translateToCommand(retryStrategies[attempt], perms, []);
+          if (!retryCmd || retryCmd === actualCmd || isIrreversible(retryCmd) || checkPermissions(retryCmd, perms)) continue;
+
+          console.error(`[open-terminal] retry ${attempt + 2}/3: $ ${retryCmd}`);
+          const retryResult = execSync(retryCmd + ` #(retry${attempt + 2})`, { encoding: "utf8", maxBuffer: 10 * 1024 * 1024, cwd: process.cwd() });
           const retryClean = stripNoise(stripAnsi(retryResult)).cleaned;
           if (retryClean.length > 5) {
-            // Record the correction so we learn from it
+            // Record correction — AI learns for next time
             recordCorrection(prompt, actualCmd, errStderr.slice(0, 500), retryCmd, true);
             const processed = await processOutput(retryCmd, retryClean, prompt);
             console.log(processed.aiProcessed ? processed.summary : retryClean);
             process.exit(0);
           }
+        } catch (retryErr: any) {
+          // This attempt also failed — record it and try next strategy
+          const retryStderr = retryErr.stderr?.toString() ?? "";
+          errStderr = retryStderr; // update for next attempt's context
+          continue;
         }
-      } catch { /* retry also failed, fall through */ }
+      }
     }
 
     // Combine stdout+stderr and try AI answer framing (for audit/lint/test commands)

package/src/output-processor.ts

@@ -5,6 +5,7 @@ import { getProvider } from "./providers/index.js";
 import { estimateTokens } from "./parsers/index.js";
 import { recordSaving } from "./economy.js";
 import { discoverOutputHints } from "./context-hints.js";
+import { formatProfileHints } from "./tool-profiles.js";
 
 export interface ProcessedOutput {
   /** AI-generated summary (concise, structured) */
@@ -86,9 +87,13 @@ export async function processOutput(
       ? `\n\nOUTPUT OBSERVATIONS:\n${outputHints.join("\n")}`
       : "";
 
+    // Inject tool-specific profile hints
+    const profileBlock = formatProfileHints(command);
+    const profileHints = profileBlock ? `\n\n${profileBlock}` : "";
+
     const provider = getProvider();
     const summary = await provider.complete(
-      `${originalPrompt ? `User asked: ${originalPrompt}\n` : ""}Command: ${command}\nOutput (${lines.length} lines):\n${toSummarize}${hintsBlock}`,
+      `${originalPrompt ? `User asked: ${originalPrompt}\n` : ""}Command: ${command}\nOutput (${lines.length} lines):\n${toSummarize}${hintsBlock}${profileHints}`,
       {
         system: SUMMARIZE_PROMPT,
         maxTokens: 300,

package/src/output-store.ts

@@ -1,13 +1,11 @@
 // Output store — saves full raw output to disk when AI compresses it
-// Agents can read the file for full detail. Rotates to cap disk usage.
+// Agents can read the file for full detail. Tiered retention strategy.
 
 import { existsSync, mkdirSync, writeFileSync, readdirSync, statSync, unlinkSync } from "fs";
 import { join } from "path";
 import { createHash } from "crypto";
 
 const OUTPUTS_DIR = join(process.env.HOME ?? "~", ".terminal", "outputs");
-const MAX_FILES = 50;
-const MAX_TOTAL_SIZE = 5 * 1024 * 1024; // 5MB
 
 /** Ensure outputs directory exists */
 function ensureDir() {
@@ -19,19 +17,59 @@ function hashOutput(command: string, output: string): string {
   return createHash("md5").update(command + output.slice(0, 1000)).digest("hex").slice(0, 12);
 }
 
-/** Rotate old files to stay within limits */
+/** Tiered retention: recent = keep all, older = keep only high-value */
 function rotate() {
   try {
+    const now = Date.now();
+    const ONE_HOUR = 60 * 60 * 1000;
+    const ONE_DAY = 24 * ONE_HOUR;
+
     const files = readdirSync(OUTPUTS_DIR)
-      .map(f => ({ name: f, path: join(OUTPUTS_DIR, f), mtime: statSync(join(OUTPUTS_DIR, f)).mtimeMs, size: statSync(join(OUTPUTS_DIR, f)).size }))
+      .filter(f => f.endsWith(".txt"))
+      .map(f => {
+        const path = join(OUTPUTS_DIR, f);
+        const stat = statSync(path);
+        return { name: f, path, mtime: stat.mtimeMs, size: stat.size };
+      })
       .sort((a, b) => b.mtime - a.mtime); // newest first
 
-    // Remove excess files
+    for (const file of files) {
+      const age = now - file.mtime;
+
+      // Last 1 hour: keep everything
+      if (age < ONE_HOUR) continue;
+
+      // Last 24 hours: keep outputs >2KB (meaningful compression)
+      if (age < ONE_DAY) {
+        if (file.size < 2000) {
+          try { unlinkSync(file.path); } catch {}
+        }
+        continue;
+      }
+
+      // Older than 24h: keep only >10KB (high-value saves)
+      if (file.size < 10000) {
+        try { unlinkSync(file.path); } catch {}
+        continue;
+      }
+
+      // Older than 7 days: remove everything
+      if (age > 7 * ONE_DAY) {
+        try { unlinkSync(file.path); } catch {}
+      }
+    }
+
+    // Hard cap: never exceed 100 files or 10MB total
+    const remaining = readdirSync(OUTPUTS_DIR)
+      .filter(f => f.endsWith(".txt"))
+      .map(f => ({ path: join(OUTPUTS_DIR, f), mtime: statSync(join(OUTPUTS_DIR, f)).mtimeMs, size: statSync(join(OUTPUTS_DIR, f)).size }))
+      .sort((a, b) => b.mtime - a.mtime);
+
     let totalSize = 0;
-    for (let i = 0; i < files.length; i++) {
-      totalSize += files[i].size;
-      if (i >= MAX_FILES || totalSize > MAX_TOTAL_SIZE) {
-        try { unlinkSync(files[i].path); } catch {}
+    for (let i = 0; i < remaining.length; i++) {
+      totalSize += remaining[i].size;
+      if (i >= 100 || totalSize > 10 * 1024 * 1024) {
+        try { unlinkSync(remaining[i].path); } catch {}
       }
     }
   } catch {}
@@ -45,12 +83,10 @@ export function saveOutput(command: string, rawOutput: string): string {
   const filename = `${hash}.txt`;
   const filepath = join(OUTPUTS_DIR, filename);
 
-  // Write with command header
   const content = `$ ${command}\n${"─".repeat(60)}\n${rawOutput}`;
   writeFileSync(filepath, content, "utf8");
 
   rotate();
-
   return filepath;
 }
 
@@ -63,3 +99,13 @@ export function formatOutputHint(filepath: string): string {
 export function getOutputsDir(): string {
   return OUTPUTS_DIR;
 }
+
+/** Manually purge all outputs */
+export function purgeOutputs(): number {
+  if (!existsSync(OUTPUTS_DIR)) return 0;
+  let count = 0;
+  for (const f of readdirSync(OUTPUTS_DIR)) {
+    try { unlinkSync(join(OUTPUTS_DIR, f)); count++; } catch {}
+  }
+  return count;
+}

package/src/tool-profiles.ts

@@ -0,0 +1,139 @@
+// 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";
+
+export interface ToolProfile {
+  name: string;
+  /** Regex pattern to detect this tool in a command */
+  detect: string;
+  /** Hints injected into the AI output processor prompt */
+  hints: {
+    compress?: string;   // How to compress this tool's output
+    errors?: string;     // How to extract errors from this tool
+    success?: string;    // What success looks like
+  };
+  /** Output handling */
+  output?: {
+    maxLines?: number;        // Cap output before AI processing
+    preservePatterns?: string[]; // Regex patterns to always keep
+    stripPatterns?: string[];    // Regex patterns to always remove
+  };
+}
+
+const PROFILES_DIR = join(process.env.HOME ?? "~", ".terminal", "profiles");
+
+/** Built-in profiles — sensible defaults, user can override */
+const BUILTIN_PROFILES: ToolProfile[] = [
+  {
+    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(): ToolProfile[] {
+  if (!existsSync(PROFILES_DIR)) return [];
+
+  const profiles: ToolProfile[] = [];
+  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 as ToolProfile);
+      } catch {}
+    }
+  } catch {}
+  return profiles;
+}
+
+/** Get all profiles — user profiles override builtins by name */
+export function getProfiles(): ToolProfile[] {
+  const user = loadUserProfiles();
+  const userNames = new Set(user.map(p => p.name));
+  const builtins = BUILTIN_PROFILES.filter(p => !userNames.has(p.name));
+  return [...user, ...builtins];
+}
+
+/** Find the matching profile for a command */
+export function matchProfile(command: string): ToolProfile | null {
+  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: string): string {
+  const profile = matchProfile(command);
+  if (!profile) return "";
+
+  const lines: string[] = [`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");
+}