backtrace-console 0.0.1

package/lib/backtrace/repair-fingerprint.js

@@ -0,0 +1,405 @@
+const fs = require("node:fs/promises");
+const path = require("node:path");
+const { normalizeFingerprint, areFingerprintsRelated, listExistingFingerprintDirectories } = require("./utils");
+const { createRepairContext, generateRepairPlan, applyRepairPlan } = require("./repair");
+
+const MAX_LOG_PROMPT_CHARS = 180000;
+const MAX_SECTION_CHARS = 60000;
+const MAX_FALLBACK_HEAD_TAIL_CHARS = 12000;
+const CONTEXT_RADIUS = 3;
+const REPAIR_PLAN_LOG_SAMPLE_SIZE = 5;
+const TEXT_FILE_EXTENSIONS = new Set([
+  ".ini",
+  ".txt",
+  ".md",
+  ".json",
+  ".js",
+  ".jsx",
+  ".ts",
+  ".tsx",
+  ".c",
+  ".cc",
+  ".cpp",
+  ".cxx",
+  ".h",
+  ".hh",
+  ".hpp",
+  ".hxx",
+  ".cs",
+  ".java",
+  ".kt",
+  ".py",
+  ".rb",
+  ".php",
+  ".go",
+  ".swift",
+  ".xml",
+  ".yml",
+  ".yaml",
+  ".cfg",
+  ".conf",
+  ".usf",
+  ".ush",
+]);
+const KEYWORD_PATTERNS = [
+  /error/i,
+  /exception/i,
+  /fatal/i,
+  /ensure/i,
+  /assert/i,
+  /stack/i,
+  /callstack/i,
+  /crash/i,
+  /Unhandled/i,
+];
+
+async function collectFingerprintLogCandidates(logsDir, relativeDir = "") {
+  const currentDir = path.join(logsDir, relativeDir);
+  const entries = await fs.readdir(currentDir, { withFileTypes: true }).catch(() => []);
+  const files = [];
+
+  for (const entry of entries) {
+    /* eslint-disable no-await-in-loop */
+    const nextRelativePath = relativeDir ? path.join(relativeDir, entry.name) : entry.name;
+    const absolutePath = path.join(logsDir, nextRelativePath);
+    if (entry.isDirectory()) {
+      files.push(...await collectFingerprintLogCandidates(logsDir, nextRelativePath));
+      continue;
+    }
+    if (!entry.isFile() || entry.name.toLowerCase() !== "aboveland.log") {
+      continue;
+    }
+    const stats = await fs.stat(absolutePath).catch(() => null);
+    if (!stats || !stats.isFile()) {
+      continue;
+    }
+    files.push({
+      relativePath: nextRelativePath,
+      absolutePath,
+      size: stats.size,
+    });
+    /* eslint-enable no-await-in-loop */
+  }
+
+  return files;
+}
+
+async function findFingerprintLogs(fingerprint, context) {
+  const normalizedFingerprint = normalizeFingerprint(fingerprint);
+  const existingDirectories = await listExistingFingerprintDirectories(context.fingerprintsRoot);
+  const matchedDirectory = existingDirectories
+    .filter((entry) => areFingerprintsRelated(entry.name, normalizedFingerprint))
+    .sort((left, right) => left.name.length - right.name.length || left.name.localeCompare(right.name))[0];
+  const resolvedFingerprint = matchedDirectory ? matchedDirectory.name : normalizedFingerprint;
+  const logsDir = path.join(context.fingerprintsRoot, resolvedFingerprint, "logs");
+  const entries = await collectFingerprintLogCandidates(logsDir);
+  if (entries.length === 0) {
+    throw new Error(`No AboveLand.LOG found under fingerprint logs: ${resolvedFingerprint}`);
+  }
+  return {
+    fingerprint: resolvedFingerprint,
+    logs: entries.sort((left, right) => left.relativePath.localeCompare(right.relativePath)),
+  };
+}
+
+function pickRandomLogs(logs, maxCount) {
+  if (!Array.isArray(logs) || logs.length <= maxCount) {
+    return Array.isArray(logs) ? [...logs] : [];
+  }
+
+  const shuffled = [...logs];
+  for (let index = shuffled.length - 1; index > 0; index -= 1) {
+    const swapIndex = Math.floor(Math.random() * (index + 1));
+    [shuffled[index], shuffled[swapIndex]] = [shuffled[swapIndex], shuffled[index]];
+  }
+
+  return shuffled
+    .slice(0, maxCount)
+    .sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+
+function clampText(text, maxChars) {
+  const normalized = String(text || "");
+  if (normalized.length <= maxChars) {
+    return normalized;
+  }
+  return `${normalized.slice(0, maxChars)}\n...[truncated]`;
+}
+
+function buildKeywordExcerpt(logContent) {
+  const lines = String(logContent || "").split(/\r?\n/);
+  const selectedIndexes = new Set();
+
+  lines.forEach((line, index) => {
+    if (!KEYWORD_PATTERNS.some((pattern) => pattern.test(line))) {
+      return;
+    }
+    const start = Math.max(0, index - CONTEXT_RADIUS);
+    const end = Math.min(lines.length - 1, index + CONTEXT_RADIUS);
+    for (let cursor = start; cursor <= end; cursor += 1) {
+      selectedIndexes.add(cursor);
+    }
+  });
+
+  const excerpt = Array.from(selectedIndexes)
+    .sort((left, right) => left - right)
+    .map((index) => `${index + 1}: ${lines[index]}`)
+    .join("\n");
+
+  return clampText(excerpt, MAX_SECTION_CHARS);
+}
+
+function buildHeadTailExcerpt(logContent) {
+  const text = String(logContent || "");
+  if (text.length <= MAX_FALLBACK_HEAD_TAIL_CHARS) {
+    return text;
+  }
+  const half = Math.floor(MAX_FALLBACK_HEAD_TAIL_CHARS / 2);
+  return [
+    text.slice(0, half),
+    "\n...[middle truncated]...\n",
+    text.slice(-half),
+  ].join("");
+}
+
+async function writeFingerprintPlanInput(fingerprint, sampledLogs, context) {
+  const reportsDir = path.join(context.fingerprintsRoot, fingerprint, "reports");
+  await fs.mkdir(reportsDir, { recursive: true });
+  const inputRelativePath = path.join(fingerprint, "reports", "fix-plan-input.md");
+  const inputAbsolutePath = path.join(context.fingerprintsRoot, inputRelativePath);
+  const wrappedContentParts = [
+    "# Fingerprint",
+    fingerprint,
+    "",
+    "# Sampled Logs",
+    `Count: ${sampledLogs.length}`,
+    "",
+  ].join("\n");
+  let wrappedContent = wrappedContentParts;
+
+  for (const logEntry of sampledLogs) {
+    /* eslint-disable no-await-in-loop */
+    const relativeLogPath = path.join(fingerprint, "logs", logEntry.relativePath).replace(/\\/g, "/");
+    const logContent = await fs.readFile(logEntry.absolutePath, "utf8");
+    const keywordExcerpt = buildKeywordExcerpt(logContent);
+    wrappedContent += [
+      "## Log Path",
+      relativeLogPath,
+      "",
+      "## Log Size",
+      String(logEntry.size),
+      "",
+      "## Key Error Excerpt",
+      "```text",
+      keywordExcerpt || "No explicit error keywords matched in log.",
+      "```",
+      "",
+    ].join("\n");
+    if (!keywordExcerpt) {
+      const headTailExcerpt = buildHeadTailExcerpt(logContent);
+      wrappedContent += [
+        "## Fallback Head Tail Excerpt",
+        "```text",
+        headTailExcerpt,
+        "```",
+        "",
+      ].join("\n");
+    }
+    /* eslint-enable no-await-in-loop */
+  }
+  const trimmedContent = clampText(wrappedContent, MAX_LOG_PROMPT_CHARS);
+  const finalContent = trimmedContent.length === wrappedContent.length
+    ? trimmedContent
+    : `${trimmedContent}\n\n# Note\nInput truncated to stay within Codex prompt limits.\n`;
+  await fs.writeFile(inputAbsolutePath, finalContent, "utf8");
+  return {
+    inputRelativePath,
+    relativeLogPaths: sampledLogs.map((logEntry) => path.join(fingerprint, "logs", logEntry.relativePath).replace(/\\/g, "/")),
+  };
+}
+
+async function generateRepairPlanFromFingerprint(input, overrides = {}) {
+  const context = createRepairContext(overrides);
+  const requestedFingerprint = normalizeFingerprint(input.fingerprint);
+  if (!requestedFingerprint || requestedFingerprint === "unknown-fingerprint") {
+    throw new Error("fingerprint is required");
+  }
+  const resolved = await findFingerprintLogs(requestedFingerprint, context);
+  const fingerprint = resolved.fingerprint;
+  const sampledLogs = pickRandomLogs(resolved.logs, REPAIR_PLAN_LOG_SAMPLE_SIZE);
+  const preparedInput = await writeFingerprintPlanInput(fingerprint, sampledLogs, context);
+  const result = await generateRepairPlan({ reportPath: preparedInput.inputRelativePath }, overrides);
+  return {
+    ...result,
+    fingerprint,
+    logPaths: preparedInput.relativeLogPaths,
+    logCount: sampledLogs.length,
+    logSizes: sampledLogs.map((logEntry) => logEntry.size),
+    inputReportPath: preparedInput.inputRelativePath,
+  };
+}
+
+async function loadLatestRepairPlanFromFingerprint(input, overrides = {}) {
+  const context = createRepairContext(overrides);
+  const requestedFingerprint = normalizeFingerprint(input.fingerprint);
+  if (!requestedFingerprint || requestedFingerprint === "unknown-fingerprint") {
+    throw new Error("fingerprint is required");
+  }
+
+  const resolved = await findFingerprintLogs(requestedFingerprint, context);
+  const fingerprint = resolved.fingerprint;
+  const repairRoot = path.join(context.fingerprintsRoot, fingerprint, "repair");
+  const repairEntries = await fs.readdir(repairRoot, { withFileTypes: true }).catch(() => []);
+  const versions = repairEntries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .sort()
+    .reverse();
+
+  for (const repairVersion of versions) {
+    /* eslint-disable no-await-in-loop */
+    const relativeJsonPath = path.join(fingerprint, "repair", repairVersion, "repair-plan.json");
+    const absoluteJsonPath = path.join(context.fingerprintsRoot, relativeJsonPath);
+    const rawText = await fs.readFile(absoluteJsonPath, "utf8").catch(() => "");
+    if (!rawText) {
+      continue;
+    }
+    let structuredPlan = null;
+    try {
+      structuredPlan = JSON.parse(rawText);
+    } catch (error) {
+      structuredPlan = null;
+    }
+    if (!structuredPlan || typeof structuredPlan !== "object") {
+      continue;
+    }
+    return {
+      fingerprint,
+      repairVersion,
+      repairPlanJsonPath: relativeJsonPath,
+      structuredPlan,
+    };
+    /* eslint-enable no-await-in-loop */
+  }
+
+  throw new Error(`No repair-plan.json found for fingerprint: ${fingerprint}`);
+}
+
+function isSupportedTextFile(filePath) {
+  return TEXT_FILE_EXTENSIONS.has(path.extname(String(filePath || "")).toLowerCase());
+}
+
+function resolveWorkspacePath(rootDir, relativePath) {
+  const absolutePath = path.resolve(rootDir, String(relativePath || "").replace(/[\\/]+/g, path.sep));
+  if (absolutePath !== rootDir && !absolutePath.startsWith(rootDir + path.sep)) {
+    throw new Error("Invalid workspace path");
+  }
+  return absolutePath;
+}
+
+async function backupTargetFile(fingerprint, repairVersion, relativeFilePath, absoluteFilePath, context) {
+  const backupRelativePath = path.join(
+    fingerprint,
+    "repair",
+    repairVersion,
+    "apply-backups",
+    String(relativeFilePath || "").replace(/[\\/]+/g, path.sep),
+  );
+  const backupAbsolutePath = path.join(context.fingerprintsRoot, backupRelativePath);
+  await fs.mkdir(path.dirname(backupAbsolutePath), { recursive: true });
+  await fs.copyFile(absoluteFilePath, backupAbsolutePath);
+  return backupRelativePath;
+}
+
+function applyReplaceBlock(content, change) {
+  const anchor = String(change.searchAnchor || "");
+  const before = String(change.before || "");
+  const after = String(change.after || "");
+  if (anchor && !content.includes(anchor)) {
+    return { ok: false, reason: "searchAnchor not found" };
+  }
+  if (!before) {
+    return { ok: false, reason: "before is required for replace_block/update_condition" };
+  }
+  if (!content.includes(before)) {
+    return { ok: false, reason: "before snippet not found" };
+  }
+  return {
+    ok: true,
+    content: content.replace(before, after),
+  };
+}
+
+function applyInsertAfter(content, change) {
+  const anchor = String(change.searchAnchor || "");
+  const after = String(change.after || "");
+  if (!anchor) {
+    return { ok: false, reason: "searchAnchor is required for insert_after" };
+  }
+  const anchorIndex = content.indexOf(anchor);
+  if (anchorIndex < 0) {
+    return { ok: false, reason: "searchAnchor not found" };
+  }
+  const insertIndex = anchorIndex + anchor.length;
+  return {
+    ok: true,
+    content: `${content.slice(0, insertIndex)}\n${after}\n${content.slice(insertIndex)}`,
+  };
+}
+
+function applyPlannedChange(content, change) {
+  const action = String(change.action || "").trim();
+  if (action === "replace_block" || action === "update_condition") {
+    return applyReplaceBlock(content, change);
+  }
+  if (action === "insert_after") {
+    return applyInsertAfter(content, change);
+  }
+  return { ok: false, reason: `unsupported action: ${action || "unknown"}` };
+}
+
+async function applyFixFromFingerprint(input, overrides = {}) {
+  const loaded = await loadLatestRepairPlanFromFingerprint(input, overrides);
+  const changes = Array.isArray(loaded.structuredPlan?.changes) ? loaded.structuredPlan.changes : [];
+  if (changes.length === 0) {
+    return {
+      ok: false,
+      command: "apply-fix",
+      fingerprint: loaded.fingerprint,
+      repairVersion: loaded.repairVersion,
+      repairPlanJsonPath: loaded.repairPlanJsonPath,
+      actionable: false,
+      reason: "repair-plan.json has no changes; there is nothing safe to apply automatically.",
+      structuredPlan: loaded.structuredPlan,
+    };
+  }
+
+  const result = await applyRepairPlan({
+    reportPath: loaded.structuredPlan.reportPath,
+    planText: JSON.stringify(loaded.structuredPlan, null, 2),
+    repairVersion: loaded.repairVersion,
+    repairPlanPath: loaded.repairPlanJsonPath,
+  }, overrides);
+
+  return {
+    ok: true,
+    command: "apply-fix",
+    fingerprint: loaded.fingerprint,
+    repairVersion: loaded.repairVersion,
+    repairPlanJsonPath: loaded.repairPlanJsonPath,
+    actionable: true,
+    reason: "Codex apply-fix executed.",
+    changeCount: changes.length,
+    applyResultPath: result.repairResultPath,
+    archivedSources: result.archivedSources,
+    repairStatusPath: result.repairStatusPath,
+    resultText: result.resultText,
+    structuredPlan: loaded.structuredPlan,
+  };
+}
+
+module.exports = {
+  applyFixFromFingerprint,
+  generateRepairPlanFromFingerprint,
+  loadLatestRepairPlanFromFingerprint,
+};