@hasna/terminal 0.1.4 → 0.2.0

package/src/Browse.tsx

@@ -0,0 +1,103 @@
+import React, { useState, useCallback } from "react";
+import { Box, Text, useInput } from "ink";
+import { readdirSync, statSync } from "fs";
+import { join, dirname } from "path";
+
+interface BrowseProps {
+  cwd: string;
+  onCd: (path: string) => void;
+  onSelect: (path: string) => void;
+  onExit: () => void;
+}
+
+interface Entry {
+  name: string;
+  isDir: boolean;
+}
+
+function readDir(dir: string): Entry[] {
+  try {
+    const names = readdirSync(dir);
+    const entries: Entry[] = [];
+    for (const name of names) {
+      try {
+        const stat = statSync(join(dir, name));
+        entries.push({ name, isDir: stat.isDirectory() });
+      } catch {
+        entries.push({ name, isDir: false });
+      }
+    }
+    entries.sort((a, b) => {
+      if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+    return entries;
+  } catch {
+    return [];
+  }
+}
+
+const PAGE = 20;
+
+export default function Browse({ cwd, onCd, onSelect, onExit }: BrowseProps) {
+  const [cursor, setCursor] = useState(0);
+
+  const entries = readDir(cwd);
+  const total = entries.length;
+
+  const safeIndex = Math.min(cursor, Math.max(0, total - 1));
+
+  const start = Math.max(0, Math.min(safeIndex - Math.floor(PAGE / 2), total - PAGE));
+  const slice = entries.slice(Math.max(0, start), Math.max(0, start) + PAGE);
+
+  useInput(useCallback((_input: string, key: any) => {
+    if (key.upArrow) {
+      setCursor(c => (c <= 0 ? Math.max(0, total - 1) : c - 1));
+      return;
+    }
+    if (key.downArrow) {
+      setCursor(c => (total === 0 ? 0 : (c >= total - 1 ? 0 : c + 1)));
+      return;
+    }
+    if (key.return) {
+      if (total === 0) return;
+      const entry = entries[safeIndex];
+      if (!entry) return;
+      const full = join(cwd, entry.name);
+      if (entry.isDir) {
+        setCursor(0);
+        onCd(full);
+      } else {
+        onSelect(full);
+      }
+      return;
+    }
+    if (key.backspace || key.delete || key.leftArrow) {
+      setCursor(0);
+      onCd(dirname(cwd));
+      return;
+    }
+    if (key.escape) {
+      onExit();
+      return;
+    }
+  }, [cwd, entries, safeIndex, total, onCd, onSelect, onExit]));
+
+  return (
+    <Box flexDirection="column">
+      <Text dimColor>{cwd}</Text>
+      {total === 0 && <Text dimColor>  (empty)</Text>}
+      {slice.map((entry, i) => {
+        const absIdx = Math.max(0, start) + i;
+        const selected = absIdx === safeIndex;
+        const icon = entry.isDir ? "▸" : "·";
+        return (
+          <Box key={entry.name}>
+            <Text inverse={selected}>{` ${icon} ${entry.name}${entry.isDir ? "/" : ""} `}</Text>
+          </Box>
+        );
+      })}
+      <Text dimColor>{"  enter  backspace  esc"}</Text>
+    </Box>
+  );
+}

package/src/FuzzyPicker.tsx

@@ -0,0 +1,69 @@
+import React, { useState, useCallback } from "react";
+import { Box, Text, useInput } from "ink";
+
+interface FuzzyPickerProps {
+  history: string[];
+  onSelect: (nl: string) => void;
+  onExit: () => void;
+}
+
+const MAX_MATCHES = 10;
+
+export default function FuzzyPicker({ history, onSelect, onExit }: FuzzyPickerProps) {
+  const [query, setQuery] = useState("");
+  const [cursor, setCursor] = useState(0);
+
+  const matches = query === ""
+    ? history.slice().reverse().slice(0, MAX_MATCHES)
+    : history.slice().reverse().filter(h => h.toLowerCase().includes(query.toLowerCase())).slice(0, MAX_MATCHES);
+
+  const safeCursor = Math.min(cursor, Math.max(0, matches.length - 1));
+
+  useInput(useCallback((_input: string, key: any) => {
+    if (key.escape || key.ctrl && _input === "c") {
+      onExit();
+      return;
+    }
+    if (key.return) {
+      if (matches.length > 0) {
+        onSelect(matches[safeCursor]);
+      }
+      return;
+    }
+    if (key.upArrow) {
+      setCursor(c => Math.max(0, c - 1));
+      return;
+    }
+    if (key.downArrow) {
+      setCursor(c => Math.min(matches.length - 1, c + 1));
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setQuery(q => q.slice(0, -1));
+      setCursor(0);
+      return;
+    }
+    if (!key.ctrl && !key.meta && _input && _input.length === 1) {
+      setQuery(q => q + _input);
+      setCursor(0);
+    }
+  }, [matches, safeCursor, onSelect, onExit]));
+
+  return (
+    <Box flexDirection="column">
+      <Text>{`  / ${query}_`}</Text>
+      {matches.length === 0
+        ? <Text dimColor>{"  no matches"}</Text>
+        : matches.map((m, i) => {
+            const selected = i === safeCursor;
+            return (
+              <Box key={i}>
+                <Text inverse={selected} dimColor={!selected}>{`  ${m} `}</Text>
+              </Box>
+            );
+          })
+      }
+      <Text dimColor>{"  enter  esc"}</Text>
+    </Box>
+  );
+}

package/src/StatusBar.tsx

@@ -4,64 +4,58 @@ import { execSync } from "child_process";
 import { homedir } from "os";
 import { type Permissions } from "./history.js";
 
-function getCwd(): string {
-  const cwd = process.cwd();
+function formatCwd(cwd: string): string {
   const home = homedir();
   return cwd.startsWith(home) ? "~" + cwd.slice(home.length) : cwd;
 }
 
-function getGitBranch(): string | null {
+function getGitBranch(cwd: string): string | null {
   try {
-    return execSync("git branch --show-current 2>/dev/null", { stdio: ["ignore", "pipe", "ignore"] })
-      .toString()
-      .trim() || null;
-  } catch {
-    return null;
-  }
+    return execSync("git branch --show-current 2>/dev/null", {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"],
+    }).toString().trim() || null;
+  } catch { return null; }
 }
 
-function getGitDirty(): boolean {
+function getGitDirty(cwd: string): boolean {
   try {
-    const out = execSync("git status --porcelain 2>/dev/null", { stdio: ["ignore", "pipe", "ignore"] }).toString();
-    return out.trim().length > 0;
-  } catch {
-    return false;
-  }
+    return execSync("git status --porcelain 2>/dev/null", {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"],
+    }).toString().trim().length > 0;
+  } catch { return false; }
 }
 
 function activePerms(perms: Permissions): string[] {
   const labels: Array<[keyof Permissions, string]> = [
     ["destructive", "del"],
-    ["network", "net"],
-    ["sudo", "sudo"],
-    ["install", "pkg"],
+    ["network",     "net"],
+    ["sudo",        "sudo"],
+    ["install",     "pkg"],
     ["write_outside_cwd", "write"],
   ];
-  return labels.filter(([k]) => perms[k]).map(([, l]) => l);
+  // only show disabled ones — full access is the default so no need to clutter
+  const disabled = labels.filter(([k]) => !perms[k]).map(([, l]) => `no-${l}`);
+  return disabled;
 }
 
 interface Props {
   permissions: Permissions;
+  cwd?: string;
 }
 
-export default function StatusBar({ permissions }: Props) {
-  const cwd = getCwd();
-  const branch = getGitBranch();
-  const dirty = branch ? getGitDirty() : false;
-  const perms = activePerms(permissions);
+export default function StatusBar({ permissions, cwd: cwdProp }: Props) {
+  const cwd = cwdProp ?? process.cwd();
+  const branch = getGitBranch(cwd);
+  const dirty = branch ? getGitDirty(cwd) : false;
+  const restricted = activePerms(permissions);
 
   return (
     <Box gap={2} paddingLeft={2} marginTop={1}>
-      <Text dimColor>{cwd}</Text>
-      {branch && (
-        <Text dimColor>
-          {branch}
-          {dirty ? " ●" : ""}
-        </Text>
-      )}
-      {perms.length > 0 && (
-        <Text dimColor>{perms.join(" · ")}</Text>
-      )}
+      <Text dimColor>{formatCwd(cwd)}</Text>
+      {branch && <Text dimColor>{branch}{dirty ? " ●" : ""}</Text>}
+      {restricted.length > 0 && <Text dimColor>{restricted.join(" · ")}</Text>}
     </Box>
   );
 }

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