everything-claude-code 1.4.3

package/scripts/ecc/kernel.js

@@ -0,0 +1,144 @@
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function isFile(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch (_err) {
+    return false;
+  }
+}
+
+function getKernelMode() {
+  // ECC_KERNEL:
+  // - "auto" (default): use ecc-kernel if available, else fallback to JS
+  // - "rust": require ecc-kernel, error if missing
+  // - "node": force JS implementation
+  const raw = process.env.ECC_KERNEL ? String(process.env.ECC_KERNEL).trim().toLowerCase() : 'auto';
+  if (!raw || raw === 'auto') return 'auto';
+  if (raw === 'rust' || raw === 'kernel') return 'rust';
+  if (raw === 'node' || raw === 'js' || raw === 'off' || raw === 'disable') return 'node';
+  return 'auto';
+}
+
+function binName() {
+  return process.platform === 'win32' ? 'ecc-kernel.exe' : 'ecc-kernel';
+}
+
+function platformArchKey() {
+  const platform = process.platform;
+  const arch = process.arch;
+  const os =
+    platform === 'darwin' ? 'darwin' :
+      platform === 'linux' ? 'linux' :
+        platform === 'win32' ? 'windows' :
+          null;
+  const cpu =
+    arch === 'x64' ? 'x64' :
+      arch === 'arm64' ? 'arm64' :
+        null;
+  if (!os || !cpu) return null;
+  return `${os}-${cpu}`;
+}
+
+function tryKernelFromPath() {
+  const res = spawnSync('ecc-kernel', ['--version'], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+  if (res.error) return null;
+  if (res.status === 0) return 'ecc-kernel';
+  return null;
+}
+
+function findKernelBinary() {
+  if (process.env.ECC_KERNEL_PATH) {
+    const p = path.resolve(String(process.env.ECC_KERNEL_PATH));
+    if (isFile(p)) return p;
+  }
+
+  // Preferred location for prebuilt binaries installed via postinstall.
+  const key = platformArchKey();
+  if (key) {
+    const packaged = path.join(__dirname, 'bin', key, binName());
+    if (isFile(packaged)) return packaged;
+  }
+
+  const fromPath = tryKernelFromPath();
+  if (fromPath) return fromPath;
+
+  const root = path.resolve(__dirname, '..', '..');
+  const candidates = [
+    path.join(root, 'crates', 'ecc-kernel', 'target', 'release', binName()),
+    path.join(root, 'crates', 'ecc-kernel', 'target', 'debug', binName())
+  ];
+  for (const p of candidates) {
+    if (isFile(p)) return p;
+  }
+  return null;
+}
+
+let _cached = null;
+
+function getKernel() {
+  if (_cached) return _cached;
+
+  const mode = getKernelMode();
+  if (mode === 'node') {
+    _cached = { mode, enabled: false, bin: null };
+    return _cached;
+  }
+
+  const bin = findKernelBinary();
+  if (mode === 'rust' && !bin) {
+    throw new Error(
+      'ECC kernel required but not found. Build it with:\n' +
+        '  cargo build --release --manifest-path crates/ecc-kernel/Cargo.toml\n' +
+        'Then re-run, or set ECC_KERNEL=node to force JS fallback.'
+    );
+  }
+
+  _cached = { mode, enabled: !!bin, bin };
+  return _cached;
+}
+
+function runKernel(command, inputObj) {
+  const kernel = getKernel();
+  if (!kernel.enabled) return null;
+
+  const res = spawnSync(kernel.bin, [command], {
+    encoding: 'utf8',
+    input: JSON.stringify(inputObj),
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  if (res.error) {
+    throw new Error(`ecc-kernel spawn failed: ${res.error.message}`);
+  }
+  const stdout = (res.stdout || '').trim();
+  const stderr = (res.stderr || '').trim();
+  if (res.status !== 0) {
+    const msg = [
+      `ecc-kernel ${command} failed (exit ${res.status})`,
+      stderr ? `stderr:\n${stderr}` : null,
+      stdout ? `stdout:\n${stdout}` : null
+    ]
+      .filter(Boolean)
+      .join('\n\n');
+    throw new Error(msg);
+  }
+
+  if (!stdout) return {};
+  try {
+    return JSON.parse(stdout);
+  } catch (err) {
+    const detail = err && err.message ? err.message : String(err);
+    throw new Error(`ecc-kernel returned non-JSON output (${detail}). Raw:\n${stdout.slice(0, 2000)}`);
+  }
+}
+
+module.exports = {
+  getKernel,
+  runKernel
+};

package/scripts/ecc/lock.js

@@ -0,0 +1,36 @@
+const fs = require('fs');
+
+const { writeJson } = require('./json');
+const { registryLockPath } = require('./project');
+const { computeEmbeddedCatalogDigest } = require('./catalog');
+const { validateLock, throwIfErrors } = require('./validate');
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function buildRegistryLock({ packs }) {
+  const lock = {
+    version: 1,
+    lockedAt: nowIso(),
+    engine: { name: 'ecc' },
+    catalog: { type: 'embedded', digest: computeEmbeddedCatalogDigest() },
+    packs
+  };
+  throwIfErrors(validateLock(lock), 'registry lock');
+  return lock;
+}
+
+function writeRegistryLock(projectRoot, { packs, overwrite = true }) {
+  const p = registryLockPath(projectRoot);
+  if (!overwrite && fs.existsSync(p)) return p;
+  const lock = buildRegistryLock({ packs });
+  writeJson(p, lock);
+  return p;
+}
+
+module.exports = {
+  buildRegistryLock,
+  writeRegistryLock
+};
+

package/scripts/ecc/paths.js

@@ -0,0 +1,28 @@
+const path = require('path');
+
+// Engine root is the repo root in this repository layout:
+//   <root>/scripts/ecc.js
+//   <root>/scripts/ecc/*
+//   <root>/packs/*
+//   <root>/prompts/ecc/*
+const ENGINE_ROOT = path.resolve(__dirname, '..', '..');
+
+function packsDir() {
+  return path.join(ENGINE_ROOT, 'packs');
+}
+
+function promptsDir() {
+  return path.join(ENGINE_ROOT, 'prompts', 'ecc');
+}
+
+function schemasDir() {
+  return path.join(ENGINE_ROOT, 'schemas');
+}
+
+module.exports = {
+  ENGINE_ROOT,
+  packsDir,
+  promptsDir,
+  schemasDir
+};
+

package/scripts/ecc/plan.js

@@ -0,0 +1,57 @@
+const fs = require('fs');
+
+const { writeJson, writeText } = require('./json');
+const { validatePlan, throwIfErrors } = require('./validate');
+const { runPaths, saveRun } = require('./run');
+
+function renderPlanMd(plan) {
+  const lines = [];
+  lines.push(`# ECC Plan`);
+  lines.push('');
+  lines.push(`Intent: ${plan.intent}`);
+  lines.push('');
+  lines.push('## Tasks');
+  lines.push('');
+  for (const t of plan.tasks) {
+    lines.push(`### ${t.id}: ${t.title}`);
+    lines.push('');
+    lines.push(`- kind: ${t.kind}`);
+    lines.push(`- dependsOn: ${t.dependsOn.length ? t.dependsOn.join(', ') : '(none)'}`);
+    lines.push(`- allowedPathPrefixes: ${t.allowedPathPrefixes.join(', ')}`);
+    lines.push('');
+    lines.push('Prompt:');
+    lines.push('');
+    lines.push('```');
+    lines.push(t.prompt.trim());
+    lines.push('```');
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+async function generatePlan({ projectRoot, run, provider }) {
+  const paths = runPaths(projectRoot, run.runId);
+
+  const plan = await provider.generatePlan({
+    intent: run.intent,
+    repoRoot: projectRoot,
+    packs: run.packs
+  });
+
+  throwIfErrors(validatePlan(plan), 'plan');
+
+  writeJson(paths.planJson, plan);
+  writeText(paths.planMd, renderPlanMd(plan));
+
+  // Ensure run.json stays valid and points to artifacts already.
+  // We also set worktree branch early for discoverability.
+  if (!fs.existsSync(paths.runJson)) saveRun(projectRoot, run.runId, run);
+
+  return { plan, paths };
+}
+
+module.exports = {
+  generatePlan,
+  renderPlanMd
+};
+

package/scripts/ecc/project.js

@@ -0,0 +1,37 @@
+const path = require('path');
+
+const ECC_DIRNAME = '.ecc';
+
+function eccDir(projectRoot) {
+  return path.join(projectRoot, ECC_DIRNAME);
+}
+
+function configPath(projectRoot) {
+  return path.join(eccDir(projectRoot), 'ecc.json');
+}
+
+function locksDir(projectRoot) {
+  return path.join(eccDir(projectRoot), 'locks');
+}
+
+function runsDir(projectRoot) {
+  return path.join(eccDir(projectRoot), 'runs');
+}
+
+function gitignorePath(projectRoot) {
+  return path.join(eccDir(projectRoot), '.gitignore');
+}
+
+function registryLockPath(projectRoot) {
+  return path.join(locksDir(projectRoot), 'registry.lock.json');
+}
+
+module.exports = {
+  eccDir,
+  configPath,
+  locksDir,
+  runsDir,
+  gitignorePath,
+  registryLockPath
+};
+

package/scripts/ecc/providers/codex.js

@@ -0,0 +1,168 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const { promptsDir, schemasDir } = require('../paths');
+const { extractJsonStringFieldToFileSync } = require('../json-extract');
+
+function readText(p) {
+  return fs.readFileSync(p, 'utf8');
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function runCodexLastMessage({ repoRoot, prompt, schemaPath }) {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-codex-'));
+  const outPath = path.join(tmpDir, 'last-message.json');
+
+  const args = [
+    'exec',
+    '--sandbox',
+    'read-only',
+    '--skip-git-repo-check',
+    '--cd',
+    repoRoot,
+    '--output-schema',
+    schemaPath,
+    '--output-last-message',
+    outPath,
+    '-'
+  ];
+
+  const res = spawnSync('codex', args, {
+    cwd: repoRoot,
+    input: prompt,
+    encoding: 'utf8',
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  const stdout = (res.stdout || '').trimEnd();
+  const stderr = (res.stderr || '').trimEnd();
+
+  if (res.status !== 0) {
+    const msg = [
+      `codex exec failed (exit ${res.status})`,
+      stdout ? `stdout:\n${stdout}` : null,
+      stderr ? `stderr:\n${stderr}` : null
+    ]
+      .filter(Boolean)
+      .join('\n\n');
+    throw new Error(msg);
+  }
+
+  if (!fs.existsSync(outPath)) {
+    throw new Error('codex exec did not write --output-last-message file');
+  }
+
+  return { tmpDir, outPath };
+}
+
+function planTemplate() {
+  return readText(path.join(promptsDir(), 'plan.md'));
+}
+
+function patchTemplate() {
+  return readText(path.join(promptsDir(), 'patch.md'));
+}
+
+function planSchemaPath() {
+  return path.join(schemasDir(), 'ecc.plan.schema.json');
+}
+
+function patchSchemaPath() {
+  return path.join(schemasDir(), 'ecc.patch.schema.json');
+}
+
+function buildPlanPrompt({ intent, repoRoot, packs }) {
+  return [
+    planTemplate(),
+    '',
+    '## Caller Input',
+    `generatedAt: ${nowIso()}`,
+    `projectRoot: ${repoRoot}`,
+    `packs: ${Array.isArray(packs) ? packs.join(', ') : ''}`,
+    `intent: ${String(intent || '').trim()}`,
+    '',
+    'Return JSON only.'
+  ].join('\n');
+}
+
+function buildPatchPrompt({ task, repoRoot, packs }) {
+  const taskSummary = {
+    id: task.id,
+    title: task.title,
+    prompt: task.prompt
+  };
+  return [
+    patchTemplate(),
+    '',
+    '## Caller Input',
+    `generatedAt: ${nowIso()}`,
+    `projectRoot: ${repoRoot}`,
+    `packs: ${Array.isArray(packs) ? packs.join(', ') : ''}`,
+    `task: ${JSON.stringify(taskSummary, null, 2)}`,
+    `allowedPathPrefixes: ${Array.isArray(task.allowedPathPrefixes) ? task.allowedPathPrefixes.join(', ') : ''}`,
+    '',
+    'Patch rules:',
+    '- If patch is non-empty, it should be a raw unified diff starting with "diff --git".',
+    '- Do not wrap diffs in code fences.',
+    '',
+    'Return JSON only.'
+  ].join('\n');
+}
+
+async function generatePlan({ intent, repoRoot, packs }) {
+  const prompt = buildPlanPrompt({ intent, repoRoot, packs });
+  const { tmpDir, outPath } = runCodexLastMessage({ repoRoot, prompt, schemaPath: planSchemaPath() });
+  let raw = '';
+  try {
+    raw = fs.readFileSync(outPath, 'utf8').trim();
+    return JSON.parse(raw);
+  } catch (err) {
+    const detail = err && err.message ? err.message : String(err);
+    throw new Error(`codex output is not valid JSON (${detail}). Raw:\n${raw.slice(0, 2000)}`);
+  } finally {
+    try {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    } catch (_err) {
+      // ignore cleanup failures
+    }
+  }
+}
+
+async function generatePatch({ task, repoRoot, packs, patchPath }) {
+  const prompt = buildPatchPrompt({ task, repoRoot, packs });
+  const { tmpDir, outPath } = runCodexLastMessage({ repoRoot, prompt, schemaPath: patchSchemaPath() });
+  try {
+    if (!patchPath) {
+      const raw = fs.readFileSync(outPath, 'utf8').trim();
+      return JSON.parse(raw);
+    }
+
+    extractJsonStringFieldToFileSync({
+      jsonPath: outPath,
+      fieldName: 'patch',
+      outPath: patchPath
+    });
+
+    return {
+      patchPath,
+      meta: { provider: 'codex', generatedAt: nowIso() }
+    };
+  } finally {
+    try {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    } catch (_err) {
+      // ignore cleanup failures
+    }
+  }
+}
+
+module.exports = {
+  name: 'codex',
+  generatePlan,
+  generatePatch
+};

package/scripts/ecc/providers/index.js

@@ -0,0 +1,23 @@
+const codex = require('./codex');
+const mock = require('./mock');
+
+function getProvider({ backend }) {
+  const env = String(process.env.ECC_PROVIDER || '').trim().toLowerCase();
+  if (env) {
+    if (env === 'mock') return mock;
+    if (env === 'codex') return codex;
+    throw new Error(`Unknown ECC_PROVIDER: ${env}`);
+  }
+
+  if (backend === 'codex') return codex;
+  if (backend === 'claude') {
+    throw new Error('ECC P0: backend "claude" is not implemented yet (use backend "codex")');
+  }
+
+  throw new Error(`Unknown backend: ${backend}`);
+}
+
+module.exports = {
+  getProvider
+};
+

package/scripts/ecc/providers/mock.js

@@ -0,0 +1,49 @@
+const fs = require('fs');
+const path = require('path');
+
+function fixtureRoot() {
+  const name = String(process.env.ECC_FIXTURE || 'basic').trim() || 'basic';
+  return path.resolve(__dirname, '..', 'fixtures', name);
+}
+
+function readJson(p) {
+  return JSON.parse(fs.readFileSync(p, 'utf8'));
+}
+
+function readText(p) {
+  return fs.readFileSync(p, 'utf8');
+}
+
+async function generatePlan({ intent }) {
+  const root = fixtureRoot();
+  const planPath = path.join(root, 'plan.json');
+  if (!fs.existsSync(planPath)) {
+    throw new Error(`mock provider fixture missing plan.json: ${planPath}`);
+  }
+  const plan = readJson(planPath);
+  // Keep fixtures deterministic but align plan.intent with the caller intent.
+  plan.intent = String(intent || plan.intent || '').trim() || 'intent';
+  return plan;
+}
+
+async function generatePatch({ task }) {
+  const root = fixtureRoot();
+  const patchPath = path.join(root, 'patches', `${task.id}.diff`);
+  if (!fs.existsSync(patchPath)) {
+    throw new Error(`mock provider fixture missing patch: ${patchPath}`);
+  }
+  return {
+    patch: readText(patchPath),
+    meta: {
+      note: `fixture=${path.basename(root)}`,
+      reason: '',
+      provider: 'mock'
+    }
+  };
+}
+
+module.exports = {
+  name: 'mock',
+  generatePlan,
+  generatePatch
+};

package/scripts/ecc/report.js

@@ -0,0 +1,127 @@
+const fs = require('fs');
+
+const { readJson, writeText } = require('./json');
+const { runPaths } = require('./run');
+
+function fmtList(items) {
+  if (!items || !items.length) return '(none)';
+  return items.map(s => `- ${s}`).join('\n');
+}
+
+function loadIfExists(p) {
+  try {
+    if (!fs.existsSync(p)) return null;
+    return readJson(p);
+  } catch (_err) {
+    return null;
+  }
+}
+
+function buildReport({ run, plan, applyResult, verifySummary }) {
+  const lines = [];
+
+  lines.push(`# ECC Run Report`);
+  lines.push('');
+  lines.push(`- runId: \`${run.runId}\``);
+  lines.push(`- status: \`${run.status}\``);
+  lines.push(`- intent: ${run.intent}`);
+  lines.push(`- backend: \`${run.backend}\``);
+  lines.push(`- packs: ${run.packs.join(', ')}`);
+  lines.push(`- startedAt: ${run.startedAt}`);
+  if (run.endedAt) lines.push(`- endedAt: ${run.endedAt}`);
+  lines.push('');
+
+  lines.push('## Base');
+  lines.push('');
+  lines.push(`- repoRoot: \`${run.base.repoRoot}\``);
+  lines.push(`- branch: \`${run.base.branch}\``);
+  lines.push(`- sha: \`${run.base.sha}\``);
+  lines.push('');
+
+  lines.push('## Worktree');
+  lines.push('');
+  lines.push(`- path: \`${run.worktree.path || '(not created)'}\``);
+  lines.push(`- branch: \`${run.worktree.branch}\``);
+  lines.push('');
+
+  lines.push('## Plan');
+  lines.push('');
+  if (!plan) {
+    lines.push('(missing plan.json)');
+  } else {
+    lines.push(`Intent: ${plan.intent}`);
+    lines.push('');
+    lines.push('Tasks:');
+    lines.push('');
+    for (const t of plan.tasks) {
+      lines.push(`- \`${t.id}\`: ${t.title}`);
+      lines.push(`  - allowedPathPrefixes:\n${fmtList(t.allowedPathPrefixes).split('\n').map(l => '    ' + l).join('\n')}`);
+    }
+  }
+  lines.push('');
+
+  lines.push('## Apply');
+  lines.push('');
+  if (!applyResult) {
+    lines.push('(missing apply/applied.json)');
+  } else {
+    lines.push(`- appliedAt: ${applyResult.appliedAt}`);
+    lines.push(`- baseSha: \`${applyResult.baseSha}\``);
+    lines.push('');
+    lines.push('Tasks:');
+    lines.push('');
+    for (const t of applyResult.tasks) {
+      lines.push(`- \`${t.id}\`: ${t.ok ? 'OK' : 'FAILED'}`);
+      lines.push(`  - patch: \`${t.patchPath}\``);
+      if (t.error) lines.push(`  - error: ${t.error}`);
+    }
+    if (applyResult.commit) {
+      lines.push('');
+      lines.push(`Commit: \`${applyResult.commit.sha}\``);
+    }
+  }
+  lines.push('');
+
+  lines.push('## Verify');
+  lines.push('');
+  if (!verifySummary) {
+    lines.push('(missing verify/summary.json)');
+  } else {
+    lines.push(`- ok: ${verifySummary.ok ? 'true' : 'false'}`);
+    lines.push(`- ranAt: ${verifySummary.ranAt}`);
+    lines.push('');
+    lines.push('Commands:');
+    lines.push('');
+    for (const c of verifySummary.commands) {
+      lines.push(`- \`${c.name}\`: ${c.ok ? 'OK' : 'FAILED'} (exit ${c.exitCode})`);
+      lines.push(`  - command: \`${c.command}\``);
+      lines.push(`  - output: \`${c.outputPath}\``);
+    }
+  }
+
+  lines.push('');
+  lines.push('## Next Steps');
+  lines.push('');
+  lines.push('- Inspect the worktree path above.');
+  lines.push('- If verification passed, you can commit/push the worktree branch or open a PR.');
+
+  return lines.join('\n');
+}
+
+function writeReport({ projectRoot, runId }) {
+  const paths = runPaths(projectRoot, runId);
+  const run = loadIfExists(paths.runJson);
+  if (!run) throw new Error(`missing run.json for runId=${runId}`);
+
+  const plan = loadIfExists(paths.planJson);
+  const applyResult = loadIfExists(paths.applyJson);
+  const verifySummary = loadIfExists(paths.verifySummaryJson);
+
+  writeText(paths.reportMd, buildReport({ run, plan, applyResult, verifySummary }) + '\n');
+  return paths.reportMd;
+}
+
+module.exports = {
+  writeReport,
+  buildReport
+};