backtrace-console 0.0.1

package/lib/backtrace/repair.js

@@ -0,0 +1,495 @@
+const fs = require("node:fs/promises");
+const path = require("node:path");
+const { DEFAULT_WORKDIR, DEFAULT_PROXY, DEFAULT_STORAGE_DIR } = require("./constants");
+
+function createRepairContext(overrides = {}) {
+  const rootDir = path.resolve(overrides.rootDir || process.cwd());
+  const fingerprintsRoot = path.resolve(overrides.fingerprintsRoot || path.join(rootDir, DEFAULT_STORAGE_DIR));
+  return {
+    rootDir,
+    fingerprintsRoot,
+    workdir: overrides.workdir || DEFAULT_WORKDIR,
+    proxy: resolveCodexProxy(overrides.proxy),
+  };
+}
+
+function formatRepairVersion(date) {
+  const year = String(date.getFullYear());
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hour = String(date.getHours()).padStart(2, "0");
+  const minute = String(date.getMinutes()).padStart(2, "0");
+  const second = String(date.getSeconds()).padStart(2, "0");
+  return `${year}${month}${day}-${hour}${minute}${second}`;
+}
+
+function toSafeAbsolute(rootDir, relativePath) {
+  const safeRelative = String(relativePath || "").replace(/[\\/]+/g, path.sep);
+  const targetPath = path.resolve(rootDir, safeRelative);
+  if (targetPath !== rootDir && !targetPath.startsWith(rootDir + path.sep)) {
+    throw new Error("Invalid path");
+  }
+  return targetPath;
+}
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+function getFingerprintPathFromReportPath(relativeReportPath) {
+  const normalized = String(relativeReportPath || "").replace(/[\\/]+/g, "/").trim();
+  if (!normalized) {
+    throw new Error("Invalid report path");
+  }
+  const parts = normalized.split("/").filter(Boolean);
+  const reportsIndex = parts.lastIndexOf("reports");
+  if (reportsIndex > 0) {
+    return parts.slice(0, reportsIndex).join(path.sep);
+  }
+  if (parts.length >= 2) {
+    return parts.slice(0, -1).join(path.sep);
+  }
+  return parts[0];
+}
+
+function getRepairVersionRelativeDir(relativeReportPath, repairVersion) {
+  return path.join(getFingerprintPathFromReportPath(relativeReportPath), "repair", repairVersion);
+}
+
+function getRepairVersionFromRepairPlanPath(repairPlanPath) {
+  const normalized = String(repairPlanPath || "").replace(/[\\/]+/g, "/").trim();
+  if (!normalized) {
+    return "";
+  }
+  const parts = normalized.split("/").filter(Boolean);
+  const repairIndex = parts.lastIndexOf("repair");
+  if (repairIndex >= 0 && parts.length > repairIndex + 1) {
+    return parts[repairIndex + 1];
+  }
+  return "";
+}
+
+async function resolveNewRepairVersion(relativeReportPath, context) {
+  const baseVersion = formatRepairVersion(new Date());
+  const repairRootRelative = path.join(getFingerprintPathFromReportPath(relativeReportPath), "repair");
+  const repairRootAbsolute = toSafeAbsolute(context.fingerprintsRoot, repairRootRelative);
+  let suffix = 0;
+  while (true) {
+    const repairVersion = suffix === 0 ? baseVersion : `${baseVersion}-${String(suffix).padStart(2, "0")}`;
+    const candidateDir = path.join(repairRootAbsolute, repairVersion);
+    if (!(await pathExists(candidateDir))) {
+      return repairVersion;
+    }
+    suffix += 1;
+  }
+}
+
+async function resolveRepairVersionForApply(relativeReportPath, repairVersion, repairPlanPath, context) {
+  const normalized = String(repairVersion || "").trim();
+  if (normalized) {
+    return normalized;
+  }
+  const planVersion = getRepairVersionFromRepairPlanPath(repairPlanPath);
+  if (planVersion) {
+    return planVersion;
+  }
+  const repairRootRelative = path.join(getFingerprintPathFromReportPath(relativeReportPath), "repair");
+  const repairRootAbsolute = toSafeAbsolute(context.fingerprintsRoot, repairRootRelative);
+  const entries = await fs.readdir(repairRootAbsolute, { withFileTypes: true }).catch(() => []);
+  const versions = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().reverse();
+  if (versions.length > 0) {
+    return versions[0];
+  }
+  return formatRepairVersion(new Date());
+}
+
+async function ensureRepairVersionDir(relativeReportPath, repairVersion, context) {
+  const relativeDir = getRepairVersionRelativeDir(relativeReportPath, repairVersion);
+  const absoluteDir = toSafeAbsolute(context.fingerprintsRoot, relativeDir);
+  await fs.mkdir(absoluteDir, { recursive: true });
+  return { relativeDir, absoluteDir };
+}
+
+async function writeRepairArtifact(relativeReportPath, repairVersion, fileName, text, context) {
+  const versionDir = await ensureRepairVersionDir(relativeReportPath, repairVersion, context);
+  const relativePath = path.join(versionDir.relativeDir, fileName);
+  const absolutePath = path.join(versionDir.absoluteDir, fileName);
+  await fs.writeFile(absolutePath, String(text || ""), "utf8");
+  return { repairVersion, relativeDir: versionDir.relativeDir, relativePath, absolutePath };
+}
+
+function collectModifiedSourceCandidates(text) {
+  const matches = String(text || "").match(/(?:[A-Za-z]:)?[A-Za-z0-9_./\\-]+\.(?:js|jsx|ts|tsx|json|css|scss|less|html|vue|java|kt|go|py|rb|php|cs|cpp|c|h|hpp|m|mm|swift|xml|yml|yaml)/g) || [];
+  return Array.from(new Set(matches.map((item) => String(item || "").replace(/\\/g, "/").replace(/^\.\//, "").trim()).filter(Boolean)));
+}
+
+async function archiveModifiedSources(repairVersionRelativeDir, text, context) {
+  const candidates = collectModifiedSourceCandidates(text);
+  const archived = [];
+  for (const candidate of candidates) {
+    /* eslint-disable no-await-in-loop */
+    const workspaceAbsolute = path.resolve(context.rootDir, candidate);
+    if (workspaceAbsolute !== context.rootDir && !workspaceAbsolute.startsWith(context.rootDir + path.sep)) {
+      continue;
+    }
+    const stats = await fs.stat(workspaceAbsolute).catch(() => null);
+    if (!stats || !stats.isFile()) {
+      continue;
+    }
+    const sourceRelativePath = path.relative(context.rootDir, workspaceAbsolute);
+    if (!sourceRelativePath || sourceRelativePath.startsWith("fingerprints" + path.sep)) {
+      continue;
+    }
+    const targetRelativePath = path.join(repairVersionRelativeDir, "sources", sourceRelativePath);
+    const targetAbsolutePath = toSafeAbsolute(context.fingerprintsRoot, targetRelativePath);
+    await fs.mkdir(path.dirname(targetAbsolutePath), { recursive: true });
+    await fs.copyFile(workspaceAbsolute, targetAbsolutePath);
+    archived.push(targetRelativePath);
+    /* eslint-enable no-await-in-loop */
+  }
+  return archived;
+}
+
+async function writeRepairStatus(relativeReportPath, payload, context) {
+  const reportsRelativeDir = path.dirname(relativeReportPath);
+  const statusPath = toSafeAbsolute(context.fingerprintsRoot, path.join(reportsRelativeDir, ".repair-status.json"));
+  await fs.writeFile(statusPath, JSON.stringify(payload, null, 2), "utf8");
+  return path.relative(context.fingerprintsRoot, statusPath);
+}
+
+async function readFilePreview(rootDir, relativePath) {
+  const targetPath = toSafeAbsolute(rootDir, relativePath);
+  const content = await fs.readFile(targetPath, "utf8");
+  return {
+    path: relativePath,
+    absolutePath: targetPath,
+    content,
+  };
+}
+
+async function getCodex(proxyUrl) {
+  const mod = await import("@openai/codex-sdk");
+  const env = Object.assign({}, process.env, {
+    HTTP_PROXY: proxyUrl,
+    HTTPS_PROXY: proxyUrl,
+    ALL_PROXY: proxyUrl,
+  });
+  return new mod.Codex({ env });
+}
+
+function resolveCodexProxy(proxyValue) {
+  return String(proxyValue || process.env.HTTP_PROXY || process.env.HTTPS_PROXY || process.env.ALL_PROXY || DEFAULT_PROXY || "").trim();
+}
+
+async function withHeartbeat(scope, stage, context, task) {
+  return task();
+}
+
+function truncateConsoleText(value, maxLength) {
+  const text = String(value || "").replace(/\r\n/g, "\n");
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return `${text.slice(0, maxLength)}\n...[truncated]`;
+}
+
+function extractCodexEventText(event) {
+  if (!event || typeof event !== "object") {
+    return "";
+  }
+  if (typeof event.text === "string" && event.text.trim()) {
+    return event.text;
+  }
+  if (typeof event.delta === "string" && event.delta.trim()) {
+    return event.delta;
+  }
+  if (event.item && typeof event.item.text === "string" && event.item.text.trim()) {
+    return event.item.text;
+  }
+  if (event.item && typeof event.item.delta === "string" && event.item.delta.trim()) {
+    return event.item.delta;
+  }
+  if (typeof event.message === "string" && event.message.trim()) {
+    return event.message;
+  }
+  return "";
+}
+
+function normalizePlanString(value) {
+  return String(value || "").replace(/\r\n/g, "\n").trim();
+}
+
+function extractJsonCodeFence(text) {
+  const normalized = normalizePlanString(text);
+  const fencedMatch = normalized.match(/```json\s*([\s\S]*?)```/i);
+  if (fencedMatch && fencedMatch[1]) {
+    return fencedMatch[1].trim();
+  }
+  return "";
+}
+
+function buildFallbackStructuredPlan(rawText, parseError, reportPath) {
+  return {
+    schemaVersion: 1,
+    reportPath,
+    summary: "",
+    rootCause: "",
+    changes: [],
+    risks: [],
+    verification: [],
+    notes: [],
+    parseError,
+    rawText: normalizePlanString(rawText),
+  };
+}
+
+function extractStructuredRepairPlan(rawText, reportPath) {
+  const normalized = normalizePlanString(rawText);
+  const jsonText = extractJsonCodeFence(normalized) || normalized;
+  try {
+    const parsed = JSON.parse(jsonText);
+    return {
+      schemaVersion: Number(parsed.schemaVersion || 1),
+      reportPath: parsed.reportPath || reportPath,
+      summary: String(parsed.summary || ""),
+      rootCause: String(parsed.rootCause || ""),
+      changes: Array.isArray(parsed.changes) ? parsed.changes : [],
+      risks: Array.isArray(parsed.risks) ? parsed.risks : [],
+      verification: Array.isArray(parsed.verification) ? parsed.verification : [],
+      notes: Array.isArray(parsed.notes) ? parsed.notes : [],
+    };
+  } catch (error) {
+    return buildFallbackStructuredPlan(
+      rawText,
+      error instanceof Error ? error.message : String(error),
+      reportPath,
+    );
+  }
+}
+
+function logCodexEvent(scope, stage, context, event) {
+  const text = extractCodexEventText(event);
+  if (text) {
+    console.log(truncateConsoleText(text, 4000));
+  }
+}
+
+async function runCodexTurnWithStreaming(thread, prompt, scope, stage, context) {
+  let lastEventAt = Date.now();
+  let finalResponse = "";
+  let usage = null;
+  let waitingLogged = false;
+  const timer = setInterval(() => {
+    if (!waitingLogged && Date.now() - lastEventAt >= 15000) {
+      waitingLogged = true;
+      console.log(`${scope} ${stage} waiting`);
+    }
+  }, 5000);
+  if (typeof timer.unref === "function") {
+    timer.unref();
+  }
+  try {
+    const stream = await thread.runStreamed(prompt);
+    for await (const event of stream.events) {
+      lastEventAt = Date.now();
+      waitingLogged = false;
+      logCodexEvent(scope, stage, context, event);
+      if (event.type === "item.completed" && event.item && event.item.type === "agent_message") {
+        finalResponse = event.item.text || finalResponse;
+      } else if (event.type === "turn.completed") {
+        usage = event.usage || null;
+      } else if (event.type === "turn.failed") {
+        throw new Error(event.error && event.error.message ? event.error.message : "Codex turn failed");
+      }
+    }
+    return {
+      finalResponse,
+      usage,
+    };
+  } finally {
+    clearInterval(timer);
+  }
+}
+
+async function runRepairPlan(reportText, reportPath, options) {
+  const proxy = resolveCodexProxy(options.proxy);
+  const codex = await withHeartbeat("[backtrace-repair][generate]", "create-client", { reportPath, proxy }, () => getCodex(proxy));
+  const thread = codex.startThread({
+    workingDirectory: options.workdir,
+    skipGitRepoCheck: true,
+    sandboxMode: "read-only",
+    approvalPolicy: "never",
+    modelReasoningEffort: "high",
+  });
+  const prompt = [
+    "你是一名资深工程师。当前只输出修复方案，不执行任何代码修改。",
+    "请先输出一个严格可解析的 JSON 代码块，然后再输出一份人类可读的 Markdown 修复说明。",
+    "重要要求：JSON 的键名保持英文不变，但 JSON 的值内容和后续 Markdown 说明必须全部使用中文。",
+    "第一部分必须是一个合法的 JSON 代码块，结构如下：",
+    "{",
+    '  "schemaVersion": 1,',
+    '  "reportPath": "string",',
+    '  "summary": "一句话总结",',
+    '  "rootCause": "根因判断",',
+    '  "changes": [',
+    "    {",
+    '      "file": "工作区相对路径",',
+    '      "searchAnchor": "稳定定位锚点文本",',
+    '      "lineHint": 0,',
+    '      "action": "replace_block | insert_before | insert_after | update_condition",',
+    '      "before": "尽量小的修改前代码片段",',
+    '      "after": "尽量小的修改后代码片段",',
+    '      "reason": "为什么这样修改",',
+    '      "risk": "该修改的风险",',
+    '      "verify": ["验证步骤1", "验证步骤2"]',
+    "    }",
+    "  ],",
+    '  "risks": ["整体风险"],',
+    '  "verification": ["整体验证步骤"],',
+    '  "notes": ["补充说明"]',
+    "}",
+    "Rules:",
+    "1. The JSON must be valid and parseable.",
+    "2. Prefer to output non-empty changes whenever there is any plausible actionable fix.",
+    "3. If you cannot identify an exact file, still output candidate changes using the most likely file type or location, such as Config/DefaultEngine.ini, a Blueprint default, construction logic, runtime guard code, or a C++ validation path.",
+    "4. Only return an empty changes array when you truly cannot infer any file type, any protective code change, or any temporary mitigation.",
+    "5. For common guard scenarios such as zero scale, invalid transform, null pointer, or bounds validation, you must provide at least one candidate protective change and explain uncertainty in risk.",
+    "报告路径: " + reportPath,
+    "",
+    reportText,
+  ].join("\n");
+  const turn = await runCodexTurnWithStreaming(thread, prompt, "[backtrace-repair][generate]", "run-prompt", { reportPath, threadId: thread.id });
+  return {
+    threadId: thread.id,
+    planText: turn.finalResponse || "Codex 未返回修复方案。",
+  };
+}
+
+async function runApplyRepairPlan(reportText, planText, reportPath, options) {
+  const proxy = resolveCodexProxy(options.proxy);
+  const codex = await withHeartbeat("[backtrace-repair][apply]", "create-client", { reportPath, proxy }, () => getCodex(proxy));
+  const thread = codex.startThread({
+    workingDirectory: options.workdir,
+    skipGitRepoCheck: true,
+    sandboxMode: "workspace-write",
+    approvalPolicy: "never",
+    modelReasoningEffort: "high",
+  });
+  const prompt = [
+    "你是一名资深工程师，现在根据下面已经确认的修复方案，直接在工作目录中实施代码修改。",
+    "请实际修改文件，不要只给建议。",
+    "修改完成后，说明你改了哪些文件、每个文件做了什么修改，以及你进行了哪些验证。",
+    "最后请单独列出所有实际修改过的源码文件路径，每行一个。",
+    "",
+    `分析报告路径: ${reportPath}`,
+    "",
+    "原始分析报告:",
+    reportText,
+    "",
+    "已确认的修复方案:",
+    planText,
+  ].join("\n");
+  const turn = await runCodexTurnWithStreaming(thread, prompt, "[backtrace-repair][apply]", "run-prompt", { reportPath, threadId: thread.id });
+  return {
+    threadId: thread.id,
+    resultText: turn.finalResponse || "Codex 未返回应用结果。",
+  };
+}
+
+async function generateRepairPlan(input, overrides = {}) {
+  const context = createRepairContext(overrides);
+  const reportPath = String(input.reportPath || "").trim();
+  if (!reportPath) {
+    throw new Error("reportPath is required");
+  }
+  const repairVersion = await resolveNewRepairVersion(reportPath, context);
+  const file = await readFilePreview(context.fingerprintsRoot, reportPath);
+  const result = await runRepairPlan(file.content, reportPath, {
+    workdir: overrides.workdir || context.workdir,
+    proxy: overrides.proxy || context.proxy,
+  });
+  const structuredPlan = extractStructuredRepairPlan(result.planText, reportPath);
+  const repairPlanFile = await writeRepairArtifact(reportPath, repairVersion, "repair-plan.md", result.planText, context);
+  const repairPlanJsonFile = await writeRepairArtifact(
+    reportPath,
+    repairVersion,
+    "repair-plan.json",
+    JSON.stringify(structuredPlan, null, 2),
+    context,
+  );
+  return {
+    ok: true,
+    reportPath,
+    plan: result.planText,
+    structuredPlan,
+    threadId: result.threadId,
+    repairVersion,
+    repairPlanPath: repairPlanFile.relativePath,
+    repairPlanJsonPath: repairPlanJsonFile.relativePath,
+  };
+}
+
+async function applyRepairPlan(input, overrides = {}) {
+  const context = createRepairContext(overrides);
+  const reportPath = String(input.reportPath || "").trim();
+  const planText = String(input.planText || "").trim();
+  if (!reportPath || !planText) {
+    throw new Error("reportPath and planText are required");
+  }
+  const repairVersion = await resolveRepairVersionForApply(reportPath, input.repairVersion, input.repairPlanPath, context);
+  const file = await readFilePreview(context.fingerprintsRoot, reportPath);
+  const result = await runApplyRepairPlan(file.content, planText, reportPath, {
+    workdir: overrides.workdir || context.workdir,
+    proxy: overrides.proxy || context.proxy,
+  });
+  const repairResultFile = await writeRepairArtifact(reportPath, repairVersion, "apply-result.md", result.resultText, context);
+  const archivedSources = await archiveModifiedSources(path.dirname(repairResultFile.relativePath), `${result.resultText}\n${planText}`, context);
+  const repairStatusPath = await writeRepairStatus(reportPath, {
+    completed: true,
+    appliedAt: new Date().toISOString(),
+    reportPath,
+    repairVersion,
+    repairResultPath: repairResultFile.relativePath,
+    archivedSources,
+    threadId: result.threadId,
+    resultText: result.resultText,
+  }, context);
+  return {
+    ok: true,
+    reportPath,
+    resultText: result.resultText,
+    threadId: result.threadId,
+    repairStatusPath,
+    repairVersion,
+    repairResultPath: repairResultFile.relativePath,
+    archivedSources,
+    status: "已完成",
+  };
+}
+
+async function readRepairPlanText(input, overrides = {}) {
+  const context = createRepairContext(overrides);
+  if (input.planText) {
+    return String(input.planText);
+  }
+  const repairPlanPath = String(input.repairPlanPath || "").trim();
+  if (!repairPlanPath) {
+    throw new Error("planText or repairPlanPath is required");
+  }
+  const file = await readFilePreview(context.fingerprintsRoot, repairPlanPath);
+  return file.content;
+}
+
+module.exports = {
+  createRepairContext,
+  formatRepairVersion,
+  resolveCodexProxy,
+  generateRepairPlan,
+  applyRepairPlan,
+  readRepairPlanText,
+};