@hasna/terminal 0.1.4 → 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.4",
-  "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",