deepdebug-local-agent 0.3.1

package/src/patch_bkp.js

@@ -0,0 +1,154 @@
+import path from "path";
+import { writeFile, readFile, exists } from "./fs-utils.js";
+import pkg from "unidiff";
+
+const { parsePatch, applyPatch } = pkg;
+
+/**
+ * Aplica um unified diff ao arquivo alvo.
+ * VERSION 2: Melhor logging e fallback para replace direto.
+ */
+export async function applyUnifiedDiff(root, diffText) {
+    console.log("🔧 [patch_bkp.js] Applying unified diff...");
+    console.log("📂 Root:", root);
+    console.log("📋 Diff length:", diffText?.length || 0, "chars");
+
+    if (!diffText || diffText.trim() === "") {
+        throw new Error("Empty diff text provided");
+    }
+
+    // Log primeiras linhas do diff para debug
+    const diffLines = diffText.split("\n");
+    console.log("📋 Diff preview:");
+    for (let i = 0; i < Math.min(10, diffLines.length); i++) {
+        console.log(`   ${i + 1}: ${diffLines[i]}`);
+    }
+
+    // Parse o diff
+    let patches;
+    try {
+        patches = parsePatch(diffText);
+        console.log("✅ Parsed", patches.length, "patch(es)");
+    } catch (parseErr) {
+        console.error("❌ Failed to parse diff:", parseErr.message);
+        throw new Error("Failed to parse diff: " + parseErr.message);
+    }
+
+    if (!patches || patches.length === 0) {
+        throw new Error("No patches found in diff text");
+    }
+
+    const p = patches[0];
+    console.log("📦 Patch info:", {
+        oldFileName: p?.oldFileName,
+        newFileName: p?.newFileName,
+        hunks: p?.hunks?.length || 0
+    });
+
+    // Descobre path alvo a partir do patch
+    const targetRel =
+        p?.newFileName?.replace(/^b\//, "") ||
+        p?.oldFileName?.replace(/^a\//, "");
+
+    if (!targetRel) {
+        throw new Error("Could not infer target file from diff headers");
+    }
+
+    console.log("🎯 Target file:", targetRel);
+
+    const full = path.join(root, targetRel);
+    console.log("📄 Full path:", full);
+
+    // Verificar se arquivo existe
+    if (!(await exists(full))) {
+        throw new Error(`Target file not found: ${full}`);
+    }
+
+    // Ler arquivo original
+    let original;
+    try {
+        original = await readFile(full, "utf8");
+        console.log("📖 Original file:", original.length, "chars,", original.split("\n").length, "lines");
+    } catch (readErr) {
+        throw new Error(`Failed to read target file: ${readErr.message}`);
+    }
+
+    // Tentar aplicar o patch
+    let result;
+    try {
+        result = applyPatch(original, p);
+        console.log("🔧 applyPatch result:", result === false ? "FAILED" : `${result?.length} chars`);
+    } catch (applyErr) {
+        console.error("❌ applyPatch threw error:", applyErr.message);
+        throw new Error(`Patch application error: ${applyErr.message}`);
+    }
+
+    if (result === false) {
+        // Log mais detalhes sobre por que falhou
+        console.error("❌ Patch failed to apply. Possible reasons:");
+        console.error("   - Line numbers don't match current file");
+        console.error("   - Context lines don't match");
+        console.error("   - File was modified since diff was generated");
+
+        // Log hunks para debug
+        if (p.hunks) {
+            for (const hunk of p.hunks) {
+                console.error(`   Hunk: @@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`);
+            }
+        }
+
+        throw new Error("Patch failed to apply - context mismatch");
+    }
+
+    // Escrever resultado
+    try {
+        await writeFile(full, result, "utf8");
+        console.log("✅ Patch applied successfully!");
+        console.log("   Target:", targetRel);
+        console.log("   Bytes:", Buffer.byteLength(result, "utf8"));
+    } catch (writeErr) {
+        throw new Error(`Failed to write patched file: ${writeErr.message}`);
+    }
+
+    return {
+        target: targetRel,
+        bytes: Buffer.byteLength(result, "utf8"),
+        linesChanged: countChangedLines(p)
+    };
+}
+
+/**
+ * Conta quantas linhas foram alteradas
+ */
+function countChangedLines(patch) {
+    if (!patch.hunks) return 0;
+    let count = 0;
+    for (const hunk of patch.hunks) {
+        if (hunk.lines) {
+            count += hunk.lines.filter(l => l.startsWith("+") || l.startsWith("-")).length;
+        }
+    }
+    return count;
+}
+
+/**
+ * Fallback: aplica substituição direta do arquivo
+ * Usado quando o patch unidiff falha mas temos o conteúdo completo
+ */
+export async function applyDirectReplace(root, targetRel, newContent) {
+    console.log("🔄 [patch_bkp.js] Applying direct replace...");
+
+    const full = path.join(root, targetRel);
+
+    if (!(await exists(full))) {
+        throw new Error(`Target file not found: ${full}`);
+    }
+
+    await writeFile(full, newContent, "utf8");
+
+    return {
+        target: targetRel,
+        bytes: Buffer.byteLength(newContent, "utf8"),
+        method: "direct-replace"
+    };
+}

package/src/ports.js

@@ -0,0 +1,69 @@
+import path from "path";
+import yaml from "js-yaml";
+import PropertiesReader from "properties-reader";
+import { exists, readFile } from "./fs-utils.js";
+
+export async function detectPort(root) {
+    // Spring Boot
+    const ymlCandidates = [
+        "src/main/resources/application.yml",
+        "src/main/resources/application.yaml",
+        "application.yml",
+        "application.yaml"
+    ];
+    for (const rel of ymlCandidates) {
+        const full = path.join(root, rel);
+        if (await exists(full)) {
+            try {
+                const content = await readFile(full, "utf8");
+                const doc = yaml.load(content);
+
+                // Tentar pegar do objeto parseado
+                let port = doc?.server?.port ?? doc?.SERVER?.PORT;
+
+                // Se for string com ${PORT:8090}, extrair o valor padrão
+                if (typeof port === 'string') {
+                    const match = port.match(/\$\{PORT:(\d+)\}/);
+                    if (match) port = match[1];
+                }
+
+                if (port) return Number(port);
+            } catch {}
+        }
+    }
+
+    const propCandidates = [
+        "src/main/resources/application.properties",
+        "application.properties"
+    ];
+    for (const rel of propCandidates) {
+        const full = path.join(root, rel);
+        if (await exists(full)) {
+            try {
+                const props = PropertiesReader(full);
+                let port = props.get("server.port");
+
+                // Se for string com ${PORT:8090}, extrair o valor padrão
+                if (typeof port === 'string') {
+                    const match = port.match(/\$\{PORT:(\d+)\}/);
+                    if (match) port = match[1];
+                }
+
+                if (port) return Number(port);
+            } catch {}
+        }
+    }
+
+    // Node (com .env padrão)
+    const envCandidates = [".env", "src/.env"];
+    for (const rel of envCandidates) {
+        const full = path.join(root, rel);
+        if (await exists(full)) {
+            const content = await readFile(full, "utf8");
+            const m = content.match(/PORT\s*=\s*(\d+)/i);
+            if (m) return Number(m[1]);
+        }
+    }
+
+    return null;
+}