@riddledc/riddle-proof 0.5.4 → 0.5.6

package/lib/workspace-core.mjs

@@ -2,9 +2,11 @@ import { createHash, randomUUID } from "node:crypto";
 import { execSync } from "node:child_process";
 import {
   existsSync,
+  copyFileSync,
   lstatSync,
   mkdirSync,
   readFileSync,
+  renameSync,
   rmSync,
   symlinkSync,
   unlinkSync,
@@ -276,6 +278,7 @@ export function ensureWorktree({
 }
 
 const DEPS_MANIFEST = ".workspace-core-deps.json";
+const DEPS_INPUT_FILES = ["package.json", "package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock"];
 
 function depsManifestPath(projectDir) {
   return path.join(projectDir, "node_modules", DEPS_MANIFEST);
@@ -285,7 +288,7 @@ export function computeDependencyFingerprint(projectDir) {
   const packageJson = path.join(projectDir, "package.json");
   if (!existsSync(packageJson)) return "";
   const digest = createHash("sha256");
-  for (const name of ["package.json", "package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock"]) {
+  for (const name of DEPS_INPUT_FILES) {
     const filePath = path.join(projectDir, name);
     if (!existsSync(filePath)) continue;
     digest.update(name);
@@ -318,6 +321,93 @@ function writeDepsManifest(projectDir, fingerprint, installCmd) {
   writeFileSync(manifestPath, JSON.stringify({ fingerprint, install_cmd: installCmd }, null, 2));
 }
 
+function dependencyCacheRoot(projectDir) {
+  if (process.env.RIDDLE_PROOF_DISABLE_DEPS_CACHE === "1") return "";
+  const configured = (process.env.RIDDLE_PROOF_DEPS_CACHE_ROOT || "").trim();
+  if (configured) return path.resolve(configured);
+
+  const resolved = path.resolve(projectDir);
+  const worktreeMarker = `${path.sep}.riddle-proof-worktrees${path.sep}`;
+  const worktreeIndex = resolved.indexOf(worktreeMarker);
+  if (worktreeIndex >= 0) {
+    return path.join(resolved.slice(0, worktreeIndex), ".riddle-proof-deps-cache");
+  }
+  return path.join(path.dirname(resolved), ".riddle-proof-deps-cache");
+}
+
+function dependencyCacheKey(fingerprint, installCmd) {
+  const nodeMajor = (process.versions.node || "").split(".")[0] || "unknown";
+  return [
+    sanitizeFragment(installCmd, "install"),
+    process.platform,
+    process.arch,
+    `node${sanitizeFragment(nodeMajor, "unknown")}`,
+    fingerprint.slice(0, 24),
+  ].join("-");
+}
+
+function copyDependencyInputs(sourceDir, targetDir) {
+  mkdirSync(targetDir, { recursive: true });
+  for (const name of DEPS_INPUT_FILES) {
+    const sourcePath = path.join(sourceDir, name);
+    if (existsSync(sourcePath)) {
+      copyFileSync(sourcePath, path.join(targetDir, name));
+    }
+  }
+}
+
+function linkNodeModules(projectDir, sourceModules) {
+  const projectModules = path.join(projectDir, "node_modules");
+  removePath(projectModules);
+  symlinkSync(sourceModules, projectModules, "dir");
+}
+
+function tryEnsureCachedDeps({ projectDir, fingerprint, installCmd }) {
+  const cacheRoot = dependencyCacheRoot(projectDir);
+  if (!cacheRoot) return "";
+
+  const cacheDir = path.join(cacheRoot, dependencyCacheKey(fingerprint, installCmd));
+  const cacheModules = path.join(cacheDir, "node_modules");
+  const cacheManifest = readDepsManifest(cacheDir);
+  if (cacheManifest.fingerprint === fingerprint && cacheManifest.install_cmd === installCmd && existsSync(cacheModules)) {
+    linkNodeModules(projectDir, cacheModules);
+    return `reused_cache:${cacheDir}`;
+  }
+
+  const tempCacheDir = `${cacheDir}.tmp-${process.pid}-${randomUUID().slice(0, 8)}`;
+  try {
+    mkdirSync(path.dirname(cacheDir), { recursive: true });
+    removePath(tempCacheDir);
+    copyDependencyInputs(projectDir, tempCacheDir);
+
+    const installResult = runSafe(`${installCmd} 2>&1 | tail -5`, tempCacheDir, dependencyInstallTimeoutMs());
+    if (!installResult.ok) {
+      removePath(tempCacheDir);
+      return "";
+    }
+    writeDepsManifest(tempCacheDir, fingerprint, installCmd);
+
+    if (!existsSync(cacheDir)) {
+      try {
+        renameSync(tempCacheDir, cacheDir);
+      } catch {
+        removePath(tempCacheDir);
+      }
+    } else {
+      removePath(tempCacheDir);
+    }
+
+    const finalManifest = readDepsManifest(cacheDir);
+    if (finalManifest.fingerprint === fingerprint && finalManifest.install_cmd === installCmd && existsSync(cacheModules)) {
+      linkNodeModules(projectDir, cacheModules);
+      return `cached:${installCmd}`;
+    }
+  } catch {
+    removePath(tempCacheDir);
+  }
+  return "";
+}
+
 function dependencyInstallTimeoutMs() {
   const parsed = Number.parseInt(process.env.RIDDLE_PROOF_INSTALL_TIMEOUT_MS || "", 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : 600000;
@@ -337,15 +427,17 @@ export function ensureDeps({ projectDir, reuseFrom = "" } = {}) {
     const sourceManifest = readDepsManifest(reuseFrom);
     const sourceModules = path.join(reuseFrom, "node_modules");
     if (sourceFingerprint === fingerprint && sourceManifest.fingerprint === fingerprint && existsSync(sourceModules)) {
-      const projectModules = path.join(projectDir, "node_modules");
-      removePath(projectModules);
-      symlinkSync(sourceModules, projectModules);
+      linkNodeModules(projectDir, sourceModules);
       return `reused_from:${reuseFrom}`;
     }
   }
 
   const installCmd = detectInstallCommand(projectDir);
   if (!installCmd) return "no_install_command";
+  const cachedStatus = tryEnsureCachedDeps({ projectDir, fingerprint, installCmd });
+  if (cachedStatus) return cachedStatus;
+
+  removePath(path.join(projectDir, "node_modules"));
   const installResult = runSafe(`${installCmd} 2>&1 | tail -5`, projectDir, dependencyInstallTimeoutMs());
   if (!installResult.ok) {
     throw new Error(`dependency install failed in ${projectDir}: ${installResult.output.slice(0, 300)}`);
@@ -385,6 +477,9 @@ async function main() {
     case "ensure-deps":
       ok({ status: ensureDeps(payload) });
       return;
+    case "dependency-fingerprint":
+      ok({ fingerprint: computeDependencyFingerprint(payload.projectDir) });
+      return;
     default:
       throw new Error(`Unsupported command: ${command}`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riddledc/riddle-proof",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "Reusable Riddle Proof contracts and helpers for evidence-backed agent changes.",
   "license": "MIT",
   "author": "RiddleDC",

package/runtime/lib/setup.py

@@ -77,6 +77,13 @@ def ensure_deps(project_dir, reuse_from=''):
     return result.get('status', '')
 
 
+def dependency_fingerprint(project_dir):
+    if not project_dir:
+        return ''
+    result = workspace_core('dependency-fingerprint', {'projectDir': project_dir}, timeout=30)
+    return result.get('fingerprint', '') or ''
+
+
 def record_setup_phase(phase, status='running', summary=''):
     global s
     ts = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
@@ -131,6 +138,24 @@ def ensure_deps_phase(phase, project_dir, reuse_from='', summary=''):
     return status
 
 
+def dependencies_match(left_dir, right_dir):
+    left = dependency_fingerprint(left_dir)
+    right = dependency_fingerprint(right_dir)
+    return bool(left and right and left == right)
+
+
+def compatible_reuse_source(source_dir, target_dirs):
+    if not source_dir:
+        return ''
+    source = dependency_fingerprint(source_dir)
+    if not source:
+        return ''
+    for target_dir in target_dirs:
+        if target_dir and dependency_fingerprint(target_dir) == source:
+            return source_dir
+    return ''
+
+
 def resolve_worktree_root(repo_dir):
     configured = (s.get('worktree_root') or os.environ.get('RIDDLE_PROOF_WORKTREE_ROOT') or '').strip()
     if configured:
@@ -401,17 +426,36 @@ print('After worktree: ' + AFTER_DIR + ' (' + AFTER_WORKTREE_BRANCH + ' -> ' + b
 apply_repo_profile(AFTER_DIR)
 save_state(s)
 
+target_dependency_dirs = [AFTER_DIR]
+if reference in ('before', 'both'):
+    target_dependency_dirs.append(BEFORE_DIR)
+
 reuse_source = repo_dir if os.path.exists(os.path.join(repo_dir, 'package.json')) else ''
-shared_status = ensure_deps_phase('shared_deps', reuse_source, summary='Ensuring shared repository dependencies.') if reuse_source else ''
-if shared_status:
-    print('Shared deps status: ' + shared_status)
+shared_reuse_source = compatible_reuse_source(reuse_source, target_dependency_dirs)
+shared_status = ''
+if shared_reuse_source:
+    shared_status = ensure_deps_phase('shared_deps', shared_reuse_source, summary='Ensuring shared repository dependencies.')
+    if shared_status:
+        print('Shared deps status: ' + shared_status)
+elif reuse_source:
+    record_setup_phase(
+        'shared_deps',
+        'completed',
+        'skipped: active workspace dependencies differ from proof worktrees',
+    )
+    print('Shared deps skipped: active workspace dependencies differ from proof worktrees')
 
 before_dep_status = ''
 if reference in ('before', 'both'):
-    before_dep_status = ensure_deps_phase('before_deps', BEFORE_DIR, reuse_from=reuse_source, summary='Ensuring before-worktree dependencies.')
+    before_dep_status = ensure_deps_phase('before_deps', BEFORE_DIR, reuse_from=shared_reuse_source, summary='Ensuring before-worktree dependencies.')
     print('Before deps status: ' + before_dep_status)
 
-after_dep_status = ensure_deps_phase('after_deps', AFTER_DIR, reuse_from=reuse_source, summary='Ensuring after-worktree dependencies.')
+after_reuse_source = ''
+if before_dep_status and dependencies_match(BEFORE_DIR, AFTER_DIR):
+    after_reuse_source = BEFORE_DIR
+elif shared_reuse_source:
+    after_reuse_source = shared_reuse_source
+after_dep_status = ensure_deps_phase('after_deps', AFTER_DIR, reuse_from=after_reuse_source, summary='Ensuring after-worktree dependencies.')
 print('After deps status: ' + after_dep_status)
 
 # Patch Next.js config in after worktree if needed