@hasna/terminal 0.1.3 → 0.1.5

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,13 +1,30 @@
 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 });
 
+// ── model routing ─────────────────────────────────────────────────────────────
+// Simple queries → haiku (fast). Complex/ambiguous → sonnet.
+
+const COMPLEX_SIGNALS = [
+  /\b(undo|revert|rollback|previous|last)\b/i,
+  /\b(all files?|recursively|bulk|batch)\b/i,
+  /\b(pipeline|chain|then|and then|after)\b/i,
+  /\b(if|when|unless|only if)\b/i,
+  /[|&;]{2}/,           // pipes / &&  in NL (unusual = complex intent)
+];
+
+function pickModel(nl: string): string {
+  const isComplex = COMPLEX_SIGNALS.some((r) => r.test(nl)) || nl.split(" ").length > 10;
+  return isComplex ? "claude-sonnet-4-6" : "claude-haiku-4-5-20251001";
+}
+
 // ── irreversibility ───────────────────────────────────────────────────────────
 
 const IRREVERSIBLE_PATTERNS = [
   /\brm\s/, /\brmdir\b/, /\btruncate\b/, /\bdrop\s+table\b/i,
-  /\bdelete\s+from\b/i, /\bmv\b.*\/dev\/null/, /\b>\s*[^>]/, // overwrite redirect
+  /\bdelete\s+from\b/i, /\bmv\b.*\/dev\/null/, /\b>\s*[^>]/,
   /\bdd\b/, /\bmkfs\b/, /\bformat\b/, /\bshred\b/,
 ];
 
@@ -17,11 +34,11 @@ export function isIrreversible(command: string): boolean {
 
 // ── permissions ───────────────────────────────────────────────────────────────
 
-const DESTRUCTIVE_PATTERNS = [/\brm\b/, /\brmdir\b/, /\btruncate\b/, /\bdrop\s+table\b/i, /\bdelete\s+from\b/i];
-const NETWORK_PATTERNS    = [/\bcurl\b/, /\bwget\b/, /\bssh\b/, /\bscp\b/, /\bping\b/, /\bnc\b/, /\bnetcat\b/];
-const SUDO_PATTERNS       = [/\bsudo\b/];
-const INSTALL_PATTERNS    = [/\bbrew\s+install\b/, /\bnpm\s+install\s+-g\b/, /\bpip\s+install\b/, /\bapt\s+install\b/, /\byum\s+install\b/];
-const WRITE_OUTSIDE_PATTERNS = [/\s(\/etc|\/usr|\/var|\/opt|\/root|~\/[^.])/, />\s*\//];
+const DESTRUCTIVE_PATTERNS    = [/\brm\b/, /\brmdir\b/, /\btruncate\b/, /\bdrop\s+table\b/i, /\bdelete\s+from\b/i];
+const NETWORK_PATTERNS        = [/\bcurl\b/, /\bwget\b/, /\bssh\b/, /\bscp\b/, /\bping\b/, /\bnc\b/, /\bnetcat\b/];
+const SUDO_PATTERNS           = [/\bsudo\b/];
+const INSTALL_PATTERNS        = [/\bbrew\s+install\b/, /\bnpm\s+install\s+-g\b/, /\bpip\s+install\b/, /\bapt\s+install\b/, /\byum\s+install\b/];
+const WRITE_OUTSIDE_PATTERNS  = [/\s(\/etc|\/usr|\/var|\/opt|\/root|~\/[^.])/, />\s*\//];
 
 export function checkPermissions(command: string, perms: Permissions): string | null {
   if (!perms.destructive && DESTRUCTIVE_PATTERNS.some((r) => r.test(command)))
@@ -42,32 +59,87 @@ export function checkPermissions(command: string, perms: Permissions): string |
 function buildSystemPrompt(perms: Permissions, sessionCmds: string[]): string {
   const restrictions: string[] = [];
   if (!perms.destructive)
-    restrictions.push("- NEVER generate commands that delete, remove, or overwrite files/data (rm, rmdir, truncate, DROP TABLE, etc.)");
+    restrictions.push("- NEVER generate commands that delete, remove, or overwrite files/data");
   if (!perms.network)
-    restrictions.push("- NEVER generate commands that make network requests (curl, wget, ssh, scp, ping, nc, etc.)");
+    restrictions.push("- NEVER generate commands that make network requests (curl, wget, ssh, etc.)");
   if (!perms.sudo)
-    restrictions.push("- NEVER generate commands that use sudo or require root privileges");
+    restrictions.push("- NEVER generate commands requiring sudo");
   if (!perms.write_outside_cwd)
-    restrictions.push("- NEVER generate commands that write to paths outside the current working directory");
+    restrictions.push("- NEVER write to paths outside the current working directory");
   if (!perms.install)
-    restrictions.push("- NEVER generate commands that install packages (brew install, npm install -g, pip install, apt install, etc.)");
+    restrictions.push("- NEVER install packages (brew, npm -g, pip, apt, etc.)");
 
   const restrictionBlock = restrictions.length > 0
-    ? `\n\nCURRENT RESTRICTIONS (respect absolutely):\n${restrictions.join("\n")}\nIf restricted, output exactly: BLOCKED: <reason>`
+    ? `\n\nRESTRICTIONS:\n${restrictions.join("\n")}\nIf restricted, output: BLOCKED: <reason>`
     : "";
 
   const contextBlock = sessionCmds.length > 0
-    ? `\n\nRECENT COMMANDS THIS SESSION (for context — e.g. "undo that", "do the same for X"):\n${sessionCmds.map((c) => `$ ${c}`).join("\n")}`
+    ? `\n\nSESSION HISTORY:\n${sessionCmds.map((c) => `$ ${c}`).join("\n")}`
     : "";
 
-  const cwd = process.cwd();
+  return `You are a terminal assistant. Output ONLY the exact shell command — no explanation, no markdown, no backticks.
+cwd: ${process.cwd()}
+shell: zsh / macOS${restrictionBlock}${contextBlock}`;
+}
+
+// ── streaming translate ───────────────────────────────────────────────────────
+
+export async function translateToCommand(
+  nl: string,
+  perms: Permissions,
+  sessionCmds: string[],
+  onToken?: (partial: string) => void
+): Promise<string> {
+  // cache hit — instant
+  const cached = cacheGet(nl);
+  if (cached) { onToken?.(cached); return cached; }
+
+  const model = pickModel(nl);
+  let result = "";
+
+  if (onToken) {
+    // streaming path
+    const stream = await client.messages.stream({
+      model,
+      max_tokens: 256,
+      system: buildSystemPrompt(perms, sessionCmds),
+      messages: [{ role: "user", content: nl }],
+    });
+    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;
+  }
+
+  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
 
-  return `You are a terminal assistant. The user will describe what they want to do in plain English.
-Your job is to output ONLY the exact shell command(s) to accomplish this — nothing else.
-No explanation. No markdown. No backticks. Just the raw command.
-If multiple commands are needed, join them with && or use a newline.
-Assume macOS/Linux zsh environment.
-Current working directory: ${cwd}${restrictionBlock}${contextBlock}`;
+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(() => {});
 }
 
 // ── explain ───────────────────────────────────────────────────────────────────
@@ -76,7 +148,7 @@ export async function explainCommand(command: string): Promise<string> {
   const message = await client.messages.create({
     model: "claude-haiku-4-5-20251001",
     max_tokens: 128,
-    system: "Explain what this shell command does in one plain English sentence. No markdown. No code blocks. Just a sentence.",
+    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];
@@ -94,35 +166,13 @@ export async function fixCommand(
   sessionCmds: string[]
 ): Promise<string> {
   const message = await client.messages.create({
-    model: "claude-opus-4-6",
-    max_tokens: 256,
-    system: buildSystemPrompt(perms, sessionCmds),
-    messages: [
-      {
-        role: "user",
-        content: `I wanted to: ${originalNl}\nI ran: ${failedCommand}\nIt failed with:\n${errorOutput}\n\nGive me the corrected command.`,
-      },
-    ],
-  });
-  const block = message.content[0];
-  if (block.type !== "text") throw new Error("Unexpected response type");
-  const text = block.text.trim();
-  if (text.startsWith("BLOCKED:")) throw new Error(text);
-  return text;
-}
-
-// ── translate ─────────────────────────────────────────────────────────────────
-
-export async function translateToCommand(
-  nl: string,
-  perms: Permissions,
-  sessionCmds: string[]
-): Promise<string> {
-  const message = await client.messages.create({
-    model: "claude-opus-4-6",
+    model: "claude-sonnet-4-6",
     max_tokens: 256,
     system: buildSystemPrompt(perms, sessionCmds),
-    messages: [{ role: "user", content: nl }],
+    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");

package/src/cache.ts

@@ -0,0 +1,43 @@
+// In-memory LRU cache + disk persistence for command translations
+
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+const CACHE_FILE = join(homedir(), ".terminal", "cache.json");
+const MAX_ENTRIES = 500;
+
+type CacheMap = Record<string, string>;
+
+let mem: CacheMap = {};
+
+export function loadCache() {
+  if (!existsSync(CACHE_FILE)) return;
+  try { mem = JSON.parse(readFileSync(CACHE_FILE, "utf8")); } catch {}
+}
+
+function persistCache() {
+  try { writeFileSync(CACHE_FILE, JSON.stringify(mem)); } catch {}
+}
+
+/** Normalize a natural language query for cache lookup */
+export function normalizeNl(nl: string): string {
+  return nl
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9\s]/g, "")   // strip punctuation
+    .replace(/\s+/g, " ");
+}
+
+export function cacheGet(nl: string): string | null {
+  return mem[normalizeNl(nl)] ?? null;
+}
+
+export function cacheSet(nl: string, command: string) {
+  const key = normalizeNl(nl);
+  // evict oldest if full
+  const keys = Object.keys(mem);
+  if (keys.length >= MAX_ENTRIES) delete mem[keys[0]];
+  mem[key] = command;
+  persistCache();
+}