@mmerterden/multi-agent-pipeline 8.6.0

package/pipeline/scripts/uninstall.mjs

@@ -0,0 +1,331 @@
+#!/usr/bin/env node
+
+/**
+ * @file Token-preserving uninstaller — removes the multi-agent-pipeline
+ * footprint from Claude Code, Copilot CLI, Cursor, Windsurf, and Cline
+ * without touching personal access tokens stored in the OS credential store
+ * (macOS Keychain / Windows Credential Manager / Linux libsecret).
+ *
+ * Invocation:
+ *   node uninstall.mjs                  # interactive, removes from all installed targets
+ *   node uninstall.mjs --yes            # skip prompts, remove from all
+ *   node uninstall.mjs --claude         # only Claude Code
+ *   node uninstall.mjs --cursor --target=/path/to/repo
+ *   node uninstall.mjs --dry-run        # report what would be removed, change nothing
+ *
+ * Targeted by:
+ *   - `/multi-agent:delete` slash command (Claude Code)
+ *   - `multi-agent-delete` skill (Copilot CLI)
+ *   - `npx @mmerterden/multi-agent-pipeline uninstall` (direct CLI)
+ *
+ * Always preserved:
+ *   - $HOME/.claude/CLAUDE.md (user customizations)
+ *   - $HOME/.claude/multi-agent-preferences.json
+ *   - Personal access tokens in the OS credential store
+ *   - User content outside the `<!-- multi-agent-pipeline:begin/end -->` markers
+ *     in shared rules files (copilot-instructions.md)
+ *
+ * @module pipeline/scripts/runtime/uninstall
+ */
+
+import { existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { createInterface } from "readline";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PIPELINE_ROOT = join(__dirname, "..");
+const HOME = process.env.HOME || process.env.USERPROFILE;
+
+const flags = process.argv.slice(2).filter((a) => a !== "uninstall");
+
+const TOOL_FLAGS = [
+  "--claude",
+  "--copilot",
+  "--cursor",
+  "--copilot-chat",
+];
+const explicitlyTargeted =
+  flags.some((f) => TOOL_FLAGS.includes(f)) || flags.includes("--all");
+
+const forClaude = flags.includes("--claude") || flags.includes("--all") || !explicitlyTargeted;
+const forCopilot = flags.includes("--copilot") || flags.includes("--all") || !explicitlyTargeted;
+const forCursor = flags.includes("--cursor") || flags.includes("--all") || !explicitlyTargeted;
+const forCopilotChat = flags.includes("--copilot-chat") || flags.includes("--all") || !explicitlyTargeted;
+
+const dryRun = flags.includes("--dry-run");
+const skipPrompt = flags.includes("--yes") || flags.includes("-y");
+
+const adapterTarget = (() => {
+  const raw = flags.find((f) => f.startsWith("--target="));
+  return raw ? raw.slice("--target=".length) : process.cwd();
+})();
+
+/**
+ * Report a planned action. Always logged; in --dry-run mode, no side effects
+ * are performed.
+ * @param {string} verb - "would remove" / "would update"
+ * @param {string} path
+ */
+function report(verb, path) {
+  console.log(`    ${verb}: ${path}`);
+}
+
+/**
+ * Conditional rm — respects --dry-run.
+ * @param {string} path
+ */
+function rmIfExists(path) {
+  if (!existsSync(path)) return false;
+  if (dryRun) {
+    report("would remove", path);
+    return false;
+  }
+  rmSync(path, { recursive: true, force: true });
+  console.log(`    removed: ${path}`);
+  return true;
+}
+
+/**
+ * Remove every directory under `parent` whose name matches a predicate.
+ * @param {string} parent
+ * @param {(name: string) => boolean} predicate
+ */
+function rmMatchingDirs(parent, predicate) {
+  if (!existsSync(parent)) return 0;
+  let count = 0;
+  for (const entry of readdirSync(parent, { withFileTypes: true })) {
+    if (!(entry.isDirectory() || entry.isSymbolicLink())) continue;
+    if (!predicate(entry.name)) continue;
+    if (rmIfExists(join(parent, entry.name))) count++;
+  }
+  return count;
+}
+
+/**
+ * Strip a marker-wrapped `<!-- multi-agent-pipeline:begin/end -->` block from
+ * a user-owned file. Preserves everything outside the markers. Deletes the
+ * file entirely if it becomes empty.
+ * @param {string} filePath
+ */
+function stripManagedBlock(filePath) {
+  if (!existsSync(filePath)) return false;
+  const content = readFileSync(filePath, "utf-8");
+  const re =
+    /\s*<!-- multi-agent-pipeline:begin -->[\s\S]*?<!-- multi-agent-pipeline:end -->\s*/m;
+  if (!re.test(content)) {
+    // Legacy: maybe the whole file is ours (Copilot wrote it before markers)
+    if (content.includes("# Multi-Agent Development Pipeline") && content.length < 50000) {
+      // Heuristic: Copilot's generateCopilotInstructions output. Only strip the
+      // pipeline section, not the whole file.
+      const marker = "# Multi-Agent Development Pipeline";
+      const idx = content.indexOf(marker);
+      if (idx >= 0) {
+        const before = content.slice(0, idx).trimEnd();
+        if (dryRun) {
+          report("would update", filePath);
+        } else if (before.length === 0) {
+          rmSync(filePath, { force: true });
+          console.log(`    removed (was pipeline-only): ${filePath}`);
+        } else {
+          writeFileSync(filePath, before + "\n");
+          console.log(`    cleaned pipeline section: ${filePath}`);
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+  if (dryRun) {
+    report("would update", filePath);
+    return true;
+  }
+  const cleaned = content.replace(re, "\n").trim();
+  if (cleaned.length === 0) {
+    rmSync(filePath, { force: true });
+    console.log(`    removed (was pipeline-only): ${filePath}`);
+  } else {
+    writeFileSync(filePath, cleaned + "\n");
+    console.log(`    cleaned pipeline block from: ${filePath}`);
+  }
+  return true;
+}
+
+/**
+ * Remove the pipeline-added hooks + env from settings.json. Other hooks the
+ * user added stay intact.
+ * @param {string} settingsPath
+ */
+function cleanClaudeSettings(settingsPath) {
+  if (!existsSync(settingsPath)) return;
+  let settings;
+  try {
+    settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+  } catch {
+    console.log(`    skipped (unparseable): ${settingsPath}`);
+    return;
+  }
+  let touched = false;
+
+  if (settings.env?.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE === "65") {
+    delete settings.env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE;
+    if (Object.keys(settings.env).length === 0) delete settings.env;
+    touched = true;
+  }
+
+  if (settings.hooks?.PreToolUse?.length) {
+    const before = settings.hooks.PreToolUse.length;
+    settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(
+      (h) =>
+        !(h.matcher === "Bash(git commit:*)" &&
+          h.hooks?.some((sub) => sub.command?.includes("pre-commit-check.sh"))),
+    );
+    if (settings.hooks.PreToolUse.length < before) touched = true;
+    if (settings.hooks.PreToolUse.length === 0) delete settings.hooks.PreToolUse;
+    if (settings.hooks && Object.keys(settings.hooks).length === 0) delete settings.hooks;
+  }
+
+  if (touched) {
+    if (dryRun) {
+      report("would update", settingsPath);
+    } else {
+      writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      console.log(`    cleaned pipeline hook + env from: ${settingsPath}`);
+    }
+  }
+}
+
+async function confirm(question) {
+  if (skipPrompt || dryRun) return true;
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(/^y(es)?$/i.test(answer.trim()));
+    });
+  });
+}
+
+async function main() {
+  console.log("");
+  console.log("  multi-agent-pipeline uninstaller");
+  console.log("  ================================");
+  console.log("");
+  if (dryRun) console.log("  [DRY-RUN] Nothing will be modified.");
+  console.log("");
+  console.log("  Targets:");
+  if (forClaude) console.log("    - Claude Code (~/.claude/{commands,skills,agents,rules,scripts}/multi-agent*)");
+  if (forCopilot) console.log("    - Copilot CLI (~/.copilot/{skills,agents,scripts}/multi-agent* + copilot-instructions.md section)");
+  if (forCursor) console.log(`    - Cursor (${adapterTarget}/.cursor/rules/multi-agent-* + .cursorrules)`);
+  if (forCopilotChat) console.log(`    - GitHub Copilot Chat (${adapterTarget}/.github/copilot-instructions.md block + .github/instructions/multi-agent-*)`);
+  console.log("");
+  console.log("  PRESERVED (never touched):");
+  console.log("    - Personal access tokens in OS credential store (Keychain / Credential Manager / libsecret)");
+  console.log("    - ~/.claude/CLAUDE.md (your customizations)");
+  console.log("    - ~/.claude/multi-agent-preferences.json (your settings)");
+  console.log("    - User content outside <!-- multi-agent-pipeline:begin/end --> markers");
+  console.log("");
+
+  if (!(await confirm("  Proceed? (y/N) "))) {
+    console.log("  Aborted.");
+    process.exit(0);
+  }
+
+  if (forClaude && HOME) {
+    console.log("");
+    console.log("  [Claude Code] Removing...");
+    const CLAUDE = join(HOME, ".claude");
+    rmIfExists(join(CLAUDE, "commands", "multi-agent"));
+    rmIfExists(join(CLAUDE, "scripts"));
+    rmIfExists(join(CLAUDE, "rules"));
+    const skills = join(CLAUDE, "skills");
+    let n = rmMatchingDirs(skills, (name) => name === "multi-agent" || name.startsWith("multi-agent-"));
+    n += rmMatchingDirs(skills, (name) => name === "figma-ios" || name === "figma-android" || name === "figma-common");
+    if (n > 0) console.log(`    removed ${n} skill dir(s) under ${skills}`);
+    rmIfExists(join(skills, ".skills-index.json"));
+    rmIfExists(join(skills, "skills-index.md"));
+    rmIfExists(join(skills, "README.md"));
+    rmMatchingDirs(join(CLAUDE, "agents"), (name) =>
+      [
+        "code-reviewer.md",
+        "explorer.md",
+        "ios-architect.md",
+        "android-architect.md",
+        "backend-architect.md",
+        "security-auditor.md",
+      ].includes(name),
+    );
+    cleanClaudeSettings(join(CLAUDE, "settings.json"));
+  }
+
+  if (forCopilot && HOME) {
+    console.log("");
+    console.log("  [Copilot CLI] Removing...");
+    const COP = join(HOME, ".copilot");
+    rmIfExists(join(COP, "scripts"));
+    const skills = join(COP, "skills");
+    let n = rmMatchingDirs(skills, (name) => name === "multi-agent" || name.startsWith("multi-agent-"));
+    n += rmMatchingDirs(skills, (name) => name === "figma-ios" || name === "figma-android" || name === "figma-common");
+    if (n > 0) console.log(`    removed ${n} skill dir(s) under ${skills}`);
+    rmIfExists(join(skills, "README.md"));
+    rmMatchingDirs(join(COP, "agents"), (name) =>
+      [
+        "code-reviewer.md",
+        "explorer.md",
+        "ios-architect.md",
+        "android-architect.md",
+        "backend-architect.md",
+        "security-auditor.md",
+      ].includes(name),
+    );
+    stripManagedBlock(join(COP, "copilot-instructions.md"));
+  }
+
+  if (forCursor) {
+    console.log("");
+    console.log(`  [Cursor] Removing from ${adapterTarget}...`);
+    if (!dryRun) {
+      try {
+        const adapter = (await import(join(PIPELINE_ROOT, "adapters", "cursor.mjs"))).default;
+        const result = adapter.uninstall({ target: adapterTarget });
+        console.log(`    removed: ${result.removed} file(s)`);
+      } catch (e) {
+        console.log(`    skipped (adapter unavailable): ${e.message}`);
+      }
+    } else {
+      report("would invoke", "cursor adapter uninstall");
+    }
+  }
+
+  if (forCopilotChat) {
+    console.log("");
+    console.log(`  [GitHub Copilot Chat] Removing from ${adapterTarget}...`);
+    if (!dryRun) {
+      try {
+        const adapter = (await import(join(PIPELINE_ROOT, "adapters", "copilot-chat.mjs"))).default;
+        const result = adapter.uninstall({ target: adapterTarget });
+        console.log(`    main: ${result.mainStatus} · per-skill removed: ${result.perSkillRemoved}`);
+      } catch (e) {
+        console.log(`    skipped (adapter unavailable): ${e.message}`);
+      }
+    } else {
+      report("would invoke", "copilot-chat adapter uninstall");
+    }
+  }
+
+  console.log("");
+  console.log("  ✓ Pipeline removed.");
+  console.log("");
+  console.log("  Personal access tokens were NOT touched. Inspect with:");
+  console.log("    macOS:   security find-generic-password -s \"<service>\" -w");
+  console.log("    Windows: cmdkey /list:<target>");
+  console.log("    Linux:   secret-tool search service <service>");
+  console.log("");
+  if (dryRun) console.log("  [DRY-RUN] No changes applied. Re-run without --dry-run to execute.");
+  console.log("");
+}
+
+main().catch((e) => {
+  console.error("uninstall failed:", e.message);
+  process.exit(1);
+});

package/pipeline/scripts/update-issue-progress.sh

@@ -0,0 +1,146 @@
+#!/usr/bin/env bash
+#
+# update-issue-progress.sh
+#
+# Synchronises the GitHub issue body's `### Progress` table with the run's
+# state.flags. Idempotent — running twice with the same state produces the
+# same body and a no-op edit.
+#
+# Replaces the python `update-issue-from-registry.py` referenced in the issue
+# body comment legend. Same contract: the table is owned by the pipeline,
+# never hand-edited.
+#
+# Usage:
+#   update-issue-progress.sh <task-id>
+#
+# Inputs:
+#   $HOME/.claude/projects/{slug}/state/{taskId}/agent-state.json
+#     .issue.url, .issue.number, .repos.primary.org, .repos.primary.name
+#     .flags.implementation, .flags.testing, .flags.codeConnect, .flags.wiki
+#
+# Side effects:
+#   gh issue edit --body-file <updated body>
+#
+# Exit codes:
+#   0 success (or no-op when body unchanged)
+#   2 missing agent-state.json
+#   3 missing required flags
+#   4 GitHub edit failed
+
+set -euo pipefail
+
+TASK_ID="${1:-}"
+if [ -z "$TASK_ID" ]; then
+  echo "usage: update-issue-progress.sh <task-id>" >&2
+  exit 64
+fi
+
+# Resolve the project state directory (matches phase-tracker convention).
+STATE_GLOB="$HOME/.claude/projects/-Users-*"
+AGENT_STATE=""
+for dir in $STATE_GLOB; do
+  candidate="$dir/state/$TASK_ID/agent-state.json"
+  if [ -f "$candidate" ]; then
+    AGENT_STATE="$candidate"
+    break
+  fi
+done
+
+if [ -z "$AGENT_STATE" ]; then
+  echo "update-issue-progress: no agent-state.json found for task=$TASK_ID" >&2
+  exit 2
+fi
+
+ISSUE_URL=$(jq -r '.issue.url // empty' "$AGENT_STATE")
+ISSUE_NUM=$(jq -r '.issue.number // empty' "$AGENT_STATE")
+ORG_REPO=$(jq -r '.repos.primary.name // empty' "$AGENT_STATE")
+# Derive org/repo from URL if not present in state.
+if [ -z "$ORG_REPO" ] || ! [[ "$ORG_REPO" == */* ]]; then
+  if [[ "$ISSUE_URL" =~ github\.com/([^/]+/[^/]+)/issues/ ]]; then
+    ORG_REPO="${BASH_REMATCH[1]}"
+  fi
+fi
+
+if [ -z "$ORG_REPO" ] || [ -z "$ISSUE_NUM" ]; then
+  echo "update-issue-progress: cannot resolve org/repo or issue number from state" >&2
+  exit 3
+fi
+
+# Read the four flags (default false).
+F_IMPL=$(jq -r '.flags.implementation // false' "$AGENT_STATE")
+F_TEST=$(jq -r '.flags.testing       // false' "$AGENT_STATE")
+F_CC=$(jq   -r '.flags.codeConnect   // false' "$AGENT_STATE")
+F_WIKI=$(jq -r '.flags.wiki          // false' "$AGENT_STATE")
+
+# Each flag may be: true | false | "yellow" (validated against older impl).
+glyph_for() {
+  case "$1" in
+    true|"true")    echo "🟢" ;;
+    yellow|"yellow") echo "🟡" ;;
+    *)              echo "⚪" ;;
+  esac
+}
+
+G_IMPL=$(glyph_for "$F_IMPL")
+G_TEST=$(glyph_for "$F_TEST")
+G_CC=$(glyph_for "$F_CC")
+G_WIKI=$(glyph_for "$F_WIKI")
+
+# Fetch current body, replace the Progress table, write back.
+TMP_BODY=$(mktemp /tmp/issue-progress-${TASK_ID}-XXXXXX.md)
+trap 'rm -f "$TMP_BODY"' EXIT
+
+gh issue view "$ISSUE_NUM" --repo "$ORG_REPO" --json body --jq .body > "$TMP_BODY"
+
+# Build the new Progress block.
+NEW_BLOCK=$(cat <<EOF
+| Flag | State |
+|---|---|
+| Implementation | ${G_IMPL} |
+| Testing        | ${G_TEST} |
+| Code Connect   | ${G_CC} |
+| Wiki           | ${G_WIKI} |
+EOF
+)
+
+# Replace the table between `### Progress` and the next `<!--` HTML comment.
+# Use awk to keep the legend comment in place.
+awk -v new_block="$NEW_BLOCK" '
+  BEGIN { in_progress = 0; replaced = 0 }
+  /^### Progress/ {
+    print
+    print ""
+    print new_block
+    print ""
+    in_progress = 1
+    replaced = 1
+    next
+  }
+  in_progress && /^<!--/ {
+    in_progress = 0
+    print
+    next
+  }
+  in_progress { next }
+  { print }
+  END {
+    if (replaced == 0) {
+      # Body had no Progress section; nothing to replace.
+      exit 0
+    }
+  }
+' "$TMP_BODY" > "${TMP_BODY}.new"
+
+# Check if body actually changed (idempotent no-op).
+if cmp -s "$TMP_BODY" "${TMP_BODY}.new"; then
+  echo "update-issue-progress: no change for #$ISSUE_NUM (idempotent no-op)" >&2
+  exit 0
+fi
+
+# Apply.
+if ! gh issue edit "$ISSUE_NUM" --repo "$ORG_REPO" --body-file "${TMP_BODY}.new" >/dev/null; then
+  echo "update-issue-progress: gh issue edit failed for #$ISSUE_NUM" >&2
+  exit 4
+fi
+
+echo "update-issue-progress: updated #$ISSUE_NUM (Impl=$G_IMPL Test=$G_TEST CC=$G_CC Wiki=$G_WIKI)"

package/pipeline/scripts/validate-analysis.mjs

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+// validate-analysis.mjs — runtime validator for Phase 1 Explorer subagent output.
+//
+// Phase 1's Explorer returns a structured research summary conforming to
+// pipeline/schemas/analysis-output.schema.json. Phase 2 and Phase 4 consume
+// this; a malformed output breaks downstream scope reasoning.
+//
+// Zero deps. Reads JSON from path arg or STDIN.
+//
+// Usage:
+//   node validate-analysis.mjs path/to/analysis.json
+//   cat analysis.json | node validate-analysis.mjs -
+//
+// Exit codes:
+//   0 — valid
+//   1 — invalid structure, missing field, or bad enum
+
+import { readFileSync } from "node:fs";
+
+const ALLOWED_STACKS = new Set(["ios", "android", "backend", "frontend", "mobile", "unknown"]);
+const ALLOWED_SEVERITIES = new Set(["low", "medium", "high"]);
+
+function readInput() {
+  const arg = process.argv[2];
+  if (!arg) {
+    console.error("usage: validate-analysis.mjs <path|->");
+    process.exit(64);
+  }
+  if (arg === "-") {
+    const chunks = [];
+    process.stdin.setEncoding("utf-8");
+    return new Promise((resolve) => {
+      process.stdin.on("data", (c) => chunks.push(c));
+      process.stdin.on("end", () => resolve(chunks.join("")));
+    });
+  }
+  return Promise.resolve(readFileSync(arg, "utf-8"));
+}
+
+async function main() {
+  const raw = await readInput();
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    emit({ ok: false, code: 1, errors: [`invalid JSON: ${err.message}`] });
+    process.exit(1);
+  }
+
+  const errors = [];
+
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    errors.push("root must be an object");
+    emit({ ok: false, code: 1, errors });
+    process.exit(1);
+  }
+
+  // stack
+  if (typeof parsed.stack !== "object" || parsed.stack === null) {
+    errors.push("stack must be an object");
+  } else {
+    if (!ALLOWED_STACKS.has(parsed.stack.primary)) {
+      errors.push(`stack.primary invalid: "${parsed.stack.primary}"`);
+    }
+    if (parsed.stack.language !== undefined && typeof parsed.stack.language !== "string") {
+      errors.push("stack.language must be string if present");
+    }
+    if (parsed.stack.framework !== undefined && typeof parsed.stack.framework !== "string") {
+      errors.push("stack.framework must be string if present");
+    }
+  }
+
+  // touchedAreas
+  if (!Array.isArray(parsed.touchedAreas) || parsed.touchedAreas.length === 0) {
+    errors.push("touchedAreas must be non-empty array");
+  } else {
+    parsed.touchedAreas.forEach((a, i) => {
+      if (typeof a !== "object" || a === null) {
+        errors.push(`touchedAreas[${i}]: not an object`);
+        return;
+      }
+      if (typeof a.path !== "string" || a.path.length === 0) {
+        errors.push(`touchedAreas[${i}].path: missing`);
+      }
+      if (typeof a.why !== "string" || a.why.length < 4) {
+        errors.push(`touchedAreas[${i}].why: too short`);
+      }
+    });
+  }
+
+  // risks (optional array, but if present must be well-formed)
+  if (parsed.risks !== undefined) {
+    if (!Array.isArray(parsed.risks)) {
+      errors.push("risks must be an array if present");
+    } else {
+      parsed.risks.forEach((r, i) => {
+        if (typeof r !== "object" || r === null) {
+          errors.push(`risks[${i}]: not an object`);
+          return;
+        }
+        if (typeof r.risk !== "string" || r.risk.length < 4) {
+          errors.push(`risks[${i}].risk: too short`);
+        }
+        if (!ALLOWED_SEVERITIES.has(r.severity)) {
+          errors.push(`risks[${i}].severity: invalid`);
+        }
+      });
+    }
+  }
+
+  // summary
+  if (typeof parsed.summary !== "string" || parsed.summary.length < 20) {
+    errors.push("summary must be string >= 20 chars");
+  }
+
+  if (errors.length > 0) {
+    emit({ ok: false, code: 1, errors });
+    process.exit(1);
+  }
+
+  emit({ ok: true, code: 0, errors: [] });
+  process.exit(0);
+}
+
+function emit(result) {
+  process.stdout.write(JSON.stringify(result) + "\n");
+}
+
+main().catch((err) => {
+  emit({ ok: false, code: 1, errors: [`unhandled: ${err.message}`] });
+  process.exit(1);
+});