svamp-cli 0.2.225 → 0.2.227

package/dist/pinnedClaudeCode-VIupR1NK.mjs

@@ -0,0 +1,58 @@
+import { spawn, exec as exec$1 } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const PINNED_CLAUDE_CODE_VERSION = "2.1.195";
+const exec = promisify(exec$1);
+async function readClaudeVersion() {
+  try {
+    const { stdout } = await exec("claude --version", { timeout: 1e4 });
+    const m = stdout.trim().match(/(\d+\.\d+\.\d+(?:[-.][\w]+)?)/);
+    return m ? m[1] : null;
+  } catch {
+    return null;
+  }
+}
+function runInstaller(version, log) {
+  return new Promise((resolve) => {
+    const proc = spawn("claude", ["install", version], { stdio: ["ignore", "pipe", "pipe"] });
+    let stderr = "";
+    proc.stdout?.on("data", (b) => log(`[claude install] ${b.toString().trimEnd()}`));
+    proc.stderr?.on("data", (b) => {
+      const s = b.toString();
+      stderr += s;
+      log(`[claude install] ${s.trimEnd()}`);
+    });
+    proc.on("error", (e) => {
+      stderr += String(e);
+      resolve({ ok: false, stderr });
+    });
+    proc.on("exit", (code) => resolve({ ok: code === 0, stderr }));
+  });
+}
+async function ensureClaudeCodeVersion(log, pinned = PINNED_CLAUDE_CODE_VERSION, opts) {
+  const autoInstall = opts?.allowAutoInstall !== false;
+  const current = await readClaudeVersion();
+  if (!current) {
+    log(`[claude-version] 'claude' not on PATH \u2014 please run the Anthropic installer once: curl -fsSL https://claude.ai/install.sh | sh`);
+    return { kind: "not-installed", want: pinned };
+  }
+  if (current === pinned) {
+    log(`[claude-version] OK \u2014 claude ${current} matches pinned ${pinned}`);
+    return { kind: "ok", version: current };
+  }
+  if (!autoInstall) {
+    log(`[claude-version] DRIFT \u2014 installed ${current} \u2260 pinned ${pinned} (auto-install disabled)`);
+    return { kind: "skipped", reason: `installed=${current} pinned=${pinned}` };
+  }
+  log(`[claude-version] DRIFT \u2014 installed ${current} \u2260 pinned ${pinned}; running 'claude install ${pinned}'`);
+  const { ok, stderr } = await runInstaller(pinned, log);
+  if (!ok) {
+    log(`[claude-version] install failed for ${pinned}: ${stderr.trim().slice(0, 400)}`);
+    return { kind: "install-failed", from: current, want: pinned, error: stderr.slice(0, 400) };
+  }
+  const after = await readClaudeVersion();
+  log(`[claude-version] installer finished; now reports ${after ?? "unknown"}`);
+  return { kind: "installed", from: current, to: after ?? pinned };
+}
+
+export { PINNED_CLAUDE_CODE_VERSION, ensureClaudeCodeVersion };

package/dist/rpc-DMj8ZJPz.mjs

@@ -0,0 +1,92 @@
+import { m as resolveProjectRoot } from './run-LEPH8aka.mjs';
+import { g as getWorkflow, s as setWorkflowEnabled, r as removeWorkflow, a as saveWorkflow, b as rawWorkflow, l as listWorkflows } from './store-BTs0H_y0.mjs';
+import { g as getRun, l as listRuns, r as runWorkflow } from './runStore-CtptN7US.mjs';
+import 'os';
+import 'fs/promises';
+import 'fs';
+import 'path';
+import 'url';
+import 'child_process';
+import 'crypto';
+import 'node:crypto';
+import 'node:fs';
+import 'node:child_process';
+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';
+import 'yaml';
+
+async function workflowRpc(cwd, params) {
+  const root = resolveProjectRoot(cwd || process.cwd());
+  const op = params.op;
+  switch (op) {
+    case "list":
+      return listWorkflows(root);
+    case "show": {
+      const wf = getWorkflow(root, String(params.name));
+      return { meta: wf, yaml: wf ? rawWorkflow(root, String(params.name)) || "" : null };
+    }
+    case "add": {
+      const on = {};
+      const crons = Array.isArray(params.cron) ? params.cron.map(String) : params.cron ? [String(params.cron)] : [];
+      if (crons.length) on.schedule = crons.map((c) => ({ cron: c }));
+      if (params.dispatch || params.workflow_dispatch) on.workflow_dispatch = true;
+      if (params.channel) on.channel = String(params.channel);
+      if (Array.isArray(params.issue) && params.issue.length) on.issue = params.issue.map(String);
+      const runs = Array.isArray(params.runs) ? params.runs.map(String).filter(Boolean) : [];
+      if (!params.name || !runs.length) throw new Error("workflow add: name and at least one run step required");
+      const wf = {
+        name: String(params.name),
+        on: Object.keys(on).length ? on : void 0,
+        jobs: { run: { steps: runs.map((r) => ({ run: r })) } },
+        session: params.session || null
+      };
+      saveWorkflow(root, wf);
+      return wf;
+    }
+    case "remove":
+      return { removed: removeWorkflow(root, String(params.name)) };
+    case "enable":
+    case "disable": {
+      const wf = setWorkflowEnabled(root, String(params.name), op === "enable");
+      if (!wf) throw new Error(`Workflow not found: ${params.name}`);
+      return wf;
+    }
+    case "run": {
+      const wf = getWorkflow(root, String(params.name));
+      if (!wf) throw new Error(`Workflow not found: ${params.name}`);
+      const run = await runWorkflow(root, wf, { trigger: "manual", actor: params.actor || params.session || null });
+      const out = [`\u25B6 ran workflow "${wf.name}" (${run.steps.length} step${run.steps.length === 1 ? "" : "s"}) \u2192 ${run.status}`];
+      for (const s of run.steps) {
+        out.push(`  [${s.index + 1}] $ ${s.cmd}`);
+        if (s.stdout) out.push(s.stdout.trimEnd());
+        if (s.stderr) out.push(s.stderr.trimEnd());
+        if (s.timedOut) out.push(`  \u2717 step ${s.index + 1} timed out.`);
+        else if (s.exitCode !== 0) out.push(`  \u2717 step ${s.index + 1} failed (exit ${s.exitCode ?? "signal"}).`);
+      }
+      out.push(run.status === "success" ? `\u2713 workflow "${wf.name}" completed.` : `\u2717 workflow "${wf.name}" failed.`);
+      return { ok: run.status === "success", output: out.join("\n"), runId: run.id };
+    }
+    case "runs": {
+      const limit = Number(params.limit) > 0 ? Number(params.limit) : void 0;
+      return { runs: listRuns(root, String(params.name), limit) };
+    }
+    case "run-detail": {
+      const run = getRun(root, String(params.name), String(params.runId));
+      if (!run) throw new Error(`Run not found: ${params.name}/${params.runId}`);
+      return run;
+    }
+    default:
+      throw new Error(`workflow rpc: unknown op "${op}"`);
+  }
+}
+
+export { workflowRpc };

package/dist/rpc-a0fp9HhD.mjs

@@ -0,0 +1,194 @@
+import { m as resolveProjectRoot, u as updateIssue, n as getIssue, o as resumeIssue, p as pauseIssue, q as addComment, t as addIssue, v as listIssues, w as searchIssues, x as isVisibleTo } from './run-LEPH8aka.mjs';
+import 'os';
+import 'fs/promises';
+import 'fs';
+import 'path';
+import 'url';
+import 'child_process';
+import 'crypto';
+import 'node:crypto';
+import 'node:fs';
+import 'node:child_process';
+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';
+
+function followUpCount(body) {
+  if (!body) return 0;
+  return (body.match(/\*\*Follow-up/g) || []).length;
+}
+function notifyOwnerOnFollowUp(issue, text, author, deps) {
+  if (!deps.notifySession) return;
+  if (!issue || !text.trim()) return;
+  const owner = issue.session;
+  if (!owner) return;
+  if (issue.status === "in_progress") return;
+  if (author && author === owner) return;
+  deps.notifySession(
+    owner,
+    `User added a follow-up (comment ${followUpCount(issue.body)}) to issue #${issue.id} \u2014 triage the change and decide: reopen+work, or leave closed.`
+  );
+}
+function compact(i) {
+  const { body, original, ...rest } = i;
+  return rest;
+}
+function buildVerify(p) {
+  if (p.verifyCmd) return { type: "command", text: String(p.verifyCmd) };
+  if (p.verify) return { type: "agent", text: String(p.verify) };
+  if (p.manual) return { type: "manual" };
+  if (p.noVerify) return null;
+  return void 0;
+}
+function ownerScoped(items, session) {
+  if (!session) return items;
+  return items.filter((i) => isVisibleTo(i, session));
+}
+const STATUS_MAP = {
+  ready: "ready",
+  start: "in_progress",
+  close: "archived",
+  done: "archived",
+  reopen: "ready",
+  archive: "archived",
+  backlog: "ready"
+};
+function issueRpc(cwd, params, deps = {}) {
+  const root = resolveProjectRoot(cwd || process.cwd());
+  const op = params.op;
+  switch (op) {
+    case "list": {
+      const opts = { includeArchived: params.status === "all" || params.status === "archived" || params.includeArchived };
+      if (params.status && params.status !== "all") opts.status = params.status;
+      if (params.label) opts.label = params.label;
+      if (params.scope) opts.scope = params.scope;
+      return ownerScoped(listIssues(root, opts), params.session).map(compact);
+    }
+    case "show":
+      return getIssue(root, String(params.id));
+    case "search":
+      return ownerScoped(searchIssues(root, String(params.query || "")), params.session).map(compact);
+    case "pending": {
+      const items = ownerScoped(listIssues(root), params.session).filter((i) => i.status === "ready" || i.status === "in_progress");
+      return { pending: items.map((i) => i.id), count: items.length };
+    }
+    case "add": {
+      const owner = params.session || null;
+      const scope = params.scope || (owner ? "session" : "project");
+      let title = params.title ? String(params.title) : "";
+      let body = params.body ? String(params.body) : void 0;
+      let original;
+      if (!title) {
+        const src = (body || "").trim();
+        if (!src) throw new Error("issue add: title or body required");
+        const nl = src.indexOf("\n");
+        title = (nl === -1 ? src : src.slice(0, nl)).trim().slice(0, 200);
+        original = src;
+        body = void 0;
+      }
+      const created = addIssue(root, {
+        title,
+        status: "ready",
+        scope,
+        labels: Array.isArray(params.labels) ? params.labels.map(String) : [],
+        verify: buildVerify(params) ?? null,
+        session: scope === "session" ? owner : null,
+        // Record the creating session as the owner (#0099) so a project issue stays
+        // visible to its creator/parent (and the "all" view) but doesn't leak into
+        // unrelated parallel sessions. Null owner (no session) → globally shared.
+        owner,
+        original,
+        body
+      });
+      if (params.rekick) {
+        const loopOwner = created.session || created.owner;
+        if (loopOwner) deps.rekickLoopOwner?.(String(loopOwner), { skipStalled: true });
+      }
+      return created;
+    }
+    case "comment": {
+      const text = String(params.text || "");
+      const updated = addComment(root, String(params.id), text);
+      notifyOwnerOnFollowUp(updated, text, params.session || null, deps);
+      return updated;
+    }
+    case "pause": {
+      const question = params.question ? { text: String(params.question), options: Array.isArray(params.options) ? params.options.map(String) : [] } : void 0;
+      const updated = pauseIssue(root, String(params.id), question);
+      if (!updated) throw new Error(`Issue not found: ${params.id}`);
+      if (question) notifyOwnerOnFollowUp(updated, `needs your input: ${question.text}`, params.session || null, deps);
+      return updated;
+    }
+    case "resume": {
+      const updated = resumeIssue(root, String(params.id), params.answer ? String(params.answer) : void 0);
+      if (!updated) throw new Error(`Issue not found: ${params.id}`);
+      const loopOwner = updated.session || updated.owner;
+      if (loopOwner) deps.rekickLoopOwner?.(String(loopOwner));
+      return updated;
+    }
+    case "status": {
+      const status = STATUS_MAP[params.status];
+      if (!status) throw new Error(`issue status: unknown status "${params.status}"`);
+      const patch = { status };
+      if (status === "in_progress" && params.session) {
+        const cur = getIssue(root, String(params.id));
+        if (cur && cur.scope === "project" && !cur.session) patch.session = params.session;
+      }
+      const updated = updateIssue(root, String(params.id), patch);
+      if (!updated) throw new Error(`Issue not found: ${params.id}`);
+      return updated;
+    }
+    case "work": {
+      const patch = { status: "in_progress", answer: null };
+      if (params.branch) patch.branch = String(params.branch);
+      const worker = params.session || null;
+      const cur = getIssue(root, String(params.id));
+      if (worker && cur && cur.scope === "project" && !cur.session) patch.session = worker;
+      const updated = updateIssue(root, String(params.id), patch);
+      if (!updated) throw new Error(`Issue not found: ${params.id}`);
+      return updated;
+    }
+    case "edit": {
+      const patch = {};
+      if (params.title != null) patch.title = String(params.title);
+      if (Array.isArray(params.labels)) patch.labels = params.labels.map(String);
+      const v = buildVerify(params);
+      if (v !== void 0) patch.verify = v;
+      if (params.scope) patch.scope = params.scope;
+      if (params.unclaim) patch.session = null;
+      else if (params.session != null) patch.session = String(params.session);
+      if (params.body != null) patch.body = String(params.body);
+      if (params.status) patch.status = params.status;
+      if (params.disposition) patch.disposition = params.disposition === "crew" ? "crew" : "inline";
+      if (params.triaged) patch.triaged = true;
+      const updated = updateIssue(root, String(params.id), patch);
+      if (!updated) throw new Error(`Issue not found: ${params.id}`);
+      return updated;
+    }
+    case "triage": {
+      const patch = { triaged: true };
+      if (params.title != null) patch.title = String(params.title);
+      if (Array.isArray(params.labels) && params.labels.length) patch.labels = params.labels.map(String);
+      if (params.disposition) patch.disposition = params.disposition === "crew" ? "crew" : "inline";
+      const v = buildVerify(params);
+      if (v) patch.verify = v;
+      if (params.body != null) patch.body = String(params.body);
+      patch.status = "ready";
+      const updated = updateIssue(root, String(params.id), patch);
+      if (!updated) throw new Error(`Issue not found: ${params.id}`);
+      return updated;
+    }
+    default:
+      throw new Error(`issue rpc: unknown op "${op}"`);
+  }
+}
+
+export { issueRpc };