@hasna/terminal 0.1.0

package/.claude/scheduled_tasks.lock

@@ -0,0 +1 @@
+{"sessionId":"501c27b4-5243-40d6-8fb5-04ebdb3c8df8","pid":90841,"acquiredAt":1773556984409}

package/dist/App.js

@@ -0,0 +1,119 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback } from "react";
+import { Box, Text, useInput, useApp } from "ink";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { translateToCommand, checkPermissions } from "./ai.js";
+import { loadHistory, appendHistory, loadConfig, saveConfig, } from "./history.js";
+import Onboarding from "./Onboarding.js";
+const execAsync = promisify(exec);
+export default function App() {
+    const { exit } = useApp();
+    const [config, setConfig] = useState(() => loadConfig());
+    const [nlHistory] = useState(() => loadHistory().map((h) => h.nl).filter(Boolean));
+    const [sessionNl, setSessionNl] = useState([]);
+    const [scroll, setScroll] = useState([]);
+    const [phase, setPhase] = useState({ type: "input", value: "", histIdx: -1 });
+    const allNl = [...nlHistory, ...sessionNl];
+    const finishOnboarding = (perms) => {
+        const next = { onboarded: true, permissions: perms };
+        setConfig(next);
+        saveConfig(next);
+    };
+    const pushScroll = (entry) => setScroll((s) => [...s, entry]);
+    useInput(useCallback(async (input, key) => {
+        if (phase.type === "input") {
+            if (key.ctrl && input === "c") {
+                exit();
+                return;
+            }
+            if (key.upArrow) {
+                const nextIdx = Math.min(phase.histIdx + 1, allNl.length - 1);
+                const val = allNl[allNl.length - 1 - nextIdx] ?? "";
+                setPhase({ type: "input", value: val, histIdx: nextIdx });
+                return;
+            }
+            if (key.downArrow) {
+                const nextIdx = Math.max(phase.histIdx - 1, -1);
+                const val = nextIdx === -1 ? "" : allNl[allNl.length - 1 - nextIdx] ?? "";
+                setPhase({ type: "input", value: val, histIdx: nextIdx });
+                return;
+            }
+            if (key.return) {
+                const nl = phase.value.trim();
+                if (!nl)
+                    return;
+                setSessionNl((h) => [...h, nl]);
+                setPhase({ type: "thinking", nl });
+                try {
+                    const command = await translateToCommand(nl, config.permissions);
+                    // Local permission guard on the returned command
+                    const blocked = checkPermissions(command, config.permissions);
+                    if (blocked) {
+                        pushScroll({ nl, cmd: command, output: `blocked: ${blocked}`, error: true });
+                        setPhase({ type: "input", value: "", histIdx: -1 });
+                        return;
+                    }
+                    setPhase({ type: "confirm", nl, command });
+                }
+                catch (e) {
+                    setPhase({ type: "error", message: e.message });
+                }
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setPhase({ ...phase, value: phase.value.slice(0, -1), histIdx: -1 });
+                return;
+            }
+            if (input && !key.ctrl && !key.meta) {
+                setPhase({ ...phase, value: phase.value + input, histIdx: -1 });
+            }
+            return;
+        }
+        if (phase.type === "confirm") {
+            if (key.ctrl && input === "c") {
+                exit();
+                return;
+            }
+            if (input === "y" || input === "Y" || key.return) {
+                const { nl, command } = phase;
+                setPhase({ type: "running", nl, command });
+                try {
+                    const { stdout, stderr } = await execAsync(command, { shell: "/bin/zsh" });
+                    const output = (stdout + stderr).trim();
+                    pushScroll({ nl, cmd: command, output });
+                    appendHistory({ nl, cmd: command, output, ts: Date.now() });
+                    setPhase({ type: "input", value: "", histIdx: -1 });
+                }
+                catch (e) {
+                    const output = ((e.stdout ?? "") + (e.stderr ?? "")).trim() || e.message;
+                    pushScroll({ nl, cmd: command, output, error: true });
+                    appendHistory({ nl, cmd: command, output, ts: Date.now(), error: true });
+                    setPhase({ type: "input", value: "", histIdx: -1 });
+                }
+                return;
+            }
+            if (input === "n" || input === "N" || key.escape) {
+                setPhase({ type: "input", value: "", histIdx: -1 });
+                return;
+            }
+            if (input === "e" || input === "E") {
+                setPhase({ type: "input", value: phase.command, histIdx: -1 });
+                return;
+            }
+            return;
+        }
+        if (phase.type === "error") {
+            if (key.ctrl && input === "c") {
+                exit();
+                return;
+            }
+            setPhase({ type: "input", value: "", histIdx: -1 });
+            return;
+        }
+    }, [phase, allNl, config, exit]));
+    if (!config.onboarded) {
+        return _jsx(Onboarding, { onDone: finishOnboarding });
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [scroll.map((entry, i) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "\u203A" }), _jsx(Text, { dimColor: true, children: entry.nl })] }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "$" }), _jsx(Text, { children: entry.cmd })] }), entry.output && (_jsx(Text, { color: entry.error ? "red" : undefined, children: entry.output }))] }, i))), phase.type === "input" && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "\u203A" }), _jsx(Text, { children: phase.value }), _jsx(Text, { inverse: true, children: " " })] })), phase.type === "thinking" && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "\u203A" }), _jsx(Text, { dimColor: true, children: phase.nl })] }), _jsx(Text, { dimColor: true, children: "  translating\u2026" })] })), phase.type === "confirm" && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "\u203A" }), _jsx(Text, { dimColor: true, children: phase.nl })] }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "$" }), _jsx(Text, { children: phase.command })] }), _jsx(Text, { dimColor: true, children: "  [enter] run  [n] cancel  [e] edit" })] })), phase.type === "running" && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "$" }), _jsx(Text, { children: phase.command })] }), _jsx(Text, { dimColor: true, children: "  running\u2026" })] })), phase.type === "error" && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "red", children: ["  ", phase.message] }), _jsx(Text, { dimColor: true, children: "  press any key" })] }))] }));
+}

package/dist/Onboarding.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { DEFAULT_PERMISSIONS } from "./history.js";
+const PERM_KEYS = [
+    { key: "destructive", label: "destructive", description: "rm, delete, drop table…" },
+    { key: "network", label: "network", description: "curl, wget, ssh, ping…" },
+    { key: "sudo", label: "sudo", description: "commands requiring root" },
+    { key: "install", label: "install", description: "brew, npm -g, pip…" },
+    { key: "write_outside_cwd", label: "write outside cwd", description: "files outside current directory" },
+];
+export default function Onboarding({ onDone }) {
+    const [step, setStep] = useState({ type: "welcome" });
+    const [perms, setPerms] = useState({ ...DEFAULT_PERMISSIONS });
+    useInput((input, key) => {
+        if (key.ctrl && input === "c")
+            process.exit(0);
+        if (step.type === "welcome") {
+            setStep({ type: "permissions", cursor: 0 });
+            return;
+        }
+        if (step.type === "permissions") {
+            const { cursor } = step;
+            if (key.upArrow) {
+                setStep({ type: "permissions", cursor: Math.max(0, cursor - 1) });
+                return;
+            }
+            if (key.downArrow) {
+                setStep({ type: "permissions", cursor: Math.min(PERM_KEYS.length - 1, cursor + 1) });
+                return;
+            }
+            if (input === " ") {
+                const k = PERM_KEYS[cursor].key;
+                setPerms((p) => ({ ...p, [k]: !p[k] }));
+                return;
+            }
+            if (key.return) {
+                onDone(perms);
+                return;
+            }
+            return;
+        }
+    });
+    if (step.type === "welcome") {
+        return (_jsxs(Box, { flexDirection: "column", paddingTop: 1, gap: 1, children: [_jsx(Text, { bold: true, children: "terminal" }), _jsx(Text, { children: "Type anything in plain English." }), _jsx(Text, { children: "The AI translates it to a shell command and runs it." }), _jsx(Text, { children: "Use \u2191 / \u2193 to browse history. Enter to run, n to cancel, e to edit." }), _jsx(Text, { dimColor: true, children: "press any key to set up permissions \u2192" })] }));
+    }
+    if (step.type === "permissions") {
+        return (_jsxs(Box, { flexDirection: "column", paddingTop: 1, gap: 1, children: [_jsx(Text, { bold: true, children: "what can the AI do?" }), _jsx(Text, { dimColor: true, children: "space to toggle  \u00B7  enter to confirm" }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: PERM_KEYS.map((p, i) => {
+                        const active = step.cursor === i;
+                        const on = perms[p.key];
+                        return (_jsxs(Box, { gap: 2, children: [_jsx(Text, { children: active ? "›" : " " }), _jsx(Text, { color: on ? undefined : "red", children: on ? "✓" : "✗" }), _jsx(Text, { bold: active, children: p.label }), _jsx(Text, { dimColor: true, children: p.description })] }, p.key));
+                    }) }), _jsx(Text, { dimColor: true, children: "you can change this later in ~/.terminal/config.json" })] }));
+    }
+    return null;
+}

package/dist/ai.js

@@ -0,0 +1,57 @@
+import Anthropic from "@anthropic-ai/sdk";
+const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+function buildSystemPrompt(perms) {
+    const restrictions = [];
+    if (!perms.destructive)
+        restrictions.push("- NEVER generate commands that delete, remove, or overwrite files/data (rm, rmdir, truncate, DROP TABLE, etc.)");
+    if (!perms.network)
+        restrictions.push("- NEVER generate commands that make network requests (curl, wget, ssh, scp, ping, nc, etc.)");
+    if (!perms.sudo)
+        restrictions.push("- NEVER generate commands that use sudo or require root privileges");
+    if (!perms.write_outside_cwd)
+        restrictions.push("- NEVER generate commands that 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.)");
+    const restrictionBlock = restrictions.length > 0
+        ? `\n\nCURRENT RESTRICTIONS (respect these absolutely):\n${restrictions.join("\n")}\nIf the user asks for something restricted, output exactly: BLOCKED: <reason>`
+        : "";
+    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.${restrictionBlock}`;
+}
+/** Regex patterns for permission checks — fast local guard before even calling AI */
+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, perms) {
+    if (!perms.destructive && DESTRUCTIVE_PATTERNS.some((r) => r.test(command)))
+        return "destructive commands are disabled in your permissions";
+    if (!perms.network && NETWORK_PATTERNS.some((r) => r.test(command)))
+        return "network commands are disabled in your permissions";
+    if (!perms.sudo && SUDO_PATTERNS.some((r) => r.test(command)))
+        return "sudo is disabled in your permissions";
+    if (!perms.install && INSTALL_PATTERNS.some((r) => r.test(command)))
+        return "package installation is disabled in your permissions";
+    if (!perms.write_outside_cwd && WRITE_OUTSIDE_PATTERNS.some((r) => r.test(command)))
+        return "writing outside cwd is disabled in your permissions";
+    return null;
+}
+export async function translateToCommand(nl, perms) {
+    const message = await client.messages.create({
+        model: "claude-opus-4-6",
+        max_tokens: 256,
+        system: buildSystemPrompt(perms),
+        messages: [{ role: "user", content: nl }],
+    });
+    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;
+}

package/dist/cli.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+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);
+}
+render(_jsx(App, {}));

package/dist/history.js

@@ -0,0 +1,60 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+const DIR = join(homedir(), ".terminal");
+const HISTORY_FILE = join(DIR, "history.json");
+const CONFIG_FILE = join(DIR, "config.json");
+export const DEFAULT_PERMISSIONS = {
+    destructive: false,
+    network: true,
+    sudo: false,
+    write_outside_cwd: false,
+    install: false,
+};
+export const DEFAULT_CONFIG = {
+    onboarded: false,
+    permissions: DEFAULT_PERMISSIONS,
+};
+function ensureDir() {
+    if (!existsSync(DIR))
+        mkdirSync(DIR, { recursive: true });
+}
+export function loadHistory() {
+    ensureDir();
+    if (!existsSync(HISTORY_FILE))
+        return [];
+    try {
+        return JSON.parse(readFileSync(HISTORY_FILE, "utf8"));
+    }
+    catch {
+        return [];
+    }
+}
+export function saveHistory(entries) {
+    ensureDir();
+    writeFileSync(HISTORY_FILE, JSON.stringify(entries.slice(-500), null, 2));
+}
+export function appendHistory(entry) {
+    const existing = loadHistory();
+    saveHistory([...existing, entry]);
+}
+export function loadConfig() {
+    ensureDir();
+    if (!existsSync(CONFIG_FILE))
+        return { ...DEFAULT_CONFIG };
+    try {
+        const saved = JSON.parse(readFileSync(CONFIG_FILE, "utf8"));
+        return {
+            ...DEFAULT_CONFIG,
+            ...saved,
+            permissions: { ...DEFAULT_PERMISSIONS, ...(saved.permissions ?? {}) },
+        };
+    }
+    catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}
+export function saveConfig(config) {
+    ensureDir();
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@hasna/terminal",
+  "version": "0.1.0",
+  "description": "Natural language terminal — speak plain English, get shell commands",
+  "type": "module",
+  "bin": {
+    "t": "./dist/cli.js",
+    "terminal": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli.tsx",
+    "start": "node dist/cli.js"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.39.0",
+    "ink": "^5.0.1",
+    "react": "^18.2.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hasna/terminal.git"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/react": "^18.2.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  }
+}

package/src/App.tsx

@@ -0,0 +1,212 @@
+import React, { useState, useCallback } from "react";
+import { Box, Text, useInput, useApp } from "ink";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { translateToCommand, checkPermissions } from "./ai.js";
+import {
+  loadHistory,
+  appendHistory,
+  loadConfig,
+  saveConfig,
+  type HistoryEntry,
+  type Permissions,
+} from "./history.js";
+import Onboarding from "./Onboarding.js";
+
+const execAsync = promisify(exec);
+
+type Phase =
+  | { type: "input"; value: string; histIdx: number }
+  | { type: "thinking"; nl: string }
+  | { type: "confirm"; nl: string; command: string }
+  | { type: "running"; nl: string; command: string }
+  | { type: "error"; message: string };
+
+interface ScrollEntry {
+  nl: string;
+  cmd: string;
+  output: string;
+  error?: boolean;
+}
+
+export default function App() {
+  const { exit } = useApp();
+  const [config, setConfig] = useState(() => loadConfig());
+  const [nlHistory] = useState<string[]>(() =>
+    loadHistory().map((h) => h.nl).filter(Boolean)
+  );
+  const [sessionNl, setSessionNl] = useState<string[]>([]);
+  const [scroll, setScroll] = useState<ScrollEntry[]>([]);
+  const [phase, setPhase] = useState<Phase>({ type: "input", value: "", histIdx: -1 });
+
+  const allNl = [...nlHistory, ...sessionNl];
+
+  const finishOnboarding = (perms: Permissions) => {
+    const next = { onboarded: true, permissions: perms };
+    setConfig(next);
+    saveConfig(next);
+  };
+
+  const pushScroll = (entry: ScrollEntry) => setScroll((s) => [...s, entry]);
+
+  useInput(
+    useCallback(
+      async (input: string, key: any) => {
+        if (phase.type === "input") {
+          if (key.ctrl && input === "c") { exit(); return; }
+
+          if (key.upArrow) {
+            const nextIdx = Math.min(phase.histIdx + 1, allNl.length - 1);
+            const val = allNl[allNl.length - 1 - nextIdx] ?? "";
+            setPhase({ type: "input", value: val, histIdx: nextIdx });
+            return;
+          }
+          if (key.downArrow) {
+            const nextIdx = Math.max(phase.histIdx - 1, -1);
+            const val = nextIdx === -1 ? "" : allNl[allNl.length - 1 - nextIdx] ?? "";
+            setPhase({ type: "input", value: val, histIdx: nextIdx });
+            return;
+          }
+          if (key.return) {
+            const nl = phase.value.trim();
+            if (!nl) return;
+            setSessionNl((h) => [...h, nl]);
+            setPhase({ type: "thinking", nl });
+            try {
+              const command = await translateToCommand(nl, config.permissions);
+              // Local permission guard on the returned command
+              const blocked = checkPermissions(command, config.permissions);
+              if (blocked) {
+                pushScroll({ nl, cmd: command, output: `blocked: ${blocked}`, error: true });
+                setPhase({ type: "input", value: "", histIdx: -1 });
+                return;
+              }
+              setPhase({ type: "confirm", nl, command });
+            } catch (e: any) {
+              setPhase({ type: "error", message: e.message });
+            }
+            return;
+          }
+          if (key.backspace || key.delete) {
+            setPhase({ ...phase, value: phase.value.slice(0, -1), histIdx: -1 });
+            return;
+          }
+          if (input && !key.ctrl && !key.meta) {
+            setPhase({ ...phase, value: phase.value + input, histIdx: -1 });
+          }
+          return;
+        }
+
+        if (phase.type === "confirm") {
+          if (key.ctrl && input === "c") { exit(); return; }
+          if (input === "y" || input === "Y" || key.return) {
+            const { nl, command } = phase;
+            setPhase({ type: "running", nl, command });
+            try {
+              const { stdout, stderr } = await execAsync(command, { shell: "/bin/zsh" });
+              const output = (stdout + stderr).trim();
+              pushScroll({ nl, cmd: command, output });
+              appendHistory({ nl, cmd: command, output, ts: Date.now() });
+              setPhase({ type: "input", value: "", histIdx: -1 });
+            } catch (e: any) {
+              const output = ((e.stdout ?? "") + (e.stderr ?? "")).trim() || e.message;
+              pushScroll({ nl, cmd: command, output, error: true });
+              appendHistory({ nl, cmd: command, output, ts: Date.now(), error: true });
+              setPhase({ type: "input", value: "", histIdx: -1 });
+            }
+            return;
+          }
+          if (input === "n" || input === "N" || key.escape) {
+            setPhase({ type: "input", value: "", histIdx: -1 });
+            return;
+          }
+          if (input === "e" || input === "E") {
+            setPhase({ type: "input", value: phase.command, histIdx: -1 });
+            return;
+          }
+          return;
+        }
+
+        if (phase.type === "error") {
+          if (key.ctrl && input === "c") { exit(); return; }
+          setPhase({ type: "input", value: "", histIdx: -1 });
+          return;
+        }
+      },
+      [phase, allNl, config, exit]
+    )
+  );
+
+  if (!config.onboarded) {
+    return <Onboarding onDone={finishOnboarding} />;
+  }
+
+  return (
+    <Box flexDirection="column">
+      {scroll.map((entry, i) => (
+        <Box key={i} flexDirection="column" marginBottom={1}>
+          <Box gap={1}>
+            <Text dimColor>›</Text>
+            <Text dimColor>{entry.nl}</Text>
+          </Box>
+          <Box gap={1}>
+            <Text dimColor>$</Text>
+            <Text>{entry.cmd}</Text>
+          </Box>
+          {entry.output && (
+            <Text color={entry.error ? "red" : undefined}>{entry.output}</Text>
+          )}
+        </Box>
+      ))}
+
+      {phase.type === "input" && (
+        <Box gap={1}>
+          <Text dimColor>›</Text>
+          <Text>{phase.value}</Text>
+          <Text inverse> </Text>
+        </Box>
+      )}
+
+      {phase.type === "thinking" && (
+        <Box flexDirection="column">
+          <Box gap={1}>
+            <Text dimColor>›</Text>
+            <Text dimColor>{phase.nl}</Text>
+          </Box>
+          <Text dimColor>  translating…</Text>
+        </Box>
+      )}
+
+      {phase.type === "confirm" && (
+        <Box flexDirection="column">
+          <Box gap={1}>
+            <Text dimColor>›</Text>
+            <Text dimColor>{phase.nl}</Text>
+          </Box>
+          <Box gap={1}>
+            <Text dimColor>$</Text>
+            <Text>{phase.command}</Text>
+          </Box>
+          <Text dimColor>  [enter] run  [n] cancel  [e] edit</Text>
+        </Box>
+      )}
+
+      {phase.type === "running" && (
+        <Box flexDirection="column">
+          <Box gap={1}>
+            <Text dimColor>$</Text>
+            <Text>{phase.command}</Text>
+          </Box>
+          <Text dimColor>  running…</Text>
+        </Box>
+      )}
+
+      {phase.type === "error" && (
+        <Box flexDirection="column">
+          <Text color="red">  {phase.message}</Text>
+          <Text dimColor>  press any key</Text>
+        </Box>
+      )}
+    </Box>
+  );
+}

package/src/Onboarding.tsx

@@ -0,0 +1,94 @@
+import React, { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { type Permissions, DEFAULT_PERMISSIONS } from "./history.js";
+
+interface Props {
+  onDone: (perms: Permissions) => void;
+}
+
+type Step =
+  | { type: "welcome" }
+  | { type: "permissions"; cursor: number }
+  | { type: "done" };
+
+const PERM_KEYS: Array<{ key: keyof Permissions; label: string; description: string }> = [
+  { key: "destructive", label: "destructive", description: "rm, delete, drop table…" },
+  { key: "network",     label: "network",     description: "curl, wget, ssh, ping…"  },
+  { key: "sudo",        label: "sudo",        description: "commands requiring root"  },
+  { key: "install",     label: "install",     description: "brew, npm -g, pip…"       },
+  { key: "write_outside_cwd", label: "write outside cwd", description: "files outside current directory" },
+];
+
+export default function Onboarding({ onDone }: Props) {
+  const [step, setStep] = useState<Step>({ type: "welcome" });
+  const [perms, setPerms] = useState<Permissions>({ ...DEFAULT_PERMISSIONS });
+
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") process.exit(0);
+
+    if (step.type === "welcome") {
+      setStep({ type: "permissions", cursor: 0 });
+      return;
+    }
+
+    if (step.type === "permissions") {
+      const { cursor } = step;
+      if (key.upArrow) {
+        setStep({ type: "permissions", cursor: Math.max(0, cursor - 1) });
+        return;
+      }
+      if (key.downArrow) {
+        setStep({ type: "permissions", cursor: Math.min(PERM_KEYS.length - 1, cursor + 1) });
+        return;
+      }
+      if (input === " ") {
+        const k = PERM_KEYS[cursor].key;
+        setPerms((p) => ({ ...p, [k]: !p[k] }));
+        return;
+      }
+      if (key.return) {
+        onDone(perms);
+        return;
+      }
+      return;
+    }
+  });
+
+  if (step.type === "welcome") {
+    return (
+      <Box flexDirection="column" paddingTop={1} gap={1}>
+        <Text bold>terminal</Text>
+        <Text>Type anything in plain English.</Text>
+        <Text>The AI translates it to a shell command and runs it.</Text>
+        <Text>Use ↑ / ↓ to browse history. Enter to run, n to cancel, e to edit.</Text>
+        <Text dimColor>press any key to set up permissions →</Text>
+      </Box>
+    );
+  }
+
+  if (step.type === "permissions") {
+    return (
+      <Box flexDirection="column" paddingTop={1} gap={1}>
+        <Text bold>what can the AI do?</Text>
+        <Text dimColor>space to toggle  ·  enter to confirm</Text>
+        <Box flexDirection="column" marginTop={1}>
+          {PERM_KEYS.map((p, i) => {
+            const active = step.cursor === i;
+            const on = perms[p.key];
+            return (
+              <Box key={p.key} gap={2}>
+                <Text>{active ? "›" : " "}</Text>
+                <Text color={on ? undefined : "red"}>{on ? "✓" : "✗"}</Text>
+                <Text bold={active}>{p.label}</Text>
+                <Text dimColor>{p.description}</Text>
+              </Box>
+            );
+          })}
+        </Box>
+        <Text dimColor>you can change this later in ~/.terminal/config.json</Text>
+      </Box>
+    );
+  }
+
+  return null;
+}

package/src/ai.ts

@@ -0,0 +1,65 @@
+import Anthropic from "@anthropic-ai/sdk";
+import type { Permissions } from "./history.js";
+
+const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+
+function buildSystemPrompt(perms: Permissions): 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.)");
+  if (!perms.network)
+    restrictions.push("- NEVER generate commands that make network requests (curl, wget, ssh, scp, ping, nc, etc.)");
+  if (!perms.sudo)
+    restrictions.push("- NEVER generate commands that use sudo or require root privileges");
+  if (!perms.write_outside_cwd)
+    restrictions.push("- NEVER generate commands that 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.)");
+
+  const restrictionBlock =
+    restrictions.length > 0
+      ? `\n\nCURRENT RESTRICTIONS (respect these absolutely):\n${restrictions.join("\n")}\nIf the user asks for something restricted, output exactly: BLOCKED: <reason>`
+      : "";
+
+  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.${restrictionBlock}`;
+}
+
+/** Regex patterns for permission checks — fast local guard before even calling AI */
+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)))
+    return "destructive commands are disabled in your permissions";
+  if (!perms.network && NETWORK_PATTERNS.some((r) => r.test(command)))
+    return "network commands are disabled in your permissions";
+  if (!perms.sudo && SUDO_PATTERNS.some((r) => r.test(command)))
+    return "sudo is disabled in your permissions";
+  if (!perms.install && INSTALL_PATTERNS.some((r) => r.test(command)))
+    return "package installation is disabled in your permissions";
+  if (!perms.write_outside_cwd && WRITE_OUTSIDE_PATTERNS.some((r) => r.test(command)))
+    return "writing outside cwd is disabled in your permissions";
+  return null;
+}
+
+export async function translateToCommand(nl: string, perms: Permissions): Promise<string> {
+  const message = await client.messages.create({
+    model: "claude-opus-4-6",
+    max_tokens: 256,
+    system: buildSystemPrompt(perms),
+    messages: [{ role: "user", content: nl }],
+  });
+
+  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;
+}

package/src/cli.tsx

@@ -0,0 +1,12 @@
+#!/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);
+}
+
+render(<App />);

package/src/history.ts

@@ -0,0 +1,90 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+const DIR = join(homedir(), ".terminal");
+const HISTORY_FILE = join(DIR, "history.json");
+const CONFIG_FILE = join(DIR, "config.json");
+
+export interface HistoryEntry {
+  nl: string;
+  cmd: string;
+  output: string;
+  ts: number;
+  error?: boolean;
+}
+
+export interface Permissions {
+  /** Allow commands that delete files/data (rm, drop, truncate, etc.) */
+  destructive: boolean;
+  /** Allow commands that make network requests (curl, wget, ssh, etc.) */
+  network: boolean;
+  /** Allow commands that require sudo / root */
+  sudo: boolean;
+  /** Allow writing to files outside the current directory */
+  write_outside_cwd: boolean;
+  /** Allow installing packages (npm, brew, pip, apt, etc.) */
+  install: boolean;
+}
+
+export interface Config {
+  onboarded: boolean;
+  permissions: Permissions;
+}
+
+export const DEFAULT_PERMISSIONS: Permissions = {
+  destructive: false,
+  network: true,
+  sudo: false,
+  write_outside_cwd: false,
+  install: false,
+};
+
+export const DEFAULT_CONFIG: Config = {
+  onboarded: false,
+  permissions: DEFAULT_PERMISSIONS,
+};
+
+function ensureDir() {
+  if (!existsSync(DIR)) mkdirSync(DIR, { recursive: true });
+}
+
+export function loadHistory(): HistoryEntry[] {
+  ensureDir();
+  if (!existsSync(HISTORY_FILE)) return [];
+  try {
+    return JSON.parse(readFileSync(HISTORY_FILE, "utf8"));
+  } catch {
+    return [];
+  }
+}
+
+export function saveHistory(entries: HistoryEntry[]) {
+  ensureDir();
+  writeFileSync(HISTORY_FILE, JSON.stringify(entries.slice(-500), null, 2));
+}
+
+export function appendHistory(entry: HistoryEntry) {
+  const existing = loadHistory();
+  saveHistory([...existing, entry]);
+}
+
+export function loadConfig(): Config {
+  ensureDir();
+  if (!existsSync(CONFIG_FILE)) return { ...DEFAULT_CONFIG };
+  try {
+    const saved = JSON.parse(readFileSync(CONFIG_FILE, "utf8"));
+    return {
+      ...DEFAULT_CONFIG,
+      ...saved,
+      permissions: { ...DEFAULT_PERMISSIONS, ...(saved.permissions ?? {}) },
+    };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+export function saveConfig(config: Config) {
+  ensureDir();
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "jsx": "react-jsx",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"]
+}