svamp-cli 0.2.190 → 0.2.193

package/dist/commands-CPT-Wu41.mjs

@@ -0,0 +1,390 @@
+import { execSync } from 'node:child_process';
+import { m as resolveProjectRoot, t as searchIssues, q as listIssues, o as addComment, u as updateIssue, n as getIssue, w as summarize, p as addIssue } from './run-B_UWCqRV.mjs';
+import 'os';
+import 'fs/promises';
+import 'fs';
+import 'path';
+import 'url';
+import 'child_process';
+import 'crypto';
+import 'node:crypto';
+import 'node:fs';
+import 'util';
+import 'node:path';
+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",
+  archived: "\u25A3"
+};
+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 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 fmtIssue(i) {
+  const tri = i.triaged === false ? " \u25B3triage" : "";
+  const disp = i.disposition === "crew" ? " {crew}" : "";
+  const label = i.labels.length ? ` [${i.labels.join(", ")}]` : "";
+  const v = i.verify ? ` (verify:${i.verify.type})` : "";
+  const br = i.branch ? ` {branch:${i.branch}}` : "";
+  return `#${i.id} ${STATUS_GLYPH[i.status]} ${i.title}${tri}${disp}${label}${v}${br}`;
+}
+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,
+        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) => i.scope === "project" || i.session === 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.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", ...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 "pending": {
+      const mine = flag(rest, "--session") || (has(rest, "--mine") ? sessionId : null);
+      const inScope = (i) => !mine || i.scope === "project" || i.session === 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? Do not guess. Enrich from the codebase where you can, and CONFIRM with the user",
+          "     for anything genuinely ambiguous (ask 1-2 sharp questions) BEFORE marking it ready.",
+          "  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 ready issues in THIS session's backlog (your own + shared project items; leave other",
+          "sessions' private items alone). List: svamp issue list --status ready --session <id>.",
+          "  TRIAGE FIRST any \u25B3triage (untriaged) issue \u2014 see `svamp issue guide triage`.",
+          "  For each issue:",
+          "   1. On pickup: svamp issue work <id>   (status \u2192 in_progress; live status reflects the work).",
+          '   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.",
+          "  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.",
+          "  Keep going until `svamp issue pending --session <id>` is empty."
+        ].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 };