@ikunin/sprintpilot 1.0.0

package/lib/commands/uninstall.js

@@ -0,0 +1,218 @@
+'use strict';
+
+const path = require('node:path');
+const { execFile } = require('node:child_process');
+const { promisify } = require('node:util');
+const fs = require('fs-extra');
+const pc = require('picocolors');
+
+const { ALL_TOOLS, getToolDir, getSystemPromptFile, getSystemPromptMode } = require('../core/tool-registry');
+const { stripBlock, hasBlock, writeAtomic } = require('../core/markers');
+const {
+  V1_ADDON_DIR_NAME,
+  V1_SKILL_NAMES,
+  detectV1Installation,
+} = require('../core/v1-detect');
+
+const execFileAsync = promisify(execFile);
+const ADDON_DIR = path.resolve(__dirname, '..', '..', '_Sprintpilot');
+
+async function listSkills() {
+  const entries = await fs.readdir(path.join(ADDON_DIR, 'skills'), { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+}
+
+async function removeSystemPrompt(tool, projectRoot) {
+  const mode = getSystemPromptMode(tool);
+  const promptFileRel = getSystemPromptFile(tool);
+
+  if (mode === 'claude-code') {
+    const agentsFile = path.join(projectRoot, 'AGENTS.md');
+    if (await fs.pathExists(agentsFile)) {
+      const content = await fs.readFile(agentsFile, 'utf8');
+      if (hasBlock(content)) {
+        const stripped = stripBlock(content);
+        if (!stripped.trim()) {
+          await fs.remove(agentsFile);
+          console.log(`${tool}: removed AGENTS.md (was Sprintpilot-only)`);
+        } else {
+          await writeAtomic(agentsFile, stripped);
+          console.log(`${tool}: removed Sprintpilot section from AGENTS.md`);
+        }
+      }
+    }
+
+    const claudeFile = path.join(projectRoot, 'CLAUDE.md');
+    if (await fs.pathExists(claudeFile)) {
+      const content = await fs.readFile(claudeFile, 'utf8');
+      if (content.includes('@AGENTS.md')) {
+        const newContent = content.split(/\r?\n/).filter((l) => !l.includes('@AGENTS.md')).join('\n');
+        if (!newContent.trim()) {
+          await fs.remove(claudeFile);
+          console.log(`${tool}: removed CLAUDE.md (was Sprintpilot-only)`);
+        } else {
+          await writeAtomic(claudeFile, newContent.endsWith('\n') ? newContent : `${newContent}\n`);
+          console.log(`${tool}: removed @AGENTS.md from CLAUDE.md`);
+        }
+      }
+    }
+    return;
+  }
+
+  if (!promptFileRel) return;
+  const promptFile = path.join(projectRoot, promptFileRel);
+
+  if (mode === 'own-file') {
+    if (await fs.pathExists(promptFile)) {
+      await fs.remove(promptFile);
+      console.log(`${tool}: removed ${promptFileRel}`);
+    }
+    return;
+  }
+
+  if (mode === 'append') {
+    if (!(await fs.pathExists(promptFile))) return;
+    const content = await fs.readFile(promptFile, 'utf8');
+    if (!hasBlock(content)) return;
+    const stripped = stripBlock(content);
+    if (!stripped.trim()) {
+      await fs.remove(promptFile);
+      console.log(`${tool}: removed ${promptFileRel} (was Sprintpilot-only)`);
+    } else {
+      await writeAtomic(promptFile, stripped);
+      console.log(`${tool}: removed Sprintpilot section from ${promptFileRel}`);
+    }
+  }
+}
+
+async function cleanupWorktrees(projectRoot, force) {
+  const worktreesDir = path.join(projectRoot, '.worktrees');
+  if (!(await fs.pathExists(worktreesDir))) return;
+
+  console.log('');
+  console.log('Cleaning worktrees...');
+  const entries = await fs.readdir(worktreesDir, { withFileTypes: true });
+  let skipped = 0;
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const wt = path.join(worktreesDir, entry.name);
+
+    let dirty = false;
+    try {
+      const { stdout } = await execFileAsync('git', ['-C', wt, 'status', '--porcelain']);
+      dirty = stdout.trim().length > 0;
+    } catch {
+      dirty = false;
+    }
+
+    if (dirty && !force) {
+      console.log(`  SKIPPED: ${entry.name} (has uncommitted changes — use --force to override)`);
+      skipped++;
+      continue;
+    }
+
+    let removed = false;
+    try {
+      await execFileAsync('git', ['worktree', 'remove', '--force', wt]);
+      removed = true;
+    } catch {
+      // fallback
+    }
+    if (!removed) {
+      await fs.remove(wt);
+    }
+    console.log(`  Removed: ${entry.name}`);
+  }
+
+  try {
+    await execFileAsync('git', ['-C', projectRoot, 'worktree', 'prune']);
+  } catch {
+    // ignore
+  }
+
+  if (skipped > 0) {
+    console.log('');
+    console.log(pc.yellow(`WARNING: ${skipped} worktree(s) skipped due to uncommitted changes.`));
+    console.log(pc.yellow('Remove manually after saving your work.'));
+  }
+}
+
+async function runUninstall(options = {}) {
+  const projectRoot = process.env.BMAD_PROJECT_ROOT || process.cwd();
+  const force = !!options.force;
+
+  console.log('=== Sprintpilot Uninstaller ===');
+  console.log('');
+
+  const skills = await listSkills();
+  const skillsToRemove = Array.from(new Set([...skills, ...V1_SKILL_NAMES]));
+  let totalRemoved = 0;
+
+  for (const tool of ALL_TOOLS) {
+    const toolDir = getToolDir(tool);
+    const skillsDir = path.join(projectRoot, toolDir, 'skills');
+    if (!(await fs.pathExists(skillsDir))) continue;
+
+    let removed = 0;
+    for (const skillName of skillsToRemove) {
+      const target = path.join(skillsDir, skillName);
+      if (await fs.pathExists(target)) {
+        await fs.remove(target);
+        removed++;
+      }
+    }
+
+    if (removed > 0) {
+      console.log(`${tool}: removed ${removed} skills from ${toolDir}/skills/`);
+      totalRemoved += removed;
+    }
+
+    const backupDir = path.join(projectRoot, toolDir, '.addon-backups');
+    if (await fs.pathExists(backupDir)) {
+      await fs.remove(backupDir);
+      console.log(`${tool}: removed backup directory`);
+    }
+
+    await removeSystemPrompt(tool, projectRoot);
+  }
+
+  if (totalRemoved === 0) {
+    console.log('No Sprintpilot skills found in any tool directory.');
+  }
+
+  await cleanupWorktrees(projectRoot, force);
+
+  const targetAddonDir = path.join(projectRoot, '_Sprintpilot');
+  if (await fs.pathExists(targetAddonDir)) {
+    await fs.remove(targetAddonDir);
+    console.log('');
+    console.log('Removed _Sprintpilot/');
+  }
+
+  // Remove the v1 directory only when it carries a v1 signature (manifest
+  // name or v1-named skill dirs). An unrelated user directory that happens
+  // to be named `_bmad-addons/` must not be silently nuked.
+  const v1 = await detectV1Installation(projectRoot);
+  if (v1) {
+    await fs.remove(v1.v1Dir);
+    console.log(`Removed legacy ${V1_ADDON_DIR_NAME}/ (v1 artifact)`);
+  } else {
+    const legacyAddonDir = path.join(projectRoot, V1_ADDON_DIR_NAME);
+    if (await fs.pathExists(legacyAddonDir)) {
+      console.log(pc.yellow(`Skipped ${V1_ADDON_DIR_NAME}/ — no v1 signature found (not a Sprintpilot v1 artifact).`));
+    }
+  }
+
+  const lockFile = path.join(projectRoot, '.autopilot.lock');
+  if (await fs.pathExists(lockFile)) {
+    await fs.remove(lockFile);
+    console.log('');
+    console.log('Removed .autopilot.lock');
+  }
+
+  console.log('');
+  console.log(pc.green(`Sprintpilot uninstalled (${totalRemoved} skills removed). BMad Method skills are unaffected.`));
+}
+
+module.exports = { runUninstall };

package/lib/core/bmad-config.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('js-yaml');
+
+async function readYaml(filePath) {
+  let raw;
+  try {
+    raw = await fs.readFile(filePath, 'utf8');
+  } catch {
+    // Missing/unreadable: return null silently — callers treat this as "no
+    // config here", which is a legitimate state.
+    return null;
+  }
+  try {
+    return yaml.load(raw);
+  } catch (e) {
+    // Distinguish "file absent" from "file malformed" — a silent fallback in
+    // the malformed case caused the installer to use the default
+    // output_folder instead of the user's configured value.
+    // eslint-disable-next-line no-console
+    console.warn(`WARN: failed to parse YAML at ${filePath}: ${e.message}`);
+    return null;
+  }
+}
+
+function stripProjectRootPrefix(value) {
+  if (typeof value !== 'string') return value;
+  return value.replace(/^\{project-root\}\/?/, '');
+}
+
+async function verifyBmadInstalled(projectRoot) {
+  const manifest = path.join(projectRoot, '_bmad', '_config', 'manifest.yaml');
+  if (!(await fs.pathExists(manifest))) return null;
+  const data = await readYaml(manifest);
+  return data || {};
+}
+
+// BMad Method has used two manifest shapes:
+//   - flat:   { version: "6.3.0" }
+//   - nested: { bmad: { version: "6.2.0" } }
+// The shipping v6 installer writes the nested form; some older installs
+// and our own unit-test fixture use the flat form. Try nested first,
+// then fall back to flat so either layout resolves to a real version.
+function extractBmadVersion(data) {
+  if (!data) return null;
+  if (data.bmad && data.bmad.version) return data.bmad.version;
+  if (data.version) return data.version;
+  return null;
+}
+
+async function readBmadVersion(projectRoot) {
+  const data = await verifyBmadInstalled(projectRoot);
+  return extractBmadVersion(data);
+}
+
+async function readOutputFolder(projectRoot) {
+  const bmadDir = path.join(projectRoot, '_bmad');
+  if (!(await fs.pathExists(bmadDir))) return '_bmad-output';
+
+  const modulePriority = ['bmm', 'core', 'bmb', 'cis'];
+  const seen = new Set();
+  const ordered = [];
+
+  for (const mod of modulePriority) {
+    const candidate = path.join(bmadDir, mod, 'config.yaml');
+    ordered.push(candidate);
+    seen.add(candidate);
+  }
+
+  try {
+    const entries = await fs.readdir(bmadDir, { withFileTypes: true });
+    // Sort by name for deterministic precedence across filesystems; otherwise
+    // two users on different OSes could resolve different output_folder
+    // values when multiple non-priority module configs are present.
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const cfg = path.join(bmadDir, entry.name, 'config.yaml');
+      if (!seen.has(cfg)) {
+        ordered.push(cfg);
+        seen.add(cfg);
+      }
+    }
+  } catch {
+    // ignore
+  }
+
+  for (const cfgPath of ordered) {
+    if (!(await fs.pathExists(cfgPath))) continue;
+    const cfg = await readYaml(cfgPath);
+    if (cfg && typeof cfg.output_folder === 'string' && cfg.output_folder.trim()) {
+      return stripProjectRootPrefix(cfg.output_folder.trim());
+    }
+  }
+
+  return '_bmad-output';
+}
+
+async function readAddonManifestVersion(manifestPath) {
+  const data = await readYaml(manifestPath);
+  return (data && data.addon && data.addon.version) || null;
+}
+
+module.exports = {
+  readYaml,
+  verifyBmadInstalled,
+  readBmadVersion,
+  extractBmadVersion,
+  readOutputFolder,
+  readAddonManifestVersion,
+};

package/lib/core/file-ops.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const path = require('node:path');
+const fs = require('fs-extra');
+const { isTextFile, renderString } = require('../substitute');
+
+async function walkFiles(dir) {
+  const out = [];
+  async function walk(current) {
+    const entries = await fs.readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else if (entry.isFile()) {
+        out.push(full);
+      }
+    }
+  }
+  await walk(dir);
+  return out;
+}
+
+async function copyDirWithSubstitution(src, dest, ctx, { dryRun = false } = {}) {
+  if (dryRun) return;
+
+  await fs.ensureDir(dest);
+  const files = await walkFiles(src);
+
+  for (const file of files) {
+    const rel = path.relative(src, file);
+    const target = path.join(dest, rel);
+    await fs.ensureDir(path.dirname(target));
+
+    if (ctx && isTextFile(file)) {
+      const raw = await fs.readFile(file, 'utf8');
+      const rendered = renderString(raw, ctx);
+      await fs.writeFile(target, rendered, 'utf8');
+      try {
+        const mode = (await fs.stat(file)).mode;
+        await fs.chmod(target, mode);
+      } catch {
+        // chmod best-effort
+      }
+    } else {
+      await fs.copy(file, target, { overwrite: true, dereference: false, preserveTimestamps: false });
+    }
+  }
+}
+
+async function copyFileWithSubstitution(src, dest, ctx) {
+  await fs.ensureDir(path.dirname(dest));
+  if (ctx && isTextFile(src)) {
+    const raw = await fs.readFile(src, 'utf8');
+    const rendered = renderString(raw, ctx);
+    await fs.writeFile(dest, rendered, 'utf8');
+  } else {
+    await fs.copy(src, dest, { overwrite: true });
+  }
+}
+
+async function backupSkill(target, backupDir, timestamp) {
+  const name = path.basename(target);
+  const backup = path.join(backupDir, `${name}.${timestamp}`);
+  await fs.ensureDir(backupDir);
+  await fs.copy(target, backup);
+  return backup;
+}
+
+async function pruneBackups(backupDir, skillName, max = 3) {
+  if (!(await fs.pathExists(backupDir))) return;
+  const prefix = `${skillName}.`;
+  const entries = await fs.readdir(backupDir);
+  const matches = entries
+    .filter((e) => e.startsWith(prefix))
+    .sort();
+  if (matches.length <= max) return;
+  const toRemove = matches.slice(0, matches.length - max);
+  for (const name of toRemove) {
+    await fs.remove(path.join(backupDir, name));
+  }
+}
+
+module.exports = {
+  walkFiles,
+  copyDirWithSubstitution,
+  copyFileWithSubstitution,
+  backupSkill,
+  pruneBackups,
+};

package/lib/core/gitignore.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const path = require('node:path');
+const fs = require('fs-extra');
+
+async function resolveIgnoreFile(projectRoot) {
+  const gitignore = path.join(projectRoot, '.gitignore');
+  if (await fs.pathExists(gitignore)) return { path: gitignore, created: false };
+
+  const exclude = path.join(projectRoot, '.git', 'info', 'exclude');
+  if (await fs.pathExists(exclude)) {
+    try {
+      const stat = await fs.stat(exclude);
+      if (stat.size > 0) {
+        return { path: exclude, created: false, usedExclude: true };
+      }
+    } catch {
+      // fall through
+    }
+  }
+
+  return { path: gitignore, created: true };
+}
+
+async function addIgnoreEntry(ignoreFile, entry, { dryRun = false } = {}) {
+  const exists = await fs.pathExists(ignoreFile);
+  let content = '';
+  if (exists) {
+    content = await fs.readFile(ignoreFile, 'utf8');
+    const lines = content.split(/\r?\n/);
+    if (lines.some((l) => l.trim() === entry.trim())) {
+      return { added: false, created: false };
+    }
+  }
+
+  if (dryRun) {
+    return { added: true, created: !exists, dryRun: true };
+  }
+
+  if (!exists) {
+    await fs.ensureDir(path.dirname(ignoreFile));
+    await fs.writeFile(ignoreFile, `${entry}\n`, 'utf8');
+    return { added: true, created: true };
+  }
+
+  const needsNewline = content.length > 0 && !content.endsWith('\n');
+  await fs.appendFile(ignoreFile, `${needsNewline ? '\n' : ''}${entry}\n`, 'utf8');
+  return { added: true, created: false };
+}
+
+module.exports = {
+  resolveIgnoreFile,
+  addIgnoreEntry,
+};

package/lib/core/markers.js

@@ -0,0 +1,126 @@
+'use strict';
+
+const path = require('node:path');
+const crypto = require('node:crypto');
+const fs = require('fs-extra');
+
+const BEGIN = '<!-- BEGIN:sprintpilot-rules -->';
+const END = '<!-- END:sprintpilot-rules -->';
+
+// Legacy markers from bmad-autopilot-addon v1. We never write these, but
+// uninstall / v1 eviction must recognize and strip them.
+const LEGACY_BEGIN = '<!-- BEGIN:bmad-workflow-rules -->';
+const LEGACY_END = '<!-- END:bmad-workflow-rules -->';
+
+function escRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// Match BEGIN / END only at the start of a line (optionally preceded by
+// whitespace) so plain-text mentions of the marker string inside code
+// blocks or documentation don't get mistaken for real delimiters.
+const BEGIN_RE = new RegExp(`^[ \\t]*${escRegex(BEGIN)}[ \\t]*$`, 'm');
+const END_RE_GLOBAL = new RegExp(`^[ \\t]*${escRegex(END)}[ \\t]*$`, 'gm');
+const LEGACY_BEGIN_RE = new RegExp(`^[ \\t]*${escRegex(LEGACY_BEGIN)}[ \\t]*$`, 'm');
+const LEGACY_END_RE_GLOBAL = new RegExp(`^[ \\t]*${escRegex(LEGACY_END)}[ \\t]*$`, 'gm');
+
+// Find a BEGIN..END span where both markers sit on their own line. Uses the
+// FIRST line-anchored BEGIN and the FIRST line-anchored END after it.
+//
+// Earlier revisions used the LAST END to aggressively collapse nested /
+// duplicate marker pairs from buggy prior installs. That was unsafe: if a
+// document contained two independent, well-formed blocks with unrelated
+// user content between them, a single strip would delete everything from
+// the first BEGIN through the last END — including the user content.
+// First-END is safe: it strips exactly one block. Duplicate cleanup is
+// still handled because stripBlock iterates until no blocks remain.
+function findSpan(text, beginRe, endReGlobal) {
+  const beginMatch = text.match(beginRe);
+  if (!beginMatch) return null;
+  const start = beginMatch.index;
+
+  for (const m of text.matchAll(endReGlobal)) {
+    if (m.index >= start) return { start, end: m.index + m[0].length };
+  }
+  return null;
+}
+
+function findBlock(text) {
+  return findSpan(text, BEGIN_RE, END_RE_GLOBAL);
+}
+
+function findLegacyBlock(text) {
+  return findSpan(text, LEGACY_BEGIN_RE, LEGACY_END_RE_GLOBAL);
+}
+
+function stripSpan(text, block) {
+  const before = text.slice(0, block.start).replace(/\s+$/, '');
+  const after = text.slice(block.end).replace(/^\s+/, '');
+  if (before && after) return `${before}\n\n${after}\n`;
+  if (before) return `${before}\n`;
+  return after ? after : '';
+}
+
+// Strip ALL matching blocks — not just the first — so duplicate/nested
+// blocks from buggy prior installs collapse cleanly. Iterating with
+// first-END semantics preserves any unrelated content between blocks.
+function stripBlock(text) {
+  let result = text;
+  while (true) {
+    const block = findBlock(result);
+    if (!block) return result;
+    result = stripSpan(result, block);
+  }
+}
+
+function stripLegacyBlock(text) {
+  let result = text;
+  while (true) {
+    const block = findLegacyBlock(result);
+    if (!block) return result;
+    result = stripSpan(result, block);
+  }
+}
+
+function upsertBlock(existingText, block) {
+  const baseline = stripBlock(existingText || '').replace(/\s+$/, '');
+  const trimmedBlock = block.replace(/^\s+|\s+$/g, '');
+  if (!baseline) return `${trimmedBlock}\n`;
+  return `${baseline}\n\n${trimmedBlock}\n`;
+}
+
+function hasBlock(text) {
+  return findBlock(text) !== null;
+}
+
+function hasLegacyBlock(text) {
+  return findLegacyBlock(text) !== null;
+}
+
+async function writeAtomic(filePath, content) {
+  await fs.ensureDir(path.dirname(filePath));
+  const suffix = crypto.randomBytes(4).toString('hex');
+  const tmp = `${filePath}.${process.pid}.${Date.now()}.${suffix}.tmp`;
+  try {
+    await fs.writeFile(tmp, content, 'utf8');
+    await fs.move(tmp, filePath, { overwrite: true });
+  } catch (e) {
+    try { await fs.remove(tmp); } catch { /* best effort */ }
+    throw e;
+  }
+}
+
+module.exports = {
+  BEGIN,
+  END,
+  LEGACY_BEGIN,
+  LEGACY_END,
+  findBlock,
+  findLegacyBlock,
+  stripBlock,
+  stripLegacyBlock,
+  upsertBlock,
+  hasBlock,
+  hasLegacyBlock,
+  writeAtomic,
+};

package/lib/core/tool-registry.js

@@ -0,0 +1,73 @@
+'use strict';
+
+const TOOL_DIRS = {
+  'claude-code': '.claude',
+  'cursor': '.cursor',
+  'windsurf': '.windsurf',
+  'cline': '.cline',
+  'roo': '.roo',
+  'trae': '.trae',
+  'kiro': '.kiro',
+  'github-copilot': '.github/copilot',
+  'gemini-cli': '.gemini',
+};
+
+const SYSTEM_PROMPT_FILES = {
+  'claude-code': 'AGENTS.md',
+  'cursor': '.cursor/rules/bmad.md',
+  'windsurf': '.windsurfrules',
+  'cline': '.clinerules',
+  'roo': '.roo/rules/bmad.md',
+  'gemini-cli': 'GEMINI.md',
+  'github-copilot': '.github/copilot-instructions.md',
+  'kiro': '.kiro/rules/bmad.md',
+  'trae': '.trae/rules/bmad.md',
+};
+
+const SYSTEM_PROMPT_MODES = {
+  'claude-code': 'claude-code',
+  'cursor': 'own-file',
+  'roo': 'own-file',
+  'kiro': 'own-file',
+  'trae': 'own-file',
+  'windsurf': 'append',
+  'cline': 'append',
+  'gemini-cli': 'append',
+  'github-copilot': 'append',
+};
+
+const ALL_TOOLS = [
+  'claude-code',
+  'cursor',
+  'windsurf',
+  'gemini-cli',
+  'cline',
+  'roo',
+  'trae',
+  'kiro',
+  'github-copilot',
+];
+
+function getToolDir(tool) {
+  return TOOL_DIRS[tool] || '';
+}
+
+function getSystemPromptFile(tool) {
+  return SYSTEM_PROMPT_FILES[tool] || '';
+}
+
+function getSystemPromptMode(tool) {
+  return SYSTEM_PROMPT_MODES[tool] || '';
+}
+
+function isKnownTool(tool) {
+  return Object.prototype.hasOwnProperty.call(TOOL_DIRS, tool);
+}
+
+module.exports = {
+  ALL_TOOLS,
+  getToolDir,
+  getSystemPromptFile,
+  getSystemPromptMode,
+  isKnownTool,
+};