@hasna/terminal 0.1.5 → 0.2.0

package/dist/supervisor.js

@@ -0,0 +1,112 @@
+// Process supervisor — manages background processes for agents and humans
+import { spawn } from "child_process";
+import { createConnection } from "net";
+const processes = new Map();
+/** Auto-detect port from common commands */
+function detectPort(command) {
+    // "next dev -p 3001", "vite --port 4000", etc.
+    const portMatch = command.match(/-p\s+(\d+)|--port\s+(\d+)|PORT=(\d+)/);
+    if (portMatch)
+        return parseInt(portMatch[1] ?? portMatch[2] ?? portMatch[3]);
+    // Common defaults
+    if (/\bnext\s+dev\b/.test(command))
+        return 3000;
+    if (/\bvite\b/.test(command))
+        return 5173;
+    if (/\bnuxt\s+dev\b/.test(command))
+        return 3000;
+    if (/\bremix\s+dev\b/.test(command))
+        return 5173;
+    return undefined;
+}
+/** Start a background process */
+export function bgStart(command, cwd) {
+    const workDir = cwd ?? process.cwd();
+    const proc = spawn("/bin/zsh", ["-c", command], {
+        cwd: workDir,
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: false,
+    });
+    const meta = {
+        pid: proc.pid,
+        command,
+        cwd: workDir,
+        port: detectPort(command),
+        startedAt: Date.now(),
+        lastOutput: [],
+    };
+    const pushOutput = (d) => {
+        const lines = d.toString().split("\n").filter(l => l.trim());
+        meta.lastOutput.push(...lines);
+        // Keep last 50 lines
+        if (meta.lastOutput.length > 50) {
+            meta.lastOutput = meta.lastOutput.slice(-50);
+        }
+    };
+    proc.stdout?.on("data", pushOutput);
+    proc.stderr?.on("data", pushOutput);
+    proc.on("close", (code) => {
+        meta.exitCode = code ?? 0;
+    });
+    processes.set(proc.pid, { proc, meta });
+    return meta;
+}
+/** List all managed processes */
+export function bgStatus() {
+    const result = [];
+    for (const [pid, { proc, meta }] of processes) {
+        // Check if still alive
+        try {
+            process.kill(pid, 0);
+            result.push({ ...meta, lastOutput: meta.lastOutput.slice(-5) });
+        }
+        catch {
+            // Process is dead
+            result.push({ ...meta, exitCode: meta.exitCode ?? -1, lastOutput: meta.lastOutput.slice(-5) });
+        }
+    }
+    return result;
+}
+/** Stop a background process */
+export function bgStop(pid) {
+    const entry = processes.get(pid);
+    if (!entry)
+        return false;
+    try {
+        entry.proc.kill("SIGTERM");
+        processes.delete(pid);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Get logs for a background process */
+export function bgLogs(pid, tail = 20) {
+    const entry = processes.get(pid);
+    if (!entry)
+        return [];
+    return entry.meta.lastOutput.slice(-tail);
+}
+/** Wait for a port to be ready */
+export function bgWaitPort(port, timeoutMs = 30000) {
+    return new Promise((resolve) => {
+        const start = Date.now();
+        const check = () => {
+            if (Date.now() - start > timeoutMs) {
+                resolve(false);
+                return;
+            }
+            const sock = createConnection({ port, host: "127.0.0.1" });
+            sock.on("connect", () => {
+                sock.destroy();
+                resolve(true);
+            });
+            sock.on("error", () => {
+                sock.destroy();
+                setTimeout(check, 500);
+            });
+        };
+        check();
+    });
+}

package/dist/tree.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hasna/terminal",
-  "version": "0.1.5",
-  "description": "Natural language terminal — speak plain English, get shell commands",
+  "version": "0.2.0",
+  "description": "Smart terminal wrapper for AI agents and humans — structured output, token compression, MCP server, natural language",
   "type": "module",
   "bin": {
     "t": "dist/cli.js",
@@ -10,12 +10,15 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsx src/cli.tsx",
-    "start": "node dist/cli.js"
+    "start": "node dist/cli.js",
+    "test": "bun test"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
+    "@modelcontextprotocol/sdk": "^1.27.1",
     "ink": "^5.0.1",
-    "react": "^18.2.0"
+    "react": "^18.2.0",
+    "zod": "^4.3.6"
   },
   "publishConfig": {
     "access": "public",

package/src/ai.ts

@@ -1,11 +1,9 @@
-import Anthropic from "@anthropic-ai/sdk";
 import type { Permissions } from "./history.js";
 import { cacheGet, cacheSet } from "./cache.js";
-
-const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+import { getProvider } from "./providers/index.js";
 
 // ── model routing ─────────────────────────────────────────────────────────────
-// Simple queries → haiku (fast). Complex/ambiguous → sonnet.
+// Simple queries → fast model. Complex/ambiguous → smart model.
 
 const COMPLEX_SIGNALS = [
   /\b(undo|revert|rollback|previous|last)\b/i,
@@ -15,9 +13,25 @@ const COMPLEX_SIGNALS = [
   /[|&;]{2}/,           // pipes / &&  in NL (unusual = complex intent)
 ];
 
-function pickModel(nl: string): string {
+/** Model routing per provider */
+function pickModel(nl: string): { fast: string; smart: string; pick: "fast" | "smart" } {
   const isComplex = COMPLEX_SIGNALS.some((r) => r.test(nl)) || nl.split(" ").length > 10;
-  return isComplex ? "claude-sonnet-4-6" : "claude-haiku-4-5-20251001";
+  const provider = getProvider();
+
+  if (provider.name === "anthropic") {
+    return {
+      fast: "claude-haiku-4-5-20251001",
+      smart: "claude-sonnet-4-6",
+      pick: isComplex ? "smart" : "fast",
+    };
+  }
+
+  // Cerebras — single fast model (Llama is already fast)
+  return {
+    fast: "llama-4-scout-17b-16e",
+    smart: "llama-4-scout-17b-16e",
+    pick: isComplex ? "smart" : "fast",
+  };
 }
 
 // ── irreversibility ───────────────────────────────────────────────────────────
@@ -94,50 +108,33 @@ export async function translateToCommand(
   const cached = cacheGet(nl);
   if (cached) { onToken?.(cached); return cached; }
 
-  const model = pickModel(nl);
-  let result = "";
+  const provider = getProvider();
+  const routing = pickModel(nl);
+  const model = routing.pick === "smart" ? routing.smart : routing.fast;
+  const system = buildSystemPrompt(perms, sessionCmds);
+
+  let text: string;
 
   if (onToken) {
-    // streaming path
-    const stream = await client.messages.stream({
-      model,
-      max_tokens: 256,
-      system: buildSystemPrompt(perms, sessionCmds),
-      messages: [{ role: "user", content: nl }],
+    text = await provider.stream(nl, { model, maxTokens: 256, system }, {
+      onToken: (partial) => onToken(partial),
     });
-    for await (const chunk of stream) {
-      if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
-        result += chunk.delta.text;
-        onToken(result.trim());
-      }
-    }
   } else {
-    const message = await client.messages.create({
-      model,
-      max_tokens: 256,
-      system: buildSystemPrompt(perms, sessionCmds),
-      messages: [{ role: "user", content: nl }],
-    });
-    const block = message.content[0];
-    if (block.type !== "text") throw new Error("Unexpected response type");
-    result = block.text;
+    text = await provider.complete(nl, { model, maxTokens: 256, system });
   }
 
-  const text = result.trim();
   if (text.startsWith("BLOCKED:")) throw new Error(text);
   cacheSet(nl, text);
   return text;
 }
 
 // ── prefetch ──────────────────────────────────────────────────────────────────
-// Silently warm the cache after a command runs — no await, fire and forget
 
 export function prefetchNext(
   lastNl: string,
   perms: Permissions,
   sessionCmds: string[]
 ) {
-  // Only prefetch if we don't have it cached already
   if (cacheGet(lastNl)) return;
   translateToCommand(lastNl, perms, sessionCmds).catch(() => {});
 }
@@ -145,15 +142,13 @@ export function prefetchNext(
 // ── explain ───────────────────────────────────────────────────────────────────
 
 export async function explainCommand(command: string): Promise<string> {
-  const message = await client.messages.create({
-    model: "claude-haiku-4-5-20251001",
-    max_tokens: 128,
+  const provider = getProvider();
+  const routing = pickModel("explain"); // simple = fast model
+  return provider.complete(command, {
+    model: routing.fast,
+    maxTokens: 128,
     system: "Explain what this shell command does in one plain English sentence. No markdown, no code blocks.",
-    messages: [{ role: "user", content: command }],
   });
-  const block = message.content[0];
-  if (block.type !== "text") return "";
-  return block.text.trim();
 }
 
 // ── auto-fix ──────────────────────────────────────────────────────────────────
@@ -165,18 +160,35 @@ export async function fixCommand(
   perms: Permissions,
   sessionCmds: string[]
 ): Promise<string> {
-  const message = await client.messages.create({
-    model: "claude-sonnet-4-6",
-    max_tokens: 256,
-    system: buildSystemPrompt(perms, sessionCmds),
-    messages: [{
-      role: "user",
-      content: `I wanted to: ${originalNl}\nI ran: ${failedCommand}\nError:\n${errorOutput}\n\nGive me the corrected command only.`,
-    }],
-  });
-  const block = message.content[0];
-  if (block.type !== "text") throw new Error("Unexpected response type");
-  const text = block.text.trim();
+  const provider = getProvider();
+  const routing = pickModel(originalNl);
+  const text = await provider.complete(
+    `I wanted to: ${originalNl}\nI ran: ${failedCommand}\nError:\n${errorOutput}\n\nGive me the corrected command only.`,
+    {
+      model: routing.smart, // always use smart model for fixes
+      maxTokens: 256,
+      system: buildSystemPrompt(perms, sessionCmds),
+    }
+  );
   if (text.startsWith("BLOCKED:")) throw new Error(text);
   return text;
 }
+
+// ── summarize output (for MCP/agent use) ──────────────────────────────────────
+
+export async function summarizeOutput(
+  command: string,
+  output: string,
+  maxTokens: number = 200
+): Promise<string> {
+  const provider = getProvider();
+  const routing = pickModel("summarize");
+  return provider.complete(
+    `Command: ${command}\nOutput:\n${output}\n\nSummarize this output concisely for an AI agent. Focus on: status, key results, errors. Be terse.`,
+    {
+      model: routing.fast,
+      maxTokens,
+      system: "You summarize command output for AI agents. Be extremely concise. Return structured info. No prose.",
+    }
+  );
+}

package/src/cli.tsx

@@ -1,12 +1,138 @@
 #!/usr/bin/env node
 import React from "react";
 import { render } from "ink";
-import App from "./App.js";
 
-if (!process.env.ANTHROPIC_API_KEY) {
-  console.error("terminal: ANTHROPIC_API_KEY is not set.");
-  console.error("Add it to your shell: export ANTHROPIC_API_KEY=your_key");
-  process.exit(1);
+const args = process.argv.slice(2);
+
+// ── MCP commands ─────────────────────────────────────────────────────────────
+
+if (args[0] === "mcp") {
+  if (args[1] === "serve" || args.length === 1) {
+    const { startMcpServer } = await import("./mcp/server.js");
+    startMcpServer().catch((err) => {
+      console.error("MCP server error:", err);
+      process.exit(1);
+    });
+  } else if (args[1] === "install") {
+    const { handleMcpInstall } = await import("./mcp/install.js");
+    handleMcpInstall(args.slice(2));
+  } else {
+    console.log("Usage: t mcp [serve|install]");
+  }
+}
+
+// ── Recipe commands ──────────────────────────────────────────────────────────
+
+else if (args[0] === "recipe") {
+  const { listRecipes, getRecipe, createRecipe, deleteRecipe, listCollections, createCollection } = await import("./recipes/storage.js");
+  const { substituteVariables } = await import("./recipes/model.js");
+  const sub = args[1];
+
+  if (sub === "list") {
+    const collection = args.find(a => a.startsWith("--collection="))?.split("=")[1];
+    let recipes = listRecipes(process.cwd());
+    if (collection) recipes = recipes.filter(r => r.collection === collection);
+    if (recipes.length === 0) { console.log("No recipes found."); }
+    else {
+      for (const r of recipes) {
+        const scope = r.project ? "(project)" : "(global)";
+        const col = r.collection ? ` [${r.collection}]` : "";
+        console.log(`  ${r.name}${col} ${scope} → ${r.command}`);
+      }
+    }
+  } else if (sub === "add" && args[2] && args[3]) {
+    const name = args[2];
+    const command = args[3];
+    const collection = args.find(a => a.startsWith("--collection="))?.split("=")[1];
+    const project = args.includes("--project") ? process.cwd() : undefined;
+    const recipe = createRecipe({ name, command, collection, project });
+    console.log(`✓ Saved recipe '${recipe.name}' → ${recipe.command}`);
+  } else if (sub === "run" && args[2]) {
+    const recipe = getRecipe(args[2], process.cwd());
+    if (!recipe) { console.error(`Recipe '${args[2]}' not found.`); process.exit(1); }
+    // Parse --var=value arguments
+    const vars: Record<string, string> = {};
+    for (const arg of args.slice(3)) {
+      const match = arg.match(/^--(\w+)=(.+)$/);
+      if (match) vars[match[1]] = match[2];
+    }
+    const cmd = substituteVariables(recipe.command, vars);
+    console.log(`$ ${cmd}`);
+    const { execSync } = await import("child_process");
+    try { execSync(cmd, { stdio: "inherit", cwd: process.cwd() }); }
+    catch (e: any) { process.exit(e.status ?? 1); }
+  } else if (sub === "delete" && args[2]) {
+    const ok = deleteRecipe(args[2], process.cwd());
+    console.log(ok ? `✓ Deleted recipe '${args[2]}'` : `Recipe '${args[2]}' not found.`);
+  } else {
+    console.log("Usage: t recipe [add|list|run|delete]");
+    console.log("  t recipe add <name> <command> [--collection=X] [--project]");
+    console.log("  t recipe list [--collection=X]");
+    console.log("  t recipe run <name> [--var=value]");
+    console.log("  t recipe delete <name>");
+  }
+}
+
+// ── Collection commands ──────────────────────────────────────────────────────
+
+else if (args[0] === "collection") {
+  const { listCollections, createCollection } = await import("./recipes/storage.js");
+  const sub = args[1];
+
+  if (sub === "create" && args[2]) {
+    const col = createCollection({ name: args[2], description: args[3], project: args.includes("--project") ? process.cwd() : undefined });
+    console.log(`✓ Created collection '${col.name}'`);
+  } else if (sub === "list") {
+    const cols = listCollections(process.cwd());
+    if (cols.length === 0) console.log("No collections.");
+    else for (const c of cols) console.log(`  ${c.name}${c.description ? ` — ${c.description}` : ""}`);
+  } else {
+    console.log("Usage: t collection [create|list]");
+  }
+}
+
+// ── Stats command ────────────────────────────────────────────────────────────
+
+else if (args[0] === "stats") {
+  const { getEconomyStats, formatTokens } = await import("./economy.js");
+  const s = getEconomyStats();
+  console.log("Token Economy:");
+  console.log(`  Total saved:  ${formatTokens(s.totalTokensSaved)}`);
+  console.log(`  Total used:   ${formatTokens(s.totalTokensUsed)}`);
+  console.log(`  By feature:`);
+  console.log(`    Structured: ${formatTokens(s.savingsByFeature.structured)}`);
+  console.log(`    Compressed: ${formatTokens(s.savingsByFeature.compressed)}`);
+  console.log(`    Diff cache: ${formatTokens(s.savingsByFeature.diff)}`);
+  console.log(`    NL cache:   ${formatTokens(s.savingsByFeature.cache)}`);
+  console.log(`    Search:     ${formatTokens(s.savingsByFeature.search)}`);
+}
+
+// ── Snapshot command ─────────────────────────────────────────────────────────
+
+else if (args[0] === "snapshot") {
+  const { captureSnapshot } = await import("./snapshots.js");
+  console.log(JSON.stringify(captureSnapshot(), null, 2));
 }
 
-render(<App />);
+// ── Project init ─────────────────────────────────────────────────────────────
+
+else if (args[0] === "project" && args[1] === "init") {
+  const { initProject } = await import("./recipes/storage.js");
+  initProject(process.cwd());
+  console.log("✓ Initialized .terminal/recipes.json");
+}
+
+// ── TUI mode (default) ──────────────────────────────────────────────────────
+
+else {
+  if (!process.env.ANTHROPIC_API_KEY && !process.env.CEREBRAS_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)");
+    process.exit(1);
+  }
+
+  const App = (await import("./App.js")).default;
+  render(<App />);
+}

package/src/compression.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from "bun:test";
+import { compress, stripAnsi } from "./compression.js";
+
+describe("stripAnsi", () => {
+  it("removes ANSI escape codes", () => {
+    expect(stripAnsi("\x1b[31mred\x1b[0m")).toBe("red");
+    expect(stripAnsi("\x1b[1;32mbold green\x1b[0m")).toBe("bold green");
+  });
+
+  it("leaves clean text unchanged", () => {
+    expect(stripAnsi("hello world")).toBe("hello world");
+  });
+});
+
+describe("compress", () => {
+  it("strips ANSI by default", () => {
+    const result = compress("ls", "\x1b[32mfile.ts\x1b[0m");
+    expect(result.content).not.toContain("\x1b");
+  });
+
+  it("uses structured parser when format=json", () => {
+    const output = `total 16
+-rw-r--r--  1 user staff  450 Mar 10 09:00 package.json
+drwxr-xr-x  5 user staff  160 Mar 10 09:00 src`;
+
+    const result = compress("ls -la", output, { format: "json" });
+    // Parser may or may not save tokens on small input, just check it parsed
+    expect(result.content).toBeTruthy();
+    const parsed = JSON.parse(result.content);
+    expect(Array.isArray(parsed)).toBe(true);
+  });
+
+  it("respects maxTokens budget", () => {
+    const longOutput = Array.from({ length: 100 }, (_, i) => `Line ${i}: some output text here`).join("\n");
+    const result = compress("some-command", longOutput, { maxTokens: 50 });
+    expect(result.compressedTokens).toBeLessThanOrEqual(60); // allow some slack
+  });
+
+  it("deduplicates similar lines", () => {
+    const output = Array.from({ length: 20 }, (_, i) => `Compiling module ${i}...`).join("\n");
+    const result = compress("build", output);
+    expect(result.compressedTokens).toBeLessThan(result.originalTokens);
+  });
+
+  it("tracks savings on large output", () => {
+    const output = Array.from({ length: 100 }, (_, i) => `Line ${i}: some long output text here that takes tokens`).join("\n");
+    const result = compress("cmd", output, { maxTokens: 50 });
+    expect(result.compressedTokens).toBeLessThan(result.originalTokens);
+  });
+});