@jsonstudio/rcc 0.89.1121 → 0.89.1136

package/scripts/scan-apply-patch-samples.mjs

@@ -17,6 +17,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
+import crypto from 'node:crypto';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -27,8 +28,13 @@ const coreLoaderUrl = pathToFileURL(coreLoaderPath).href;
 
 const HOME = os.homedir();
 const USER_CODEX_ROOT = path.join(HOME, '.routecodex', 'codex-samples');
+const USER_CODEX_ROOT_ALT = path.join(HOME, '.routecodex', 'codex samples');
 const USER_CODEX_PENDING = path.join(USER_CODEX_ROOT, 'openai-chat', '__pending__');
 const REPO_GOLDENS_ROOT = path.join(repoRoot, 'samples', 'ci-goldens');
+const ERROR_SAMPLES_ROOT = path.join(HOME, '.routecodex', 'errorsamples', 'apply_patch');
+
+const DEFAULT_CAPTURE_TOTAL_LIMIT = 5000;
+const DEFAULT_CAPTURE_PER_REASON_LIMIT = 250;
 
 async function fileExists(p) {
   try {
@@ -111,6 +117,74 @@ function extractApplyPatchArgs(doc, { allowRegressionOriginalArgs } = { allowReg
   return out;
 }
 
+function isContextMismatchReason(reason) {
+  // We only capture/repair shape issues; context mismatches are not actionable here.
+  // Keep this conservative: if a new reason is introduced, we still capture it unless
+  // it clearly indicates a context mismatch.
+  if (!reason) return false;
+  const r = String(reason);
+  return (
+    r.includes('context') ||
+    r.includes('expected') ||
+    r.includes('hunk') ||
+    r.includes('no_match') ||
+    r.includes('not_found')
+  );
+}
+
+function stableHash(input) {
+  return crypto.createHash('sha256').update(input).digest('hex').slice(0, 16);
+}
+
+async function captureFailure({
+  destRoot,
+  label,
+  sourceFile,
+  reason,
+  originalArgs,
+  validationResult,
+  captureState,
+}) {
+  if (isContextMismatchReason(reason)) return;
+  if (captureState?.reasonAllowList && !captureState.reasonAllowList.has(reason)) return;
+  if (!destRoot) return;
+
+  const totalLimit = captureState.totalLimit ?? DEFAULT_CAPTURE_TOTAL_LIMIT;
+  const perReasonLimit = captureState.perReasonLimit ?? DEFAULT_CAPTURE_PER_REASON_LIMIT;
+  if (captureState.totalCaptured >= totalLimit) return;
+
+  const currentReasonCount = captureState.byReason.get(reason) ?? 0;
+  if (currentReasonCount >= perReasonLimit) return;
+
+  const key = `${label}\n${reason}\n${sourceFile}\n${originalArgs}`;
+  const filename = `sample_${stableHash(key)}.json`;
+  const folder = path.join(destRoot, reason);
+  const outPath = path.join(folder, filename);
+
+  try {
+    await fs.access(outPath);
+    return;
+  } catch {
+    // continue
+  }
+
+  await fs.mkdir(folder, { recursive: true });
+  const payload = {
+    tool: 'apply_patch',
+    label,
+    reason,
+    capturedAt: new Date().toISOString(),
+    sourceFile,
+    argsSha256: crypto.createHash('sha256').update(originalArgs).digest('hex'),
+    originalArgs,
+    validationResult,
+  };
+  await fs.writeFile(outPath, JSON.stringify(payload, null, 2), 'utf-8');
+
+  captureState.totalCaptured += 1;
+  captureState.byReason.set(reason, currentReasonCount + 1);
+}
+
 async function loadValidator() {
   if (!(await fileExists(coreLoaderPath))) {
     throw new Error(`core-loader missing at ${coreLoaderPath} (run npm run build:dev first)`);
@@ -123,7 +197,7 @@ async function loadValidator() {
   return { validateToolCall };
 }
 
-async function scanRoot(label, rootDir, validateToolCall) {
+async function scanRoot(label, rootDir, validateToolCall, capture) {
   if (!(await fileExists(rootDir))) {
     return { label, rootDir, files: 0, calls: 0, ok: 0, byReason: new Map(), examples: [] };
   }
@@ -168,6 +242,17 @@ async function scanRoot(label, rootDir, validateToolCall) {
       const cur = byReason.get(reason) || { count: 0 };
       cur.count += 1;
       byReason.set(reason, cur);
+      if (capture?.enabled) {
+        await captureFailure({
+          destRoot: capture.destRoot,
+          label,
+          sourceFile: filePath,
+          reason,
+          originalArgs: args,
+          validationResult: res,
+          captureState: capture.state,
+        });
+      }
       if (examples.length < 12) {
         examples.push({ file: filePath, reason });
       }
@@ -200,17 +285,73 @@ function printReport(report) {
 async function main() {
   const { validateToolCall } = await loadValidator();
 
-  const repo = await scanRoot('repo samples/ci-goldens', REPO_GOLDENS_ROOT, validateToolCall);
+  const captureEnabled = process.argv.slice(2).includes('--capture') || process.env.ROUTECODEX_SCAN_CAPTURE === '1';
+  const captureRepo = process.argv.slice(2).includes('--capture-repo') || process.env.ROUTECODEX_SCAN_CAPTURE_REPO === '1';
+  const captureRoot = process.env.ROUTECODEX_ERRORSAMPLES_DIR || ERROR_SAMPLES_ROOT;
+  const totalLimit = Number.parseInt(process.env.ROUTECODEX_CAPTURE_TOTAL_LIMIT || '', 10);
+  const perReasonLimit = Number.parseInt(process.env.ROUTECODEX_CAPTURE_PER_REASON_LIMIT || '', 10);
+  const reasonsArg = process.argv
+    .slice(2)
+    .find((arg) => arg.startsWith('--capture-reasons='))
+    ?.split('=')[1];
+  const reasonsEnv = process.env.ROUTECODEX_CAPTURE_REASONS;
+  const reasonAllowListRaw = (reasonsArg || reasonsEnv || '').trim();
+  const reasonAllowList = reasonAllowListRaw
+    ? new Set(
+        reasonAllowListRaw
+          .split(',')
+          .map((s) => s.trim())
+          .filter(Boolean)
+      )
+    : null;
+  const captureState = {
+    totalCaptured: 0,
+    totalLimit: Number.isFinite(totalLimit) ? totalLimit : DEFAULT_CAPTURE_TOTAL_LIMIT,
+    perReasonLimit: Number.isFinite(perReasonLimit) ? perReasonLimit : DEFAULT_CAPTURE_PER_REASON_LIMIT,
+    byReason: new Map(),
+    reasonAllowList,
+  };
+
+  const repo = await scanRoot('repo samples/ci-goldens', REPO_GOLDENS_ROOT, validateToolCall, {
+    enabled: captureEnabled && captureRepo,
+    destRoot: captureRoot,
+    state: captureState,
+  });
   printReport(repo);
 
   const userAll = process.argv.slice(2).includes('--user-all');
-  const userRoot = userAll && (await fileExists(USER_CODEX_ROOT)) ? USER_CODEX_ROOT : (await fileExists(USER_CODEX_PENDING)) ? USER_CODEX_PENDING : USER_CODEX_ROOT;
-  const user = await scanRoot(`user ${userAll ? '~/.routecodex/codex-samples (all)' : '~/.routecodex/codex-samples/openai-chat/__pending__'}`, userRoot, validateToolCall);
-  printReport(user);
+  const userRoots = [];
+  if (userAll) {
+    if (await fileExists(USER_CODEX_ROOT)) userRoots.push({ label: 'user ~/.routecodex/codex-samples (all)', root: USER_CODEX_ROOT });
+    if (await fileExists(USER_CODEX_ROOT_ALT))
+      userRoots.push({ label: 'user ~/.routecodex/codex samples (all)', root: USER_CODEX_ROOT_ALT });
+  } else {
+    const pending = (await fileExists(USER_CODEX_PENDING)) ? USER_CODEX_PENDING : null;
+    if (pending) userRoots.push({ label: 'user ~/.routecodex/codex-samples/openai-chat/__pending__', root: pending });
+    else if (await fileExists(USER_CODEX_ROOT)) userRoots.push({ label: 'user ~/.routecodex/codex-samples', root: USER_CODEX_ROOT });
+    else if (await fileExists(USER_CODEX_ROOT_ALT)) userRoots.push({ label: 'user ~/.routecodex/codex samples', root: USER_CODEX_ROOT_ALT });
+    else userRoots.push({ label: 'user ~/.routecodex/codex-samples', root: USER_CODEX_ROOT });
+  }
 
-  const totalCalls = repo.calls + user.calls;
-  const totalOk = repo.ok + user.ok;
+  const userReports = [];
+  for (const entry of userRoots) {
+    const report = await scanRoot(entry.label, entry.root, validateToolCall, {
+      enabled: captureEnabled,
+      destRoot: captureRoot,
+      state: captureState,
+    });
+    userReports.push(report);
+    printReport(report);
+  }
+
+  const totalCalls = repo.calls + userReports.reduce((sum, r) => sum + r.calls, 0);
+  const totalOk = repo.ok + userReports.reduce((sum, r) => sum + r.ok, 0);
   console.log(`\n[scan] TOTAL apply_patch_calls=${totalCalls} ok=${totalOk} fail=${totalCalls - totalOk}`);
+  if (captureEnabled) {
+    console.log(
+      `[scan] captured_failures=${captureState.totalCaptured} dest=${captureRoot} (per_reason<=${captureState.perReasonLimit}, total<=${captureState.totalLimit})`
+    );
+  }
 
   process.exitCode = totalCalls - totalOk > 0 ? 1 : 0;
 }