@hasna/terminal 2.0.5 → 2.2.0

package/dist/cli.js

@@ -41,7 +41,9 @@ MCP TOOLS (20+):
   snapshot, token_stats, session_history
 
 ENVIRONMENT:
-  CEREBRAS_API_KEY             Cerebras API key (free, open-source default)
+  XAI_API_KEY                  xAI API key (Grok, code-optimized — default)
+  CEREBRAS_API_KEY             Cerebras API key (free, open-source)
+  GROQ_API_KEY                 Groq API key (free, ultra-fast inference)
   ANTHROPIC_API_KEY            Anthropic API key (Claude models)
 `);
     process.exit(0);
@@ -397,7 +399,7 @@ else if (args[0] === "history") {
 // ── Explain command ─────────────────────────────────────────────────────────
 else if (args[0] === "explain" && args[1]) {
     const command = args.slice(1).join(" ");
-    if (!process.env.ANTHROPIC_API_KEY && !process.env.CEREBRAS_API_KEY) {
+    if (!process.env.ANTHROPIC_API_KEY && !process.env.CEREBRAS_API_KEY && !process.env.GROQ_API_KEY && !process.env.XAI_API_KEY) {
         console.error("explain requires an API key");
         process.exit(1);
     }
@@ -420,7 +422,7 @@ else if (args[0] === "project" && args[1] === "init") {
 else if (args.length > 0) {
     // Everything that doesn't match a subcommand is treated as natural language
     const prompt = args.join(" ");
-    const offlineMode = !process.env.ANTHROPIC_API_KEY && !process.env.CEREBRAS_API_KEY;
+    const offlineMode = !process.env.ANTHROPIC_API_KEY && !process.env.CEREBRAS_API_KEY && !process.env.GROQ_API_KEY && !process.env.XAI_API_KEY;
     const { translateToCommand, checkPermissions, isIrreversible } = await import("./ai.js");
     const { execSync } = await import("child_process");
     const { compress, stripAnsi } = await import("./compression.js");
@@ -477,9 +479,10 @@ else if (args.length > 0) {
                     catch { }
                 }
             }
-            // "I don't know" honesty — better than wrong answer
+            // Show the block reason clearly
             if (e.message?.startsWith("BLOCKED:")) {
-                console.log(`I don't know how to do this with shell commands. Try running it directly.`);
+                console.log(`⚠ ${e.message}`);
+                console.log(`  This is a READ-ONLY terminal. Run directly in your shell if you're sure.`);
             }
             else {
                 console.error(e.message);
@@ -525,13 +528,22 @@ else if (args.length > 0) {
         // Auto-retry: re-translate with simpler constraints
         console.error(`[open-terminal] invalid command detected: ${validation.issues.join(", ")}`);
         try {
-            const retryCommand = await translateToCommand(`${prompt} (IMPORTANT: keep it simple. Use basic grep/find/cat/ls/wc commands. No complex awk/sed pipelines. No GNU flags. Verify file paths from the project context.)`, perms, []);
+            const retryCommand = await translateToCommand(`${prompt} (Previous command had issues: ${validation.issues.join(", ")}. Fix those specific issues. Keep the approach but correct the errors.)`, perms, []);
             if (retryCommand && retryCommand !== command) {
                 const retryValidation = validateCommand(retryCommand, process.cwd());
                 if (retryValidation.valid || retryValidation.issues.length < validation.issues.length) {
                     command = retryCommand;
                     console.error(`[open-terminal] retried: $ ${command}`);
                 }
+                else {
+                    // Retry also invalid — use the simpler of the two
+                    const retryPipes = (retryCommand.match(/\|/g) || []).length;
+                    const origPipes = (command.match(/\|/g) || []).length;
+                    if (retryPipes < origPipes) {
+                        command = retryCommand;
+                        console.error(`[open-terminal] retried (simpler): $ ${command}`);
+                    }
+                }
             }
         }
         catch { }
@@ -652,11 +664,13 @@ else if (args.length > 0) {
 }
 // ── TUI mode (no args) ──────────────────────────────────────────────────────
 else {
-    if (!process.env.ANTHROPIC_API_KEY && !process.env.CEREBRAS_API_KEY) {
+    if (!process.env.ANTHROPIC_API_KEY && !process.env.CEREBRAS_API_KEY && !process.env.GROQ_API_KEY && !process.env.XAI_API_KEY) {
         console.error("terminal: No API key found.");
         console.error("Set one of:");
-        console.error("  export CEREBRAS_API_KEY=your_key  (free, open-source)");
-        console.error("  export ANTHROPIC_API_KEY=your_key  (Claude)");
+        console.error("  export XAI_API_KEY=your_key        (Grok, code-optimized — default)");
+        console.error("  export CEREBRAS_API_KEY=your_key   (free, open-source)");
+        console.error("  export GROQ_API_KEY=your_key       (free, ultra-fast)");
+        console.error("  export ANTHROPIC_API_KEY=your_key   (Claude)");
         process.exit(1);
     }
     const App = (await import("./App.js")).default;

package/package.json

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

package/src/ai.ts

@@ -3,6 +3,7 @@ import { cacheGet, cacheSet } from "./cache.js";
 import { getProvider } from "./providers/index.js";
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";
+import { discoverProjectHints, discoverSafetyHints, formatHints } from "./context-hints.js";
 
 // ── model routing ─────────────────────────────────────────────────────────────
 // Simple queries → fast model. Complex/ambiguous → smart model.
@@ -30,6 +31,22 @@ function pickModel(nl: string): { fast: string; smart: string; pick: "fast" | "s
     };
   }
 
+  if (provider.name === "groq") {
+    return {
+      fast: "openai/gpt-oss-120b",
+      smart: "moonshotai/kimi-k2-instruct",
+      pick: isComplex ? "smart" : "fast",
+    };
+  }
+
+  if (provider.name === "xai") {
+    return {
+      fast: "grok-code-fast-1",
+      smart: "grok-4-fast-non-reasoning",
+      pick: isComplex ? "smart" : "fast",
+    };
+  }
+
   // Cerebras — qwen for everything (llama3.1-8b too unreliable)
   return {
     fast: "qwen-3-235b-a22b-instruct-2507",
@@ -107,118 +124,11 @@ export interface SessionEntry {
   error?: boolean;
 }
 
-// ── project context ──────────────────────────────────────────────────────────
+// ── project context (powered by context-hints) ──────────────────────────────
 
 function detectProjectContext(): string {
-  const cwd = process.cwd();
-  const parts: string[] = [];
-
-  // Node.js / TypeScript
-  const pkgPath = join(cwd, "package.json");
-  if (existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-      parts.push(`Project: ${pkg.name}@${pkg.version} (Node.js/TypeScript)`);
-      parts.push(`npm package: ${pkg.name} (use this name for npm view, npm info, etc.)`);
-      if (pkg.scripts) {
-        const scripts = Object.entries(pkg.scripts).map(([k, v]) => `${k}: ${v}`).slice(0, 8);
-        parts.push(`Available scripts: ${scripts.join(", ")}`);
-      }
-      if (pkg.dependencies) parts.push(`Dependencies: ${Object.keys(pkg.dependencies).join(", ")}`);
-      parts.push(`Use npm/bun/pnpm commands, NOT maven/gradle/cargo.`);
-    } catch {}
-  }
-
-  // Python
-  if (existsSync(join(cwd, "pyproject.toml"))) {
-    try {
-      const pyproject = readFileSync(join(cwd, "pyproject.toml"), "utf8");
-      const nameMatch = pyproject.match(/name\s*=\s*"([^"]+)"/);
-      const versionMatch = pyproject.match(/version\s*=\s*"([^"]+)"/);
-      parts.push(`Project: ${nameMatch?.[1] ?? "Python"}${versionMatch ? `@${versionMatch[1]}` : ""} (Python)`);
-    } catch { parts.push("Project: Python (pyproject.toml found)"); }
-    parts.push("Use pip/python/pytest commands. Test: pytest. Build: python -m build.");
-  } else if (existsSync(join(cwd, "requirements.txt"))) {
-    parts.push("Project: Python (requirements.txt). Use pip/python/pytest commands.");
-  }
-
-  // Go
-  if (existsSync(join(cwd, "go.mod"))) {
-    try {
-      const gomod = readFileSync(join(cwd, "go.mod"), "utf8");
-      const moduleMatch = gomod.match(/module\s+(\S+)/);
-      parts.push(`Project: ${moduleMatch?.[1] ?? "Go"} (Go module)`);
-    } catch { parts.push("Project: Go (go.mod found)"); }
-    parts.push("Use go build/test/run. Test: go test ./... Build: go build.");
-  }
-
-  // Rust
-  if (existsSync(join(cwd, "Cargo.toml"))) {
-    try {
-      const cargo = readFileSync(join(cwd, "Cargo.toml"), "utf8");
-      const nameMatch = cargo.match(/name\s*=\s*"([^"]+)"/);
-      const versionMatch = cargo.match(/version\s*=\s*"([^"]+)"/);
-      parts.push(`Project: ${nameMatch?.[1] ?? "Rust"}${versionMatch ? `@${versionMatch[1]}` : ""} (Rust/Cargo)`);
-    } catch { parts.push("Project: Rust (Cargo.toml found)"); }
-    parts.push("Use cargo build/test/run. Test: cargo test. Build: cargo build --release.");
-  }
-
-  // Java
-  if (existsSync(join(cwd, "pom.xml"))) {
-    parts.push("Project: Java/Maven. Use mvn commands. Test: mvn test. Build: mvn package.");
-  }
-  if (existsSync(join(cwd, "build.gradle")) || existsSync(join(cwd, "build.gradle.kts"))) {
-    parts.push("Project: Java/Gradle. Use gradle commands. Test: gradle test. Build: gradle build.");
-  }
-
-  // Docker
-  if (existsSync(join(cwd, "Dockerfile")) || existsSync(join(cwd, "docker-compose.yml")) || existsSync(join(cwd, "docker-compose.yaml"))) {
-    parts.push("Docker: Dockerfile/docker-compose present. Container commands available.");
-  }
-
-  // Makefile
-  if (existsSync(join(cwd, "Makefile"))) {
-    try {
-      const { execSync: execS } = require("child_process");
-      const targets = execS("grep -E '^[a-zA-Z_-]+:' Makefile | head -10 | cut -d: -f1", { cwd, encoding: "utf8", timeout: 1000 }).trim();
-      if (targets) parts.push(`Makefile targets: ${targets.split("\n").join(", ")}`);
-    } catch {}
-  }
-
-  // Directory structure — so AI knows actual paths (not guessed ones)
-  try {
-    const { execSync } = require("child_process");
-    // Top-level dirs
-    const topLevel = execSync("ls -1", { cwd, encoding: "utf8", timeout: 2000 }).trim();
-    parts.push(`Top-level: ${topLevel.split("\n").join(", ")}`);
-
-    // Detect monorepo (packages/ or workspaces in package.json)
-    const isMonorepo = existsSync(join(cwd, "packages")) || existsSync(join(cwd, "apps"));
-    if (isMonorepo) {
-      const pkgDirs = execSync(
-        `ls -d packages/*/src 2>/dev/null || ls -d apps/*/src 2>/dev/null || echo ""`,
-        { cwd, encoding: "utf8", timeout: 2000 }
-      ).trim();
-      if (pkgDirs) {
-        parts.push(`MONOREPO: Source is in packages/*/src/, NOT src/. Search packages/ not src/.`);
-        parts.push(`Package sources:\n${pkgDirs}`);
-      }
-    }
-
-    // src/ structure — include FILES so AI knows exact filenames + extensions
-    for (const srcDir of isMonorepo ? ["packages"] : ["src", "lib", "app"]) {
-      if (existsSync(join(cwd, srcDir))) {
-        const tree = execSync(
-          `find ${srcDir} -maxdepth ${isMonorepo ? 4 : 3} -not -path '*/node_modules/*' -not -path '*/dist/*' -not -name '*.test.*' -not -name '*.spec.*' 2>/dev/null | sort | head -80`,
-          { cwd, encoding: "utf8", timeout: 3000 }
-        ).trim();
-        if (tree) parts.push(`Files in ${srcDir}/:\n${tree}`);
-        break;
-      }
-    }
-  } catch { /* timeout or no exec — skip */ }
-
-  return parts.length > 0 ? `\n\nPROJECT CONTEXT:\n${parts.join("\n")}` : "";
+  const hints = discoverProjectHints(process.cwd());
+  return hints.length > 0 ? `\n\n${formatHints(hints)}` : "";
 }
 
 // ── system prompt ─────────────────────────────────────────────────────────────
@@ -254,10 +164,24 @@ function buildSystemPrompt(perms: Permissions, sessionEntries: SessionEntry[]):
 
   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;
+        if (lastCmd) {
+          const safetyHints = discoverSafetyHints(lastCmd);
+          return safetyHints.length > 0 ? `\n\nLAST COMMAND SAFETY:\n${safetyHints.join("\n")}` : "";
+        }
+        return "";
+      })()
+    : "";
+
   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
@@ -265,6 +189,7 @@ RULES:
 - 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.
@@ -272,8 +197,10 @@ RULES:
 - 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": use grep -A 20 "function X" src/ to show the function body.
+- 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.
 
 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)
@@ -287,7 +214,13 @@ BLOCKED ALTERNATIVES: If your preferred command would require installing package
 - 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. Always try a grep/find/cat read-only alternative.
+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
@@ -300,7 +233,7 @@ EXISTENCE CHECKS: If the prompt starts with "is there", "does this have", "do we
 
 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/.
 cwd: ${process.cwd()}
-shell: zsh / macOS${projectContext}${restrictionBlock}${contextBlock}`;
+shell: zsh / macOS${projectContext}${safetyBlock}${restrictionBlock}${contextBlock}`;
 }
 
 // ── streaming translate ───────────────────────────────────────────────────────

package/src/cli.tsx

@@ -44,7 +44,9 @@ MCP TOOLS (20+):
   snapshot, token_stats, session_history
 
 ENVIRONMENT:
-  CEREBRAS_API_KEY             Cerebras API key (free, open-source default)
+  XAI_API_KEY                  xAI API key (Grok, code-optimized — default)
+  CEREBRAS_API_KEY             Cerebras API key (free, open-source)
+  GROQ_API_KEY                 Groq API key (free, ultra-fast inference)
   ANTHROPIC_API_KEY            Anthropic API key (Claude models)
 `);
   process.exit(0);
@@ -371,7 +373,7 @@ else if (args[0] === "history") {
 
 else if (args[0] === "explain" && args[1]) {
   const command = args.slice(1).join(" ");
-  if (!process.env.ANTHROPIC_API_KEY && !process.env.CEREBRAS_API_KEY) {
+  if (!process.env.ANTHROPIC_API_KEY && !process.env.CEREBRAS_API_KEY && !process.env.GROQ_API_KEY && !process.env.XAI_API_KEY) {
     console.error("explain requires an API key"); process.exit(1);
   }
   const { explainCommand } = await import("./ai.js");
@@ -400,7 +402,7 @@ else if (args.length > 0) {
   // Everything that doesn't match a subcommand is treated as natural language
   const prompt = args.join(" ");
 
-  const offlineMode = !process.env.ANTHROPIC_API_KEY && !process.env.CEREBRAS_API_KEY;
+  const offlineMode = !process.env.ANTHROPIC_API_KEY && !process.env.CEREBRAS_API_KEY && !process.env.GROQ_API_KEY && !process.env.XAI_API_KEY;
 
   const { translateToCommand, checkPermissions, isIrreversible } = await import("./ai.js");
   const { execSync } = await import("child_process");
@@ -458,9 +460,10 @@ else if (args.length > 0) {
         } catch {}
       }
     }
-    // "I don't know" honesty — better than wrong answer
+    // Show the block reason clearly
     if (e.message?.startsWith("BLOCKED:")) {
-      console.log(`I don't know how to do this with shell commands. Try running it directly.`);
+      console.log(`⚠ ${e.message}`);
+      console.log(`  This is a READ-ONLY terminal. Run directly in your shell if you're sure.`);
     } else {
       console.error(e.message);
     }
@@ -507,7 +510,7 @@ else if (args.length > 0) {
     console.error(`[open-terminal] invalid command detected: ${validation.issues.join(", ")}`);
     try {
       const retryCommand = await translateToCommand(
-        `${prompt} (IMPORTANT: keep it simple. Use basic grep/find/cat/ls/wc commands. No complex awk/sed pipelines. No GNU flags. Verify file paths from the project context.)`,
+        `${prompt} (Previous command had issues: ${validation.issues.join(", ")}. Fix those specific issues. Keep the approach but correct the errors.)`,
         perms, []
       );
       if (retryCommand && retryCommand !== command) {
@@ -515,6 +518,14 @@ else if (args.length > 0) {
         if (retryValidation.valid || retryValidation.issues.length < validation.issues.length) {
           command = retryCommand;
           console.error(`[open-terminal] retried: $ ${command}`);
+        } else {
+          // Retry also invalid — use the simpler of the two
+          const retryPipes = (retryCommand.match(/\|/g) || []).length;
+          const origPipes = (command.match(/\|/g) || []).length;
+          if (retryPipes < origPipes) {
+            command = retryCommand;
+            console.error(`[open-terminal] retried (simpler): $ ${command}`);
+          }
         }
       }
     } catch {}
@@ -642,11 +653,13 @@ else if (args.length > 0) {
 // ── TUI mode (no args) ──────────────────────────────────────────────────────
 
 else {
-  if (!process.env.ANTHROPIC_API_KEY && !process.env.CEREBRAS_API_KEY) {
+  if (!process.env.ANTHROPIC_API_KEY && !process.env.CEREBRAS_API_KEY && !process.env.GROQ_API_KEY && !process.env.XAI_API_KEY) {
     console.error("terminal: No API key found.");
     console.error("Set one of:");
-    console.error("  export CEREBRAS_API_KEY=your_key  (free, open-source)");
-    console.error("  export ANTHROPIC_API_KEY=your_key  (Claude)");
+    console.error("  export XAI_API_KEY=your_key        (Grok, code-optimized — default)");
+    console.error("  export CEREBRAS_API_KEY=your_key   (free, open-source)");
+    console.error("  export GROQ_API_KEY=your_key       (free, ultra-fast)");
+    console.error("  export ANTHROPIC_API_KEY=your_key   (Claude)");
     process.exit(1);
   }
 

package/src/command-validator.ts

@@ -78,6 +78,17 @@ export function validateCommand(command: string, cwd: string): ValidationResult
     issues.push(`GNU flag on macOS: ${gnuFlags.join(", ")}`);
   }
 
+  // Complexity guard — extreme pipe chains are fragile
+  const pipeCount = (command.match(/\|/g) || []).length;
+  if (pipeCount > 7) {
+    issues.push(`too complex: ${pipeCount} pipes — simplify`);
+  }
+
+  // grep -P (PCRE) doesn't exist on macOS
+  if (/grep\s+.*-[a-zA-Z]*P/.test(command)) {
+    issues.push("grep -P (PCRE) not available on macOS — use grep -E");
+  }
+
   return {
     valid: issues.length === 0,
     issues,

package/src/context-hints.ts

@@ -0,0 +1,202 @@
+// Context hints — discover context via lightweight checks, inject into AI prompt
+// Regex DISCOVERS, AI DECIDES. No hardcoded logic that makes decisions.
+
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+
+export interface ContextHints {
+  project: string[];    // project metadata
+  output: string[];     // observations about command output
+  safety: string[];     // safety-relevant observations
+  environment: string[]; // system/env observations
+}
+
+/** Discover project context from the filesystem */
+export function discoverProjectHints(cwd: string): string[] {
+  const hints: string[] = [];
+
+  // Package managers and project files
+  const projectFiles: [string, string][] = [
+    ["package.json", "Node.js/TypeScript"],
+    ["pyproject.toml", "Python"],
+    ["requirements.txt", "Python"],
+    ["go.mod", "Go"],
+    ["Cargo.toml", "Rust"],
+    ["pom.xml", "Java/Maven"],
+    ["build.gradle", "Java/Gradle"],
+    ["build.gradle.kts", "Java/Gradle (Kotlin DSL)"],
+    ["Makefile", "Has Makefile"],
+    ["Dockerfile", "Has Docker"],
+    ["docker-compose.yml", "Has Docker Compose"],
+    ["docker-compose.yaml", "Has Docker Compose"],
+    [".github/workflows", "Has GitHub Actions CI"],
+    ["Gemfile", "Ruby"],
+    ["composer.json", "PHP"],
+    ["mix.exs", "Elixir"],
+    ["build.zig", "Zig"],
+    ["CMakeLists.txt", "C/C++ (CMake)"],
+  ];
+
+  for (const [file, lang] of projectFiles) {
+    if (existsSync(join(cwd, file))) {
+      hints.push(`Project type: ${lang} (${file} found)`);
+    }
+  }
+
+  // Extract rich metadata from package.json
+  const pkgPath = join(cwd, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+      if (pkg.name) hints.push(`Package name: ${pkg.name}@${pkg.version ?? "unknown"}`);
+      if (pkg.scripts) {
+        hints.push(`Available scripts: ${Object.entries(pkg.scripts).map(([k, v]) => `${k}: ${v}`).slice(0, 10).join(", ")}`);
+      }
+      if (pkg.dependencies) hints.push(`Dependencies: ${Object.keys(pkg.dependencies).join(", ")}`);
+    } catch {}
+  }
+
+  // Extract from pyproject.toml
+  const pyPath = join(cwd, "pyproject.toml");
+  if (existsSync(pyPath)) {
+    try {
+      const py = readFileSync(pyPath, "utf8");
+      const name = py.match(/name\s*=\s*"([^"]+)"/)?.[1];
+      if (name) hints.push(`Python package: ${name}`);
+    } catch {}
+  }
+
+  // Extract from go.mod
+  const goPath = join(cwd, "go.mod");
+  if (existsSync(goPath)) {
+    try {
+      const go = readFileSync(goPath, "utf8");
+      const mod = go.match(/module\s+(\S+)/)?.[1];
+      if (mod) hints.push(`Go module: ${mod}`);
+    } catch {}
+  }
+
+  // Extract from Cargo.toml
+  const cargoPath = join(cwd, "Cargo.toml");
+  if (existsSync(cargoPath)) {
+    try {
+      const cargo = readFileSync(cargoPath, "utf8");
+      const name = cargo.match(/name\s*=\s*"([^"]+)"/)?.[1];
+      if (name) hints.push(`Rust crate: ${name}`);
+    } catch {}
+  }
+
+  // Monorepo detection
+  if (existsSync(join(cwd, "packages"))) {
+    try {
+      const pkgs = readdirSync(join(cwd, "packages")).filter(d => !d.startsWith("."));
+      hints.push(`MONOREPO: ${pkgs.length} packages in packages/ — search packages/ not src/`);
+      hints.push(`Packages: ${pkgs.slice(0, 10).join(", ")}`);
+    } catch {}
+  }
+  if (existsSync(join(cwd, "apps"))) {
+    hints.push("MONOREPO: apps/ directory detected");
+  }
+
+  // Makefile targets
+  if (existsSync(join(cwd, "Makefile"))) {
+    try {
+      const { execSync } = require("child_process");
+      const targets = execSync("grep -E '^[a-zA-Z_-]+:' Makefile | head -10 | cut -d: -f1", { cwd, encoding: "utf8", timeout: 1000 }).trim();
+      if (targets) hints.push(`Makefile targets: ${targets.split("\n").join(", ")}`);
+    } catch {}
+  }
+
+  // Source directory structure
+  try {
+    const { execSync } = require("child_process");
+    const srcDirs = ["src", "lib", "app", "packages"];
+    for (const dir of srcDirs) {
+      if (existsSync(join(cwd, dir))) {
+        const tree = execSync(
+          `find ${dir} -maxdepth 3 -not -path '*/node_modules/*' -not -path '*/dist/*' -not -name '*.test.*' 2>/dev/null | sort | head -60`,
+          { cwd, encoding: "utf8", timeout: 3000 }
+        ).trim();
+        if (tree) hints.push(`Files in ${dir}/:\n${tree}`);
+        break;
+      }
+    }
+    // Top-level files
+    const topLevel = execSync("ls -1", { cwd, encoding: "utf8", timeout: 1000 }).trim();
+    hints.push(`Top-level: ${topLevel.split("\n").join(", ")}`);
+  } catch {}
+
+  return hints;
+}
+
+/** Discover output-specific hints (observations about command output) */
+export function discoverOutputHints(output: string, command: string): string[] {
+  const hints: string[] = [];
+
+  const lines = output.split("\n");
+  hints.push(`Output: ${lines.length} lines, ${output.length} chars`);
+
+  // Only detect test results from actual test runners (not grep output containing "pass"/"fail" in code)
+  const isGrepOutput = /^\s*(src\/|\.\/|packages\/).*:\d+:/.test(output);
+  if (!isGrepOutput) {
+    const passMatch = output.match(/(\d+)\s+pass(?:ed|ing)?\b/i);
+    const failMatch = output.match(/(\d+)\s+fail(?:ed|ing|ure)?\b/i);
+    if (passMatch) hints.push(`Test results detected: ${passMatch[0]}`);
+    if (failMatch) hints.push(`Test results detected: ${failMatch[0]}`);
+
+    // Error patterns (only from actual command output, not code search)
+    if (output.match(/error\s*TS\d+/i)) hints.push("TypeScript errors detected in output");
+    if (output.match(/ENOENT|EACCES|EADDRINUSE/)) hints.push("System error code detected in output");
+  }
+
+  // Coverage patterns
+  if (output.match(/%\s*Funcs|%\s*Lines|coverage/i)) hints.push("Code coverage data detected in output");
+
+  // Large/repetitive output
+  if (lines.length > 100) hints.push(`Large output (${lines.length} lines) — consider summarizing`);
+  const uniqueLines = new Set(lines.map(l => l.trim())).size;
+  if (uniqueLines < lines.length * 0.5) hints.push("Output has many duplicate/similar lines");
+
+  // Sensitive data (only env var assignments, not code containing the word KEY/TOKEN)
+  if (output.match(/^[A-Z_]+(KEY|TOKEN|SECRET|PASSWORD)\s*=\s*\S+/m)) hints.push("Output may contain sensitive data — redact credentials");
+
+  return hints;
+}
+
+/** Discover safety hints about a command */
+export function discoverSafetyHints(command: string): string[] {
+  const hints: string[] = [];
+
+  // Observations about the command (AI decides if it's safe)
+  if (command.match(/\brm\b|\brmdir\b|\btruncate\b/)) hints.push("SAFETY: command contains file deletion (rm/rmdir/truncate)");
+  if (command.match(/\bkill\b|\bkillall\b|\bpkill\b/)) hints.push("SAFETY: command kills processes");
+  if (command.match(/\bgit\s+push\b|\bgit\s+reset\s+--hard\b/)) hints.push("SAFETY: command pushes/resets git");
+  if (command.match(/\bnpx\b|\bnpm\s+install\b|\bpip\s+install\b/)) hints.push("SAFETY: command installs packages");
+  if (command.match(/\bsed\s+-i\b|\bcodemod\b/)) hints.push("SAFETY: command modifies files in-place");
+  if (command.match(/\btouch\b|\bmkdir\b/)) hints.push("SAFETY: command creates files/directories");
+  if (command.match(/>\s*\S+\.\w+/)) hints.push("SAFETY: command writes to a file via redirect");
+  if (command.match(/\b(bun|npm|pnpm)\s+run\s+dev\b|\bstart\b/)) hints.push("SAFETY: command starts a server/process");
+
+  // Read-only observations
+  if (command.match(/^\s*git\s+(log|show|diff|status|branch|blame|tag)\b/)) hints.push("This is a read-only git command");
+  if (command.match(/^\s*(ls|cat|head|tail|grep|find|wc|du|df|uptime|whoami|pwd)\b/)) hints.push("This is a read-only command");
+
+  return hints;
+}
+
+/** Format all hints for system prompt injection */
+export function formatHints(project: string[], output?: string[], safety?: string[]): string {
+  const sections: string[] = [];
+
+  if (project.length > 0) {
+    sections.push("PROJECT CONTEXT:\n" + project.join("\n"));
+  }
+  if (output && output.length > 0) {
+    sections.push("OUTPUT OBSERVATIONS:\n" + output.join("\n"));
+  }
+  if (safety && safety.length > 0) {
+    sections.push("SAFETY OBSERVATIONS:\n" + safety.join("\n"));
+  }
+
+  return sections.join("\n\n");
+}

package/src/output-processor.ts

@@ -4,6 +4,7 @@
 import { getProvider } from "./providers/index.js";
 import { estimateTokens } from "./parsers/index.js";
 import { recordSaving } from "./economy.js";
+import { discoverOutputHints } from "./context-hints.js";
 
 export interface ProcessedOutput {
   /** AI-generated summary (concise, structured) */
@@ -79,27 +80,15 @@ export async function processOutput(
   }
 
   try {
-    // Pre-parse: if output contains clear pass/fail counts, extract and return directly
-    // No hardcoded test runner list — works for ANY tool that outputs "X pass, Y fail"
-    const passMatch = output.match(/(\d+)\s+pass/i);
-    const failMatch = output.match(/(\d+)\s+fail/i);
-    // Pre-parse fires when output has BOTH pass+fail counts AND the user asked about tests
-    if (passMatch && failMatch && originalPrompt && /test|pass|fail/i.test(originalPrompt)) {
-      const passed = parseInt(passMatch[1]);
-      const failed = parseInt(failMatch[1]);
-      const answer = failed === 0
-        ? `✓ Yes, all ${passed} tests pass.`
-        : `✗ ${failed} of ${passed + failed} tests failed.`;
-      const savedTokens = estimateTokens(output) - estimateTokens(answer);
-      return {
-        summary: answer, full: output, tokensSaved: Math.max(0, savedTokens),
-        aiTokensUsed: 0, aiProcessed: true, aiCostUsd: 0, savingsValueUsd: 0, netSavingsUsd: 0,
-      };
-    }
+    // Discover output hints — regex discovers patterns, AI decides what matters
+    const outputHints = discoverOutputHints(output, command);
+    const hintsBlock = outputHints.length > 0
+      ? `\n\nOUTPUT OBSERVATIONS:\n${outputHints.join("\n")}`
+      : "";
 
     const provider = getProvider();
     const summary = await provider.complete(
-      `${originalPrompt ? `User asked: ${originalPrompt}\n` : ""}Command: ${command}\nOutput (${lines.length} lines):\n${toSummarize}`,
+      `${originalPrompt ? `User asked: ${originalPrompt}\n` : ""}Command: ${command}\nOutput (${lines.length} lines):\n${toSummarize}${hintsBlock}`,
       {
         system: SUMMARIZE_PROMPT,
         maxTokens: 300,