@hasna/terminal 0.1.4 → 0.2.0

package/src/snapshots.ts

@@ -0,0 +1,67 @@
+// Session snapshots — capture terminal state for agent context handoff
+
+import { loadHistory } from "./history.js";
+import { bgStatus } from "./supervisor.js";
+import { getEconomyStats, formatTokens } from "./economy.js";
+import { listRecipes } from "./recipes/storage.js";
+
+export interface SessionSnapshot {
+  cwd: string;
+  env: Record<string, string>;
+  runningProcesses: { pid: number; command: string; port?: number; uptime: number }[];
+  recentCommands: { cmd: string; exitCode?: boolean; summary?: string }[];
+  recipes: { name: string; command: string }[];
+  economy: { tokensSaved: string; tokensUsed: string };
+  timestamp: number;
+}
+
+/** Capture a compact snapshot of the current terminal state */
+export function captureSnapshot(): SessionSnapshot {
+  // Filtered env — only relevant vars, no secrets
+  const safeEnvKeys = [
+    "PATH", "HOME", "USER", "SHELL", "NODE_ENV", "PWD", "LANG",
+    "TERM", "EDITOR", "VISUAL",
+  ];
+  const env: Record<string, string> = {};
+  for (const key of safeEnvKeys) {
+    if (process.env[key]) env[key] = process.env[key]!;
+  }
+
+  // Running processes
+  const processes = bgStatus().map(p => ({
+    pid: p.pid,
+    command: p.command,
+    port: p.port,
+    uptime: Date.now() - p.startedAt,
+  }));
+
+  // Recent commands (last 10, compressed)
+  const history = loadHistory().slice(-10);
+  const recentCommands = history.map(h => ({
+    cmd: h.cmd,
+    exitCode: h.error,
+    summary: h.nl !== h.cmd ? h.nl : undefined,
+  }));
+
+  // Project recipes
+  const recipes = listRecipes(process.cwd()).slice(0, 10).map(r => ({
+    name: r.name,
+    command: r.command,
+  }));
+
+  // Economy
+  const econ = getEconomyStats();
+
+  return {
+    cwd: process.cwd(),
+    env,
+    runningProcesses: processes,
+    recentCommands,
+    recipes,
+    economy: {
+      tokensSaved: formatTokens(econ.totalTokensSaved),
+      tokensUsed: formatTokens(econ.totalTokensUsed),
+    },
+    timestamp: Date.now(),
+  };
+}

package/src/supervisor.ts

@@ -0,0 +1,129 @@
+// Process supervisor — manages background processes for agents and humans
+
+import { spawn, type ChildProcess } from "child_process";
+import { createConnection } from "net";
+
+export interface ManagedProcess {
+  pid: number;
+  command: string;
+  cwd: string;
+  port?: number;
+  startedAt: number;
+  lastOutput: string[];
+  exitCode?: number;
+}
+
+const processes = new Map<number, { proc: ChildProcess; meta: ManagedProcess }>();
+
+/** Auto-detect port from common commands */
+function detectPort(command: string): number | undefined {
+  // "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: string, cwd?: string): ManagedProcess {
+  const workDir = cwd ?? process.cwd();
+  const proc = spawn("/bin/zsh", ["-c", command], {
+    cwd: workDir,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: false,
+  });
+
+  const meta: ManagedProcess = {
+    pid: proc.pid!,
+    command,
+    cwd: workDir,
+    port: detectPort(command),
+    startedAt: Date.now(),
+    lastOutput: [],
+  };
+
+  const pushOutput = (d: Buffer) => {
+    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(): ManagedProcess[] {
+  const result: ManagedProcess[] = [];
+  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: number): boolean {
+  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: number, tail: number = 20): string[] {
+  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: number, timeoutMs: number = 30000): Promise<boolean> {
+  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/src/tree.ts

@@ -0,0 +1,101 @@
+// 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";
+
+export interface TreeNode {
+  name: string;
+  type: "file" | "dir";
+  size?: number;
+  children?: TreeNode[];
+  fileCount?: number;
+}
+
+/** Build a tree from a directory */
+export function buildTree(
+  dirPath: string,
+  options: { maxDepth?: number; includeHidden?: boolean; depth?: number } = {}
+): TreeNode {
+  const { maxDepth = 2, includeHidden = false, depth = 0 } = options;
+  const name = basename(dirPath) || dirPath;
+
+  const node: TreeNode = { 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: TreeNode, indent: number = 0): string {
+  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: string[] = [];
+    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: TreeNode): object {
+  return node;
+}

package/tsconfig.json

@@ -10,5 +10,6 @@
     "esModuleInterop": true,
     "skipLibCheck": true
   },
-  "include": ["src/**/*"]
+  "include": ["src/**/*"],
+  "exclude": ["src/**/*.test.ts"]
 }