svamp-cli 0.2.225 → 0.2.226

package/dist/commands-_Dkx6klo.mjs

@@ -0,0 +1,493 @@
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { m as resolveProjectRoot, w as searchIssues, v as listIssues, o as resumeIssue, p as pauseIssue, q as addComment, u as updateIssue, n as getIssue, x as isVisibleTo, z as summarize, t as addIssue } from './run-BCUQw-5v.mjs';
+import 'os';
+import 'fs/promises';
+import 'fs';
+import 'path';
+import 'url';
+import 'child_process';
+import 'crypto';
+import 'node:crypto';
+import 'util';
+import 'node:events';
+import 'node:os';
+import '@agentclientprotocol/sdk';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '@modelcontextprotocol/sdk/client/stdio.js';
+import '@modelcontextprotocol/sdk/types.js';
+import 'zod';
+import 'node:fs/promises';
+import 'node:util';
+
+const STATUS_GLYPH = {
+  ready: "\u25C9",
+  in_progress: "\u25D0",
+  paused: "\u23F8",
+  archived: "\u25A3"
+};
+function allFlags(args, name) {
+  const out = [];
+  for (let i = 0; i < args.length; i++) if (args[i] === name && i + 1 < args.length) out.push(args[++i]);
+  return out;
+}
+function flag(args, name) {
+  const i = args.indexOf(name);
+  return i !== -1 && i + 1 < args.length ? args[i + 1] : void 0;
+}
+function has(args, name) {
+  return args.includes(name);
+}
+function loopActiveForCwd(cwd = process.cwd(), sid = process.env.SVAMP_SESSION_ID) {
+  const candidates = [];
+  if (sid) candidates.push(join(cwd, ".svamp", sid, "loop", "loop-state.json"));
+  candidates.push(join(cwd, ".claude", "loop", "loop-state.json"));
+  for (const p of candidates) {
+    try {
+      if (existsSync(p)) {
+        const st = JSON.parse(readFileSync(p, "utf-8"));
+        if (st && st.active === true) return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+function positional(args) {
+  const out = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a.startsWith("--")) {
+      if (a !== "--json" && a !== "--ready") i++;
+      continue;
+    }
+    out.push(a);
+  }
+  return out;
+}
+function shortSess(s) {
+  if (!s) return "";
+  const p = s.split("-");
+  return p.length >= 2 ? `${p[0]}-${p[1]}` : s;
+}
+function fmtIssue(i) {
+  const tri = i.triaged === false ? " \u25B3triage" : "";
+  const owner = i.status === "in_progress" && i.session ? shortSess(i.session) : "";
+  const disp = i.disposition === "crew" ? owner ? ` {crew:${owner}}` : " {crew}" : owner ? ` {session:${owner}}` : "";
+  const label = i.labels.length ? ` [${i.labels.join(", ")}]` : "";
+  const v = i.verify ? ` (verify:${i.verify.type})` : "";
+  const br = i.branch ? ` {branch:${i.branch}}` : "";
+  const ans = i.answer ? " \u21A9answered" : "";
+  return `#${i.id} ${STATUS_GLYPH[i.status]} ${i.title}${tri}${disp}${label}${v}${br}${ans}`;
+}
+function buildVerify(args) {
+  const cmd = flag(args, "--verify-cmd");
+  if (cmd) return { type: "command", text: cmd };
+  const agent = flag(args, "--verify");
+  if (agent) return { type: "agent", text: agent };
+  if (has(args, "--manual")) return { type: "manual" };
+  return null;
+}
+async function issueCommand(args) {
+  const sub = args[0];
+  const rest = args.slice(1);
+  const root = resolveProjectRoot();
+  const json = has(args, "--json");
+  const sessionId = process.env.SVAMP_SESSION_ID || null;
+  const out = (text) => console.log(text);
+  const ok = (obj, text) => {
+    if (json) console.log(JSON.stringify(obj));
+    else out(text);
+  };
+  switch (sub) {
+    case "add": {
+      let title = positional(rest)[0];
+      let body = flag(rest, "--body");
+      let original;
+      if (!title) {
+        const src = (body || "").trim();
+        if (!src) {
+          console.error('usage: svamp issue add "<title or text>" [--ready] [--label x] [--verify-cmd "npm test"] [--scope project|session] [--body "\u2026"]');
+          process.exit(1);
+        }
+        const nl = src.indexOf("\n");
+        title = (nl === -1 ? src : src.slice(0, nl)).trim().slice(0, 200);
+        original = src;
+        body = void 0;
+      }
+      const labels = rest.filter((a, idx) => rest[idx - 1] === "--label");
+      const owner = flag(rest, "--session") || sessionId;
+      const scope = flag(rest, "--scope") || (owner ? "session" : "project");
+      const issue = addIssue(root, {
+        title,
+        // New issues are actionable immediately (#0049) — there is no backlog to promote from.
+        // `--ready` is accepted for back-compat but is now the only behavior.
+        status: "ready",
+        scope,
+        labels,
+        verify: buildVerify(rest),
+        session: scope === "session" ? owner : null,
+        owner,
+        // creating session (#0099) — scopes project issues to their creator/parent
+        original,
+        body
+      });
+      ok(issue, `Created #${issue.id} (${issue.status}): ${issue.title}`);
+      break;
+    }
+    case "list":
+    case "ls": {
+      const status = flag(rest, "--status");
+      const opts = { includeArchived: status === "all" || status === "archived" || has(rest, "--all") };
+      if (status && status !== "all") opts.status = status;
+      if (flag(rest, "--label")) opts.label = flag(rest, "--label");
+      if (flag(rest, "--scope")) opts.scope = flag(rest, "--scope");
+      const mineList = flag(rest, "--session") || (has(rest, "--mine") ? sessionId : null);
+      let items = listIssues(root, opts);
+      if (mineList) items = items.filter((i) => isVisibleTo(i, mineList));
+      if (json) {
+        console.log(JSON.stringify(items.map(({ body, original, ...r }) => r)));
+        break;
+      }
+      if (!items.length) {
+        out("No issues.");
+        break;
+      }
+      for (const i of items) out(fmtIssue(i));
+      const s = summarize(listIssues(root, { includeArchived: true }));
+      out(`
+${s.ready} ready \xB7 ${s.in_progress} in-progress \xB7 ${s.archived} archived`);
+      break;
+    }
+    case "show": {
+      const id = positional(rest)[0];
+      const issue = id ? getIssue(root, id) : null;
+      if (!issue) {
+        console.error(`Issue not found: ${id}`);
+        process.exit(1);
+      }
+      if (json) {
+        console.log(JSON.stringify(issue));
+        break;
+      }
+      out(fmtIssue(issue));
+      out(`status: ${issue.status} \xB7 scope: ${issue.scope} \xB7 created: ${issue.created}${issue.closed ? ` \xB7 closed: ${issue.closed}` : ""}`);
+      if (issue.answer) out(`
+\u21A9 The user answered your question \u2014 act on this: ${issue.answer}`);
+      if (issue.question) out(`
+\u23F8 Paused \u2014 awaiting your question: ${issue.question.text}`);
+      if (issue.original) out(`
+Original request:
+${issue.original}`);
+      if (issue.body) out(`
+Description:
+${issue.body}`);
+      break;
+    }
+    case "work": {
+      const id = positional(rest)[0];
+      if (!id) {
+        console.error("usage: svamp issue work <id> [--branch <name>] [--session <id>]");
+        process.exit(1);
+      }
+      const branch = flag(rest, "--branch");
+      const worker = flag(rest, "--session") || sessionId;
+      const cur = getIssue(root, id);
+      const claim = worker && cur && cur.scope === "project" && !cur.session ? { session: worker } : {};
+      const updated = updateIssue(root, id, { status: "in_progress", answer: null, ...branch ? { branch } : {}, ...claim });
+      if (!updated) {
+        console.error(`Issue not found: ${id}`);
+        process.exit(1);
+      }
+      ok(updated, `#${updated.id} \u2192 in_progress${updated.branch ? ` on ${updated.branch}` : ""}${claim.session ? ` (claimed by ${claim.session})` : ""}`);
+      break;
+    }
+    case "ready":
+    case "start":
+    case "close":
+    case "done":
+    case "reopen":
+    case "archive":
+    case "backlog": {
+      const id = positional(rest)[0];
+      if (!id) {
+        console.error(`usage: svamp issue ${sub} <id>`);
+        process.exit(1);
+      }
+      const map = {
+        ready: "ready",
+        start: "in_progress",
+        close: "archived",
+        done: "archived",
+        reopen: "ready",
+        archive: "archived",
+        backlog: "ready"
+      };
+      if (sub === "close" || sub === "done") {
+        const current = getIssue(root, id);
+        const vc = current?.verify?.type === "command" ? current.verify.text?.trim() : "";
+        if (vc) {
+          if (has(rest, "--force")) {
+            console.error(`\u26A0 #${id}: closing WITHOUT running verify-cmd (--force): \`${vc}\``);
+          } else {
+            try {
+              execSync(vc, { cwd: root, stdio: "pipe", timeout: 6e5, maxBuffer: 64 * 1024 * 1024 });
+            } catch (e) {
+              const tail = (String(e?.stdout || "") + String(e?.stderr || "")).split("\n").slice(-15).join("\n").trim();
+              console.error(`Refusing to close #${id}: its verify-cmd failed \u2014 the fix is not verified.
+  $ ${vc}
+${tail}
+(Fix the issue, or pass --force to override.)`);
+              process.exit(1);
+            }
+          }
+        }
+      }
+      const updated = updateIssue(root, id, { status: map[sub] });
+      if (!updated) {
+        console.error(`Issue not found: ${id}`);
+        process.exit(1);
+      }
+      ok(updated, `#${updated.id} \u2192 ${updated.status}: ${updated.title}`);
+      break;
+    }
+    case "edit": {
+      const id = positional(rest)[0];
+      if (!id) {
+        console.error("usage: svamp issue edit <id> [--title \u2026] [--label x] [--verify-cmd \u2026] [--scope \u2026] [--body \u2026]");
+        process.exit(1);
+      }
+      const patch = {};
+      if (flag(rest, "--title")) patch.title = flag(rest, "--title");
+      const labels = rest.filter((a, idx) => rest[idx - 1] === "--label");
+      if (labels.length) patch.labels = labels;
+      const v = buildVerify(rest);
+      if (v || has(rest, "--no-verify")) patch.verify = has(rest, "--no-verify") ? null : v;
+      if (flag(rest, "--scope")) patch.scope = flag(rest, "--scope");
+      if (has(rest, "--unclaim")) patch.session = null;
+      else if (flag(rest, "--session")) patch.session = flag(rest, "--session");
+      if (flag(rest, "--body")) patch.body = flag(rest, "--body");
+      if (flag(rest, "--status")) patch.status = flag(rest, "--status");
+      if (has(rest, "--crew")) patch.disposition = "crew";
+      else if (has(rest, "--inline")) patch.disposition = "inline";
+      if (has(rest, "--triaged")) patch.triaged = true;
+      const updated = updateIssue(root, id, patch);
+      if (!updated) {
+        console.error(`Issue not found: ${id}`);
+        process.exit(1);
+      }
+      ok(updated, `Updated #${updated.id}: ${updated.title}`);
+      break;
+    }
+    case "triage": {
+      const id = positional(rest)[0];
+      if (!id) {
+        console.error('usage: svamp issue triage <id> [--title "\u2026"] [--label x \u2026] [--crew|--inline] [--verify-cmd "cmd" | --verify "criterion" | --manual] [--body "rewritten"] [--backlog]');
+        process.exit(1);
+      }
+      const patch = { triaged: true };
+      if (flag(rest, "--title")) patch.title = flag(rest, "--title");
+      const tlabels = rest.filter((a, idx) => rest[idx - 1] === "--label");
+      if (tlabels.length) patch.labels = tlabels;
+      if (has(rest, "--crew")) patch.disposition = "crew";
+      else if (has(rest, "--inline")) patch.disposition = "inline";
+      const tv = buildVerify(rest);
+      if (tv) patch.verify = tv;
+      if (flag(rest, "--body")) patch.body = flag(rest, "--body");
+      patch.status = "ready";
+      const updated = updateIssue(root, id, patch);
+      if (!updated) {
+        console.error(`Issue not found: ${id}`);
+        process.exit(1);
+      }
+      ok(updated, `Triaged #${updated.id}: ${updated.title} [${updated.disposition}${updated.verify ? ", verify:" + updated.verify.type : ""}] \u2192 ${updated.status}`);
+      break;
+    }
+    case "comment": {
+      const id = positional(rest)[0];
+      const text = positional(rest)[1];
+      if (!id || !text) {
+        console.error('usage: svamp issue comment <id> "<text>"');
+        process.exit(1);
+      }
+      const updated = addComment(root, id, text);
+      if (!updated) {
+        console.error(`Issue not found: ${id}`);
+        process.exit(1);
+      }
+      ok(updated, `Commented on #${updated.id}`);
+      break;
+    }
+    case "pause": {
+      const id = positional(rest)[0];
+      if (!id) {
+        console.error('usage: svamp issue pause <id> --blocked "<reason>" [--question "\u2026"] [--option "A" --option "B"]');
+        process.exit(1);
+      }
+      const question = flag(rest, "--question");
+      const options = allFlags(rest, "--option");
+      const blocked = flag(rest, "--blocked");
+      if (loopActiveForCwd() && !blocked) {
+        console.error(
+          `Refusing to pause #${id}: a loop is active and no genuine block was declared.
+Finished work should be CLOSED, not paused for verification \u2014 self-verify (cite the
+commit/tests, note anything you couldn't check), \`svamp issue close ${id}\`, and the user
+reopens with a follow-up if it's wrong. Only pause for a REAL block you cannot resolve by
+any default (missing secret/access, a destructive action needing sign-off, or a decision
+the user explicitly reserved): re-run with \`--blocked "<the specific blocker>"\`.`
+        );
+        process.exit(1);
+      }
+      const updated = pauseIssue(root, id, question ? { text: question, options } : void 0);
+      if (!updated) {
+        console.error(`Issue not found: ${id}`);
+        process.exit(1);
+      }
+      ok(updated, `Paused #${updated.id}${blocked ? ` \u2014 BLOCKED: ${blocked}` : ""}${question ? ` \u2014 asked: ${question}` : ""}`);
+      break;
+    }
+    case "resume": {
+      const id = positional(rest)[0];
+      if (!id) {
+        console.error('usage: svamp issue resume <id> [--answer "\u2026"]');
+        process.exit(1);
+      }
+      const answer = flag(rest, "--answer") || positional(rest)[1];
+      const updated = resumeIssue(root, id, answer);
+      if (!updated) {
+        console.error(`Issue not found: ${id}`);
+        process.exit(1);
+      }
+      ok(updated, `Resumed #${updated.id}`);
+      break;
+    }
+    case "pending": {
+      const mine = flag(rest, "--session") || (has(rest, "--mine") ? sessionId : null);
+      const inScope = (i) => !mine || isVisibleTo(i, mine);
+      const pending = listIssues(root).filter(inScope).filter((i) => i.status === "ready" || i.status === "in_progress");
+      if (json) console.log(JSON.stringify(pending));
+      else out(pending.length ? `${pending.length} pending: ${pending.map((i) => "#" + i.id).join(" ")}` : "No pending issues.");
+      process.exit(pending.length ? 1 : 0);
+      break;
+    }
+    case "search": {
+      const q = positional(rest)[0] || "";
+      const items = searchIssues(root, q);
+      if (json) {
+        console.log(JSON.stringify(items.map(({ body, original, ...r }) => r)));
+        break;
+      }
+      if (!items.length) {
+        out(`No issues match "${q}".`);
+        break;
+      }
+      for (const i of items) out(fmtIssue(i));
+      break;
+    }
+    case "guide": {
+      const topic = positional(rest)[0];
+      if (topic === "triage") {
+        out([
+          "TRIAGE like a thoughtful human reviewer \u2014 turn a raw user post into the RIGHT outcome, which is",
+          'not always "a ready inline issue". First READ it (svamp issue show <id> \u2014 the original text is',
+          "preserved separately), then DECIDE THE DISPOSITION:",
+          "",
+          "  A. NOT-AN-ISSUE? Resolve directly instead of leaving a stale item:",
+          "     - Already done / duplicate / obsolete \u2192 `svamp issue close <id>` with a one-line why (cite the",
+          "       commit/PR or the issue it duplicates).",
+          "     - A question you can just answer \u2192 reply, then close.",
+          "     - Belongs to another session/repo \u2192 say where it should go (and route it), then close/redirect.",
+          "  B. UNDERSPECIFIED? Strongly prefer to PROCEED on a sensible default and document the assumption \u2014",
+          "     the user dislikes being asked about every issue. Enrich from the codebase first. Only when a choice",
+          "     is genuinely ambiguous AND you truly cannot pick a reasonable default (e.g. two incompatible",
+          "     directions only the user can choose) pause with the real blocker declared \u2014 TRIAGE is the place for",
+          "     that, since the work loop won't stop to ask:",
+          `       svamp issue pause <id> --blocked "<why you can't default>" --question "\u2026" [--option "A" --option "B"]`,
+          "  C. SPLIT if the post bundles several independent asks: `svamp issue add` one per piece (carry the",
+          "     relevant context), triage each, keep the original as the primary.",
+          "  D. AUTOMATION: if it implies running on a schedule/event, `svamp workflow add` it (instead of / in",
+          "     addition to an issue).",
+          "",
+          "  Once it IS a real, actionable issue, set crew-vs-inline by SIZE + INTERFERENCE:",
+          "     - --inline  \u2192 small, low-risk, self-contained: work it in THIS session.",
+          "     - --crew    \u2192 substantial, OR likely to interfere with this session's working tree / long-running",
+          "                   work, OR the user asked for a separate branch: an isolated worktree child does it.",
+          "       Rule of thumb: if you would not want it half-done in your working tree mid-review, use --crew.",
+          "  Then specify it:",
+          '       svamp issue triage <id> --title "<concise title>" [--label <tag>]... \\',
+          `         [--inline | --crew] [--verify-cmd "<pass/fail cmd>" | --verify "<how we know it's done>"] \\`,
+          '         [--body "<expanded description>"]',
+          "     - verify-cmd = a real pass/fail command (oracle); --verify = an agent/human criterion.",
+          "  Be smart and helpful \u2014 match the disposition to what the user actually needs. Reply with a one-line summary."
+        ].join("\n"));
+      } else if (topic === "work") {
+        out([
+          "WORK the actionable issues in THIS session's backlog (your own + shared project items; leave other",
+          "sessions' private items alone). List them with: svamp issue list --session <id>  (shows ready AND",
+          "in-progress \u2014 a RESUMED issue is in-progress, so a ready-only filter would hide it). An issue badged",
+          "\u21A9answered carries a fresh user answer \u2014 work that one FIRST.",
+          "  TRIAGE FIRST any \u25B3triage (untriaged) issue \u2014 see `svamp issue guide triage`.",
+          "  For each issue:",
+          "   1. On pickup: `svamp issue show <id>` FIRST, then `svamp issue work <id>`. ALWAYS read show \u2014 its",
+          '      top surfaces any "\u21A9 The user answered your question \u2014 act on this: \u2026" line. Picking up via',
+          "      `work` clears that badge, so read it before you do. (status \u2192 in_progress; live status updates.)",
+          '   2. As you go: leave substantive `svamp issue comment <id> "\u2026"` notes \u2014 decisions, takeaways, blockers.',
+          "   3. Before closing: VERIFY with evidence \u2014 run its verify-cmd; for verify:agent cite the files/commit",
+          "      that resolve it in a summary comment. Post the summary, THEN `svamp issue close <id>`.",
+          "      NEVER close an issue that isn't genuinely resolved. The finished state is CLOSED, not paused.",
+          "      Can't fully verify (a perceptual/on-device/UI look-and-feel result you can't observe headlessly)?",
+          "      Verify what you CAN (build/tests/deploy + a clear summary of what you couldn't check), then CLOSE",
+          "      anyway \u2014 the user reviews closed issues and reopens with a follow-up if it's wrong. Do NOT pause an",
+          '      issue to ask the user to verify/confirm/"look at" finished work \u2014 that defeats the loop.',
+          "  CONVERGE TO MAIN: if an issue used an isolated branch/worktree, merge it back to `main` (and remove",
+          "  the worktree) BEFORE closing \u2014 never leave unmerged branches.",
+          "",
+          "  DEFAULT FORWARD \u2014 DON'T PAUSE. Clarifying/preference questions belong in TRIAGE, not here. While",
+          "  working, if something is ambiguous, pick the most sensible default, PROCEED, and DOCUMENT the assumption",
+          "  in a `svamp issue comment` (so the user can correct it). An over-eager pause defeats the whole point of",
+          "  an automated loop \u2014 and pausing just to have the user VERIFY/CONFIRM finished work is the #1 anti-pattern:",
+          "  close it instead (see step 3). The user reopens if it's wrong.",
+          "  PAUSE ONLY when you are genuinely BLOCKED and cannot proceed by ANY reasonable default \u2014 you need a",
+          "  secret/credential/access only the user has, an irreversible/destructive action needs sign-off, or the",
+          "  user EXPLICITLY reserved the decision. Inside a loop the pause is REFUSED unless you declare the real",
+          '  blocker, and "I want the user to check my work" is NOT a blocker:',
+          '    svamp issue pause <id> --blocked "<the specific blocker>" [--question "\u2026"] [--option "A" --option "B"]',
+          "  A paused issue is EXCLUDED from `pending`, so the loop stops cleanly. The user answers (app renders the",
+          "  options as buttons) \u2192 it resumes in-progress, badged \u21A9answered with the answer surfaced at the top of",
+          "  `show` \u2014 re-pick it up and act on the answer (do NOT re-ask the same question).",
+          "  Keep going until `svamp issue pending --session <id>` is empty (paused issues don't count)."
+        ].join("\n"));
+      } else {
+        out("usage: svamp issue guide <triage|work>");
+      }
+      break;
+    }
+    case "help":
+    case void 0:
+    case "--help":
+    case "-h":
+      out([
+        "svamp issue \u2014 the session backlog (folder of .svamp/issues/<id>.md)",
+        "",
+        '  add ["<title>"] [--ready] [--label x] [--verify-cmd "cmd"] [--scope project|session] [--body "\u2026"]',
+        "          # title optional \u2014 if omitted, the first line of --body becomes the title",
+        "  list [--status ready|in_progress|archived|all] [--label x] [--scope \u2026] [--session <id>] [--json]",
+        "  show <id> [--json]",
+        "  ready <id> | close <id> (\u2192 archived) | reopen <id> | archive <id>   # lifecycle: ready \u2192 in_progress \u2192 archived",
+        "  work <id> [--branch <name>]   # mark in-progress (optionally on a branch; merge to main before close)",
+        "  triage <id> [--title \u2026] [--label x] [--inline|--crew] [--verify-cmd \u2026|--verify \u2026] [--body \u2026]",
+        "  edit <id> [--title \u2026] [--label x] [--verify-cmd \u2026] [--no-verify] [--status \u2026] [--body \u2026]",
+        '  comment <id> "<text>"   # append a follow-up to the issue',
+        "  pending [--session <id>]   # exit 0 if no actionable (ready/in_progress) issues \u2014 the loop oracle",
+        '  search "<query>" [--json]',
+        "  guide <triage|work>   # the triage / work-loop procedure (so triggers can stay short)"
+      ].join("\n"));
+      break;
+    default:
+      console.error(`Unknown: svamp issue ${sub}. Try: svamp issue help`);
+      process.exit(1);
+  }
+}
+
+export { issueCommand, loopActiveForCwd };