@hasna/terminal 4.3.1 → 4.3.2

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/loop-detector.js

@@ -0,0 +1,75 @@
+// Edit-test loop detector — detects repetitive test→edit→test patterns
+// and suggests narrowing to specific test files
+const history = [];
+const MAX_HISTORY = 20;
+// Detect test commands
+const TEST_PATTERNS = [
+    /\bbun\s+test\b/, /\bnpm\s+test\b/, /\bnpx\s+jest\b/, /\bnpx\s+vitest\b/,
+    /\bpnpm\s+test\b/, /\byarn\s+test\b/, /\bpytest\b/, /\bgo\s+test\b/,
+    /\bcargo\s+test\b/, /\brspec\b/, /\bphpunit\b/, /\bmocha\b/,
+];
+function isTestCommand(cmd) {
+    return TEST_PATTERNS.some(p => p.test(cmd));
+}
+function isFullSuiteCommand(cmd) {
+    // Full suite = test command without specific file/pattern
+    if (!isTestCommand(cmd))
+        return false;
+    // If it has a specific file or --grep, it's already narrowed
+    if (/\.(test|spec)\.(ts|tsx|js|jsx|py|rs|go)/.test(cmd))
+        return false;
+    if (/--grep|--filter|-t\s/.test(cmd))
+        return false;
+    return true;
+}
+/** Record a command execution and detect loops */
+export function detectLoop(command) {
+    history.push({ command, timestamp: Date.now() });
+    if (history.length > MAX_HISTORY)
+        history.shift();
+    if (!isTestCommand(command)) {
+        return { detected: false, iteration: 0, testCommand: command };
+    }
+    // Count consecutive test runs (allowing non-test commands between them)
+    let testCount = 0;
+    for (let i = history.length - 1; i >= 0; i--) {
+        if (isTestCommand(history[i].command))
+            testCount++;
+        // If we hit a non-test, non-edit command, stop counting
+        // (edits are invisible to us since we only see exec'd commands)
+    }
+    if (testCount < 3 || !isFullSuiteCommand(command)) {
+        return { detected: false, iteration: testCount, testCommand: command };
+    }
+    // Detected loop — suggest narrowing
+    // Try to find a recently-mentioned test file in recent commands
+    let suggestedNarrow;
+    // Look for file paths in recent history that could be test targets
+    for (let i = history.length - 2; i >= Math.max(0, history.length - 10); i--) {
+        const cmd = history[i].command;
+        // Look for edited/touched files
+        const fileMatch = cmd.match(/(\S+\.(ts|tsx|js|jsx|py|rs|go))\b/);
+        if (fileMatch && !isTestCommand(cmd)) {
+            const file = fileMatch[1];
+            // Suggest corresponding test file
+            const testFile = file.replace(/\.(ts|tsx|js|jsx)$/, ".test.$1");
+            suggestedNarrow = command.replace(/\b(test)\b/, `test ${testFile}`);
+            break;
+        }
+    }
+    // Fallback: suggest adding --grep or specific file
+    if (!suggestedNarrow) {
+        suggestedNarrow = undefined; // Can't determine which file
+    }
+    return {
+        detected: true,
+        iteration: testCount,
+        testCommand: command,
+        suggestedNarrow,
+        reason: `Full test suite run ${testCount} times. Consider narrowing to specific test file.`,
+    };
+}
+/** Reset loop detection (e.g., on session start) */
+export function resetLoopDetector() {
+    history.length = 0;
+}

package/dist/mcp/install.js

@@ -0,0 +1,189 @@
+// MCP installation — one command to rule them all
+// `npx @hasna/terminal install` → installs globally + configures all AI agents
+import { execSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function which(cmd) {
+    try {
+        return execSync(`which ${cmd}`, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+function log(icon, msg) { console.log(`  ${icon} ${msg}`); }
+// ── Detect what's installed ──────────────────────────────────────────────────
+function hasClaude() { return !!which("claude"); }
+function hasCodex() { return !!which("codex"); }
+function hasGemini() { return !!which("gemini"); }
+// ── Install for Claude Code ─────────────────────────────────────────────────
+function installClaude(bin) {
+    if (!hasClaude()) {
+        log("–", "Claude Code not found, skipping");
+        return false;
+    }
+    try {
+        execSync(`claude mcp add --transport stdio --scope user terminal -- ${bin} mcp serve`, { stdio: ["pipe", "pipe", "pipe"] });
+        log("✓", "Claude Code");
+        return true;
+    }
+    catch {
+        // May already exist
+        try {
+            execSync(`claude mcp remove terminal -s user`, { stdio: ["pipe", "pipe", "pipe"] });
+            execSync(`claude mcp add --transport stdio --scope user terminal -- ${bin} mcp serve`, { stdio: ["pipe", "pipe", "pipe"] });
+            log("✓", "Claude Code (updated)");
+            return true;
+        }
+        catch (e) {
+            log("✗", `Claude Code — ${e}`);
+            return false;
+        }
+    }
+}
+// ── Install for Codex ───────────────────────────────────────────────────────
+function installCodex(bin) {
+    if (!hasCodex()) {
+        log("–", "Codex not found, skipping");
+        return false;
+    }
+    const dir = join(homedir(), ".codex");
+    const configPath = join(dir, "config.toml");
+    try {
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        let content = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
+        // Remove old entry if exists
+        content = content.replace(/\n?\[mcp_servers\.terminal\][^\[]*/g, "");
+        content += `\n[mcp_servers.terminal]\ncommand = "${bin}"\nargs = ["mcp", "serve"]\n`;
+        writeFileSync(configPath, content);
+        log("✓", "Codex");
+        return true;
+    }
+    catch (e) {
+        log("✗", `Codex — ${e}`);
+        return false;
+    }
+}
+// ── Install for Gemini ──────────────────────────────────────────────────────
+function installGemini(bin) {
+    if (!hasGemini()) {
+        log("–", "Gemini CLI not found, skipping");
+        return false;
+    }
+    const dir = join(homedir(), ".gemini");
+    const configPath = join(dir, "settings.json");
+    try {
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        let config = {};
+        if (existsSync(configPath)) {
+            try {
+                config = JSON.parse(readFileSync(configPath, "utf8"));
+            }
+            catch { }
+        }
+        if (!config.mcpServers)
+            config.mcpServers = {};
+        config.mcpServers["terminal"] = { command: bin, args: ["mcp", "serve"] };
+        writeFileSync(configPath, JSON.stringify(config, null, 2));
+        log("✓", "Gemini CLI");
+        return true;
+    }
+    catch (e) {
+        log("✗", `Gemini — ${e}`);
+        return false;
+    }
+}
+// ── Uninstall ───────────────────────────────────────────────────────────────
+function uninstallClaude() {
+    if (!hasClaude())
+        return false;
+    try {
+        execSync(`claude mcp remove terminal -s user`, { stdio: ["pipe", "pipe", "pipe"] });
+        log("✓", "Removed from Claude Code");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function uninstallCodex() {
+    const configPath = join(homedir(), ".codex", "config.toml");
+    if (!existsSync(configPath))
+        return false;
+    try {
+        let content = readFileSync(configPath, "utf8");
+        if (!content.includes("terminal"))
+            return false;
+        content = content.replace(/\n?\[mcp_servers\.terminal\][^\[]*/g, "");
+        writeFileSync(configPath, content);
+        log("✓", "Removed from Codex");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function uninstallGemini() {
+    const configPath = join(homedir(), ".gemini", "settings.json");
+    if (!existsSync(configPath))
+        return false;
+    try {
+        const config = JSON.parse(readFileSync(configPath, "utf8"));
+        if (!config.mcpServers?.["terminal"])
+            return false;
+        delete config.mcpServers["terminal"];
+        writeFileSync(configPath, JSON.stringify(config, null, 2));
+        log("✓", "Removed from Gemini CLI");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ── Main install handler ────────────────────────────────────────────────────
+export function handleInstall(args) {
+    const flags = new Set(args);
+    // Uninstall
+    if (flags.has("uninstall") || flags.has("--uninstall")) {
+        console.log("\n  Removing terminal MCP server...\n");
+        uninstallClaude();
+        uninstallCodex();
+        uninstallGemini();
+        console.log("\n  Done. Restart your agents to apply.\n");
+        return;
+    }
+    // Targeted install
+    if (flags.has("--claude") || flags.has("--codex") || flags.has("--gemini")) {
+        const bin = which("terminal") ?? which("t") ?? "npx @hasna/terminal";
+        console.log("");
+        if (flags.has("--claude"))
+            installClaude(bin);
+        if (flags.has("--codex"))
+            installCodex(bin);
+        if (flags.has("--gemini"))
+            installGemini(bin);
+        console.log("");
+        return;
+    }
+    // ── Default: install everything ─────────────────────────────────────────
+    const bin = which("terminal") ?? which("t") ?? "npx @hasna/terminal";
+    console.log(`\n  terminal — setting up MCP...\n`);
+    let count = 0;
+    if (installClaude(bin))
+        count++;
+    if (installCodex(bin))
+        count++;
+    if (installGemini(bin))
+        count++;
+    if (count === 0) {
+        console.log(`\n  No agents found. Install Claude Code, Codex, or Gemini CLI first.\n`);
+    }
+    else {
+        console.log(`\n  ${count} agent${count > 1 ? "s" : ""} ready. Restart to apply.\n`);
+    }
+}
+// Re-export individual installers for programmatic use
+export { installClaude, installCodex, installGemini, uninstallClaude, uninstallCodex, uninstallGemini };

package/dist/mcp/server.js

@@ -0,0 +1,56 @@
+// MCP Server for terminal — exposes terminal capabilities to AI agents
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createSession } from "../sessions-db.js";
+import { createHelpers } from "./tools/helpers.js";
+// Tool registration modules
+import { registerExecuteTools } from "./tools/execute.js";
+import { registerGitTools } from "./tools/git.js";
+import { registerSearchTools } from "./tools/search.js";
+import { registerFileTools } from "./tools/files.js";
+import { registerProjectTools } from "./tools/project.js";
+import { registerProcessTools } from "./tools/process.js";
+import { registerBatchTools } from "./tools/batch.js";
+import { registerMemoryTools } from "./tools/memory.js";
+import { registerMetaTools } from "./tools/meta.js";
+import { registerCloudTools } from "@hasna/cloud";
+// ── server ───────────────────────────────────────────────────────────────────
+export function createServer() {
+    const server = new McpServer({
+        name: "terminal",
+        version: "4.2.0",
+    });
+    // Create a session for this MCP server instance
+    const sessionId = createSession(process.cwd(), "mcp");
+    // ── Mementos: cross-session project memory ────────────────────────────────
+    try {
+        const mementos = require("@hasna/mementos");
+        const projectName = process.cwd().split("/").pop() ?? "unknown";
+        const project = mementos.registerProject(projectName, process.cwd());
+        const mementosProjectId = project?.id ?? null;
+        mementos.registerAgent("terminal-mcp");
+        if (mementosProjectId)
+            mementos.setFocus(mementosProjectId);
+    }
+    catch { } // mementos optional — works without it
+    // Create shared helpers and register all tool groups
+    const h = createHelpers(sessionId);
+    registerExecuteTools(server, h);
+    registerGitTools(server, h);
+    registerSearchTools(server, h);
+    registerFileTools(server, h);
+    registerProjectTools(server, h);
+    registerProcessTools(server, h);
+    registerBatchTools(server, h);
+    registerMemoryTools(server, h);
+    registerMetaTools(server, h);
+    registerCloudTools(server, "terminal");
+    return server;
+}
+// ── main: start MCP server via stdio ─────────────────────────────────────────
+export async function startMcpServer() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("terminal MCP server running on stdio");
+}

package/dist/mcp/tools/batch.js

@@ -0,0 +1,111 @@
+// Batch tools: batch
+import { z } from "./helpers.js";
+import { stripAnsi } from "../../compression.js";
+import { processOutput } from "../../output-processor.js";
+import { getOutputProvider } from "../../providers/index.js";
+import { searchContent } from "../../search/index.js";
+import { cachedRead } from "../../file-cache.js";
+export function registerBatchTools(server, h) {
+    server.tool("batch", "Run multiple operations in ONE call. Saves N-1 round trips. Each op can be: execute (run command), read (file read/summarize), search (grep pattern), or symbols (file outline).", {
+        ops: z.array(z.object({
+            type: z.enum(["execute", "read", "write", "search", "symbols"]).describe("Operation type"),
+            command: z.string().optional().describe("Shell command (for execute)"),
+            path: z.string().optional().describe("File path (for read/write/symbols)"),
+            content: z.string().optional().describe("File content (for write)"),
+            pattern: z.string().optional().describe("Search pattern (for search)"),
+            summarize: z.boolean().optional().describe("AI summarize (for read)"),
+            format: z.enum(["raw", "summary"]).optional().describe("Output format (for execute)"),
+        })).describe("Array of operations to run"),
+        cwd: z.string().optional().describe("Working directory for all ops"),
+    }, async ({ ops, cwd }) => {
+        const start = Date.now();
+        const workDir = cwd ?? process.cwd();
+        const results = [];
+        for (let i = 0; i < ops.slice(0, 10).length; i++) {
+            const op = ops[i];
+            try {
+                if (op.type === "execute" && op.command) {
+                    const result = await h.exec(op.command, workDir, 30000);
+                    const output = (result.stdout + result.stderr).trim();
+                    if (op.format === "summary" && output.split("\n").length > 15) {
+                        const processed = await processOutput(op.command, output);
+                        results.push({ op: i, type: "execute", summary: processed.summary, exitCode: result.exitCode, tokensSaved: processed.tokensSaved });
+                    }
+                    else {
+                        results.push({ op: i, type: "execute", output: stripAnsi(output).slice(0, 2000), exitCode: result.exitCode });
+                    }
+                }
+                else if (op.type === "read" && op.path) {
+                    const filePath = h.resolvePath(op.path, workDir);
+                    const result = cachedRead(filePath, {});
+                    if (op.summarize && result.content.length > 500) {
+                        const provider = getOutputProvider();
+                        const outputModel = provider.name === "groq" ? "llama-3.1-8b-instant" : undefined;
+                        const content = result.content.length > 8000 ? result.content.slice(0, 8000) : result.content;
+                        const summary = await provider.complete(`File: ${filePath}\n\n${content}`, {
+                            model: outputModel,
+                            system: `Describe what this source file does in 2-4 lines. Include: main class/module name, key methods/functions, what it exports, and its purpose. Be specific.`,
+                            maxTokens: 300, temperature: 0.2,
+                        });
+                        results.push({ op: i, type: "read", path: op.path, summary, lines: result.content.split("\n").length });
+                    }
+                    else {
+                        results.push({ op: i, type: "read", path: op.path, content: result.content, lines: result.content.split("\n").length });
+                    }
+                }
+                else if (op.type === "write" && op.path && op.content !== undefined) {
+                    const filePath = h.resolvePath(op.path, workDir);
+                    const { writeFileSync, mkdirSync, existsSync } = await import("fs");
+                    const { dirname } = await import("path");
+                    const dir = dirname(filePath);
+                    if (!existsSync(dir))
+                        mkdirSync(dir, { recursive: true });
+                    writeFileSync(filePath, op.content);
+                    results.push({ op: i, type: "write", path: op.path, ok: true, bytes: op.content.length });
+                }
+                else if (op.type === "search" && op.pattern) {
+                    // Search accepts both files and directories — resolve to parent dir if file
+                    let searchPath = op.path ? h.resolvePath(op.path, workDir) : workDir;
+                    try {
+                        const { statSync } = await import("fs");
+                        if (statSync(searchPath).isFile())
+                            searchPath = searchPath.replace(/\/[^/]+$/, "");
+                    }
+                    catch { }
+                    const result = await searchContent(op.pattern, searchPath, {});
+                    results.push({ op: i, type: "search", pattern: op.pattern, totalMatches: result.totalMatches, files: result.files.slice(0, 10) });
+                }
+                else if (op.type === "symbols" && op.path) {
+                    const filePath = h.resolvePath(op.path, workDir);
+                    const result = cachedRead(filePath, {});
+                    if (result.content && !result.content.startsWith("Error:")) {
+                        const provider = getOutputProvider();
+                        const outputModel = provider.name === "groq" ? "llama-3.1-8b-instant" : undefined;
+                        const content = result.content.length > 8000 ? result.content.slice(0, 8000) : result.content;
+                        const summary = await provider.complete(`File: ${filePath}\n\n${content}`, {
+                            model: outputModel,
+                            system: `Extract all symbols. Return ONLY a JSON array. Each: {"name":"x","kind":"function|class|method|interface|type","line":N,"signature":"brief"}. For class methods use "Class.method". Exclude imports.`,
+                            maxTokens: 2000, temperature: 0,
+                        });
+                        let symbols = [];
+                        try {
+                            const m = summary.match(/\[[\s\S]*\]/);
+                            if (m)
+                                symbols = JSON.parse(m[0]);
+                        }
+                        catch { }
+                        results.push({ op: i, type: "symbols", path: op.path, symbols });
+                    }
+                    else {
+                        results.push({ op: i, type: "symbols", path: op.path, error: "Cannot read file" });
+                    }
+                }
+            }
+            catch (err) {
+                results.push({ op: i, type: op.type, error: err.message?.slice(0, 200) });
+            }
+        }
+        h.logCall("batch", { command: `${ops.length} ops`, durationMs: Date.now() - start, aiProcessed: true });
+        return { content: [{ type: "text", text: JSON.stringify({ results, total: results.length, durationMs: Date.now() - start }) }] };
+    });
+}