@hasna/terminal 2.3.0 → 2.3.2

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");
+}

package/.claude/scheduled_tasks.lock

@@ -1 +0,0 @@
-{"sessionId":"c1e414c7-f1a5-4b9e-bcc4-64c451584cb8","pid":1236,"acquiredAt":1773584959902}

package/.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,20 +0,0 @@
----
-name: Bug Report
-about: Report a bug in open-terminal
-labels: bug
----
-
-**Command:**
-`terminal exec "..."`
-
-**Expected:**
-What you expected to happen
-
-**Actual:**
-What actually happened
-
-**Environment:**
-- OS:
-- Node/Bun version:
-- open-terminal version: (`terminal --version`)
-- Provider: Cerebras / Anthropic

package/.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,14 +0,0 @@
----
-name: Feature Request
-about: Suggest a feature for open-terminal
-labels: enhancement
----
-
-**Use case:**
-What problem does this solve?
-
-**Proposed solution:**
-How should it work?
-
-**Alternatives considered:**
-Other approaches you thought about

package/CONTRIBUTING.md

@@ -1,80 +0,0 @@
-# Contributing to open-terminal
-
-Thanks for your interest in contributing! open-terminal is an open-source smart terminal wrapper that saves AI agents 73-90% of tokens on terminal output.
-
-## Development Setup
-
-```bash
-git clone https://github.com/hasna/terminal.git
-cd terminal
-npm install
-npm run build    # TypeScript compilation
-bun test         # Run tests
-```
-
-## Architecture
-
-```
-src/
-  cli.tsx              # CLI entry point (TUI + subcommands)
-  ai.ts                # NL translation (Cerebras/Anthropic providers)
-  compression.ts       # Token compression engine
-  noise-filter.ts      # Strip noise (npm fund, progress bars, etc.)
-  command-rewriter.ts   # Auto-optimize commands before execution
-  output-processor.ts  # AI-powered output summarization
-  diff-cache.ts        # Diff-aware output caching
-  smart-display.ts     # Visual output compression for TUI
-  file-cache.ts        # Session file read cache
-  lazy-executor.ts     # Lazy execution for large results
-  expand-store.ts      # Progressive disclosure store
-  economy.ts           # Token savings tracker
-  sessions-db.ts       # SQLite session tracking
-  supervisor.ts        # Background process manager
-  snapshots.ts         # Session state snapshots
-  tree.ts              # Tree compression for file listings
-  mcp/
-    server.ts          # MCP server (20+ tools)
-    install.ts         # MCP installer for Claude/Codex/Gemini
-  providers/
-    base.ts            # LLM provider interface
-    anthropic.ts       # Anthropic provider
-    cerebras.ts        # Cerebras provider (default)
-  parsers/             # Structured output parsers
-  search/              # Smart search (file, content, semantic)
-  recipes/             # Reusable command templates
-```
-
-## How to Contribute
-
-### Adding a new parser
-Parsers detect and structure specific command output types. See `src/parsers/` for examples. Each parser needs:
-- `detect(command, output)` — returns true if this parser can handle the output
-- `parse(command, output)` — returns structured data
-
-### Adding a command rewrite rule
-See `src/command-rewriter.ts`. Add a pattern + rewrite function to the `rules` array.
-
-### Adding an MCP tool
-See `src/mcp/server.ts`. Register with `server.tool(name, description, schema, handler)`.
-
-## Running Tests
-
-```bash
-bun test                    # All tests
-bun test src/parsers/       # Parser tests only
-bun test --coverage         # With coverage
-```
-
-## Commit Convention
-
-We use conventional commits:
-- `feat:` — new feature
-- `fix:` — bug fix
-- `refactor:` — code restructuring
-- `test:` — adding tests
-- `docs:` — documentation
-- `chore:` — maintenance
-
-## License
-
-Apache 2.0 — Copyright 2026 Hasna, Inc.

package/benchmarks/benchmark.mjs

@@ -1,115 +0,0 @@
-#!/usr/bin/env bun
-// Reproducible benchmark: measures token savings across real commands
-// Run: bun benchmarks/benchmark.mjs
-
-import { compress, stripAnsi } from "../dist/compression.js";
-import { parseOutput, estimateTokens, tokenSavings } from "../dist/parsers/index.js";
-import { searchContent } from "../dist/search/index.js";
-import { diffOutput, clearDiffCache } from "../dist/diff-cache.js";
-import { smartDisplay } from "../dist/smart-display.js";
-import { stripNoise } from "../dist/noise-filter.js";
-import { rewriteCommand } from "../dist/command-rewriter.js";
-import { execSync } from "child_process";
-
-const cwd = process.cwd();
-const run = (cmd) => { try { return execSync(cmd, { encoding: "utf8", cwd, maxBuffer: 10*1024*1024 }).trim(); } catch(e) { return e.stdout?.trim() ?? ""; } };
-
-let totalRaw = 0, totalSaved = 0;
-const rows = [];
-
-function track(name, rawText, compressedText) {
-  const raw = estimateTokens(rawText);
-  const comp = estimateTokens(compressedText);
-  const saved = Math.max(0, raw - comp);
-  totalRaw += raw;
-  totalSaved += saved;
-  rows.push({ name, raw, comp, saved, pct: raw > 0 ? Math.round(saved/raw*100) : 0 });
-}
-
-console.log("open-terminal benchmark — measuring real token savings\n");
-
-// 1. Noise filter on npm install-like output
-const npmSim = "added 847 packages in 12s\n\n143 packages are looking for funding\n  run `npm fund` for details\n\nfound 0 vulnerabilities\n";
-const npmClean = stripNoise(npmSim).cleaned;
-track("npm install (noise filter)", npmSim, npmClean);
-
-// 2. Command rewriting
-const rwTests = [
-  ["find . -name '*.ts' | grep -v node_modules", "find pipe→filter"],
-  ["cat package.json | grep name", "cat pipe→grep"],
-  ["git log", "git log→oneline"],
-  ["npm ls", "npm ls→depth0"],
-];
-for (const [cmd, label] of rwTests) {
-  const rw = rewriteCommand(cmd);
-  if (rw.changed) {
-    const rawOut = run(cmd) || cmd;
-    const rwOut = run(rw.rewritten) || rw.rewritten;
-    track(`rewrite: ${label}`, rawOut, rwOut);
-  }
-}
-
-// 3. Structured parsing
-const gitStatus = run("git status");
-const gsParsed = parseOutput("git status", gitStatus);
-if (gsParsed) track("git status (structured)", gitStatus, JSON.stringify(gsParsed.data));
-
-const gitLog = run("git log -15");
-const glParsed = parseOutput("git log -15", gitLog);
-if (glParsed) track("git log -15 (structured)", gitLog, JSON.stringify(glParsed.data));
-
-// 4. Token budget compression
-const bigLs = run("ls -laR src/");
-const c1 = compress("ls -laR src/", bigLs, { maxTokens: 150 });
-track("ls -laR src/ (budget 150)", bigLs, c1.content);
-
-// 5. Search overflow guard
-const rawGrep = run("grep -rn export src/ | head -200");
-const search = await searchContent("export", cwd, { maxResults: 10 });
-track("grep export (overflow guard)", rawGrep, JSON.stringify(search));
-
-// 6. Smart display on paths
-const findPng = run("find . -name '*.png' -not -path '*/node_modules/*' 2>/dev/null | head -50");
-if (findPng) {
-  const display = smartDisplay(findPng.split("\n"));
-  track("find *.png (smart display)", findPng, display.join("\n"));
-}
-
-// 7. Diff caching (identical re-run)
-clearDiffCache();
-const testOut = run("bun test 2>&1");
-diffOutput("bun test", cwd, testOut);
-const d2 = diffOutput("bun test", cwd, testOut);
-track("bun test (identical re-run)", testOut, d2.diffSummary);
-
-// 8. Diff caching (fuzzy — simulated 95% similar)
-clearDiffCache();
-const testA = "PASS test1\nPASS test2\nPASS test3\nPASS test4\nPASS test5\nPASS test6\nPASS test7\nPASS test8\nPASS test9\nFAIL test10\nTests: 9 passed, 1 failed";
-const testB = "PASS test1\nPASS test2\nPASS test3\nPASS test4\nPASS test5\nPASS test6\nPASS test7\nPASS test8\nPASS test9\nPASS test10\nTests: 10 passed, 0 failed";
-diffOutput("test", "/tmp", testA);
-const fuzzyDiff = diffOutput("test", "/tmp", testB);
-track("test (fuzzy diff, 1 change)", testA, fuzzyDiff.added.join("\n") + "\n" + fuzzyDiff.removed.join("\n"));
-
-// 9. Budget compression on large ls
-const bigLs2 = run("ls -laR . 2>/dev/null | head -300");
-const c2 = compress("ls -laR .", bigLs2, { maxTokens: 100 });
-track("ls -laR . (budget 100, 300 lines)", bigLs2, c2.content);
-
-// Print results
-console.log("┌─────────────────────────────────────────────┬──────┬──────┬───────┬──────┐");
-console.log("│ Scenario                                    │  Raw │ Comp │ Saved │    % │");
-console.log("├─────────────────────────────────────────────┼──────┼──────┼───────┼──────┤");
-for (const r of rows) {
-  console.log("│ " + r.name.padEnd(43) + " │ " + String(r.raw).padStart(4) + " │ " + String(r.comp).padStart(4) + " │ " + String(r.saved).padStart(5) + " │ " + (r.pct + "%").padStart(4) + " │");
-}
-console.log("├─────────────────────────────────────────────┼──────┼──────┼───────┼──────┤");
-const pct = Math.round(totalSaved/totalRaw*100);
-console.log("│ " + "TOTAL".padEnd(43) + " │ " + String(totalRaw).padStart(4) + " │ " + String(totalRaw-totalSaved).padStart(4) + " │ " + String(totalSaved).padStart(5) + " │ " + (pct + "%").padStart(4) + " │");
-console.log("└─────────────────────────────────────────────┴──────┴──────┴───────┴──────┘");
-
-// Cost analysis
-const sonnetRate = 3.0;
-const cerebrasInputRate = 0.60;
-const savingsUsd = totalSaved * sonnetRate / 1_000_000;
-console.log(`\nAt Claude Sonnet $3/M: ${totalSaved} tokens saved = $${savingsUsd.toFixed(6)}`);
-console.log(`At 500 commands/day: ~$${(savingsUsd * 50).toFixed(2)}/day, $${(savingsUsd * 50 * 30).toFixed(0)}/month saved`);