@hasna/terminal 2.3.1 → 3.0.1

package/src/context-hints.ts

@@ -43,16 +43,29 @@ export function discoverProjectHints(cwd: string): string[] {
     }
   }
 
-  // Extract rich metadata from package.json
+  // Extract metadata from package.json — trimmed to save tokens
   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.name) hints.push(`Package: ${pkg.name}@${pkg.version ?? "?"}`);
       if (pkg.scripts) {
-        hints.push(`Available scripts: ${Object.entries(pkg.scripts).map(([k, v]) => `${k}: ${v}`).slice(0, 10).join(", ")}`);
+        // Only top-5 most useful scripts
+        const priority = ["dev", "build", "test", "lint", "start", "typecheck", "check"];
+        const scripts = Object.keys(pkg.scripts);
+        const top = priority.filter(s => scripts.includes(s));
+        const rest = scripts.filter(s => !priority.includes(s)).slice(0, Math.max(0, 5 - top.length));
+        hints.push(`Scripts: ${[...top, ...rest].join(", ")}`);
+      }
+      if (pkg.dependencies) {
+        // Only framework/major deps — skip utility libs
+        const major = ["react", "next", "express", "fastify", "hono", "vue", "angular", "svelte",
+          "prisma", "drizzle", "mongoose", "typeorm", "zod", "trpc", "graphql", "tailwindcss",
+          "electron", "bun", "elysia", "nest", "nuxt", "remix", "astro", "vite"];
+        const deps = Object.keys(pkg.dependencies);
+        const found = deps.filter(d => major.some(m => d.includes(m)));
+        if (found.length > 0) hints.push(`Key deps: ${found.slice(0, 10).join(", ")}`);
       }
-      if (pkg.dependencies) hints.push(`Dependencies: ${Object.keys(pkg.dependencies).join(", ")}`);
     } catch {}
   }
 
@@ -107,23 +120,20 @@ export function discoverProjectHints(cwd: string): string[] {
     } catch {}
   }
 
-  // Source directory structure
+  // Source directory structure — max 20 files to save tokens
   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 }
+          `find ${dir} -maxdepth 2 -not -path '*/node_modules/*' -not -path '*/dist/*' -not -name '*.test.*' -not -name '*.spec.*' 2>/dev/null | sort | head -20`,
+          { cwd, encoding: "utf8", timeout: 2000 }
         ).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;

package/src/diff-cache.ts

@@ -1,6 +1,6 @@
 // Diff-aware output caching — when same command runs again, return only what changed
 
-import { estimateTokens } from "./parsers/index.js";
+import { estimateTokens } from "./tokens.js";
 
 interface CachedOutput {
   command: string;

package/src/discover.ts

@@ -4,7 +4,7 @@
 
 import { readdirSync, readFileSync, statSync, existsSync } from "fs";
 import { join } from "path";
-import { estimateTokens } from "./parsers/index.js";
+import { estimateTokens } from "./tokens.js";
 
 export interface DiscoveredCommand {
   command: string;

package/src/economy.ts

@@ -62,13 +62,30 @@ function loadStats(): EconomyStats {
   return stats;
 }
 
+let _saveTimer: ReturnType<typeof setTimeout> | null = null;
+
 function saveStats() {
-  ensureDir();
-  if (stats) {
-    writeFileSync(ECONOMY_FILE, JSON.stringify(stats, null, 2));
-  }
+  // Debounce: coalesce multiple writes within 1 second
+  if (_saveTimer) return;
+  _saveTimer = setTimeout(() => {
+    _saveTimer = null;
+    ensureDir();
+    if (stats) {
+      writeFileSync(ECONOMY_FILE, JSON.stringify(stats, null, 2));
+    }
+  }, 1000);
 }
 
+// Flush on exit
+process.on("exit", () => {
+  if (_saveTimer) {
+    clearTimeout(_saveTimer);
+    _saveTimer = null;
+    ensureDir();
+    if (stats) writeFileSync(ECONOMY_FILE, JSON.stringify(stats, null, 2));
+  }
+});
+
 /** Record token savings from a feature */
 export function recordSaving(feature: keyof EconomyStats["savingsByFeature"], tokensSaved: number) {
   const s = loadStats();
@@ -112,12 +129,27 @@ const PROVIDER_PRICING: Record<string, { input: number; output: number }> = {
   "anthropic-opus":   { input: 5.00, output: 25.00 },
 };
 
+/** Load configurable turns-before-compaction from ~/.terminal/config.json */
+function loadTurnsMultiplier(): number {
+  try {
+    const configPath = join(DIR, "config.json");
+    if (existsSync(configPath)) {
+      const config = JSON.parse(readFileSync(configPath, "utf8"));
+      return config.economy?.turnsBeforeCompaction ?? 5;
+    }
+  } catch {}
+  return 5; // Default: tokens saved are repeated ~5 turns before agent compacts context
+}
+
 /** Estimate USD savings from compressed tokens */
 export function estimateSavingsUsd(
   tokensSaved: number,
   consumerModel: string = "anthropic-opus",
-  avgTurnsBeforeCompaction: number = 5,
+  avgTurnsBeforeCompaction?: number,
 ): { savingsUsd: number; multipliedTokens: number; ratePerMillion: number } {
+  if (avgTurnsBeforeCompaction === undefined) {
+    avgTurnsBeforeCompaction = loadTurnsMultiplier();
+  }
   const pricing = PROVIDER_PRICING[consumerModel] ?? PROVIDER_PRICING["anthropic-opus"];
   const multipliedTokens = tokensSaved * avgTurnsBeforeCompaction;
   const savingsUsd = (multipliedTokens * pricing.input) / 1_000_000;

package/src/expand-store.ts

@@ -26,6 +26,11 @@ export function storeOutput(command: string, output: string): string {
   return key;
 }
 
+/** Escape regex special characters for safe use in new RegExp() */
+function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 /** Retrieve full output by key, optionally filtered */
 export function expandOutput(key: string, grep?: string): { found: boolean; output?: string; lines?: number } {
   const entry = store.get(key);
@@ -33,7 +38,9 @@ export function expandOutput(key: string, grep?: string): { found: boolean; outp
 
   let output = entry.output;
   if (grep) {
-    const pattern = new RegExp(grep, "i");
+    // Escape metacharacters so user input like "[error" or "func()" doesn't crash
+    const safe = escapeRegex(grep);
+    const pattern = new RegExp(safe, "i");
     output = output.split("\n").filter(l => pattern.test(l)).join("\n");
   }
 

package/src/mcp/server.ts

@@ -6,17 +6,16 @@ import { z } from "zod";
 import { spawn } from "child_process";
 import { compress, stripAnsi } from "../compression.js";
 import { stripNoise } from "../noise-filter.js";
-import { parseOutput, tokenSavings, estimateTokens } from "../parsers/index.js";
-import { summarizeOutput } from "../ai.js";
+import { estimateTokens } from "../tokens.js";
+import { processOutput } from "../output-processor.js";
 import { searchFiles, searchContent, semanticSearch } from "../search/index.js";
 import { listRecipes, listCollections, getRecipe, createRecipe } from "../recipes/storage.js";
 import { substituteVariables } from "../recipes/model.js";
 import { bgStart, bgStatus, bgStop, bgLogs, bgWaitPort } from "../supervisor.js";
 import { diffOutput } from "../diff-cache.js";
-import { processOutput } from "../output-processor.js";
 import { listSessions, getSessionInteractions, getSessionStats } from "../sessions-db.js";
 import { cachedRead, cacheStats } from "../file-cache.js";
-import { getBootContext } from "../session-boot.js";
+import { getBootContext, invalidateBootCache } from "../session-boot.js";
 import { storeOutput, expandOutput } from "../expand-store.js";
 import { rewriteCommand } from "../command-rewriter.js";
 import { shouldBeLazy, toLazy } from "../lazy-executor.js";
@@ -49,6 +48,10 @@ function exec(command: string, cwd?: string, timeout?: number): Promise<{ exitCo
       // Strip noise before returning (npm fund, progress bars, etc.)
       const cleanStdout = stripNoise(stdout).cleaned;
       const cleanStderr = stripNoise(stderr).cleaned;
+      // Invalidate boot cache after state-changing git commands
+      if (/\bgit\s+(commit|checkout|branch|merge|reset|push|pull|rebase|stash)\b/.test(actualCommand)) {
+        invalidateBootCache();
+      }
       resolve({ exitCode: code ?? 0, stdout: cleanStdout, stderr: cleanStderr, duration: Date.now() - start, rewritten: rw.changed ? rw.rewritten : undefined });
     });
   });
@@ -100,44 +103,20 @@ export function createServer(): McpServer {
         };
       }
 
-      // JSON mode — structured parsing (only if it actually saves tokens)
-      if (format === "json") {
-        const parsed = parseOutput(command, output);
-        if (parsed) {
-          const savings = tokenSavings(output, parsed.data);
-          if (savings.saved > 0) {
-            return {
-              content: [{ type: "text" as const, text: JSON.stringify({
-                exitCode: result.exitCode, parsed: parsed.data, parser: parsed.parser,
-                duration: result.duration, tokensSaved: savings.saved, savingsPercent: savings.percent,
-              }) }],
-            };
-          }
-          // JSON was larger — fall through to compression
-        }
-      }
-
-      // Compressed mode (also fallback for json when no parser matches)
-      if (format === "compressed" || format === "json") {
-        const compressed = compress(command, output, { maxTokens, format: "json" });
-        return {
-          content: [{ type: "text" as const, text: JSON.stringify({
-            exitCode: result.exitCode, output: compressed.content, format: compressed.format,
-            duration: result.duration, tokensSaved: compressed.tokensSaved, savingsPercent: compressed.savingsPercent,
-          }) }],
-        };
-      }
-
-      // Summary mode — AI-powered
-      if (format === "summary") {
+      // JSON and Summary modes — both go through AI processing
+      if (format === "json" || format === "summary") {
         try {
-          const summary = await summarizeOutput(command, output, maxTokens ?? 200);
-          const rawTokens = estimateTokens(output);
-          const summaryTokens = estimateTokens(summary);
+          const processed = await processOutput(command, output);
+          const detailKey = output.split("\n").length > 15 ? storeOutput(command, output) : undefined;
           return {
             content: [{ type: "text" as const, text: JSON.stringify({
-              exitCode: result.exitCode, summary, duration: result.duration,
-              tokensSaved: rawTokens - summaryTokens,
+              exitCode: result.exitCode,
+              summary: processed.summary,
+              structured: processed.structured,
+              duration: result.duration,
+              tokensSaved: processed.tokensSaved,
+              aiProcessed: processed.aiProcessed,
+              ...(detailKey ? { detailKey, expandable: true } : {}),
             }) }],
           };
         } catch {
@@ -151,6 +130,17 @@ export function createServer(): McpServer {
         }
       }
 
+      // Compressed mode — fast non-AI: strip + dedup + truncate
+      if (format === "compressed") {
+        const compressed = compress(command, output, { maxTokens });
+        return {
+          content: [{ type: "text" as const, text: JSON.stringify({
+            exitCode: result.exitCode, output: compressed.content, duration: result.duration,
+            tokensSaved: compressed.tokensSaved, savingsPercent: compressed.savingsPercent,
+          }) }],
+        };
+      }
+
       return { content: [{ type: "text" as const, text: output }] };
     }
   );
@@ -230,16 +220,8 @@ export function createServer(): McpServer {
       }
 
       const result = await exec(command);
-      const parsed = parseOutput(command, result.stdout);
-
-      if (parsed) {
-        return {
-          content: [{ type: "text" as const, text: JSON.stringify({ cwd: target, ...parsed.data as object, parser: parsed.parser }) }],
-        };
-      }
-
       const files = result.stdout.split("\n").filter(l => l.trim());
-      return { content: [{ type: "text" as const, text: JSON.stringify({ cwd: target, files }) }] };
+      return { content: [{ type: "text" as const, text: JSON.stringify({ cwd: target, files, count: files.length }) }] };
     }
   );
 
@@ -253,14 +235,13 @@ export function createServer(): McpServer {
       command: z.string().optional().describe("The command that produced the error"),
     },
     async ({ error, command }) => {
-      const { errorParser } = await import("../parsers/errors.js");
-      if (errorParser.detect(command ?? "", error)) {
-        const info = errorParser.parse(command ?? "", error);
-        return { content: [{ type: "text" as const, text: JSON.stringify(info) }] };
-      }
+      // AI processes the error — no regex guessing
+      const processed = await processOutput(command ?? "unknown", error);
       return {
         content: [{ type: "text" as const, text: JSON.stringify({
-          type: "unknown", message: error.split("\n")[0]?.trim() ?? "Unknown error",
+          summary: processed.summary,
+          structured: processed.structured,
+          aiProcessed: processed.aiProcessed,
         }) }],
       };
     }
@@ -274,9 +255,8 @@ export function createServer(): McpServer {
     async () => {
       return {
         content: [{ type: "text" as const, text: JSON.stringify({
-          name: "open-terminal", version: "0.2.0", cwd: process.cwd(),
-          parsers: ["ls", "find", "test", "git-log", "git-status", "build", "npm-install", "error"],
-          features: ["structured-output", "token-compression", "ai-summary", "error-diagnosis"],
+          name: "open-terminal", version: "0.3.0", cwd: process.cwd(),
+          features: ["ai-output-processing", "token-compression", "noise-filtering", "diff-caching", "lazy-execution", "progressive-disclosure"],
         }) }],
       };
     }
@@ -376,20 +356,12 @@ export function createServer(): McpServer {
       const result = await exec(command, cwd, 30000);
       const output = (result.stdout + result.stderr).trim();
 
-      if (format === "json") {
-        const parsed = parseOutput(command, output);
-        if (parsed) {
-          return { content: [{ type: "text" as const, text: JSON.stringify({
-            recipe: name, exitCode: result.exitCode, parsed: parsed.data, duration: result.duration,
-          }) }] };
-        }
-      }
-
-      if (format === "compressed") {
-        const compressed = compress(command, output, { format: "json" });
+      if (format === "json" || format === "compressed") {
+        const processed = await processOutput(command, output);
         return { content: [{ type: "text" as const, text: JSON.stringify({
-          recipe: name, exitCode: result.exitCode, output: compressed.content, duration: result.duration,
-          tokensSaved: compressed.tokensSaved,
+          recipe: name, exitCode: result.exitCode, summary: processed.summary,
+          structured: processed.structured, duration: result.duration,
+          tokensSaved: processed.tokensSaved, aiProcessed: processed.aiProcessed,
         }) }] };
       }
 
@@ -534,10 +506,10 @@ export function createServer(): McpServer {
         }) }] };
       }
 
-      // First run — return full output
-      const compressed = compress(command, output, { format: "json" });
+      // First run — return full output (ANSI stripped)
+      const clean = stripAnsi(output);
       return { content: [{ type: "text" as const, text: JSON.stringify({
-        exitCode: result.exitCode, output: compressed.content,
+        exitCode: result.exitCode, output: clean,
         diffSummary: "first run", duration: result.duration,
       }) }] };
     }

package/src/output-processor.ts

@@ -2,10 +2,12 @@
 // NOTHING is hardcoded. The AI decides what's important, what's noise, what to keep.
 
 import { getProvider } from "./providers/index.js";
-import { estimateTokens } from "./parsers/index.js";
+import { estimateTokens } from "./tokens.js";
 import { recordSaving } from "./economy.js";
 import { discoverOutputHints } from "./context-hints.js";
 import { formatProfileHints } from "./tool-profiles.js";
+import { stripAnsi } from "./compression.js";
+import { stripNoise } from "./noise-filter.js";
 
 export interface ProcessedOutput {
   /** AI-generated summary (concise, structured) */
@@ -29,7 +31,9 @@ export interface ProcessedOutput {
 }
 
 const MIN_LINES_TO_PROCESS = 15;
-const MAX_OUTPUT_FOR_AI = 8000; // chars to send to AI (truncate if longer)
+// Reserve ~2000 chars for system prompt + hints + profile + overhead
+const PROMPT_OVERHEAD_CHARS = 2000;
+const MAX_OUTPUT_FOR_AI = 6000; // chars of output to send to AI (leaves room for prompt overhead)
 
 const SUMMARIZE_PROMPT = `You are an intelligent terminal assistant. Given a user's original question and the command output, ANSWER THE QUESTION directly.
 
@@ -70,8 +74,10 @@ export async function processOutput(
     };
   }
 
-  // Truncate very long output before sending to AI
-  let toSummarize = output;
+  // Clean output before AI processing — strip ANSI codes and noise
+  let toSummarize = stripAnsi(output);
+  toSummarize = stripNoise(toSummarize).cleaned;
+
   if (toSummarize.length > MAX_OUTPUT_FOR_AI) {
     const headChars = Math.floor(MAX_OUTPUT_FOR_AI * 0.6);
     const tailChars = Math.floor(MAX_OUTPUT_FOR_AI * 0.3);
@@ -97,6 +103,7 @@ export async function processOutput(
       {
         system: SUMMARIZE_PROMPT,
         maxTokens: 300,
+        temperature: 0.2,
       }
     );
 
@@ -104,10 +111,6 @@ export async function processOutput(
     const summaryTokens = estimateTokens(summary);
     const saved = Math.max(0, originalTokens - summaryTokens);
 
-    if (saved > 0) {
-      recordSaving("compressed", saved);
-    }
-
     // Try to extract structured JSON if the AI returned it
     let structured: Record<string, unknown> | undefined;
     try {

package/src/providers/anthropic.ts

@@ -17,7 +17,9 @@ export class AnthropicProvider implements LLMProvider {
     const message = await this.client.messages.create({
       model: options.model ?? "claude-haiku-4-5-20251001",
       max_tokens: options.maxTokens ?? 256,
-      system: options.system,
+      temperature: options.temperature ?? 0,
+      ...(options.stop ? { stop_sequences: options.stop } : {}),
+      system: [{ type: "text", text: options.system, cache_control: { type: "ephemeral" } }],
       messages: [{ role: "user", content: prompt }],
     });
     const block = message.content[0];
@@ -30,7 +32,9 @@ export class AnthropicProvider implements LLMProvider {
     const stream = await this.client.messages.stream({
       model: options.model ?? "claude-haiku-4-5-20251001",
       max_tokens: options.maxTokens ?? 256,
-      system: options.system,
+      temperature: options.temperature ?? 0,
+      ...(options.stop ? { stop_sequences: options.stop } : {}),
+      system: [{ type: "text", text: options.system, cache_control: { type: "ephemeral" } }],
       messages: [{ role: "user", content: prompt }],
     });
     for await (const chunk of stream) {

package/src/providers/base.ts

@@ -3,6 +3,8 @@
 export interface ProviderOptions {
   model?: string;
   maxTokens?: number;
+  temperature?: number;
+  stop?: string[];
   system: string;
 }
 

package/src/providers/cerebras.ts

@@ -1,108 +1,9 @@
-// Cerebras provider — uses OpenAI-compatible API
-// Default for open-source users. Fast inference on Llama models.
+// Cerebras provider — fast inference on Qwen/Llama models
+import { OpenAICompatibleProvider } from "./openai-compat.js";
 
-import type { LLMProvider, ProviderOptions, StreamCallbacks } from "./base.js";
-
-const CEREBRAS_BASE_URL = "https://api.cerebras.ai/v1";
-const DEFAULT_MODEL = "qwen-3-235b-a22b-instruct-2507";
-
-export class CerebrasProvider implements LLMProvider {
+export class CerebrasProvider extends OpenAICompatibleProvider {
   readonly name = "cerebras";
-  private apiKey: string;
-
-  constructor() {
-    this.apiKey = process.env.CEREBRAS_API_KEY ?? "";
-  }
-
-  isAvailable(): boolean {
-    return !!process.env.CEREBRAS_API_KEY;
-  }
-
-  async complete(prompt: string, options: ProviderOptions): Promise<string> {
-    const model = options.model ?? DEFAULT_MODEL;
-    const res = await fetch(`${CEREBRAS_BASE_URL}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`,
-      },
-      body: JSON.stringify({
-        model,
-        max_tokens: options.maxTokens ?? 256,
-        messages: [
-          { role: "system", content: options.system },
-          { role: "user", content: prompt },
-        ],
-      }),
-    });
-
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`Cerebras API error ${res.status}: ${text}`);
-    }
-
-    const json = (await res.json()) as any;
-    return (json.choices?.[0]?.message?.content ?? "").trim();
-  }
-
-  async stream(prompt: string, options: ProviderOptions, callbacks: StreamCallbacks): Promise<string> {
-    const model = options.model ?? DEFAULT_MODEL;
-    const res = await fetch(`${CEREBRAS_BASE_URL}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`,
-      },
-      body: JSON.stringify({
-        model,
-        max_tokens: options.maxTokens ?? 256,
-        stream: true,
-        messages: [
-          { role: "system", content: options.system },
-          { role: "user", content: prompt },
-        ],
-      }),
-    });
-
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`Cerebras API error ${res.status}: ${text}`);
-    }
-
-    let result = "";
-    const reader = res.body?.getReader();
-    if (!reader) throw new Error("No response body");
-
-    const decoder = new TextDecoder();
-    let buffer = "";
-
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith("data: ")) continue;
-        const data = trimmed.slice(6);
-        if (data === "[DONE]") break;
-
-        try {
-          const parsed = JSON.parse(data) as any;
-          const delta = parsed.choices?.[0]?.delta?.content;
-          if (delta) {
-            result += delta;
-            callbacks.onToken(result.trim());
-          }
-        } catch {
-          // skip malformed chunks
-        }
-      }
-    }
-
-    return result.trim();
-  }
+  protected readonly baseUrl = "https://api.cerebras.ai/v1";
+  protected readonly defaultModel = "qwen-3-235b-a22b-instruct-2507";
+  protected readonly apiKeyEnvVar = "CEREBRAS_API_KEY";
 }