deepdebug-local-agent 0.3.7 → 0.3.9

package/fs-utils.js

@@ -0,0 +1,34 @@
+import fs from "fs";
+import path from "path";
+import { promisify } from "util";
+
+export const stat = promisify(fs.stat);
+export const readdir = promisify(fs.readdir);
+export const readFile = promisify(fs.readFile);
+export const writeFile = promisify(fs.writeFile);
+export const access = promisify(fs.access);
+
+export async function exists(p) {
+    try { await access(p, fs.constants.F_OK); return true; }
+    catch { return false; }
+}
+
+export async function listRecursive(root, { maxFiles = 5000, includeHidden = false } = {}) {
+    const results = [];
+    async function walk(dir) {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const e of entries) {
+            if (!includeHidden && e.name.startsWith(".")) continue;
+            const full = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                results.push({ type: "dir", path: path.relative(root, full) });
+                await walk(full);
+            } else {
+                results.push({ type: "file", path: path.relative(root, full) });
+                if (results.length >= maxFiles) return;
+            }
+        }
+    }
+    await walk(root);
+    return results;
+}

package/mcp-http-server.js

@@ -0,0 +1,313 @@
+import express from "express";
+import path from "path";
+import { spawn } from "child_process";
+import { readFile, writeFile, listRecursive, exists } from "./fs-utils.js";
+import { detectProject } from "./detectors.js";
+import { applyUnifiedDiff } from "./patch.js";
+
+/**
+ * MCP HTTP Bridge — Expõe as MCP tools como REST API.
+ *
+ * O Gateway Java chama estes endpoints para obter contexto do código
+ * ANTES de enviar o prompt ao Claude.
+ *
+ * Port: 5056 (separado do Express principal na 5055)
+ *
+ * Isto é mais prático que stdio MCP para comunicação Gateway ↔ Agent,
+ * e mantém compatibilidade com MCP tools para uso futuro com Claude Code.
+ */
+
+const IGNORE_DIRS = ["node_modules", ".git", "target", "build", "dist", ".idea", "__pycache__", "vendor", ".gradle"];
+
+export function startMCPHttpServer(workspaceManager, port = 5056) {
+    const app = express();
+    app.use(express.json({ limit: "50mb" }));
+
+    // ========================================
+    // Health
+    // ========================================
+    app.get("/health", (_req, res) => {
+        res.json({
+            status: "ok",
+            server: "deepdebug-mcp",
+            workspaces: workspaceManager.count,
+            openWorkspaces: workspaceManager.list().map(w => ({
+                id: w.id, root: w.root, language: w.projectInfo?.language
+            })),
+        });
+    });
+
+    // ========================================
+    // POST /mcp/open — Open workspace
+    // ========================================
+    app.post("/mcp/open", async (req, res) => {
+        const { workspaceId, root } = req.body;
+        if (!workspaceId || !root) {
+            return res.status(400).json({ error: "workspaceId and root are required" });
+        }
+        try {
+            const ws = await workspaceManager.open(workspaceId, root);
+            res.json({ ok: true, workspace: ws });
+        } catch (e) {
+            res.status(400).json({ error: e.message });
+        }
+    });
+
+    // ========================================
+    // POST /mcp/close — Close workspace
+    // ========================================
+    app.post("/mcp/close", (req, res) => {
+        const { workspaceId } = req.body;
+        const closed = workspaceManager.close(workspaceId);
+        res.json({ ok: closed });
+    });
+
+    // ========================================
+    // GET /mcp/workspaces — List all open
+    // ========================================
+    app.get("/mcp/workspaces", (_req, res) => {
+        res.json({ workspaces: workspaceManager.list() });
+    });
+
+    // ========================================
+    // POST /mcp/read-file
+    // ========================================
+    app.post("/mcp/read-file", async (req, res) => {
+        const { workspaceId, path: filePath } = req.body;
+        try {
+            const root = workspaceManager.resolveRoot(workspaceId);
+            const fullPath = path.resolve(root, filePath);
+            if (!fullPath.startsWith(root)) {
+                return res.status(403).json({ error: "Path outside workspace" });
+            }
+            if (!(await exists(fullPath))) {
+                return res.status(404).json({ error: `File not found: ${filePath}` });
+            }
+            const content = await readFile(fullPath, "utf8");
+            res.json({
+                ok: true,
+                path: filePath,
+                content,
+                size: Buffer.byteLength(content),
+                lines: content.split("\n").length,
+            });
+        } catch (e) {
+            res.status(400).json({ error: e.message });
+        }
+    });
+
+    // ========================================
+    // POST /mcp/read-files — Batch read
+    // ========================================
+    app.post("/mcp/read-files", async (req, res) => {
+        const { workspaceId, paths } = req.body;
+        if (!paths || !Array.isArray(paths)) {
+            return res.status(400).json({ error: "paths array required" });
+        }
+        try {
+            const root = workspaceManager.resolveRoot(workspaceId);
+            const results = {};
+
+            for (const filePath of paths.slice(0, 20)) { // Max 20 files
+                const fullPath = path.resolve(root, filePath);
+                if (!fullPath.startsWith(root)) continue;
+                try {
+                    const content = await readFile(fullPath, "utf8");
+                    results[filePath] = { ok: true, content, lines: content.split("\n").length };
+                } catch {
+                    results[filePath] = { ok: false, error: "File not found" };
+                }
+            }
+
+            res.json({ ok: true, files: results, count: Object.keys(results).length });
+        } catch (e) {
+            res.status(400).json({ error: e.message });
+        }
+    });
+
+    // ========================================
+    // POST /mcp/list-directory
+    // ========================================
+    app.post("/mcp/list-directory", async (req, res) => {
+        const { workspaceId, path: dirPath = "", maxFiles = 500 } = req.body;
+        try {
+            const root = workspaceManager.resolveRoot(workspaceId);
+            const targetDir = dirPath ? path.resolve(root, dirPath) : root;
+
+            if (!targetDir.startsWith(root)) {
+                return res.status(403).json({ error: "Path outside workspace" });
+            }
+
+            const files = await listRecursive(targetDir, { maxFiles });
+            const filtered = files.filter(f => !IGNORE_DIRS.some(ig => f.path.includes(ig)));
+
+            res.json({
+                ok: true,
+                root: dirPath || "/",
+                totalItems: filtered.length,
+                items: filtered,
+            });
+        } catch (e) {
+            res.status(400).json({ error: e.message });
+        }
+    });
+
+    // ========================================
+    // POST /mcp/search-code
+    // ========================================
+    app.post("/mcp/search-code", async (req, res) => {
+        const { workspaceId, query, filePattern = "", maxResults = 50 } = req.body;
+        if (!query) return res.status(400).json({ error: "query required" });
+
+        try {
+            const root = workspaceManager.resolveRoot(workspaceId);
+            const results = await grepWorkspace(root, query, filePattern, maxResults);
+            res.json({ ok: true, query, matches: results.length, results });
+        } catch (e) {
+            res.status(400).json({ error: e.message });
+        }
+    });
+
+    // ========================================
+    // POST /mcp/execute-command
+    // ========================================
+    app.post("/mcp/execute-command", async (req, res) => {
+        const { workspaceId, command, timeout = 120 } = req.body;
+        if (!command) return res.status(400).json({ error: "command required" });
+
+        // Security
+        const BLOCKED = ["rm -rf /", "mkfs", "dd if=/dev", ":(){ :|:"];
+        if (BLOCKED.some(b => command.includes(b))) {
+            return res.status(403).json({ error: "Command blocked" });
+        }
+
+        try {
+            const root = workspaceManager.resolveRoot(workspaceId);
+            const result = await execInWorkspace(root, command, timeout);
+            res.json({ ok: result.exitCode === 0, ...result });
+        } catch (e) {
+            res.status(400).json({ error: e.message });
+        }
+    });
+
+    // ========================================
+    // POST /mcp/project-info
+    // ========================================
+    app.post("/mcp/project-info", async (req, res) => {
+        const { workspaceId } = req.body;
+        try {
+            const root = workspaceManager.resolveRoot(workspaceId);
+            const projectInfo = await detectProject(root);
+            const files = await listRecursive(root, { maxFiles: 200 });
+            const filtered = files.filter(f => !IGNORE_DIRS.some(ig => f.path.includes(ig)));
+
+            const sourceExts = { java: 0, js: 0, ts: 0, py: 0, go: 0, cs: 0 };
+            filtered.forEach(f => {
+                if (f.type !== "file") return;
+                const ext = f.path.split(".").pop();
+                if (ext in sourceExts) sourceExts[ext]++;
+            });
+
+            res.json({
+                ok: true,
+                ...projectInfo,
+                root,
+                totalFiles: filtered.length,
+                sourceFiles: sourceExts,
+                topDirectories: [...new Set(filtered
+                    .filter(f => f.type === "dir")
+                    .map(f => f.path.split("/")[0])
+                )].slice(0, 25),
+            });
+        } catch (e) {
+            res.status(400).json({ error: e.message });
+        }
+    });
+
+    // ========================================
+    // POST /mcp/apply-patch
+    // ========================================
+    app.post("/mcp/apply-patch", async (req, res) => {
+        const { workspaceId, diff } = req.body;
+        if (!diff) return res.status(400).json({ error: "diff required" });
+
+        try {
+            const root = workspaceManager.resolveRoot(workspaceId);
+            const result = await applyUnifiedDiff(root, diff);
+            res.json({ ok: true, ...result });
+        } catch (e) {
+            res.status(400).json({ error: e.message });
+        }
+    });
+
+    // ========================================
+    // START SERVER
+    // ========================================
+    app.listen(port, () => {
+        console.log(`🔌 MCP HTTP Bridge listening on http://localhost:${port}`);
+    });
+
+    return app;
+}
+
+// ========================================
+// HELPERS
+// ========================================
+
+function grepWorkspace(root, query, filePattern, maxResults) {
+    return new Promise((resolve) => {
+        const args = [
+            "-r", "-n",
+            ...IGNORE_DIRS.flatMap(d => ["--exclude-dir", d]),
+        ];
+        if (filePattern) args.push("--include", filePattern);
+        args.push("-m", String(maxResults), query, ".");
+
+        const child = spawn("grep", args, { cwd: root });
+        let stdout = "";
+
+        child.stdout.on("data", d => stdout += d.toString());
+        const timer = setTimeout(() => { try { child.kill(); } catch {} }, 15000);
+
+        child.on("close", () => {
+            clearTimeout(timer);
+            if (!stdout.trim()) return resolve([]);
+
+            const results = stdout.trim().split("\n").slice(0, maxResults).map(line => {
+                // Format: ./path/to/file.java:42:  code line content
+                const match = line.match(/^\.\/(.+?):(\d+):(.*)$/);
+                if (match) {
+                    return { file: match[1], line: parseInt(match[2]), content: match[3].trim() };
+                }
+                return { raw: line };
+            });
+            resolve(results);
+        });
+    });
+}
+
+function execInWorkspace(root, command, timeoutSec) {
+    return new Promise((resolve) => {
+        const child = spawn("sh", ["-c", command], { cwd: root });
+        let stdout = "";
+        let stderr = "";
+
+        child.stdout.on("data", d => stdout += d.toString());
+        child.stderr.on("data", d => stderr += d.toString());
+
+        const timer = setTimeout(() => {
+            try { child.kill("SIGKILL"); } catch {}
+            resolve({ exitCode: -1, stdout, stderr, timedOut: true });
+        }, timeoutSec * 1000);
+
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            // Truncate long outputs
+            const maxLen = 10000;
+            if (stdout.length > maxLen) {
+                stdout = stdout.substring(0, maxLen / 2) + "\n...(truncated)...\n" + stdout.substring(stdout.length - maxLen / 2);
+            }
+            resolve({ exitCode: code, stdout, stderr: stderr.substring(0, 5000), timedOut: false });
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepdebug-local-agent",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "description": "Insptech AI — DeepDebug Local Agent. Autonomous code debugging agent for production environments.",
   "type": "module",
   "main": "server.js",