svamp-cli 0.2.118 → 0.2.119

package/bin/skills/loop/bin/checklist.mjs

@@ -0,0 +1,91 @@
+// checklist.mjs — the loop-engineering task/criteria atom.
+// See docs/svamp-loop-engineering-vision.md. A checklist is a list of evaluable
+// items persisted as JSON, in two layered scopes:
+//   session: <loopDir>/checklist.json             (this session's goal)
+//   project: <projectDir>/.svamp/checklist.json   (durable invariants, all sessions)
+// The effective checklist a session enforces = project ∪ session. Each item is
+// oracle-checked (a pass/fail command) or agent-evaluated. Done ≠ gone: a passing
+// item STAYS in the list and is re-verified every loop, so it can regress to failing.
+// The supervisor only lets the turn end when ALL effective items are passing.
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { execSync } from 'node:child_process';
+
+export function sessionChecklistPath(loopDir) { return join(loopDir, 'checklist.json'); }
+export function projectChecklistPath(projectDir) { return join(projectDir, '.svamp', 'checklist.json'); }
+
+const STATUSES = ['pending', 'passing', 'failing'];
+
+function readOne(path, scope) {
+  try {
+    if (!existsSync(path)) return [];
+    const j = JSON.parse(readFileSync(path, 'utf-8'));
+    const items = Array.isArray(j) ? j : (Array.isArray(j?.items) ? j.items : []);
+    return items.map((it, i) => ({
+      id: typeof it.id === 'string' && it.id ? it.id : `${scope}-${i}`,
+      text: String(it?.text ?? '').trim(),
+      // 'done' is a friendly alias for 'passing'.
+      status: it?.status === 'done' ? 'passing' : (STATUSES.includes(it?.status) ? it.status : 'pending'),
+      oracle: typeof it?.oracle === 'string' && it.oracle.trim() ? it.oracle.trim() : null,
+      scope,
+    })).filter((it) => it.text);
+  } catch { return []; }
+}
+
+/** Effective checklist = project invariants ∪ session goals (project first, then session). */
+export function readEffectiveChecklist(loopDir, projectDir) {
+  return [
+    ...readOne(projectChecklistPath(projectDir), 'project'),
+    ...readOne(sessionChecklistPath(loopDir), 'session'),
+  ];
+}
+
+/**
+ * Run each item's oracle (if it has one) and return items with refreshed status.
+ * Items WITHOUT an oracle keep their stored status (those are agent-evaluated, not
+ * machine-checkable here). This is the per-loop regression check: a previously
+ * passing item whose oracle now fails flips to 'failing'.
+ */
+export function evaluateChecklist(items, projectDir, timeoutSec = 600) {
+  return items.map((it) => {
+    if (!it.oracle) return it;
+    try {
+      execSync(it.oracle, { cwd: projectDir, stdio: 'pipe', maxBuffer: 16 * 1024 * 1024, timeout: timeoutSec * 1000 });
+      return { ...it, status: 'passing' };
+    } catch {
+      return { ...it, status: 'failing' };
+    }
+  });
+}
+
+/** True when every effective item is passing (an empty list is trivially satisfied). */
+export function allPassing(items) {
+  return items.length === 0 ? true : items.every((it) => it.status === 'passing');
+}
+
+/** A one-line summary for the gate's history/state. */
+export function summarize(items) {
+  const pass = items.filter((i) => i.status === 'passing').length;
+  const fail = items.filter((i) => i.status === 'failing').length;
+  return `${pass}/${items.length} passing${fail ? `, ${fail} failing` : ''}`;
+}
+
+/**
+ * Persist refreshed statuses back to each scope's file, so the UI renderer + the
+ * agent see live state. Writes the canonical { items: [...] } shape (scope stripped —
+ * it's implied by which file the item lives in).
+ */
+export function writeChecklistStatuses(loopDir, projectDir, items) {
+  const targets = [
+    ['session', sessionChecklistPath(loopDir)],
+    ['project', projectChecklistPath(projectDir)],
+  ];
+  for (const [scope, path] of targets) {
+    const scoped = items.filter((it) => it.scope === scope).map(({ scope: _s, ...rest }) => rest);
+    if (scoped.length === 0 && !existsSync(path)) continue; // don't create empty files
+    try {
+      mkdirSync(dirname(path), { recursive: true });
+      writeFileSync(path, JSON.stringify({ items: scoped }, null, 2));
+    } catch { /* best-effort persistence */ }
+  }
+}

package/bin/skills/loop/test/test-checklist.mjs

@@ -0,0 +1,65 @@
+// test-checklist.mjs — the loop-engineering checklist atom (read/merge/evaluate/persist).
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  readEffectiveChecklist, evaluateChecklist, allPassing, summarize,
+  writeChecklistStatuses, sessionChecklistPath, projectChecklistPath,
+} from '../bin/checklist.mjs';
+
+let passed = 0, failed = 0;
+function ok(cond, msg) { if (cond) { passed++; console.log(`  ✓ ${msg}`); } else { failed++; console.log(`  ✗ ${msg}`); } }
+function eq(a, b, msg) { ok(JSON.stringify(a) === JSON.stringify(b), `${msg} (got ${JSON.stringify(a)})`); }
+
+const root = mkdtempSync(join(tmpdir(), 'cl-test-'));
+const projectDir = root;
+const loopDir = join(root, '.svamp', 'sess1', 'loop');
+mkdirSync(loopDir, { recursive: true });
+mkdirSync(join(root, '.svamp'), { recursive: true });
+
+console.log('scope merge + normalization');
+writeFileSync(projectChecklistPath(projectDir), JSON.stringify({ items: [
+  { text: 'tests pass', oracle: 'true', status: 'passing' },
+] }));
+writeFileSync(sessionChecklistPath(loopDir), JSON.stringify({ items: [
+  { text: 'add feature', status: 'done' },              // 'done' alias → passing
+  { text: '   ', status: 'pending' },                    // blank → dropped
+  { text: 'no TODOs', oracle: 'false' },                 // defaults to pending
+] }));
+let eff = readEffectiveChecklist(loopDir, projectDir);
+eq(eff.length, 3, 'effective = project ∪ session, blanks dropped');
+eq(eff[0].scope, 'project', 'project items come first');
+eq(eff[0].text, 'tests pass', 'project item text');
+eq(eff[1].status, 'passing', "'done' normalized to passing");
+ok(eff.map(i => i.scope).join(',') === 'project,session,session', 'scope tags correct');
+
+console.log('evaluate — oracle pass/fail drives status (regression check)');
+const evaluated = evaluateChecklist(eff, projectDir);
+eq(evaluated.find(i => i.text === 'tests pass').status, 'passing', 'oracle `true` → passing');
+eq(evaluated.find(i => i.text === 'no TODOs').status, 'failing', 'oracle `false` → failing');
+eq(evaluated.find(i => i.text === 'add feature').status, 'passing', 'no-oracle item keeps stored status');
+
+console.log('allPassing gate');
+ok(!allPassing(evaluated), 'not all passing while one oracle fails');
+ok(allPassing([]), 'empty list is trivially satisfied');
+ok(allPassing(evaluated.map(i => ({ ...i, status: 'passing' }))), 'all passing → true');
+
+console.log('summarize');
+ok(summarize(evaluated).startsWith('2/3 passing'), `summary reads "${summarize(evaluated)}"`);
+
+console.log('persist statuses back to the right scope files');
+writeChecklistStatuses(loopDir, projectDir, evaluated);
+const proj = JSON.parse(readFileSync(projectChecklistPath(projectDir), 'utf-8'));
+const sess = JSON.parse(readFileSync(sessionChecklistPath(loopDir), 'utf-8'));
+eq(proj.items.length, 1, 'project file holds only project items');
+eq(sess.items.length, 2, 'session file holds only session items');
+ok(proj.items[0].scope === undefined, 'scope stripped from persisted file');
+ok(sess.items.find(i => i.text === 'no TODOs').status === 'failing', 'failing status persisted (UI will show it)');
+
+// regression: a re-read after persist is stable
+const reEff = readEffectiveChecklist(loopDir, projectDir);
+eq(reEff.length, 3, 're-read after persist is stable');
+
+rmSync(root, { recursive: true, force: true });
+console.log(`\nchecklist: ${passed} passed, ${failed} failed`);
+process.exit(failed ? 1 : 0);

package/dist/cli.mjs

@@ -390,7 +390,7 @@ async function main() {
   } else if (!subcommand || subcommand === "start") {
     await handleInteractiveCommand();
   } else if (subcommand === "--version" || subcommand === "-v") {
-    const pkg = await import('./package-CxWiFy_P.mjs').catch(() => ({ default: { version: "unknown" } }));
+    const pkg = await import('./package-B-M4dhbv.mjs').catch(() => ({ default: { version: "unknown" } }));
     console.log(`svamp version: ${pkg.default.version}`);
   } else {
     console.error(`Unknown command: ${subcommand}`);

package/dist/{package-CxWiFy_P.mjs → package-B-M4dhbv.mjs}

@@ -1,5 +1,5 @@
 var name = "svamp-cli";
-var version = "0.2.118";
+var version = "0.2.119";
 var description = "Svamp CLI — AI workspace daemon on Hypha Cloud";
 var author = "Amun AI AB";
 var license = "SEE LICENSE IN LICENSE";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svamp-cli",
-  "version": "0.2.118",
+  "version": "0.2.119",
   "description": "Svamp CLI — AI workspace daemon on Hypha Cloud",
   "author": "Amun AI AB",
   "license": "SEE LICENSE IN LICENSE",