spec-and-loop 2.0.1 → 2.1.1

package/lib/mini-ralph/invoker.js

@@ -11,6 +11,9 @@
  * explicitly out of scope for the first-pass mini Ralph subset.
  */
 
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
 const { spawn, execFileSync } = require('child_process');
 
 /**
@@ -22,7 +25,7 @@ const { spawn, execFileSync } = require('child_process');
  * @param {boolean} [opts.noCommit] - Skip git commit if true
  * @param {boolean} [opts.verbose]  - Enable verbose output
  * @param {string}  [opts.ralphDir] - Reserved for caller compatibility
- * @returns {Promise<{stdout: string, exitCode: number, toolUsage: Array, filesChanged: Array}>}
+ * @returns {Promise<{stdout: string, stderr: string, exitCode: ?number, signal: ?string, toolUsage: Array, filesChanged: Array}>}
  */
 async function invoke(opts) {
   const {
@@ -69,6 +72,7 @@ async function invoke(opts) {
     stdout: result.stdout,
     stderr: result.stderr,
     exitCode: result.exitCode,
+    signal: result.signal,
     toolUsage: _extractToolUsage(result.stdout),
     filesChanged,
   };
@@ -79,7 +83,7 @@ async function invoke(opts) {
  *
  * @param {Array<string>} args
  * @param {boolean} verbose
- * @returns {Promise<{stdout: string, exitCode: number}>}
+ * @returns {Promise<{stdout: string, stderr: string, exitCode: ?number, signal: ?string}>}
  */
 function _spawnOpenCode(args, verbose) {
   return new Promise((resolve, reject) => {
@@ -111,8 +115,13 @@ function _spawnOpenCode(args, verbose) {
       }
     });
 
-    child.on('close', (code) => {
-      resolve({ stdout, stderr, exitCode: code || 0 });
+    child.on('close', (code, signal) => {
+      resolve({
+        stdout,
+        stderr,
+        exitCode: typeof code === 'number' ? code : null,
+        signal: signal || null,
+      });
     });
   });
 }
@@ -127,13 +136,30 @@ function _spawnOpenCode(args, verbose) {
 function _looksLikeCliHelp(text) {
   if (!text) return false;
 
-  const hasHelpSections = text.includes('Commands:') && text.includes('Options:');
-  const hasOpenCodeUsage =
-    text.includes('opencode [project]') ||
-    text.includes('opencode run [message..]') ||
-    text.includes('run opencode with a message');
+  // Only inspect the opening portion of the transcript so help-like strings
+  // echoed later in diffs or test output do not masquerade as a CLI banner.
+  const normalized = text
+    .replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, '')
+    .replace(/\r/g, '');
+  const lines = normalized
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean);
+  const openingText = lines.slice(0, 40).join('\n');
 
-  return hasHelpSections && hasOpenCodeUsage;
+  const looksLikeRunHelp =
+    openingText.includes('opencode run [message..]') &&
+    openingText.includes('run opencode with a message') &&
+    openingText.includes('Positionals:') &&
+    openingText.includes('Options:');
+
+  const looksLikeTopLevelHelp =
+    openingText.includes('Commands:') &&
+    openingText.includes('Options:') &&
+    openingText.includes('opencode [project]') &&
+    openingText.includes('opencode run [message..]');
+
+  return looksLikeRunHelp || looksLikeTopLevelHelp;
 }
 
 /**
@@ -165,11 +191,11 @@ function _extractToolUsage(text) {
 }
 
 /**
- * Take a snapshot of modified/untracked files via git status.
- * Returns a Set of file paths relative to the repo root.
- * Returns an empty Set if git is unavailable or not in a repo.
+ * Take a snapshot of dirty/untracked paths via git status.
+ * Returns a Map of repo-relative file paths to existence/content fingerprints.
+ * Returns an empty Map if git is unavailable or not in a repo.
  *
- * @returns {Set<string>}
+ * @returns {Map<string, string>}
  */
 function _gitSnapshot() {
   try {
@@ -178,42 +204,138 @@ function _gitSnapshot() {
       encoding: 'utf8',
       stdio: ['pipe', 'pipe', 'pipe'],
     });
-    const files = new Set();
+    const files = new Map();
     for (const line of output.split('\n')) {
       const trimmed = line.trim();
       if (!trimmed) continue;
-      // Format: XY filename  (first two chars are status, then space, then path)
-      const filePath = line.slice(3).trim();
-      if (filePath) files.add(filePath);
+
+      for (const filePath of _parsePorcelainPaths(line)) {
+        if (!filePath) continue;
+        files.set(filePath, _fingerprintPath(filePath));
+      }
     }
     return files;
   } catch {
-    return new Set();
+    return new Map();
   }
 }
 
 /**
- * Return an array of files that appear in postSnapshot but not preSnapshot,
- * or whose presence changed between the two snapshots.
+ * Return an array of files whose per-path fingerprint changed between the two
+ * snapshots. A file can count as changed because it became dirty, stopped being
+ * dirty, was deleted, was created, or changed content while staying dirty.
  *
- * @param {Set<string>} preSnapshot
- * @param {Set<string>} postSnapshot
+ * @param {Map<string, string>} preSnapshot
+ * @param {Map<string, string>} postSnapshot
  * @returns {Array<string>}
  */
 function _diffSnapshots(preSnapshot, postSnapshot) {
-  const changed = [];
-  for (const file of postSnapshot) {
-    if (!preSnapshot.has(file)) {
-      changed.push(file);
+  const changed = new Set();
+  const allPaths = new Set([
+    ...Array.from((preSnapshot || new Map()).keys()),
+    ...Array.from((postSnapshot || new Map()).keys()),
+  ]);
+
+  // Compare per-path fingerprints so already-dirty files still count when the
+  // iteration mutates their contents again.
+  for (const file of allPaths) {
+    if (preSnapshot.get(file) !== postSnapshot.get(file)) {
+      changed.add(file);
     }
   }
-  // Also capture files that were in pre but are gone (e.g., deleted)
-  for (const file of preSnapshot) {
-    if (!postSnapshot.has(file)) {
-      changed.push(file);
+
+  return Array.from(changed).sort();
+}
+
+function _parsePorcelainPaths(line) {
+  const rawPath = line.slice(3).trim();
+  if (!rawPath) return [];
+
+  if (rawPath.includes(' -> ')) {
+    return rawPath.split(' -> ').map(_stripGitQuotes).filter(Boolean);
+  }
+
+  return [_stripGitQuotes(rawPath)];
+}
+
+function _stripGitQuotes(value) {
+  if (!value) return '';
+
+  const trimmed = value.trim();
+  if (!(trimmed.startsWith('"') && trimmed.endsWith('"'))) {
+    return trimmed;
+  }
+
+  return trimmed
+    .slice(1, -1)
+    .replace(/\\"/g, '"')
+    .replace(/\\\\/g, '\\');
+}
+
+function _fingerprintPath(filePath) {
+  const absolutePath = path.resolve(process.cwd(), filePath);
+
+  try {
+    const stats = fs.lstatSync(absolutePath);
+
+    if (stats.isSymbolicLink()) {
+      return `symlink:${fs.readlinkSync(absolutePath)}`;
     }
+
+    if (stats.isDirectory()) {
+      return `directory:${_hashDirectory(absolutePath)}`;
+    }
+
+    if (stats.isFile()) {
+      const content = fs.readFileSync(absolutePath);
+      const digest = crypto.createHash('sha1').update(content).digest('hex');
+      return `file:${stats.size}:${digest}`;
+    }
+
+    return `other:${stats.mode}`;
+  } catch (err) {
+    if (err && err.code === 'ENOENT') {
+      return 'missing';
+    }
+
+    return `error:${err && err.code ? err.code : 'unknown'}`;
+  }
+}
+
+function _hashDirectory(directoryPath) {
+  const hash = crypto.createHash('sha1');
+  _walkDirectory(hash, directoryPath, '');
+  return hash.digest('hex');
+}
+
+function _walkDirectory(hash, directoryPath, relativePrefix) {
+  const entries = fs.readdirSync(directoryPath, { withFileTypes: true })
+    .sort((a, b) => a.name.localeCompare(b.name));
+
+  for (const entry of entries) {
+    const relativePath = relativePrefix ? `${relativePrefix}/${entry.name}` : entry.name;
+    const absolutePath = path.join(directoryPath, entry.name);
+
+    if (entry.isDirectory()) {
+      hash.update(`dir:${relativePath}\n`);
+      _walkDirectory(hash, absolutePath, relativePath);
+      continue;
+    }
+
+    if (entry.isSymbolicLink()) {
+      hash.update(`symlink:${relativePath}:${fs.readlinkSync(absolutePath)}\n`);
+      continue;
+    }
+
+    if (entry.isFile()) {
+      hash.update(`file:${relativePath}\n`);
+      hash.update(fs.readFileSync(absolutePath));
+      continue;
+    }
+
+    const stats = fs.lstatSync(absolutePath);
+    hash.update(`other:${relativePath}:${stats.mode}\n`);
   }
-  return changed;
 }
 
 module.exports = {

package/lib/mini-ralph/prompt.js

@@ -12,11 +12,13 @@
  *   {{iteration}}          - Current iteration number
  *   {{max_iterations}}     - Configured max iterations
  *   {{change_dir}}         - Change directory path (from options.changeDir)
+ *   {{base_prompt}}        - Underlying prompt text from promptText/promptFile
  *   {{tasks}}              - Raw tasks file content
  *   {{task_context}}       - Fresh current-task and completed-task summary
  *   {{task_promise}}       - Configured task promise string
  *   {{completion_promise}} - Configured completion promise string
  *   {{context}}            - Pending context (passed in, already consumed)
+ *   {{commit_contract}}    - Commit instructions derived from options.noCommit
  */
 
 const fs = require('fs');
@@ -90,11 +92,18 @@ function render(options, iteration) {
     iteration: String(iteration),
     max_iterations: String(options.maxIterations || 50),
     change_dir: options.changeDir || '',
+    base_prompt: base,
     tasks: tasksContent,
     task_context: taskContext,
     task_promise: options.taskPromise || 'READY_FOR_NEXT_TASK',
     completion_promise: options.completionPromise || 'COMPLETE',
     context: '',  // Pending context is injected by runner after rendering
+    commit_contract: options.noCommit
+      ? [
+          '- Do not create, amend, or finalize git commits in this run.',
+          '- `--no-commit` is active. Do not run `git add` or `git commit`; leave task changes uncommitted.',
+        ].join('\n')
+      : '- Do not create git commits yourself. The Ralph runner manages automatic task commits when auto-commit is enabled.',
   };
 
   return _renderTemplate(template, vars);