shoud-cli 1.0.11 → 3.0.2

package/src/job/undo.js

@@ -0,0 +1,104 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+const { paths } = require('../utils/config');
+const { loadJob, listJobs } = require('./manager');
+
+function run(cmd, cwd) {
+  try { return { ok: true, out: execSync(cmd, { cwd, encoding: 'utf-8', stdio: 'pipe' }).trim() }; }
+  catch (err) { return { ok: false, out: (err.stdout || '').toString(), err: (err.stderr || '').toString(), code: err.status }; }
+}
+
+/**
+ * Undo a job by reversing SHOUD's changes only.
+ *
+ * Strategy:
+ *  1. Reset the working tree to the pre-job state (apply `before.patch`).
+ *  2. Re-apply the user's pre-existing changes by applying `before.patch`
+ *     on top of HEAD... actually we do the inverse: we reverse the `after.patch`
+ *     against the current tree, which reverts only SHOUD's work.
+ *
+ * Simpler & safer: 
+ *  - `git checkout -- <files>` is too aggressive.
+ *  - Instead: compute diff between before.patch and after.patch → that's SHOUD's delta.
+ *  - Reverse-apply that delta. Since before.patch already contains user changes,
+ *    reversing the delta won't disturb them.
+ */
+function undoJob(jobId) {
+  const job = loadJob(jobId);
+  if (!job) throw new Error(`Job ${jobId} not found.`);
+
+  const dir = paths.jobDir(jobId);
+  const beforePath = path.join(dir, 'before.patch');
+  const afterPath = path.join(dir, 'after.patch');
+  const untrackedPath = path.join(dir, 'untracked.json');
+
+  if (!fs.existsSync(afterPath)) {
+    throw new Error('No final checkpoint for this job. Cannot undo safely.');
+  }
+  if (!fs.existsSync(beforePath)) {
+    throw new Error('No initial checkpoint. Cannot undo safely.');
+  }
+
+  const cwd = job.projectRoot;
+  if (!fs.existsSync(cwd)) throw new Error(`Project root missing: ${cwd}`);
+
+  // Revert SHOUD's changes: reset tracked files to `after.patch` inverse.
+  // Easiest correct approach: 
+  //   1. Restore files to the current HEAD state (git checkout -- .)
+  //   2. Apply before.patch  → restores user's original uncommitted changes
+  //   3. Remove SHOUD-created untracked files (those not in the original untracked list)
+
+  const originalUntracked = fs.existsSync(untrackedPath)
+    ? JSON.parse(fs.readFileSync(untrackedPath, 'utf-8'))
+    : [];
+
+  // Step 1: hard reset tracked files to HEAD (safe — we have before.patch)
+  run('git checkout -- .', cwd);
+
+  // Step 2: re-apply the user's original changes
+  if (fs.existsSync(beforePath) && fs.readFileSync(beforePath, 'utf-8').trim()) {
+    const apply = run(`git apply --whitespace=nowarn "${beforePath}"`, cwd);
+    if (!apply.ok) {
+      throw new Error(`Failed to restore user changes: ${apply.err || apply.out}`);
+    }
+  }
+
+  // Step 3: remove untracked files that SHOUD created
+  const currentStatus = run('git status --porcelain', cwd);
+  if (currentStatus.ok) {
+    const nowUntracked = currentStatus.out.split('\n')
+      .filter(l => l.startsWith('?? '))
+      .map(l => l.slice(3).trim());
+    const created = nowUntracked.filter(f => !originalUntracked.includes(f));
+    for (const f of created) {
+      try {
+        const full = path.join(cwd, f);
+        if (fs.existsSync(full)) fs.rmSync(full, { recursive: true, force: true });
+      } catch (_) {}
+    }
+  }
+
+  // Mark job as undone
+  job.status = 'cancelled';
+  job.completedAt = new Date().toISOString();
+  job.error = 'Undone by user';
+  fs.writeFileSync(path.join(dir, 'state.json'),
+    JSON.stringify({ ...job, messages: undefined, actions: undefined }, null, 2),
+    { mode: 0o600 });
+
+  return {
+    reverted: true,
+    preservedUserChanges: originalUntracked.length > 0 || fs.readFileSync(beforePath, 'utf-8').length > 0,
+  };
+}
+
+function undoLatest() {
+  const jobs = listJobs();
+  const target = jobs.find(j => ['verified', 'implemented_not_verified', 'failed', 'blocked'].includes(j.status));
+  if (!target) throw new Error('No completed job available to undo.');
+  return { job: target, result: undoJob(target.id) };
+}
+
+module.exports = { undoJob, undoLatest };

package/src/project/discovery.js

@@ -0,0 +1,93 @@
+const fs = require('fs');
+const path = require('path');
+
+const SIGNALS = [
+  { file: 'package.json', lang: 'JavaScript/TypeScript', check: detectNode },
+  { file: 'pyproject.toml', lang: 'Python' },
+  { file: 'requirements.txt', lang: 'Python' },
+  { file: 'Cargo.toml', lang: 'Rust' },
+  { file: 'go.mod', lang: 'Go' },
+  { file: 'pom.xml', lang: 'Java' },
+  { file: 'build.gradle', lang: 'Java/Kotlin' },
+  { file: 'Gemfile', lang: 'Ruby' },
+];
+
+function detectNode(root) {
+  const pkgPath = path.join(root, 'package.json');
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+  let framework = 'Node';
+  if (deps.next) framework = 'Next.js';
+  else if (deps.react) framework = 'React';
+  else if (deps.vue) framework = 'Vue';
+  else if (deps.svelte) framework = 'Svelte';
+  else if (deps.express) framework = 'Express';
+  else if (deps.fastify) framework = 'Fastify';
+
+  let pm = 'npm';
+  if (fs.existsSync(path.join(root, 'pnpm-lock.yaml'))) pm = 'pnpm';
+  else if (fs.existsSync(path.join(root, 'yarn.lock'))) pm = 'yarn';
+  else if (fs.existsSync(path.join(root, 'bun.lockb'))) pm = 'bun';
+
+  let test = null;
+  if (deps.vitest) test = 'vitest';
+  else if (deps.jest) test = 'jest';
+  else if (deps.mocha) test = 'mocha';
+  else if (pkg.scripts?.test) test = pm + ' test';
+
+  const scripts = pkg.scripts || {};
+  const verification = [];
+  if (scripts.lint) verification.push(`${pm} run lint`);
+  if (scripts.typecheck) verification.push(`${pm} run typecheck`);
+  if (scripts.test) verification.push(`${pm} test`);
+  if (scripts.build) verification.push(`${pm} run build`);
+
+  return {
+    framework,
+    language: 'TypeScript',
+    packageManager: pm,
+    testing: test,
+    scripts: Object.keys(scripts),
+    verification,
+  };
+}
+
+function discoverProject(root) {
+  const signals = [];
+  let primary = null;
+
+  for (const s of SIGNALS) {
+    if (fs.existsSync(path.join(root, s.file))) {
+      signals.push(s.file);
+      if (s.check) primary = s.check(root);
+      else primary = primary || { language: s.lang };
+    }
+  }
+
+  if (!primary) primary = { language: 'Unknown' };
+
+  const isGit = fs.existsSync(path.join(root, '.git'));
+
+  return {
+    root,
+    signals,
+    ...primary,
+    git: isGit,
+    verification: primary.verification || [],
+  };
+}
+
+function formatProject(project) {
+  const rows = [
+    ['Language', project.language],
+    ['Framework', project.framework],
+    ['Package mgr', project.packageManager],
+    ['Testing', project.testing],
+    ['Git', project.git ? 'yes' : 'no'],
+    ['Verify', (project.verification || []).join(', ') || '—'],
+  ];
+  return rows.filter(([, v]) => v).map(([k, v]) => `${k.padEnd(14)} ${v}`).join('\n');
+}
+
+module.exports = { discoverProject, formatProject };

package/src/project/ignore.js

@@ -0,0 +1,31 @@
+const fs = require('fs');
+const path = require('path');
+const ignore = require('ignore');
+
+const DEFAULT_PATTERNS = [
+  '.env', '.env.*',
+  '*.pem', '*.key',
+  'secrets/', 'node_modules/',
+  'dist/', 'build/', 'coverage/',
+  '.git/',
+];
+
+function loadIgnore(root) {
+  const ig = ignore();
+  ig.add(DEFAULT_PATTERNS);
+
+  const file = path.join(root, '.shoudignore');
+  if (fs.existsSync(file)) {
+    ig.add(fs.readFileSync(file, 'utf-8'));
+  }
+  return ig;
+}
+
+function isIgnored(root, filePath, ig = null) {
+  const manager = ig || loadIgnore(root);
+  const rel = path.relative(root, filePath);
+  if (!rel || rel.startsWith('..')) return false;
+  return manager.ignores(rel);
+}
+
+module.exports = { loadIgnore, isIgnored };

package/src/project/shoudMd.js

@@ -0,0 +1,38 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Loads SHOUD.md from the project root (and optionally nested dirs).
+ * Returns { rules: string, verification: string[] }.
+ *
+ * In SHOUD.md, anything under a heading like "## Verification" or after a
+ * line "Before completing:" is parsed as a command list.
+ */
+function loadShoudMd(root) {
+  const file = path.join(root, 'SHOUD.md');
+  if (!fs.existsSync(file)) return { rules: '', verification: [], source: null };
+
+  const raw = fs.readFileSync(file, 'utf-8');
+  const rules = raw.trim();
+
+  // Extract bullet lines after "Before completing:" or under "## Verification"
+  const verification = [];
+  const lines = raw.split('\n');
+  let capturing = false;
+  for (const line of lines) {
+    const t = line.trim();
+    if (/^#{1,6}\s+verification/i.test(t) || /^before completing[:.]?$/i.test(t)) {
+      capturing = true;
+      continue;
+    }
+    if (capturing && /^#{1,6}\s+/.test(t)) { capturing = false; continue; }
+    if (capturing && /^[-*]\s+/.test(t)) {
+      const cmd = t.replace(/^[-*]\s+/, '').replace(/`/g, '').trim();
+      if (cmd) verification.push(cmd);
+    }
+  }
+
+  return { rules, verification, source: file };
+}
+
+module.exports = { loadShoudMd };