@hasna/terminal 0.7.6 → 0.8.0

package/dist/file-index.js

@@ -0,0 +1,62 @@
+// Pre-computed file index — build once, serve search from memory
+// Eliminates subprocess spawning for repeat file queries
+import { spawn } from "child_process";
+let index = null;
+let indexCwd = "";
+let indexTime = 0;
+let watcher = null;
+const INDEX_TTL = 30_000; // 30 seconds
+function exec(command, cwd) {
+    return new Promise((resolve) => {
+        const proc = spawn("/bin/zsh", ["-c", command], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        let out = "";
+        proc.stdout?.on("data", (d) => { out += d.toString(); });
+        proc.on("close", () => resolve(out));
+    });
+}
+/** Build or return cached file index */
+export async function getFileIndex(cwd) {
+    // Return cached if fresh
+    if (index && indexCwd === cwd && Date.now() - indexTime < INDEX_TTL) {
+        return index;
+    }
+    const raw = await exec("find . -type f -not -path '*/node_modules/*' -not -path '*/.git/*' -not -path '*/dist/*' -not -path '*/.next/*' -not -path '*/build/*' 2>/dev/null", cwd);
+    index = raw.split("\n").filter(l => l.trim()).map(p => {
+        const path = p.trim();
+        const parts = path.split("/");
+        const name = parts[parts.length - 1] ?? path;
+        const dir = parts.slice(0, -1).join("/") || ".";
+        const ext = name.includes(".") ? "." + name.split(".").pop() : "";
+        return { path, dir, name, ext };
+    });
+    indexCwd = cwd;
+    indexTime = Date.now();
+    return index;
+}
+/** Search file index by glob pattern (in-memory, no subprocess) */
+export async function searchIndex(cwd, pattern) {
+    const idx = await getFileIndex(cwd);
+    // Convert glob to regex
+    const regex = new RegExp("^" + pattern
+        .replace(/\./g, "\\.")
+        .replace(/\*/g, ".*")
+        .replace(/\?/g, ".")
+        + "$", "i");
+    return idx.filter(e => regex.test(e.name) || regex.test(e.path)).map(e => e.path);
+}
+/** Get file index stats */
+export async function indexStats(cwd) {
+    const idx = await getFileIndex(cwd);
+    const byExt = {};
+    const byDir = {};
+    for (const e of idx) {
+        byExt[e.ext || "(none)"] = (byExt[e.ext || "(none)"] ?? 0) + 1;
+        const topDir = e.dir.split("/").slice(0, 2).join("/");
+        byDir[topDir] = (byDir[topDir] ?? 0) + 1;
+    }
+    return { totalFiles: idx.length, byExtension: byExt, byDir };
+}
+/** Invalidate index */
+export function invalidateIndex() {
+    index = null;
+}

package/dist/line-dedup.js

@@ -0,0 +1,59 @@
+// Cross-command line deduplication — track lines already shown to agent
+// When new output contains >50% already-seen lines, suppress them
+const seenLines = new Set();
+const MAX_SEEN = 5000;
+function normalize(line) {
+    return line.trim().toLowerCase();
+}
+/** Deduplicate output lines against session history */
+export function dedup(output) {
+    const lines = output.split("\n");
+    if (lines.length < 5) {
+        // Short output — add to seen, don't dedup
+        for (const l of lines) {
+            if (l.trim())
+                seenLines.add(normalize(l));
+        }
+        return { output, novelCount: lines.length, seenCount: 0, deduplicated: false };
+    }
+    let novelCount = 0;
+    let seenCount = 0;
+    const novel = [];
+    for (const line of lines) {
+        const norm = normalize(line);
+        if (!norm) {
+            novel.push(line);
+            continue;
+        }
+        if (seenLines.has(norm)) {
+            seenCount++;
+        }
+        else {
+            novelCount++;
+            novel.push(line);
+            seenLines.add(norm);
+        }
+    }
+    // Evict oldest if too large
+    if (seenLines.size > MAX_SEEN) {
+        const entries = [...seenLines];
+        for (let i = 0; i < entries.length - MAX_SEEN; i++) {
+            seenLines.delete(entries[i]);
+        }
+    }
+    // Only dedup if >50% were already seen
+    if (seenCount > lines.length * 0.5) {
+        const result = novel.join("\n");
+        return { output: result + `\n(${seenCount} lines already shown, omitted)`, novelCount, seenCount, deduplicated: true };
+    }
+    // Add all to seen but return full output
+    for (const l of lines) {
+        if (l.trim())
+            seenLines.add(normalize(l));
+    }
+    return { output, novelCount: lines.length, seenCount: 0, deduplicated: false };
+}
+/** Clear dedup history */
+export function clearDedup() {
+    seenLines.clear();
+}

package/dist/mcp/server.js

@@ -15,6 +15,7 @@ import { diffOutput } from "../diff-cache.js";
 import { processOutput } from "../output-processor.js";
 import { listSessions, getSessionInteractions, getSessionStats } from "../sessions-db.js";
 import { cachedRead } from "../file-cache.js";
+import { getBootContext } from "../session-boot.js";
 import { storeOutput, expandOutput } from "../expand-store.js";
 import { rewriteCommand } from "../command-rewriter.js";
 import { shouldBeLazy, toLazy } from "../lazy-executor.js";
@@ -416,6 +417,11 @@ export function createServer() {
         const sessions = listSessions(limit ?? 20);
         return { content: [{ type: "text", text: JSON.stringify(sessions) }] };
     });
+    // ── boot: session start context (replaces first 5 agent commands) ──────────
+    server.tool("boot", "Get everything an agent needs on session start in ONE call — git state, project info, source structure. Replaces: git status + git log + cat package.json + ls src/. Cached for the session.", async () => {
+        const ctx = await getBootContext(process.cwd());
+        return { content: [{ type: "text", text: JSON.stringify(ctx) }] };
+    });
     // ── project_overview: orient agent in one call ─────────────────────────────
     server.tool("project_overview", "Get project overview in one call — package.json info, source structure, config files. Replaces: cat package.json + ls src/ + cat tsconfig.json.", {
         path: z.string().optional().describe("Project root (default: cwd)"),

package/dist/session-boot.js

@@ -0,0 +1,59 @@
+// Session boot cache — precompute common data on first MCP call
+// Agents always start with git status + file tree + package.json — do it once
+import { spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+let bootCache = null;
+let bootCwd = "";
+function exec(command, cwd) {
+    return new Promise((resolve) => {
+        const proc = spawn("/bin/zsh", ["-c", command], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        let out = "";
+        proc.stdout?.on("data", (d) => { out += d.toString(); });
+        proc.on("close", () => resolve(out.trim()));
+    });
+}
+/** Get or build session boot context */
+export async function getBootContext(cwd) {
+    if (bootCache && bootCwd === cwd)
+        return bootCache;
+    const [branch, status, log, srcLs] = await Promise.all([
+        exec("git branch --show-current 2>/dev/null", cwd),
+        exec("git status --porcelain 2>/dev/null", cwd),
+        exec("git log --oneline -8 2>/dev/null", cwd),
+        exec("ls -1 src/ 2>/dev/null || ls -1 lib/ 2>/dev/null || echo ''", cwd),
+    ]);
+    let pkg = null;
+    const pkgPath = join(cwd, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
+            pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        }
+        catch { }
+    }
+    bootCache = {
+        cwd,
+        git: {
+            branch: branch || null,
+            dirty: status.length > 0,
+            changedFiles: status.split("\n").filter(l => l.trim()).length,
+            recentCommits: log.split("\n").filter(l => l.trim()).slice(0, 5).map(l => {
+                const m = l.match(/^([a-f0-9]+)\s+(.+)$/);
+                return m ? { hash: m[1], message: m[2] } : null;
+            }).filter(Boolean),
+        },
+        project: pkg ? {
+            name: pkg.name,
+            version: pkg.version,
+            scripts: pkg.scripts ? Object.keys(pkg.scripts) : [],
+            deps: pkg.dependencies ? Object.keys(pkg.dependencies).length : 0,
+        } : null,
+        sourceFiles: srcLs.split("\n").filter(l => l.trim()),
+    };
+    bootCwd = cwd;
+    return bootCache;
+}
+/** Invalidate boot cache (call after git operations or file changes) */
+export function invalidateBootCache() {
+    bootCache = null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/terminal",
-  "version": "0.7.6",
+  "version": "0.8.0",
   "description": "Smart terminal wrapper for AI agents and humans — structured output, token compression, MCP server, natural language",
   "type": "module",
   "bin": {

package/src/file-index.ts

@@ -0,0 +1,93 @@
+// Pre-computed file index — build once, serve search from memory
+// Eliminates subprocess spawning for repeat file queries
+
+import { spawn } from "child_process";
+import { watch, type FSWatcher } from "fs";
+
+interface FileIndexEntry {
+  path: string;
+  dir: string;
+  name: string;
+  ext: string;
+}
+
+let index: FileIndexEntry[] | null = null;
+let indexCwd: string = "";
+let indexTime: number = 0;
+let watcher: FSWatcher | null = null;
+
+const INDEX_TTL = 30_000; // 30 seconds
+
+function exec(command: string, cwd: string): Promise<string> {
+  return new Promise((resolve) => {
+    const proc = spawn("/bin/zsh", ["-c", command], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let out = "";
+    proc.stdout?.on("data", (d: Buffer) => { out += d.toString(); });
+    proc.on("close", () => resolve(out));
+  });
+}
+
+/** Build or return cached file index */
+export async function getFileIndex(cwd: string): Promise<FileIndexEntry[]> {
+  // Return cached if fresh
+  if (index && indexCwd === cwd && Date.now() - indexTime < INDEX_TTL) {
+    return index;
+  }
+
+  const raw = await exec(
+    "find . -type f -not -path '*/node_modules/*' -not -path '*/.git/*' -not -path '*/dist/*' -not -path '*/.next/*' -not -path '*/build/*' 2>/dev/null",
+    cwd
+  );
+
+  index = raw.split("\n").filter(l => l.trim()).map(p => {
+    const path = p.trim();
+    const parts = path.split("/");
+    const name = parts[parts.length - 1] ?? path;
+    const dir = parts.slice(0, -1).join("/") || ".";
+    const ext = name.includes(".") ? "." + name.split(".").pop() : "";
+    return { path, dir, name, ext };
+  });
+
+  indexCwd = cwd;
+  indexTime = Date.now();
+
+  return index;
+}
+
+/** Search file index by glob pattern (in-memory, no subprocess) */
+export async function searchIndex(cwd: string, pattern: string): Promise<string[]> {
+  const idx = await getFileIndex(cwd);
+
+  // Convert glob to regex
+  const regex = new RegExp(
+    "^" + pattern
+      .replace(/\./g, "\\.")
+      .replace(/\*/g, ".*")
+      .replace(/\?/g, ".")
+    + "$",
+    "i"
+  );
+
+  return idx.filter(e => regex.test(e.name) || regex.test(e.path)).map(e => e.path);
+}
+
+/** Get file index stats */
+export async function indexStats(cwd: string): Promise<{ totalFiles: number; byExtension: Record<string, number>; byDir: Record<string, number> }> {
+  const idx = await getFileIndex(cwd);
+
+  const byExt: Record<string, number> = {};
+  const byDir: Record<string, number> = {};
+
+  for (const e of idx) {
+    byExt[e.ext || "(none)"] = (byExt[e.ext || "(none)"] ?? 0) + 1;
+    const topDir = e.dir.split("/").slice(0, 2).join("/");
+    byDir[topDir] = (byDir[topDir] ?? 0) + 1;
+  }
+
+  return { totalFiles: idx.length, byExtension: byExt, byDir };
+}
+
+/** Invalidate index */
+export function invalidateIndex(): void {
+  index = null;
+}

package/src/line-dedup.ts

@@ -0,0 +1,66 @@
+// Cross-command line deduplication — track lines already shown to agent
+// When new output contains >50% already-seen lines, suppress them
+
+const seenLines = new Set<string>();
+const MAX_SEEN = 5000;
+
+function normalize(line: string): string {
+  return line.trim().toLowerCase();
+}
+
+export interface DedupResult {
+  output: string;
+  novelCount: number;
+  seenCount: number;
+  deduplicated: boolean;
+}
+
+/** Deduplicate output lines against session history */
+export function dedup(output: string): DedupResult {
+  const lines = output.split("\n");
+  if (lines.length < 5) {
+    // Short output — add to seen, don't dedup
+    for (const l of lines) { if (l.trim()) seenLines.add(normalize(l)); }
+    return { output, novelCount: lines.length, seenCount: 0, deduplicated: false };
+  }
+
+  let novelCount = 0;
+  let seenCount = 0;
+  const novel: string[] = [];
+
+  for (const line of lines) {
+    const norm = normalize(line);
+    if (!norm) { novel.push(line); continue; }
+
+    if (seenLines.has(norm)) {
+      seenCount++;
+    } else {
+      novelCount++;
+      novel.push(line);
+      seenLines.add(norm);
+    }
+  }
+
+  // Evict oldest if too large
+  if (seenLines.size > MAX_SEEN) {
+    const entries = [...seenLines];
+    for (let i = 0; i < entries.length - MAX_SEEN; i++) {
+      seenLines.delete(entries[i]);
+    }
+  }
+
+  // Only dedup if >50% were already seen
+  if (seenCount > lines.length * 0.5) {
+    const result = novel.join("\n");
+    return { output: result + `\n(${seenCount} lines already shown, omitted)`, novelCount, seenCount, deduplicated: true };
+  }
+
+  // Add all to seen but return full output
+  for (const l of lines) { if (l.trim()) seenLines.add(normalize(l)); }
+  return { output, novelCount: lines.length, seenCount: 0, deduplicated: false };
+}
+
+/** Clear dedup history */
+export function clearDedup(): void {
+  seenLines.clear();
+}

package/src/mcp/server.ts

@@ -16,6 +16,7 @@ import { diffOutput } from "../diff-cache.js";
 import { processOutput } from "../output-processor.js";
 import { listSessions, getSessionInteractions, getSessionStats } from "../sessions-db.js";
 import { cachedRead, cacheStats } from "../file-cache.js";
+import { getBootContext } from "../session-boot.js";
 import { storeOutput, expandOutput } from "../expand-store.js";
 import { rewriteCommand } from "../command-rewriter.js";
 import { shouldBeLazy, toLazy } from "../lazy-executor.js";
@@ -587,6 +588,17 @@ export function createServer(): McpServer {
     }
   );
 
+  // ── boot: session start context (replaces first 5 agent commands) ──────────
+
+  server.tool(
+    "boot",
+    "Get everything an agent needs on session start in ONE call — git state, project info, source structure. Replaces: git status + git log + cat package.json + ls src/. Cached for the session.",
+    async () => {
+      const ctx = await getBootContext(process.cwd());
+      return { content: [{ type: "text" as const, text: JSON.stringify(ctx) }] };
+    }
+  );
+
   // ── project_overview: orient agent in one call ─────────────────────────────
 
   server.tool(

package/src/session-boot.ts

@@ -0,0 +1,64 @@
+// Session boot cache — precompute common data on first MCP call
+// Agents always start with git status + file tree + package.json — do it once
+
+import { spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+
+let bootCache: Record<string, unknown> | null = null;
+let bootCwd: string = "";
+
+function exec(command: string, cwd: string): Promise<string> {
+  return new Promise((resolve) => {
+    const proc = spawn("/bin/zsh", ["-c", command], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let out = "";
+    proc.stdout?.on("data", (d: Buffer) => { out += d.toString(); });
+    proc.on("close", () => resolve(out.trim()));
+  });
+}
+
+/** Get or build session boot context */
+export async function getBootContext(cwd: string): Promise<Record<string, unknown>> {
+  if (bootCache && bootCwd === cwd) return bootCache;
+
+  const [branch, status, log, srcLs] = await Promise.all([
+    exec("git branch --show-current 2>/dev/null", cwd),
+    exec("git status --porcelain 2>/dev/null", cwd),
+    exec("git log --oneline -8 2>/dev/null", cwd),
+    exec("ls -1 src/ 2>/dev/null || ls -1 lib/ 2>/dev/null || echo ''", cwd),
+  ]);
+
+  let pkg: any = null;
+  const pkgPath = join(cwd, "package.json");
+  if (existsSync(pkgPath)) {
+    try { pkg = JSON.parse(readFileSync(pkgPath, "utf8")); } catch {}
+  }
+
+  bootCache = {
+    cwd,
+    git: {
+      branch: branch || null,
+      dirty: status.length > 0,
+      changedFiles: status.split("\n").filter(l => l.trim()).length,
+      recentCommits: log.split("\n").filter(l => l.trim()).slice(0, 5).map(l => {
+        const m = l.match(/^([a-f0-9]+)\s+(.+)$/);
+        return m ? { hash: m[1], message: m[2] } : null;
+      }).filter(Boolean),
+    },
+    project: pkg ? {
+      name: pkg.name,
+      version: pkg.version,
+      scripts: pkg.scripts ? Object.keys(pkg.scripts) : [],
+      deps: pkg.dependencies ? Object.keys(pkg.dependencies).length : 0,
+    } : null,
+    sourceFiles: srcLs.split("\n").filter(l => l.trim()),
+  };
+  bootCwd = cwd;
+
+  return bootCache;
+}
+
+/** Invalidate boot cache (call after git operations or file changes) */
+export function invalidateBootCache(): void {
+  bootCache = null;
+}