@lyupro/codex-bridge 0.6.9 → 0.6.10

package/src/home/lib/runner/flag-baseline.mjs

@@ -0,0 +1,105 @@
+/**
+ * Records dirty files' start bytes so Plan_60 D3a can distinguish this run's flags from earlier uncommitted work.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { headSha, runsPrefixInside } from './git-state.mjs';
+import { diffNames, listUntrackedPaths } from './git-paths.mjs';
+import { readJsonFileSync } from '../json-file.mjs';
+
+export const FLAG_BASELINE_VERSION = 1;
+export const FLAG_BASELINE_MANIFEST = 'flags-baseline.json';
+export const FLAG_BASELINE_DIR = 'flags-baseline';
+export const FLAG_BASELINE_LIMITS = Object.freeze({
+  perFileBytes: 1024 * 1024,
+  perRunBytes: 32 * 1024 * 1024,
+});
+
+export function captureFlagBaseline({ runDir, repoRoot, isGitRepo, limits = FLAG_BASELINE_LIMITS }) {
+  const manifest = {
+    version: FLAG_BASELINE_VERSION,
+    head: '',
+    complete: false,
+    reason: '',
+    limits: { ...limits },
+    files: [],
+  };
+  if (!isGitRepo) {
+    manifest.reason = 'not a git repository';
+  } else {
+    const head = headSha(repoRoot);
+    // rev-parse prints the literal HEAD on an unborn branch; it is not a start commit.
+    manifest.head = head === 'HEAD' ? '' : head;
+    if (!manifest.head) {
+      manifest.reason = 'no start commit';
+    } else {
+      const dirty = diffNames(repoRoot, 'HEAD');
+      const untracked = listUntrackedPaths(repoRoot);
+      if (dirty === null || untracked === null) {
+        manifest.reason = 'git listing failed';
+      } else {
+        const tracked = new Set(dirty);
+        const skip = runsPrefixInside(repoRoot);
+        const names = [...new Set([...dirty, ...untracked])]
+          .filter((name) => !(skip && `${name}/`.startsWith(skip)))
+          .sort();
+        let total = 0;
+        for (const [index, name] of names.entries()) {
+          const entry = { path: name, tracked: tracked.has(name), state: 'unreadable' };
+          manifest.files.push(entry);
+          const full = path.join(repoRoot, name);
+          let content;
+          try {
+            const stat = fs.lstatSync(full);
+            if (!stat.isFile()) continue;
+            if (stat.size > limits.perFileBytes) {
+              entry.state = 'truncated';
+              continue;
+            }
+            if (total + stat.size > limits.perRunBytes) {
+              entry.state = 'over-run-cap';
+              continue;
+            }
+            content = fs.readFileSync(full);
+          } catch (error) {
+            if (error.code === 'ENOENT') entry.state = entry.tracked ? 'deleted' : 'absent';
+            continue;
+          }
+          // Recheck actual bytes: the file may have grown since its metadata was read.
+          if (content.length > limits.perFileBytes) {
+            entry.state = 'truncated';
+          } else if (total + content.length > limits.perRunBytes) {
+            entry.state = 'over-run-cap';
+          } else if (content.subarray(0, 8000).includes(0)) {
+            entry.state = 'binary';
+          } else {
+            const copyDir = path.join(runDir, FLAG_BASELINE_DIR);
+            fs.mkdirSync(copyDir, { recursive: true });
+            const copy = `${index}.bin`;
+            fs.writeFileSync(path.join(copyDir, copy), content);
+            Object.assign(entry, { state: 'copied', copy, bytes: content.length });
+            total += content.length;
+          }
+        }
+        manifest.complete = manifest.files.every((entry) =>
+          ['copied', 'deleted', 'absent'].includes(entry.state));
+        if (!manifest.complete) manifest.reason = 'some start contents are unknown';
+      }
+    }
+  }
+  fs.writeFileSync(path.join(runDir, FLAG_BASELINE_MANIFEST), `${JSON.stringify(manifest, null, 2)}\n`);
+  return manifest;
+}
+
+export function readFlagBaseline(runDir) {
+  try {
+    const manifest = readJsonFileSync(path.join(runDir, FLAG_BASELINE_MANIFEST));
+    return manifest?.version === FLAG_BASELINE_VERSION ? manifest : null;
+  } catch {
+    return null;
+  }
+}
+
+export function removeFlagBaselineCopies(runDir) {
+  fs.rmSync(path.join(runDir, FLAG_BASELINE_DIR), { recursive: true, force: true });
+}

package/src/home/lib/runner/flag-scan.mjs

@@ -0,0 +1,165 @@
+/**
+ * Judges added lines against start bytes because Plan_60 D3a must not blame earlier dirty work or TODO test data.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { readFlagBaseline, removeFlagBaselineCopies, FLAG_BASELINE_DIR } from './flag-baseline.mjs';
+import { runSnapshotChanges } from '../meta/run-snapshots.mjs';
+
+const STUB = /test\.(skip|only)|it\.(skip|only)|describe\.(skip|only)|NotImplemented/;
+const MARKER_PREFIX = /(?:^[ \t]*|\/\/[ \t]*|\/\*+[ \t]*|#[ \t]*|<!--[ \t]*|--[ \t]*|^[ \t]*\*[ \t]*)$/;
+const LIST_PREFIX = /^[ \t]*(?:[-+*]|\d+[.)])[ \t]+(?:\[[ xX]\][ \t]+)?$/;
+
+export function isFlagLine(text) {
+  if (STUB.test(text)) return true;
+  for (const match of text.matchAll(/(?:TODO|FIXME)(?![A-Za-z0-9_])/g)) {
+    const prefix = text.slice(0, match.index);
+    if (MARKER_PREFIX.test(prefix) || LIST_PREFIX.test(prefix)) return true;
+  }
+  return false;
+}
+
+function addedLines(diff) {
+  const added = [];
+  let inside = false;
+  let number = 0;
+  for (const line of diff.split('\n')) {
+    if (line.startsWith('diff ')) {
+      inside = false;
+      continue;
+    }
+    const hunk = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(line);
+    if (hunk) {
+      inside = true;
+      number = Number(hunk[1]);
+    } else if (inside && line.startsWith('+')) {
+      added.push({ number, text: line.slice(1) });
+      number += 1;
+    } else if (inside && line.startsWith(' ')) {
+      number += 1;
+    }
+  }
+  return added;
+}
+
+function compareFile(baseFile, currentFile) {
+  const result = spawnSync('git', [
+    '-c', 'core.quotepath=false', 'diff', '--no-index', '--no-color', '--no-ext-diff', '--no-textconv',
+    '--ignore-cr-at-eol', '--diff-algorithm=myers', '-U0', '--', baseFile, currentFile,
+  ], { windowsHide: true, timeout: 30_000, maxBuffer: 8 * 1024 * 1024 });
+  if (result.error || ![0, 1].includes(result.status)) return null;
+  return result.status === 0 ? [] : addedLines(result.stdout.toString('utf8'));
+}
+
+// `git show <head>:<path>` exits non-zero both for a path the start commit lacks (a new file: every line is added)
+// and for a start commit nobody can read; only a readable commit lets the first case accuse anyone.
+function headReadable(repoRoot, head) {
+  const result = spawnSync('git', ['-C', repoRoot, 'cat-file', '-e', `${head}^{commit}`], {
+    windowsHide: true, timeout: 30_000,
+  });
+  return !result.error && result.status === 0;
+}
+
+function scanPath({ name, entry, baseline, headKnown, runDir, repoRoot, gaps }) {
+  const currentFile = path.join(repoRoot, name);
+  let current;
+  try {
+    const stat = fs.lstatSync(currentFile);
+    if (!stat.isFile()) return [];
+    if (stat.size > baseline.limits.perFileBytes) {
+      gaps.push(`${name}: end content over the limit`);
+      return [];
+    }
+    current = fs.readFileSync(currentFile);
+  } catch (error) {
+    if (error.code !== 'ENOENT' && error.code !== 'ENOTDIR') gaps.push(`${name}: end content unreadable`);
+    return [];
+  }
+  if (current.length > baseline.limits.perFileBytes) {
+    gaps.push(`${name}: end content over the limit`);
+    return [];
+  }
+  if (current.subarray(0, 8000).includes(0)) return [];
+
+  let base = Buffer.alloc(0);
+  let baseFile;
+  let temporary = false;
+  if (entry) {
+    if (entry.state === 'copied') {
+      baseFile = path.join(runDir, FLAG_BASELINE_DIR, entry.copy);
+      try {
+        base = fs.readFileSync(baseFile);
+      } catch {
+        gaps.push(`${name}: start content unreadable`);
+        return [];
+      }
+    } else if (!['deleted', 'absent'].includes(entry.state)) {
+      gaps.push(`${name}: start content ${entry.state}`);
+      return [];
+    }
+  } else if (!headKnown) {
+    gaps.push(`${name}: start commit unreadable`);
+    return [];
+  } else {
+    const result = spawnSync('git', ['-C', repoRoot, 'show', `${baseline.head}:${name}`], {
+      windowsHide: true, timeout: 30_000, maxBuffer: 8 * 1024 * 1024,
+    });
+    if (result.error || result.status === null) {
+      gaps.push(`${name}: start content unreadable`);
+      return [];
+    }
+    if (result.status === 0) base = result.stdout;
+    if (base.length) {
+      const copyDir = path.join(runDir, FLAG_BASELINE_DIR);
+      fs.mkdirSync(copyDir, { recursive: true });
+      baseFile = path.join(copyDir, `head-${randomUUID()}.bin`);
+      fs.writeFileSync(baseFile, base, { flag: 'wx' });
+      temporary = true;
+    }
+  }
+
+  if (!base.length) {
+    return current.toString('utf8').split('\n').map((text, index) => ({ number: index + 1, text }));
+  }
+  let added;
+  try {
+    added = compareFile(baseFile, currentFile);
+  } finally {
+    if (temporary) fs.unlinkSync(baseFile);
+  }
+  if (added === null) {
+    gaps.push(`${name}: diff failed`);
+    return [];
+  }
+  return added;
+}
+
+export function scanRunFlags({ runDir, repoRoot }) {
+  const gaps = [];
+  const hits = [];
+  try {
+    const baseline = readFlagBaseline(runDir);
+    if (!baseline) {
+      gaps.push('no flag baseline');
+    } else if (!baseline.complete && baseline.files.length === 0) {
+      gaps.push(`flag baseline incomplete: ${baseline.reason}`);
+    } else {
+      const entries = new Map(baseline.files.map((entry) => [entry.path, entry]));
+      const comparison = runSnapshotChanges(runDir);
+      if (!comparison.ok) gaps.push('snapshots not comparable');
+      const names = [...new Set([...entries.keys(), ...(comparison.ok ? comparison.changed : [])])].sort();
+      const headKnown = headReadable(repoRoot, baseline.head);
+      for (const name of names) {
+        const added = scanPath({ name, entry: entries.get(name), baseline, headKnown, runDir, repoRoot, gaps });
+        for (const line of added) {
+          if (hits.length < 20 && isFlagLine(line.text)) hits.push(`${name}:${line.number}: ${line.text.trim()}\n`);
+        }
+      }
+    }
+  } finally {
+    removeFlagBaselineCopies(runDir);
+  }
+  return { text: hits.join(''), coverage: { complete: gaps.length === 0, gaps } };
+}

package/src/home/lib/runner/git-state.mjs

@@ -94,39 +94,6 @@ export const headSha = (repo) => (git(repo, ['rev-parse', 'HEAD']).stdout || '')
 export const branchName = (repo) =>
   (git(repo, ['symbolic-ref', '--short', '-q', 'HEAD']).stdout || '').trim();
 
-const FAKE_DONE_RE =
-  /TODO|FIXME|test\.(skip|only)|it\.(skip|only)|describe\.(skip|only)|NotImplemented/;
-
-/**
- * Traces of fake completion. `git diff` carries nothing for untracked files, so a brand
- * new file full of TODOs would otherwise pass as "Flags: none" — the one case the check
- * exists for.
- */
-export function findFakeDone(repo) {
-  const skip = runsPrefixInside(repo);
-  const hits = (git(repo, ['diff', '-U0']).stdout || '')
-    .split(/\r?\n/)
-    .filter((l) => l.startsWith('+') && FAKE_DONE_RE.test(l));
-  for (const file of (listUntrackedPaths(repo) ?? [])
-    // Same reason as in worktreeSnapshot: inside ~/.claude the run folder is part of the
-    // worktree, and task.md spells out the very words this scans for ("do not leave TODOs,
-    // test.skip"). A run flagged itself for quoting its own instructions.
-    .filter((file) => !(skip && `${file}/`.startsWith(skip)))) {
-    const full = path.join(repo, file);
-    try {
-      if (fs.statSync(full).size > 1024 * 1024) continue;
-      fs.readFileSync(full, 'utf8')
-        .split(/\r?\n/)
-        .forEach((l, i) => {
-          if (FAKE_DONE_RE.test(l)) hits.push(`${file}:${i + 1}: ${l.trim()}`);
-        });
-    } catch {
-      // Binary or unreadable: nothing to flag.
-    }
-  }
-  return hits.length ? `${hits.slice(0, 20).join('\n')}\n` : '';
-}
-
 /** What exactly is under review, resolved from git rather than from wording. */
 export function reviewScope(repo, changeset) {
   if (changeset.startsWith('base:')) {