svamp-cli 0.2.223-canary.2 → 0.2.223

package/bin/skills/loop/bin/loop-status.mjs

@@ -1,51 +0,0 @@
-#!/usr/bin/env node
-// loop-status.mjs — show a loop's current state + per-iteration history timeline.
-// Usage: node loop-status.mjs [project-dir] [--session <id>] [--json] [-n <count>]
-import { readFileSync, existsSync, readdirSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-
-const args = process.argv.slice(2);
-const json = args.includes('--json');
-const nIdx = args.indexOf('-n');
-const limit = nIdx !== -1 ? Number(args[nIdx + 1]) : 20;
-const sIdx = args.indexOf('--session');
-const sessionId = sIdx !== -1 ? args[sIdx + 1] : (process.env.SVAMP_SESSION_ID || null);
-const dir = resolve(args.find((a) => !a.startsWith('-') && a !== String(limit) && a !== sessionId) || process.cwd());
-
-// Find the loop home: explicit session → .svamp/<sid>/loop; else any session-scoped
-// loop that has state; else .svamp/loop; else legacy .claude/loop.
-function pickLoopDir(root, sid) {
-  const cands = [];
-  if (sid) cands.push(join(root, '.svamp', sid, 'loop'));
-  try { for (const e of readdirSync(join(root, '.svamp'), { withFileTypes: true })) if (e.isDirectory() && e.name !== sid) cands.push(join(root, '.svamp', e.name, 'loop')); } catch {}
-  cands.push(join(root, '.svamp', 'loop'), join(root, '.claude', 'loop'));
-  for (const c of cands) if (existsSync(join(c, 'loop-state.json'))) return c;
-  return sid ? join(root, '.svamp', sid, 'loop') : cands[cands.length - 1];
-}
-const LOOP_DIR = pickLoopDir(dir, sessionId);
-
-const readJSON = (p, f) => { try { return JSON.parse(readFileSync(p, 'utf8')); } catch { return f; } };
-const state = readJSON(join(LOOP_DIR, 'loop.config.json'), null)
-  ? readJSON(join(LOOP_DIR, 'loop-state.json'), {})
-  : null;
-
-let history = [];
-try {
-  history = readFileSync(join(LOOP_DIR, 'history.jsonl'), 'utf8')
-    .split('\n').filter(Boolean).map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
-} catch {}
-
-if (json) {
-  console.log(JSON.stringify({ state, history: history.slice(-limit) }, null, 2));
-} else if (!state) {
-  console.log('No loop configured in', dir);
-} else {
-  const icon = { done: '✅', gave_up: '🛑', continue: '🔄', running: '🔄' };
-  console.log(`Loop in ${dir}`);
-  console.log(`  phase: ${state.phase || '?'} | iteration: ${state.iteration ?? 0}${state.gave_up_reason ? ` | gave up: ${state.gave_up_reason}` : ''}`);
-  if (state.last_oracle) console.log(`  oracle: ${String(state.last_oracle).split('\n')[0]}`);
-  console.log(`  history (last ${Math.min(limit, history.length)} of ${history.length}):`);
-  for (const h of history.slice(-limit)) {
-    console.log(`    ${icon[h.decision] || '·'} iter ${h.iteration} [${h.decision}] ${h.ts}${h.reason ? ' — ' + h.reason : ''}`);
-  }
-}

package/bin/skills/loop/bin/precompact.mjs

@@ -1,30 +0,0 @@
-#!/usr/bin/env node
-// precompact.mjs — Claude Code `PreCompact` hook. Records a compaction event in
-// the loop's history timeline (so the monitor shows context resets) and reminds
-// the agent that LOOP.md is the durable handoff across compaction.
-import { readFileSync, appendFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-// Resolve the loop home from the per-process env (shared-settings safe); fallback to
-// the parent of this copied bin/ dir.
-const SID = process.env.SVAMP_SESSION_ID || null;
-const PROJECT_ENV = process.env.CLAUDE_PROJECT_DIR || null;
-const LOOP_DIR = (SID && PROJECT_ENV) ? join(PROJECT_ENV, '.svamp', SID, 'loop') : resolve(HERE, '..');
-
-let active = false;
-try { active = JSON.parse(readFileSync(join(LOOP_DIR, 'loop-state.json'), 'utf8')).active !== false; } catch {}
-if (!active) process.exit(0);
-
-let iteration = 0;
-try { iteration = JSON.parse(readFileSync(join(LOOP_DIR, 'loop-state.json'), 'utf8')).iteration || 0; } catch {}
-try {
-  appendFileSync(join(LOOP_DIR, 'history.jsonl'),
-    JSON.stringify({ ts: new Date().toISOString(), iteration, decision: 'compaction' }) + '\n');
-} catch {}
-
-// Context is about to be compacted — LOOP.md (auto-injected on the next turn) is
-// the durable handoff. Nudge the agent to ensure its progress is captured there.
-process.stdout.write('Context is being compacted. LOOP.md is your durable memory across this reset — ensure your latest progress, plan, and remaining work are written there before continuing.');
-process.exit(0);

package/bin/skills/loop/bin/routine-core.mjs

@@ -1,126 +0,0 @@
-#!/usr/bin/env node
-// routine-core.mjs — dependency-free primitives for the routine layer:
-//   * cron matching + next-fire (standard 5-field cron)
-//   * payload templating (${body.x}/${query.x}/${now}) for trigger -> action
-//   * routine spec validation
-// No external deps (mirrors the loop gate). Pure + unit-testable.
-
-// ---- cron ---------------------------------------------------------------
-const FIELD_RANGES = [
-  [0, 59], // minute
-  [0, 23], // hour
-  [1, 31], // day of month
-  [1, 12], // month
-  [0, 6],  // day of week (0=Sun)
-];
-
-function parseField(token, [min, max]) {
-  const set = new Set();
-  for (const part of token.split(',')) {
-    let m;
-    if (part === '*') { for (let i = min; i <= max; i++) set.add(i); }
-    else if ((m = part.match(/^\*\/(\d+)$/))) { const s = +m[1]; for (let i = min; i <= max; i += s) set.add(i); }
-    else if ((m = part.match(/^(\d+)-(\d+)\/(\d+)$/))) { const [, a, b, s] = m; for (let i = +a; i <= +b; i += +s) set.add(i); }
-    else if ((m = part.match(/^(\d+)-(\d+)$/))) { const [, a, b] = m; for (let i = +a; i <= +b; i++) set.add(i); }
-    else if ((m = part.match(/^(\d+)$/))) { set.add(+m[1]); }
-    else throw new Error(`invalid cron field: "${token}"`);
-  }
-  for (const v of set) if (v < min || v > max) throw new Error(`cron value ${v} out of range [${min},${max}]`);
-  return set;
-}
-
-export function parseCron(expr) {
-  const fields = String(expr).trim().split(/\s+/);
-  if (fields.length !== 5) throw new Error(`cron must have 5 fields, got ${fields.length}: "${expr}"`);
-  const [minute, hour, dom, month, dow] = fields.map((f, i) => parseField(f, FIELD_RANGES[i]));
-  const domRestricted = fields[2] !== '*';
-  const dowRestricted = fields[4] !== '*';
-  return { minute, hour, dom, month, dow, domRestricted, dowRestricted };
-}
-
-/** Does `date` (minute resolution) match the cron expr? */
-export function cronMatches(expr, date) {
-  const c = typeof expr === 'string' ? parseCron(expr) : expr;
-  if (!c.minute.has(date.getMinutes())) return false;
-  if (!c.hour.has(date.getHours())) return false;
-  if (!c.month.has(date.getMonth() + 1)) return false;
-  const domOk = c.dom.has(date.getDate());
-  const dowOk = c.dow.has(date.getDay());
-  // Standard cron: when BOTH dom and dow are restricted, match is OR; else AND.
-  if (c.domRestricted && c.dowRestricted) return domOk || dowOk;
-  return domOk && dowOk;
-}
-
-/** First firing strictly after `from` (defaults to now-ish; caller passes Date). */
-// Return a Date whose LOCAL fields equal the wall-clock time in `tz`, so
-// cronMatches (which reads local getHours/getMinutes/...) effectively matches
-// against that timezone. Falls back to the input on any error.
-export function inZone(date, tz) {
-  if (!tz) return date;
-  try {
-    const p = new Intl.DateTimeFormat('en-US', { timeZone: tz, hour12: false,
-      year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit' })
-      .formatToParts(date).reduce((o, x) => { o[x.type] = x.value; return o; }, {});
-    return new Date(+p.year, +p.month - 1, +p.day, +(p.hour === '24' ? 0 : p.hour), +p.minute);
-  } catch { return date; }
-}
-
-export function nextFire(expr, from, tz) {
-  const c = parseCron(expr);
-  const d = new Date(from.getTime());
-  d.setSeconds(0, 0);
-  d.setMinutes(d.getMinutes() + 1); // strictly after
-  const limit = 366 * 24 * 60; // scan up to ~1 year of minutes
-  for (let i = 0; i < limit; i++) {
-    if (cronMatches(c, tz ? inZone(d, tz) : d)) return new Date(d.getTime());
-    d.setMinutes(d.getMinutes() + 1);
-  }
-  return null;
-}
-
-// ---- templating ---------------------------------------------------------
-function resolvePath(ctx, path) {
-  return path.split('.').reduce((o, k) => (o == null ? undefined : o[k]), ctx);
-}
-/** Replace ${a.b.c} from ctx; missing -> empty string. No code eval. */
-export function renderTemplate(template, ctx) {
-  return String(template).replace(/\$\{([\w.$]+)\}/g, (_, p) => {
-    const v = resolvePath(ctx, p);
-    return v == null ? '' : (typeof v === 'object' ? JSON.stringify(v) : String(v));
-  });
-}
-
-// ---- spec validation ----------------------------------------------------
-const TRIGGER_TYPES = ['manual', 'schedule', 'webhook', 'api'];
-const ACTION_KINDS = ['message', 'loop'];
-const OVERLAP = ['queue', 'skip', 'replace'];
-
-export function validateRoutine(r) {
-  const errs = [];
-  if (!r || typeof r !== 'object') return ['routine must be an object'];
-  if (!r.session_id) errs.push('session_id required');
-  if (!r.name) errs.push('name required');
-  const t = r.trigger;
-  if (!t || !TRIGGER_TYPES.includes(t.type)) errs.push(`trigger.type must be one of ${TRIGGER_TYPES.join('|')}`);
-  if (t?.type === 'schedule') {
-    try { parseCron(t.cron); } catch (e) { errs.push(`trigger.cron: ${e.message}`); }
-    if (t.missed && !['catchup', 'skip'].includes(t.missed)) errs.push('trigger.missed must be catchup|skip');
-  }
-  const a = r.action;
-  if (!a || !ACTION_KINDS.includes(a.kind)) errs.push(`action.kind must be one of ${ACTION_KINDS.join('|')}`);
-  if (a?.kind === 'message' && !a.template) errs.push('action.template required for message action');
-  if (a?.kind === 'loop' && !a.loop && !a.task_template) errs.push('action.loop or action.task_template required for loop action');
-  if (r.overlap && !OVERLAP.includes(r.overlap)) errs.push(`overlap must be one of ${OVERLAP.join('|')}`);
-  // Security: a public (keyless) webhook + loop action = unauthenticated task
-  // injection into the session. Require a key for loop actions.
-  if ((t?.type === 'webhook' || t?.type === 'api') && t.public && a?.kind === 'loop')
-    errs.push('a public webhook/api may not use a loop action (unauthenticated task injection) — use a message action or require a key');
-  return errs;
-}
-
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const [cmd, ...rest] = process.argv.slice(2);
-  if (cmd === 'next') console.log(nextFire(rest.join(' '), new Date())?.toISOString() || 'no fire');
-  else if (cmd === 'matches') console.log(cronMatches(rest.slice(0, 5).join(' '), new Date()));
-  else console.log('usage: routine-core.mjs next "<cron>" | matches "<cron>"');
-}

package/bin/skills/loop/bin/state-fp.mjs

@@ -1,111 +0,0 @@
-#!/usr/bin/env node
-// state-fp.mjs — deterministic fingerprint of a project's working-tree state.
-// Used to tie an evaluator verdict to the exact code it judged: if the actor
-// edits anything after the evaluator ran, the fingerprint changes and the
-// stale verdict is rejected by the Stop gate.
-import { execFileSync } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import { readFileSync, statSync, readdirSync, readlinkSync } from 'node:fs';
-import { join } from 'node:path';
-
-function git(dir, args) {
-  try {
-    return execFileSync('git', ['-C', dir, ...args], {
-      encoding: 'utf8', maxBuffer: 64 * 1024 * 1024,
-      stdio: ['ignore', 'pipe', 'ignore'], // swallow "not a git repository" noise
-    });
-  } catch {
-    return '';
-  }
-}
-
-// Paths excluded from the fingerprint: the loop's own bookkeeping AND its
-// memory file (LOOP.md). The fingerprint must track the WORK PRODUCT only —
-// LOOP.md/state/verdict change every iteration and would otherwise make every
-// verdict look stale (the agent updates LOOP.md progress as it works).
-function excludedPaths(dir) {
-  // The loop's bookkeeping + memory now live under .svamp/<sid>/loop/ (and legacy
-  // loops under .claude/loop/). Both — plus a root LOOP.md a legacy loop may have
-  // left — are excluded so the fingerprint tracks the WORK PRODUCT only.
-  return { loopFile: 'LOOP.md', prefixes: ['.svamp/', '.claude/loop/'] };
-}
-
-const WALK_SKIP = new Set(['.git', 'node_modules', '.svamp', '.expo', 'dist', 'build']);
-
-/** Fallback for non-git (or no-HEAD) dirs: hash all files on disk so the
- * fingerprint actually reflects content. Without this, git plumbing returns
- * empty strings and every state hashes identically — accepting stale verdicts. */
-function walkFingerprint(dir, isExcluded) {
-  const h = createHash('sha256');
-  h.update('WALK\0');
-  const files = [];
-  const links = [];
-  const walk = (abs, rel) => {
-    let entries; try { entries = readdirSync(abs, { withFileTypes: true }); } catch { return; }
-    for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-      const childRel = rel ? `${rel}/${e.name}` : e.name;
-      if (WALK_SKIP.has(e.name) || isExcluded(childRel)) continue;
-      const childAbs = join(abs, e.name);
-      // Symlinks: hash the link TARGET (don't follow — avoids cycles/escape) so a
-      // work product reached via a symlink still changes the fingerprint.
-      if (e.isSymbolicLink()) { try { links.push([childRel, readlinkSync(childAbs)]); } catch { links.push([childRel, 'unreadable']); } }
-      else if (e.isDirectory()) walk(childAbs, childRel);
-      else if (e.isFile()) files.push([childRel, childAbs]);
-    }
-  };
-  walk(dir, '');
-  for (const [rel, abs] of files.sort((a, b) => a[0].localeCompare(b[0]))) {
-    let part = rel + ':';
-    try {
-      const st = statSync(abs);
-      part += st.size < 4 * 1024 * 1024
-        ? st.size + ':' + createHash('sha256').update(readFileSync(abs)).digest('hex')
-        : st.size + ':skip';
-    } catch { part += 'missing'; }
-    h.update(part + '\0');
-  }
-  h.update('SYMLINKS\0');
-  for (const [rel, target] of links.sort((a, b) => a[0].localeCompare(b[0]))) h.update(rel + ':->' + target + '\0');
-  return h.digest('hex');
-}
-
-/** Fingerprint = HEAD + tracked diff + untracked file contents (size+sha).
- * Falls back to a filesystem walk when the dir is not a git repo / has no HEAD. */
-export function stateFingerprint(dir) {
-  const { loopFile, prefixes } = excludedPaths(dir);
-  const isExcluded = (p) => p === loopFile || prefixes.some((pre) => p.startsWith(pre));
-  const head = git(dir, ['rev-parse', 'HEAD']).trim();
-  if (!head) return walkFingerprint(dir, isExcluded); // non-git / no commit yet
-  // Exclude bookkeeping/memory from the tracked diff too (in case they're committed).
-  const diff = git(dir, ['-c', 'core.quotepath=false', 'diff', 'HEAD', '--',
-    '.', `:(exclude)${loopFile}`, ':(exclude).claude/loop', ':(exclude).svamp']);
-  // KNOWN LIMITATION (review #8): --exclude-standard omits gitignored files, so a
-  // loop whose work product lands in a gitignored path (e.g. dist/) won't change
-  // the fingerprint. Acceptable since work products are normally tracked; loops
-  // targeting gitignored output should commit/track it or run in a non-git dir.
-  const untrackedList = git(dir, ['ls-files', '--others', '--exclude-standard'])
-    .split('\n').map((s) => s.trim()).filter(Boolean)
-    .filter((p) => !isExcluded(p))
-    .sort();
-  const h = createHash('sha256');
-  h.update('HEAD\0' + head + '\0DIFF\0' + diff + '\0UNTRACKED\0');
-  for (const rel of untrackedList) {
-    const abs = join(dir, rel);
-    let part = rel + ':';
-    try {
-      const st = statSync(abs);
-      if (st.isFile() && st.size < 4 * 1024 * 1024) {
-        part += st.size + ':' + createHash('sha256').update(readFileSync(abs)).digest('hex');
-      } else {
-        part += st.size + ':skip';
-      }
-    } catch { part += 'missing'; }
-    h.update(part + '\0');
-  }
-  return h.digest('hex');
-}
-
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const dir = process.argv[2] || process.cwd();
-  process.stdout.write(stateFingerprint(dir) + '\n');
-}