error-trace-debugger 0.1.0

package/src/tools/LogAnalyzerTool.js

@@ -0,0 +1,148 @@
+import path from "node:path";
+
+export class LogAnalyzerTool {
+  #repo_path;
+
+  constructor({ repo_path }) {
+    this.#repo_path = repo_path;
+  }
+
+  async run({ raw_logs }) {
+    const parsed = parse_stack_trace(raw_logs, { repo_path: this.#repo_path });
+    return {
+      raw_logs,
+      error_name: parsed.error_name,
+      error_message: parsed.error_message,
+      frames: parsed.frames,
+      signals: parsed.signals
+    };
+  }
+}
+
+function parse_stack_trace(raw_logs, { repo_path }) {
+  const lines = String(raw_logs).split(/\r?\n/g);
+  const first_line = lines.find((l) => l.trim().length > 0) || "";
+
+  const header = parse_error_header(first_line);
+  const error_name = header.error_name;
+  const error_message = header.error_message;
+
+  const frames = [];
+  for (const line of lines) {
+    const frame = parse_node_frame(line);
+    if (!frame) continue;
+    const normalized = normalize_frame(frame, { repo_path });
+    frames.push(normalized);
+  }
+
+  const signals = {};
+  if (error_name) signals.error_name = error_name;
+  if (error_message) signals.error_message = error_message;
+  signals.is_jest = lines.some((l) => l.includes("Jest") || l.includes("jest"));
+  signals.has_stack_frames = frames.length > 0;
+
+  return { error_name, error_message, frames, signals };
+}
+
+function parse_error_header(first_line) {
+  const trimmed = String(first_line || "").trim();
+  if (!trimmed) return { error_name: "", error_message: "" };
+
+  const match = trimmed.match(
+    /^([A-Za-z_$][A-Za-z0-9_$]*Error|Error)\s*:?\s*(.*)$/
+  );
+  if (match) {
+    return {
+      error_name: match[1] || "",
+      error_message: (match[2] || "").trim()
+    };
+  }
+
+  const looks_like_error = trimmed.includes("Error") || trimmed.includes("Exception");
+  return { error_name: looks_like_error ? "Error" : "", error_message: trimmed };
+}
+
+function parse_node_frame(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("at ")) return null;
+
+  const with_fn = trimmed.match(
+    /^at\s+(?<function_name>.+?)\s+\((?<file_path>.*?):(?<line_number>\d+):(?<column_number>\d+)\)$/
+  );
+  if (with_fn?.groups) {
+    return {
+      function_name: with_fn.groups.function_name.trim(),
+      file_path: with_fn.groups.file_path,
+      line_number: Number(with_fn.groups.line_number),
+      column_number: Number(with_fn.groups.column_number),
+      raw_line: trimmed
+    };
+  }
+
+  const without_fn = trimmed.match(
+    /^at\s+(?<file_path>.*?):(?<line_number>\d+):(?<column_number>\d+)$/
+  );
+  if (without_fn?.groups) {
+    return {
+      function_name: "",
+      file_path: without_fn.groups.file_path,
+      line_number: Number(without_fn.groups.line_number),
+      column_number: Number(without_fn.groups.column_number),
+      raw_line: trimmed
+    };
+  }
+
+  const with_fn_no_col = trimmed.match(
+    /^at\s+(?<function_name>.+?)\s+\((?<file_path>.*?):(?<line_number>\d+)\)$/
+  );
+  if (with_fn_no_col?.groups) {
+    return {
+      function_name: with_fn_no_col.groups.function_name.trim(),
+      file_path: with_fn_no_col.groups.file_path,
+      line_number: Number(with_fn_no_col.groups.line_number),
+      column_number: null,
+      raw_line: trimmed
+    };
+  }
+
+  const without_fn_no_col = trimmed.match(
+    /^at\s+(?<file_path>.*?):(?<line_number>\d+)$/
+  );
+  if (without_fn_no_col?.groups) {
+    return {
+      function_name: "",
+      file_path: without_fn_no_col.groups.file_path,
+      line_number: Number(without_fn_no_col.groups.line_number),
+      column_number: null,
+      raw_line: trimmed
+    };
+  }
+
+  return null;
+}
+
+function normalize_frame(frame, { repo_path }) {
+  const is_file_url = frame.file_path.startsWith("file://");
+  const raw_path = is_file_url ? file_url_to_path(frame.file_path) : frame.file_path;
+  const normalized_separators = raw_path.replaceAll("\\", "/");
+
+  const is_absolute_path = path.isAbsolute(normalized_separators);
+  const normalized_path = is_absolute_path
+    ? normalized_separators
+    : path.resolve(repo_path, normalized_separators);
+  const is_repo_frame = normalized_path.startsWith(repo_path);
+
+  return {
+    function_name: frame.function_name,
+    file_path: is_repo_frame ? path.relative(repo_path, normalized_path) : raw_path,
+    line_number: frame.line_number,
+    column_number: frame.column_number,
+    is_repo_frame,
+    raw_line: frame.raw_line || ""
+  };
+}
+
+function file_url_to_path(file_url) {
+  return decodeURIComponent(file_url.replace(/^file:\/\//, ""));
+}
+

package/src/tools/PatchProposerTool.js

@@ -0,0 +1,110 @@
+import { redactSecrets } from "../util/redact_secrets.js";
+
+const MAX_RETRIES = 2;
+
+export class PatchProposerTool {
+  #llm;
+
+  constructor({ llm }) {
+    this.#llm = llm;
+  }
+
+  async run({ log_artifact, search_matches, file_contexts }) {
+    const safe_logs = redactSecrets(log_artifact.raw_logs || "");
+    const prompt = buildPrompt({ log_artifact, search_matches, file_contexts, safe_logs });
+
+    let last_error = null;
+    for (let attempt_index = 0; attempt_index <= MAX_RETRIES; attempt_index += 1) {
+      const raw = await this.#llm.generateJson(prompt);
+      try {
+        const parsed = JSON.parse(raw);
+        const validated = validateFixPlan(parsed);
+        return validated;
+      } catch (error) {
+        last_error = error;
+      }
+    }
+
+    return {
+      summary: "Failed to generate a structured fix plan from the LLM.",
+      edits: [],
+      citations: [],
+      error: String(last_error || "Unknown error from LLM.")
+    };
+  }
+}
+
+function buildPrompt({ log_artifact, search_matches, file_contexts, safe_logs }) {
+  const context_lines = [];
+  context_lines.push("You are a senior JavaScript engineer.");
+  context_lines.push(
+    "You receive application logs, code search hits, and file excerpts from a Node.js repo."
+  );
+  context_lines.push(
+    "Your task is to propose a minimal, safe patch that fixes the bug described in the logs."
+  );
+  context_lines.push("");
+  context_lines.push("Logs (redacted):");
+  context_lines.push("```");
+  context_lines.push(safe_logs.slice(0, 4000));
+  context_lines.push("```");
+  context_lines.push("");
+  context_lines.push("Search matches (top):");
+  for (const match of search_matches.slice(0, 10)) {
+    context_lines.push(
+      `- ${match.file_path}:${match.line_number} :: ${match.query} :: ${match.snippet || ""}`
+    );
+  }
+  context_lines.push("");
+  context_lines.push("File excerpts:");
+  for (const context of file_contexts.slice(0, 8)) {
+    context_lines.push(
+      `--- ${context.file_path} [${context.start_line}-${context.end_line}] ---`
+    );
+    context_lines.push(context.excerpt.slice(0, 2000));
+    context_lines.push("");
+  }
+
+  context_lines.push("");
+  context_lines.push(
+    "Return ONLY a JSON object with this shape, no markdown or explanation:"
+  );
+  context_lines.push(
+    `{"summary": string, "edits": [{"file_path": string, "new_text": string, "reason": string}], "citations": [{"file_path": string, "start_line": number, "end_line": number}]}`
+  );
+
+  return context_lines.join("\n");
+}
+
+function validateFixPlan(candidate) {
+  const safe = candidate || {};
+  const summary = String(safe.summary || "").slice(0, 2000);
+  const raw_edits = Array.isArray(safe.edits) ? safe.edits : [];
+  const raw_citations = Array.isArray(safe.citations) ? safe.citations : [];
+
+  const edits = [];
+  for (const edit of raw_edits) {
+    if (!edit || typeof edit.file_path !== "string") continue;
+    if (typeof edit.new_text !== "string") continue;
+    edits.push({
+      file_path: edit.file_path,
+      new_text: edit.new_text,
+      reason: typeof edit.reason === "string" ? edit.reason : ""
+    });
+  }
+
+  const citations = [];
+  for (const citation of raw_citations) {
+    if (!citation || typeof citation.file_path !== "string") continue;
+    citations.push({
+      file_path: citation.file_path,
+      start_line: Number.isFinite(citation.start_line)
+        ? citation.start_line
+        : null,
+      end_line: Number.isFinite(citation.end_line) ? citation.end_line : null
+    });
+  }
+
+  return { summary, edits, citations };
+}
+

package/src/tools/ReadFileTool.js

@@ -0,0 +1,98 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import ignore from "ignore";
+
+const DEFAULT_MAX_BYTES_PER_FILE = 128 * 1024;
+const DEFAULT_MAX_TOTAL_BYTES = 2 * 1024 * 1024;
+
+export class ReadFileTool {
+  #repo_path;
+  #max_bytes_per_file;
+  #max_total_bytes;
+  #ig_promise;
+  #bytes_read;
+
+  constructor({
+    repo_path,
+    max_bytes_per_file = DEFAULT_MAX_BYTES_PER_FILE,
+    max_total_bytes = DEFAULT_MAX_TOTAL_BYTES
+  }) {
+    this.#repo_path = repo_path;
+    this.#max_bytes_per_file = max_bytes_per_file;
+    this.#max_total_bytes = max_total_bytes;
+    this.#ig_promise = null;
+    this.#bytes_read = 0;
+  }
+
+  async run({ file_path, start_line, end_line, max_bytes }) {
+    const ig = await this.#load_ignore();
+    const rel_path = file_path;
+    if (ig.ignores(rel_path)) {
+      return {
+        ok: false,
+        error: `File is ignored by ignore rules: ${rel_path}`
+      };
+    }
+
+    const absolute_path = path.join(this.#repo_path, rel_path);
+    let contents = "";
+    try {
+      contents = await fs.readFile(absolute_path, "utf8");
+    } catch (error) {
+      return { ok: false, error: String(error) };
+    }
+
+    const available_bytes = Math.min(
+      max_bytes || this.#max_bytes_per_file,
+      this.#max_bytes_per_file
+    );
+    const remaining_budget = this.#max_total_bytes - this.#bytes_read;
+    if (remaining_budget <= 0) {
+      return { ok: false, error: "ReadFileTool budget exhausted." };
+    }
+
+    const slice_bytes = Math.min(
+      Buffer.byteLength(contents, "utf8"),
+      available_bytes,
+      remaining_budget
+    );
+    const sliced_text = contents.slice(0, slice_bytes);
+    this.#bytes_read += Buffer.byteLength(sliced_text, "utf8");
+
+    const lines = sliced_text.split(/\r?\n/g);
+    const start_index = Number.isFinite(start_line) && start_line > 0 ? start_line - 1 : 0;
+    const end_index =
+      Number.isFinite(end_line) && end_line > 0
+        ? Math.min(end_line, lines.length)
+        : Math.min(start_index + 200, lines.length);
+
+    const excerpt = lines.slice(start_index, end_index).join("\n");
+
+    return {
+      ok: true,
+      file_path: rel_path,
+      start_line: start_index + 1,
+      end_line: end_index,
+      total_lines: lines.length,
+      excerpt
+    };
+  }
+
+  async #load_ignore() {
+    if (this.#ig_promise) return this.#ig_promise;
+    this.#ig_promise = (async () => {
+      const ig = ignore();
+      ig.add(["node_modules/", "dist/", "build/", ".git/", ".env", ".env.*"]);
+      try {
+        const gitignore_path = path.join(this.#repo_path, ".gitignore");
+        const gitignore = await fs.readFile(gitignore_path, "utf8");
+        ig.add(gitignore.split(/\r?\n/g));
+      } catch {
+        // ignore
+      }
+      return ig;
+    })();
+    return this.#ig_promise;
+  }
+}
+

package/src/tools/TestRunnerTool.js

@@ -0,0 +1,98 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execaCommand } from "execa";
+
+const DEFAULT_TEST_TIMEOUT_MS = 10 * 60 * 1000;
+
+export class TestRunnerTool {
+  #repo_path;
+
+  constructor({ repo_path }) {
+    this.#repo_path = repo_path;
+  }
+
+  async run({ repo_path, test_command }) {
+    const resolved_repo_path = repo_path || this.#repo_path;
+    const detected_command = test_command || (await detect_test_command(resolved_repo_path));
+
+    const result = await execa_command(detected_command, { cwd: resolved_repo_path });
+    return {
+      ok: result.exit_code === 0,
+      exit_code: result.exit_code,
+      detected_command,
+      summary: summarize_test_output(result.stdout, result.stderr)
+    };
+  }
+}
+
+async function detect_test_command(repo_path) {
+  const has_pnpm = await file_exists(path.join(repo_path, "pnpm-lock.yaml"));
+  if (has_pnpm) return "pnpm test";
+
+  const has_yarn = await file_exists(path.join(repo_path, "yarn.lock"));
+  if (has_yarn) return "yarn test";
+
+  return "npm test";
+}
+
+async function file_exists(absolute_path) {
+  try {
+    await fs.access(absolute_path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function execa_command(command, { cwd }) {
+  const result = await execaCommand(String(command), {
+    cwd,
+    reject: false,
+    timeout: DEFAULT_TEST_TIMEOUT_MS,
+    shell: true,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: process.env
+  });
+
+  return {
+    exit_code: result.exitCode ?? 1,
+    stdout: String(result.stdout || ""),
+    stderr: String(result.stderr || "")
+  };
+}
+
+function summarize_test_output(stdout, stderr) {
+  const combined = `${stdout}\n${stderr}`.trim();
+  if (!combined) return "";
+  const lines = combined.split(/\r?\n/g);
+  const failure_index = find_first_failure_line_index(lines);
+  if (failure_index >= 0) {
+    const start_index = Math.max(0, failure_index - 10);
+    const end_index = Math.min(lines.length, failure_index + 50);
+    return lines.slice(start_index, end_index).join("\n").trim();
+  }
+
+  return lines.slice(-80).join("\n").trim();
+}
+
+function find_first_failure_line_index(lines) {
+  const patterns = [
+    /(^|\s)FAIL(\s|$)/,
+    /^Error:\s+/,
+    /TypeError:/,
+    /ReferenceError:/,
+    /AssertionError:/,
+    /UnhandledPromiseRejection/
+  ];
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (!line) continue;
+    for (const pattern of patterns) {
+      if (pattern.test(line)) return index;
+    }
+  }
+
+  return -1;
+}

package/src/tools/create_default_tools.js

@@ -0,0 +1,14 @@
+import { LogAnalyzerTool } from "./LogAnalyzerTool.js";
+import { CodeSearchTool } from "./CodeSearchTool.js";
+import { GitDiffTool } from "./GitDiffTool.js";
+import { TestRunnerTool } from "./TestRunnerTool.js";
+
+export function create_default_tools({ repo_path }) {
+  return {
+    log_analyzer: new LogAnalyzerTool({ repo_path }),
+    code_search: new CodeSearchTool({ repo_path }),
+    diff_generator: new GitDiffTool({ repo_path }),
+    test_runner: new TestRunnerTool({ repo_path })
+  };
+}
+

package/src/util/redact_secrets.js

@@ -0,0 +1,16 @@
+const TOKEN_PATTERNS = [
+  /(ghp_[0-9A-Za-z]{20,})/g,
+  /(github_pat_[0-9A-Za-z]{20,})/g,
+  /(sk-[0-9A-Za-z]{20,})/g,
+  /(\"access_token\"\\s*:\\s*\"[0-9A-Za-z\-_.]{16,}\")/g,
+  /Bearer\\s+[0-9A-Za-z\-_.]{16,}/g
+];
+
+export function redactSecrets(text) {
+  let redacted_text = String(text || "");
+  for (const pattern of TOKEN_PATTERNS) {
+    redacted_text = redacted_text.replace(pattern, "[REDACTED_SECRET]");
+  }
+  return redacted_text;
+}
+