deepdebug-local-agent 0.3.1

package/src/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/src/patch/patch-engine.js

@@ -0,0 +1,339 @@
+import path from 'path';
+import { readFile, writeFile, exists, ensureDir, copyFile } from '../utils/fs-utils.js';
+
+/**
+ * PatchEngine
+ *
+ * Sistema de aplicação de patches com backup e rollback.
+ */
+
+/**
+ * Parseia unified diff
+ * @param {string} diffText - Texto do diff
+ * @returns {Patch[]}
+ */
+export function parsePatch(diffText) {
+    const patches = [];
+    const lines = diffText.split('\n');
+
+    let currentPatch = null;
+    let currentHunk = null;
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+
+        // Início de novo arquivo
+        if (line.startsWith('---')) {
+            if (currentPatch) {
+                patches.push(currentPatch);
+            }
+
+            currentPatch = {
+                oldFileName: extractFileName(line),
+                newFileName: null,
+                hunks: []
+            };
+        }
+
+        // Nome do novo arquivo
+        else if (line.startsWith('+++') && currentPatch) {
+            currentPatch.newFileName = extractFileName(line);
+        }
+
+        // Início de hunk
+        else if (line.startsWith('@@') && currentPatch) {
+            const hunkMatch = line.match(/@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@/);
+
+            if (hunkMatch) {
+                currentHunk = {
+                    oldStart: parseInt(hunkMatch[1]),
+                    oldLines: parseInt(hunkMatch[2]) || 1,
+                    newStart: parseInt(hunkMatch[3]),
+                    newLines: parseInt(hunkMatch[4]) || 1,
+                    lines: []
+                };
+                currentPatch.hunks.push(currentHunk);
+            }
+        }
+
+        // Linha de conteúdo do hunk
+        else if (currentHunk && (line.startsWith(' ') || line.startsWith('+') || line.startsWith('-'))) {
+            currentHunk.lines.push(line);
+        }
+    }
+
+    if (currentPatch) {
+        patches.push(currentPatch);
+    }
+
+    return patches;
+}
+
+/**
+ * Extrai nome do arquivo da linha --- ou +++
+ */
+function extractFileName(line) {
+    return line.replace(/^[-+]{3}\s+[ab]\//, '').replace(/^[-+]{3}\s+/, '');
+}
+
+/**
+ * Aplica patch a um arquivo
+ * @param {string} original - Conteúdo original
+ * @param {Patch} patch - Patch a aplicar
+ * @returns {string|false}
+ */
+export function applyPatch(original, patch) {
+    const originalLines = original.split('\n');
+    const resultLines = [...originalLines];
+
+    let offset = 0;
+
+    for (const hunk of patch.hunks) {
+        const startLine = hunk.oldStart - 1 + offset;
+        let currentLine = startLine;
+        let removedCount = 0;
+        let addedCount = 0;
+
+        // Verificar contexto
+        let contextMatches = true;
+        let checkLine = startLine;
+
+        for (const line of hunk.lines) {
+            if (line.startsWith(' ') || line.startsWith('-')) {
+                const expectedContent = line.substring(1);
+                const actualContent = originalLines[checkLine];
+
+                if (actualContent !== expectedContent) {
+                    if (actualContent?.trim() !== expectedContent.trim()) {
+                        contextMatches = false;
+                        break;
+                    }
+                }
+                checkLine++;
+            }
+        }
+
+        if (!contextMatches) {
+            console.warn(`⚠️ Hunk at line ${hunk.oldStart} doesn't match context`);
+            return false;
+        }
+
+        // Aplicar hunk
+        const linesToRemove = [];
+        const linesToAdd = [];
+
+        for (const line of hunk.lines) {
+            if (line.startsWith('-')) {
+                linesToRemove.push(currentLine);
+                removedCount++;
+                currentLine++;
+            } else if (line.startsWith('+')) {
+                linesToAdd.push({
+                    position: currentLine,
+                    content: line.substring(1)
+                });
+                addedCount++;
+            } else if (line.startsWith(' ')) {
+                currentLine++;
+            }
+        }
+
+        // Remover linhas (de trás para frente)
+        for (let i = linesToRemove.length - 1; i >= 0; i--) {
+            resultLines.splice(linesToRemove[i], 1);
+        }
+
+        // Adicionar linhas
+        for (let i = 0; i < linesToAdd.length; i++) {
+            const { position, content } = linesToAdd[i];
+            const adjustedPosition = position - removedCount + i;
+            resultLines.splice(adjustedPosition, 0, content);
+        }
+
+        offset += addedCount - removedCount;
+    }
+
+    return resultLines.join('\n');
+}
+
+/**
+ * Aplica unified diff a um workspace
+ * @param {string} root - Raiz do workspace
+ * @param {string} diffText - Texto do diff
+ * @returns {Promise<PatchResult>}
+ */
+export async function applyUnifiedDiff(root, diffText) {
+    const patches = parsePatch(diffText);
+
+    if (patches.length === 0) {
+        throw new Error('No patches found in diff');
+    }
+
+    const results = [];
+
+    for (const patch of patches) {
+        const targetRel = patch.newFileName?.replace(/^b\//, '') ||
+            patch.oldFileName?.replace(/^a\//, '');
+
+        if (!targetRel || targetRel === '/dev/null') {
+            continue;
+        }
+
+        const fullPath = path.join(root, targetRel);
+
+        if (!(await exists(fullPath))) {
+            if (patch.oldFileName === '/dev/null') {
+                const newContent = patch.hunks
+                    .flatMap(h => h.lines)
+                    .filter(l => l.startsWith('+'))
+                    .map(l => l.substring(1))
+                    .join('\n');
+
+                await ensureDir(path.dirname(fullPath));
+                await writeFile(fullPath, newContent, 'utf8');
+
+                results.push({
+                    file: targetRel,
+                    action: 'created',
+                    bytes: Buffer.byteLength(newContent, 'utf8')
+                });
+
+                continue;
+            }
+
+            throw new Error(`File not found: ${targetRel}`);
+        }
+
+        const original = await readFile(fullPath, 'utf8');
+        const result = applyPatch(original, patch);
+
+        if (result === false) {
+            throw new Error(`Failed to apply patch to ${targetRel}`);
+        }
+
+        await writeFile(fullPath, result, 'utf8');
+
+        results.push({
+            file: targetRel,
+            action: 'modified',
+            bytes: Buffer.byteLength(result, 'utf8')
+        });
+    }
+
+    const firstResult = results[0] || { file: null, action: null, bytes: 0 };
+
+    return {
+        target: firstResult.file,
+        bytes: firstResult.bytes,
+        results,
+        patchCount: results.length
+    };
+}
+
+/**
+ * Cria backup de arquivos antes de aplicar patch
+ * @param {string} root - Raiz do workspace
+ * @param {string[]} files - Lista de arquivos
+ * @param {string} backupId - ID do backup
+ * @returns {Promise<BackupResult>}
+ */
+export async function createBackup(root, files, backupId) {
+    const backupDir = path.join(root, '.insptech', 'backups', backupId);
+    await ensureDir(backupDir);
+
+    const backedUp = [];
+
+    for (const file of files) {
+        const srcPath = path.join(root, file);
+        const destPath = path.join(backupDir, file);
+
+        if (await exists(srcPath)) {
+            await ensureDir(path.dirname(destPath));
+            await copyFile(srcPath, destPath);
+            backedUp.push(file);
+        }
+    }
+
+    // Criar manifest
+    const manifest = {
+        id: backupId,
+        timestamp: new Date().toISOString(),
+        files: backedUp
+    };
+
+    await writeFile(
+        path.join(backupDir, 'manifest.json'),
+        JSON.stringify(manifest, null, 2),
+        'utf8'
+    );
+
+    return {
+        backupId,
+        backupDir,
+        files: backedUp
+    };
+}
+
+/**
+ * Restaura backup
+ * @param {string} root - Raiz do workspace
+ * @param {string} backupId - ID do backup
+ * @returns {Promise<RestoreResult>}
+ */
+export async function restoreBackup(root, backupId) {
+    const backupDir = path.join(root, '.insptech', 'backups', backupId);
+
+    if (!(await exists(backupDir))) {
+        throw new Error(`Backup not found: ${backupId}`);
+    }
+
+    const manifestPath = path.join(backupDir, 'manifest.json');
+    const manifest = JSON.parse(await readFile(manifestPath, 'utf8'));
+
+    const restored = [];
+
+    for (const file of manifest.files) {
+        const srcPath = path.join(backupDir, file);
+        const destPath = path.join(root, file);
+
+        if (await exists(srcPath)) {
+            await copyFile(srcPath, destPath);
+            restored.push(file);
+        }
+    }
+
+    return {
+        backupId,
+        files: restored
+    };
+}
+
+/**
+ * Extrai arquivos afetados por um diff
+ * @param {string} diffText - Texto do diff
+ * @returns {string[]}
+ */
+export function extractAffectedFiles(diffText) {
+    const patches = parsePatch(diffText);
+    const files = new Set();
+
+    for (const patch of patches) {
+        if (patch.newFileName && patch.newFileName !== '/dev/null') {
+            files.add(patch.newFileName.replace(/^b\//, ''));
+        }
+        if (patch.oldFileName && patch.oldFileName !== '/dev/null') {
+            files.add(patch.oldFileName.replace(/^a\//, ''));
+        }
+    }
+
+    return Array.from(files);
+}
+
+export default {
+    parsePatch,
+    applyPatch,
+    applyUnifiedDiff,
+    createBackup,
+    restoreBackup,
+    extractAffectedFiles
+};