@oevery/rsp 1.0.0

package/dist/cli.mjs

@@ -0,0 +1,1137 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { resolve } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { defineCommand, runMain } from "citty";
+
+// src/commands/archive-index.ts
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { basename, dirname as dirname2, join as join3, relative as relative2 } from "path";
+
+// src/core/config.ts
+import { existsSync as existsSync2 } from "fs";
+import { readFile } from "fs/promises";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+import pc from "picocolors";
+
+// src/core/helpers.ts
+import { existsSync } from "fs";
+import { readdir, stat } from "fs/promises";
+import { join, relative } from "path";
+function parseYamlLines(lines) {
+  const result = {};
+  let currentKey = null;
+  let currentList = null;
+  function flushList() {
+    if (currentList !== null && currentKey !== null) {
+      result[currentKey] = currentList;
+      currentList = null;
+      currentKey = null;
+    }
+  }
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) {
+      continue;
+    }
+    const li = line.match(/^[ \t]+-[ \t]+([^\n]+)$/);
+    if (li && currentList !== null) {
+      currentList.push(li[1].trim());
+      continue;
+    }
+    flushList();
+    const kv = line.match(/^([\w-]+):[ \t]*([^\n]*)$/);
+    if (kv) {
+      currentKey = kv[1];
+      const val = kv[2].trim();
+      if (!val || val === "[]") {
+        currentList = [];
+      } else {
+        result[currentKey] = val;
+        currentKey = null;
+      }
+    }
+  }
+  flushList();
+  return result;
+}
+function parseFrontmatter(content) {
+  const m = content.match(/^---\n([\s\S]*?)\n(?:---|\.\.\.)\n/);
+  if (!m)
+    return null;
+  return parseYamlLines(m[1].split("\n"));
+}
+function countCheckboxes(content) {
+  const todo = (content.match(/\[ \]/g) || []).length;
+  const progress = (content.match(/\[\/\]/g) || []).length;
+  const done = (content.match(/\[x\]/g) || []).length;
+  const dropped = (content.match(/\[-\]/g) || []).length;
+  return { todo, progress, done, total: todo + progress + done + dropped };
+}
+async function walkMarkdownFiles(dir) {
+  const files = [];
+  try {
+    const items = await readdir(dir, { withFileTypes: true });
+    for (const item of items) {
+      const filePath = join(dir, item.name);
+      if (item.isDirectory())
+        files.push(...await walkMarkdownFiles(filePath));
+      else if (item.name.endsWith(".md"))
+        files.push(filePath);
+    }
+  } catch {
+  }
+  return files;
+}
+async function walkFiles(dir) {
+  const files = [];
+  try {
+    const items = await readdir(dir, { withFileTypes: true });
+    for (const item of items) {
+      const filePath = join(dir, item.name);
+      if (item.isDirectory())
+        files.push(...await walkFiles(filePath));
+      else
+        files.push(filePath);
+    }
+  } catch {
+  }
+  return files;
+}
+function featureNameFromPath(featuresDir, filePath) {
+  const rel = relative(featuresDir, filePath);
+  return rel.replace(/\.md$/, "");
+}
+function generateFeatureContent(name, summary = "") {
+  return `---
+status: draft
+priority: medium
+tags:
+---
+# Feature: ${name}
+
+## Spec
+- Summary: ${summary || "<one-line summary>"}
+- Requirements:
+  - [ ] <verifiable requirement>
+- Constraints:
+  -
+
+## Plan
+- [ ] Phase 1:
+  - [ ] <task>
+
+## Tests
+- [ ] <test file or scenario>
+
+## Notes (optional)
+- <design decisions discovered during implementation>
+
+## Blockers
+-
+`;
+}
+function detectDeltaSections(content) {
+  const match = content.match(/^## Spec\n([\s\S]*?)(?=\n## |\n---|\n\.\.\.)/m);
+  if (!match) {
+    const m2 = content.match(/^## Spec\n([\s\S]*)$/m);
+    if (!m2)
+      return { added: false, modified: false, removed: false };
+    const body2 = m2[1];
+    return {
+      added: /^###\s*ADDED/im.test(body2),
+      modified: /^###\s*MODIFIED/im.test(body2),
+      removed: /^###\s*REMOVED/im.test(body2)
+    };
+  }
+  const body = match[1];
+  return {
+    added: /^###\s*ADDED/im.test(body),
+    modified: /^###\s*MODIFIED/im.test(body),
+    removed: /^###\s*REMOVED/im.test(body)
+  };
+}
+function parseScenarios(content) {
+  const scenarios = [];
+  const regex = /^###\s*Scenario:\s*(.+)$/gim;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    const heading = match[1].trim();
+    const startPos = match.index + match[0].length;
+    const restContent = content.slice(startPos);
+    const nextSection = restContent.match(/^###/m);
+    const block = nextSection ? restContent.slice(0, nextSection.index) : restContent;
+    const steps = block.split("\n").map((s) => s.trim()).filter((s) => s.startsWith("-") && /GIVEN|WHEN|THEN|AND|BUT/i.test(s)).map((s) => s.replace(/^-\s*/, ""));
+    if (steps.length > 0)
+      scenarios.push({ heading, steps });
+  }
+  return scenarios;
+}
+function detectCycles(graph) {
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  function dfs(node, path) {
+    if (inStack.has(node)) {
+      const cycleStart = path.indexOf(node);
+      if (cycleStart !== -1)
+        cycles.push(path.slice(cycleStart).concat(node));
+      return;
+    }
+    if (visited.has(node))
+      return;
+    visited.add(node);
+    inStack.add(node);
+    path.push(node);
+    const neighbors = graph.get(node) || [];
+    for (const next of neighbors) {
+      if (graph.has(next))
+        dfs(next, path);
+    }
+    path.pop();
+    inStack.delete(node);
+  }
+  for (const node of graph.keys())
+    dfs(node, []);
+  return cycles;
+}
+
+// src/core/config.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var PKG_ROOT = join2(__dirname, "..");
+var RSP_DIR = ".rsp";
+var ACTIVE_DIR = join2(RSP_DIR, "active.d");
+var LOCK_PATH = join2(RSP_DIR, ".lock");
+var CONFIG_PATH = join2(RSP_DIR, "config.yaml");
+var VALID_STATUSES = ["draft", "ready", "in-progress", "blocked", "done"];
+var VALID_PRIORITIES = ["low", "medium", "high", "critical"];
+var DEFAULT_REQUIRED_SECTIONS = ["Spec", "Plan"];
+var _configCache = null;
+async function loadRspConfig() {
+  if (_configCache)
+    return _configCache;
+  if (!existsSync2(CONFIG_PATH)) {
+    _configCache = {};
+    return _configCache;
+  }
+  const raw = await readFile(CONFIG_PATH, "utf-8");
+  const parsed = parseYamlLines(raw.split("\n"));
+  _configCache = {
+    statuses: Array.isArray(parsed.statuses) ? parsed.statuses.map(String) : void 0,
+    priorities: Array.isArray(parsed.priorities) ? parsed.priorities.map(String) : void 0,
+    required_sections: Array.isArray(parsed.required_sections) ? parsed.required_sections.map(String) : void 0
+  };
+  return _configCache;
+}
+function resolveStatuses(config) {
+  return config.statuses && config.statuses.length > 0 ? config.statuses : [...VALID_STATUSES];
+}
+function resolvePriorities(config) {
+  return config.priorities && config.priorities.length > 0 ? config.priorities : [...VALID_PRIORITIES];
+}
+function resolveRequiredSections(config) {
+  return config.required_sections && config.required_sections.length > 0 ? config.required_sections : [...DEFAULT_REQUIRED_SECTIONS];
+}
+async function getVersion() {
+  const { version } = JSON.parse(await readFile(join2(PKG_ROOT, "package.json"), "utf-8"));
+  return version;
+}
+
+// src/core/lock.ts
+import { mkdir, readFile as readFile2, unlink, writeFile } from "fs/promises";
+async function withRspLock(operation, fn) {
+  await mkdir(RSP_DIR, { recursive: true });
+  try {
+    await writeFile(LOCK_PATH, `${process.pid}
+${operation}
+${(/* @__PURE__ */ new Date()).toISOString()}`, { flag: "wx" });
+  } catch (err) {
+    if (err.code === "EEXIST")
+      await handleStaleLock(operation);
+    else
+      throw err;
+  }
+  try {
+    return await fn();
+  } finally {
+    try {
+      await unlink(LOCK_PATH);
+    } catch {
+    }
+  }
+}
+async function handleStaleLock(operation) {
+  try {
+    const content = await readFile2(LOCK_PATH, "utf-8");
+    const lines = content.trim().split("\n");
+    const pid = Number(lines[0]);
+    if (pid && Number.isFinite(pid)) {
+      try {
+        process.kill(pid, 0);
+        const op = lines[1] || "unknown";
+        const ts = lines[2] || "unknown";
+        throw new Error(`RSP locked by pid ${pid} (${op}) since ${ts}`);
+      } catch (e) {
+        if (e instanceof Error && e.message.startsWith("RSP locked"))
+          throw e;
+        await unlink(LOCK_PATH);
+        await writeFile(LOCK_PATH, `${process.pid}
+${operation}
+${(/* @__PURE__ */ new Date()).toISOString()}`, { flag: "wx" });
+      }
+    } else {
+      await unlink(LOCK_PATH);
+      await writeFile(LOCK_PATH, `${process.pid}
+${operation}
+${(/* @__PURE__ */ new Date()).toISOString()}`, { flag: "wx" });
+    }
+  } catch (e) {
+    if (e instanceof Error && e.message.startsWith("RSP locked"))
+      throw e;
+    throw new Error(`RSP is locked. Remove ${LOCK_PATH} manually if no other process is running.`);
+  }
+}
+
+// src/commands/archive-index.ts
+async function buildArchiveIndex({ acquireLock = true } = {}) {
+  if (acquireLock)
+    return withRspLock("archive-index", async () => buildArchiveIndex({ acquireLock: false }));
+  const archiveDir = join3(RSP_DIR, "archive");
+  if (!existsSync3(archiveDir)) {
+    console.log(`  ${pc.dim("No archive directory.")}
+`);
+    return;
+  }
+  const archiveFiles = (await walkMarkdownFiles(archiveDir)).filter((fp) => basename(fp) !== "INDEX.md").sort();
+  if (archiveFiles.length === 0) {
+    console.log(`  ${pc.dim("No archived features.")}
+`);
+    return;
+  }
+  const lines = [];
+  lines.push("# Archive Index");
+  lines.push("");
+  lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`);
+  lines.push("");
+  lines.push("| Date | Feature | Summary |");
+  lines.push("|------|---------|---------|");
+  for (const fp of archiveFiles) {
+    const base = basename(fp);
+    const archiveRel = relative2(archiveDir, fp);
+    const archiveDirPart = dirname2(archiveRel);
+    const dateMatch = base.match(/^(\d{4}-\d{2}-\d{2})_(.+)\.md$/);
+    const date = dateMatch ? dateMatch[1] : "\u2014";
+    const baseName = dateMatch ? dateMatch[2] : base.replace(/\.md$/, "");
+    const featureName = archiveDirPart !== "." ? `${archiveDirPart}/${baseName}` : baseName;
+    let summary = "";
+    try {
+      const content = await readFile3(fp, "utf-8");
+      const fm = parseFrontmatter(content);
+      if (fm?.summary)
+        summary = String(fm.summary);
+      if (!summary) {
+        const specMatch = content.match(/^## Spec[\s\S]*?\n- Summary:[ \t]*([^\n]+)$/m);
+        if (specMatch)
+          summary = specMatch[1].trim();
+      }
+    } catch {
+    }
+    const summaryCell = summary ? summary.replace(/\|/g, "\\|") : "\u2014";
+    lines.push(`| ${date} | ${featureName} | ${summaryCell} |`);
+  }
+  lines.push("");
+  lines.push("_Auto-generated by `rsp archive-index`._");
+  const indexPath = join3(archiveDir, "INDEX.md");
+  await writeFile2(indexPath, lines.join("\n"));
+  console.log(`  ${pc.green("INDEX.md updated:")} ${archiveFiles.length} archived feature(s).
+`);
+}
+
+// src/commands/check.ts
+import { existsSync as existsSync4 } from "fs";
+import { readFile as readFile4 } from "fs/promises";
+import { join as join4, relative as relative3 } from "path";
+async function runCheck() {
+  const featuresDir = join4(RSP_DIR, "features");
+  const config = await loadRspConfig();
+  const validStatuses = resolveStatuses(config);
+  const validPriorities = resolvePriorities(config);
+  const requiredSections = resolveRequiredSections(config);
+  let errors = 0;
+  let warnings = 0;
+  console.log();
+  console.log(`  ${pc.bold("RSP check")}`);
+  console.log();
+  if (existsSync4(ACTIVE_DIR)) {
+    const entries = await walkFiles(ACTIVE_DIR);
+    for (const entryPath of entries) {
+      const entryContent = relative3(ACTIVE_DIR, entryPath);
+      const markerContent = (await readFile4(entryPath, "utf-8")).trim();
+      if (markerContent) {
+        console.log(`  ${pc.yellow("\u26A0")} active.d/${entryContent} should be an empty marker file; path is the source of truth`);
+        warnings++;
+      }
+      const fp = join4(featuresDir, `${entryContent}.md`);
+      if (!existsSync4(fp)) {
+        console.log(`  ${pc.red("\u2717")} active.d/${entryContent} points to "${entryContent}" but features/${entryContent}.md not found`);
+        errors++;
+      }
+    }
+  }
+  const featureFiles = existsSync4(featuresDir) ? await walkMarkdownFiles(featuresDir) : [];
+  if (featureFiles.length === 0) {
+    console.log(`  ${pc.dim("No feature files to check.")}
+`);
+    return;
+  }
+  const allDeps = /* @__PURE__ */ new Map();
+  for (const fp of featureFiles) {
+    const name = featureNameFromPath(featuresDir, fp);
+    let content;
+    try {
+      content = await readFile4(fp, "utf-8");
+    } catch {
+      console.log(`  ${pc.red("\u2717")} ${name} \u2014 unable to read file`);
+      errors++;
+      continue;
+    }
+    const fm = parseFrontmatter(content);
+    if (!fm) {
+      console.log(`  ${pc.red("\u2717")} ${name} \u2014 missing YAML frontmatter`);
+      errors++;
+    }
+    for (const section of requiredSections) {
+      if (!new RegExp(`^## ${section}$`, "m").test(content)) {
+        console.log(`  ${pc.red("\u2717")} ${name} \u2014 missing "## ${section}" section`);
+        errors++;
+      }
+    }
+    if (fm) {
+      if (!("status" in fm)) {
+        console.log(`  ${pc.red("\u2717")} ${name} \u2014 missing frontmatter field: status`);
+        errors++;
+      } else if (!validStatuses.includes(String(fm.status))) {
+        console.log(`  ${pc.red("\u2717")} ${name} \u2014 invalid status "${fm.status}" (valid: ${validStatuses.join(", ")})`);
+        errors++;
+      }
+      if (!("priority" in fm)) {
+        console.log(`  ${pc.red("\u2717")} ${name} \u2014 missing frontmatter field: priority`);
+        errors++;
+      } else if (!validPriorities.includes(String(fm.priority))) {
+        console.log(`  ${pc.red("\u2717")} ${name} \u2014 invalid priority "${fm.priority}" (valid: ${validPriorities.join(", ")})`);
+        errors++;
+      }
+    }
+    const headingMatch = content.match(/^# Feature:[ \t]*([^\n]+)$/m);
+    if (headingMatch) {
+      const heading = headingMatch[1].trim();
+      if (heading !== name) {
+        console.log(`  ${pc.red("\u2717")} ${name} \u2014 # Feature: heading "${heading}" differs from feature name`);
+        errors++;
+      }
+    } else {
+      console.log(`  ${pc.red("\u2717")} ${name} \u2014 missing "# Feature:" heading`);
+      errors++;
+    }
+    const deltas = detectDeltaSections(content);
+    if (deltas.added || deltas.modified || deltas.removed) {
+      const parts = [];
+      if (deltas.added)
+        parts.push("ADDED");
+      if (deltas.modified)
+        parts.push("MODIFIED");
+      if (deltas.removed)
+        parts.push("REMOVED");
+      console.log(`  ${pc.dim("\u2139")} ${name} \u2014 delta markers found: ${parts.join(", ")}`);
+    }
+    const scenarios = parseScenarios(content);
+    if (scenarios.length > 0) {
+      const scenarioIssues = [];
+      for (const s of scenarios) {
+        const hasGiven = s.steps.some((st) => /^GIVEN/i.test(st));
+        const hasWhen = s.steps.some((st) => /^WHEN/i.test(st));
+        const hasThen = s.steps.some((st) => /^THEN/i.test(st));
+        const missing = [];
+        if (!hasGiven)
+          missing.push("GIVEN");
+        if (!hasWhen)
+          missing.push("WHEN");
+        if (!hasThen)
+          missing.push("THEN");
+        if (missing.length > 0)
+          scenarioIssues.push(`"${s.heading}" missing ${missing.join("/")}`);
+      }
+      if (scenarioIssues.length > 0) {
+        console.log(`  ${pc.yellow("\u26A0")} ${name} \u2014 scenario format issues:`);
+        for (const issue of scenarioIssues)
+          console.log(`      ${pc.dim(issue)}`);
+        warnings++;
+      }
+    }
+    if (fm && fm["depends-on"]) {
+      const deps = Array.isArray(fm["depends-on"]) ? fm["depends-on"] : [fm["depends-on"]];
+      const seen = /* @__PURE__ */ new Set();
+      for (const dep of deps) {
+        if (dep === name) {
+          console.log(`  ${pc.red("\u2717")} ${name} \u2014 depends on itself`);
+          errors++;
+          continue;
+        }
+        if (seen.has(dep)) {
+          console.log(`  ${pc.red("\u2717")} ${name} \u2014 duplicate dependency "${dep}"`);
+          errors++;
+          continue;
+        }
+        seen.add(dep);
+        allDeps.set(name, [...allDeps.get(name) || [], dep]);
+        const depFp = join4(featuresDir, `${dep}.md`);
+        if (!existsSync4(depFp)) {
+          console.log(`  ${pc.red("\u2717")} ${name} \u2014 depends on "${dep}" but features/${dep}.md not found`);
+          errors++;
+        }
+      }
+    }
+  }
+  const cycles = detectCycles(allDeps);
+  for (const cycle of cycles) {
+    console.log(`  ${pc.red("\u2717")} circular dependency: ${cycle.join(" \u2192 ")}`);
+    errors++;
+  }
+  console.log();
+  if (errors === 0 && warnings === 0)
+    console.log(`  ${pc.green("\u2713")} All ${featureFiles.length} feature file(s) valid.
+`);
+  else
+    console.log(`  ${pc.red(String(errors))} error(s), ${pc.yellow(String(warnings))} warning(s) in ${featureFiles.length} feature file(s).
+`);
+  return errors;
+}
+
+// src/commands/close-feature.ts
+import { existsSync as existsSync5 } from "fs";
+import { appendFile, mkdir as mkdir2, readdir as readdir2, readFile as readFile5, rename, rmdir, unlink as unlink2, writeFile as writeFile3 } from "fs/promises";
+import { basename as basename2, dirname as dirname3, join as join5 } from "path";
+async function closeFeature(name) {
+  return withRspLock("close-feature", async () => {
+    if (!name) {
+      console.error(`  ${pc.red("Usage:")} rsp close <name>`);
+      process.exit(1);
+    }
+    if (/^[a-z0-9-]+(?:\/[a-z0-9-]+)*$/.test(name) === false) {
+      console.error(`  ${pc.red("Error:")} feature name must be kebab-case with optional subdirectory (lowercase, digits, hyphens, slashes)`);
+      process.exit(1);
+    }
+    const srcPath = join5(RSP_DIR, "features", `${name}.md`);
+    if (!existsSync5(srcPath)) {
+      console.error(`  ${pc.red("Feature not found:")} .rsp/features/${name}.md`);
+      process.exit(1);
+    }
+    const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const dir = dirname3(name);
+    const base = basename2(name);
+    const archiveSubdir = dir !== "." ? join5(RSP_DIR, "archive", dir) : join5(RSP_DIR, "archive");
+    const archiveName = `${date}_${base}.md`;
+    await mkdir2(archiveSubdir, { recursive: true });
+    await rename(srcPath, join5(archiveSubdir, archiveName));
+    let activeCleared = false;
+    const activeEntry = join5(ACTIVE_DIR, name);
+    if (existsSync5(activeEntry)) {
+      await unlink2(activeEntry);
+      let parent = dirname3(activeEntry);
+      while (parent !== ACTIVE_DIR) {
+        try {
+          const remaining = await readdir2(parent);
+          if (remaining.length === 0)
+            await rmdir(parent);
+          else
+            break;
+        } catch {
+          break;
+        }
+        parent = dirname3(parent);
+      }
+      activeCleared = true;
+    }
+    const clearedMsg = activeCleared ? `  ${pc.dim("active.d cleared")}
+` : "";
+    console.log(`  ${pc.green("Archived:")} ${archiveName}
+${clearedMsg}`);
+    await buildArchiveIndex({ acquireLock: false });
+    await runCheckIfHasDependents(name);
+    await updateSpecIndex(name, date);
+    if (existsSync5(".git")) {
+      const archiveRelPath = dir !== "." ? join5(dir, archiveName) : archiveName;
+      console.log(`  ${pc.cyan("Git workflow:")}
+`);
+      console.log(`    git add .rsp/archive/${archiveRelPath}`);
+      console.log(`    git commit -m "feat: complete ${name}"`);
+      console.log();
+    }
+  });
+}
+async function runCheckIfHasDependents(name) {
+  try {
+    const featuresDir = join5(RSP_DIR, "features");
+    const allFeatureFiles = await walkMarkdownFiles(featuresDir);
+    let hasDependents = false;
+    for (const fp of allFeatureFiles) {
+      const content = await readFile5(fp, "utf-8");
+      const fm = parseFrontmatter(content);
+      if (!fm || !fm["depends-on"])
+        continue;
+      const deps = Array.isArray(fm["depends-on"]) ? fm["depends-on"] : [fm["depends-on"]];
+      if (deps.includes(name)) {
+        hasDependents = true;
+        break;
+      }
+    }
+    if (hasDependents)
+      await runCheck();
+  } catch {
+    console.warn(`  ${pc.dim("\u26A0 could not verify dependents for")} "${name}"`);
+  }
+}
+async function updateSpecIndex(name, date) {
+  const specIndexPath = join5(RSP_DIR, "spec", "INDEX.md");
+  const archiveDir = join5(RSP_DIR, "archive");
+  const escaped = name.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+  const lineRe = new RegExp(`^\\| \\d{4}-\\d{2}-\\d{2} \\| ${escaped} \\|`, "m");
+  const archiveFile = await (async () => {
+    try {
+      const entries = await walkMarkdownFiles(archiveDir);
+      return entries.find((fp) => basename2(fp).startsWith(`${date}_`) && basename2(fp).endsWith(".md"));
+    } catch {
+      return null;
+    }
+  })();
+  let summary = "\u2014";
+  if (archiveFile) {
+    try {
+      const content = await readFile5(join5(archiveDir, archiveFile), "utf-8");
+      const m = content.match(/^## Spec[\s\S]*?\n- Summary:[ \t]*([^\n]+)$/m);
+      if (m)
+        summary = m[1].trim();
+    } catch {
+    }
+  }
+  const line = `| ${date} | ${name} | ${summary} |
+`;
+  try {
+    let existing = "";
+    if (existsSync5(specIndexPath))
+      existing = await readFile5(specIndexPath, "utf-8");
+    if (lineRe.test(existing))
+      return;
+    if (!existing.includes("| Date | Feature | Summary |")) {
+      await writeFile3(specIndexPath, `# Spec Index
+
+| Date | Feature | Summary |
+|------|---------|---------|
+${line}
+`);
+    } else {
+      await appendFile(specIndexPath, line);
+    }
+  } catch {
+  }
+}
+
+// src/commands/deps.ts
+import { existsSync as existsSync6 } from "fs";
+import { readFile as readFile6 } from "fs/promises";
+import { join as join6 } from "path";
+async function showDependencies(mermaid = false) {
+  const featuresDir = join6(RSP_DIR, "features");
+  const featureFiles = existsSync6(featuresDir) ? await walkMarkdownFiles(featuresDir) : [];
+  console.log();
+  console.log(`  ${pc.bold("RSP dependencies")}`);
+  console.log();
+  if (featureFiles.length === 0) {
+    console.log(`  ${pc.dim("No features found.")}
+`);
+    return;
+  }
+  const records = [];
+  const dependents = /* @__PURE__ */ new Map();
+  for (const fp of featureFiles) {
+    const name = featureNameFromPath(featuresDir, fp);
+    let content;
+    try {
+      content = await readFile6(fp, "utf-8");
+    } catch {
+      continue;
+    }
+    const fm = parseFrontmatter(content);
+    const depsRaw = fm?.["depends-on"] ? Array.isArray(fm["depends-on"]) ? fm["depends-on"] : [fm["depends-on"]] : [];
+    const deps = depsRaw.filter(Boolean);
+    records.push({ name, deps });
+    for (const dep of deps) {
+      const list = dependents.get(dep) || [];
+      list.push(name);
+      dependents.set(dep, list);
+    }
+  }
+  if (mermaid) {
+    console.log("```mermaid");
+    console.log("graph LR");
+    const safeId = (s) => s.replace(/\//g, "__slash__").replace(/\W/g, "_");
+    for (const { name } of records) {
+      const id = safeId(name);
+      const label = name.replace(/"/g, "#quot;");
+      console.log(`    ${id}["${label}"]`);
+    }
+    for (const { name, deps } of records) {
+      const fromId = safeId(name);
+      for (const dep of deps) {
+        const toId = safeId(dep);
+        console.log(`    ${fromId} --> ${toId}`);
+      }
+    }
+    console.log("```");
+    console.log();
+    return;
+  }
+  console.log(`  ${"Feature".padEnd(28)} ${"Depends On".padEnd(28)} Dependents`);
+  console.log(`  ${"\u2500".repeat(28)} ${"\u2500".repeat(28)} \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+  for (const { name, deps } of records.sort((a, b) => a.name.localeCompare(b.name))) {
+    const depText = deps.length > 0 ? deps.join(", ") : "\u2014";
+    const dependentText = (dependents.get(name) || []).length > 0 ? pc.dim((dependents.get(name) || []).join(", ")) : "\u2014";
+    console.log(`  ${name.padEnd(28)} ${depText.padEnd(28)} ${dependentText}`);
+  }
+  console.log();
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync7 } from "fs";
+import { cp, mkdir as mkdir3, readFile as readFile7, writeFile as writeFile4 } from "fs/promises";
+import { basename as basename3, join as join7 } from "path";
+async function detectProjectName() {
+  try {
+    if (existsSync7("package.json")) {
+      const raw = await readFile7("package.json", "utf-8");
+      const pkg = JSON.parse(raw);
+      if (pkg.name && pkg.name !== "")
+        return pkg.name;
+    }
+  } catch {
+  }
+  return basename3(process.cwd());
+}
+var AGENTS_BODY = `## Collaboration Mode
+This project uses **RSP** (Rules, Spec, Plan) \u2014 see \`.rsp/rules/rsp-rules.md\` for the full workflow definition.
+
+Key conventions:
+- \`.rsp/rules/\` \u2014 technical constraints and coding conventions
+- \`.rsp/features/<name>.md\` \u2014 feature definitions (spec + plan + tests)
+- \`.rsp/active.d/\` \u2014 currently active features (path = feature name)
+- \`.rsp/archive/\` \u2014 completed features
+
+## Workflow
+- Run \`rsp status\` to see current project state
+- Run \`rsp new <name>\` to start a new feature
+- Run \`rsp close <name>\` to archive a completed feature`;
+var CONFIG_TEMPLATE = `# RSP project configuration
+# Uncomment any section below to override defaults.
+#
+# Built-in defaults:
+#   statuses:            draft, ready, in-progress, blocked, done
+#   priorities:          low, medium, high, critical
+#   required_sections:   Spec, Plan
+#
+# statuses:
+#   - draft
+#   - ready
+#   - in-progress
+#   - blocked
+#   - done
+#
+# priorities:
+#   - low
+#   - medium
+#   - high
+#   - critical
+#
+# required_sections:
+#   - Spec
+#   - Plan
+`;
+async function initProject() {
+  const isNew = !existsSync7(RSP_DIR);
+  return withRspLock("init", async () => {
+    const dirs = [
+      join7(RSP_DIR, "rules"),
+      join7(RSP_DIR, "spec"),
+      join7(RSP_DIR, "features"),
+      join7(RSP_DIR, "archive")
+    ];
+    let created = false;
+    for (const d of dirs)
+      await mkdir3(d, { recursive: true });
+    const rulesDest = join7(RSP_DIR, "rules", "rsp-rules.md");
+    if (!existsSync7(rulesDest)) {
+      await cp(join7(PKG_ROOT, "rules", "rsp-rules.md"), rulesDest);
+      created = true;
+    }
+    const configPath = join7(RSP_DIR, "config.yaml");
+    if (!existsSync7(configPath)) {
+      await writeFile4(configPath, CONFIG_TEMPLATE);
+      created = true;
+    }
+    const specIndexPath = join7(RSP_DIR, "spec", "INDEX.md");
+    if (!existsSync7(specIndexPath)) {
+      await writeFile4(specIndexPath, "# Spec Index\n\n_Extracted from archived features._\n");
+      created = true;
+    }
+    const gitignorePath = join7(RSP_DIR, ".gitignore");
+    if (!existsSync7(gitignorePath)) {
+      await writeFile4(gitignorePath, "# Transient files that should not be committed\n.lock\n");
+      created = true;
+    }
+    const agentsPath = "AGENTS.md";
+    const projectName = await detectProjectName();
+    if (existsSync7(agentsPath)) {
+      const existing = await readFile7(agentsPath, "utf-8");
+      const rspRe = /\bRSP\b/;
+      if (!rspRe.test(existing)) {
+        const h2Match = existing.match(/^## /m);
+        if (h2Match) {
+          const before = existing.slice(0, h2Match.index);
+          const after = existing.slice(h2Match.index);
+          await writeFile4(agentsPath, `${before}${AGENTS_BODY}
+
+---
+
+${after}`);
+        } else {
+          await writeFile4(agentsPath, `${existing}
+
+${AGENTS_BODY}
+`);
+        }
+        created = true;
+      }
+    } else {
+      const title = projectName.startsWith("@") ? projectName.split("/")[1] || projectName : projectName;
+      await writeFile4(agentsPath, `# ${title}
+
+${AGENTS_BODY}
+`);
+      created = true;
+    }
+    if (isNew) {
+      console.log(`
+  ${pc.green("RSP scaffolded.")}
+`);
+      console.log(`  Created: .rsp/rules/
+           .rsp/spec/
+           .rsp/features/
+           .rsp/archive/
+           .rsp/.gitignore
+           .rsp/config.yaml
+           AGENTS.md
+`);
+      console.log(`  ${pc.cyan("Next:")} rsp new <name>
+  ${pc.dim("Also:")} rsp status  rsp deps
+`);
+    } else if (created) {
+      console.log(`
+  ${pc.green("RSP initialized.")}
+`);
+    } else {
+      console.log(`
+  ${pc.yellow("RSP already initialized \u2014 nothing changed.")}
+`);
+    }
+  });
+}
+
+// src/commands/new-feature.ts
+import { existsSync as existsSync8 } from "fs";
+import { mkdir as mkdir4, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname4, join as join8 } from "path";
+async function newFeature(name, summary = "") {
+  return withRspLock("new-feature", async () => {
+    if (!name) {
+      console.error(`  ${pc.red("Usage:")} rsp new <name> [summary]`);
+      process.exit(1);
+    }
+    if (/^[a-z0-9-]+(?:\/[a-z0-9-]+)*$/.test(name) === false) {
+      console.error(`  ${pc.red("Error:")} feature name must be kebab-case with optional subdirectory (lowercase, digits, hyphens, slashes)`);
+      process.exit(1);
+    }
+    const featurePath = join8(RSP_DIR, "features", `${name}.md`);
+    await mkdir4(dirname4(featurePath), { recursive: true });
+    const existed = existsSync8(featurePath);
+    if (!existed) {
+      const content = generateFeatureContent(name, summary);
+      await writeFile5(featurePath, content);
+    }
+    await mkdir4(ACTIVE_DIR, { recursive: true });
+    const activeEntry = join8(ACTIVE_DIR, name);
+    await mkdir4(dirname4(activeEntry), { recursive: true });
+    await writeFile5(activeEntry, "");
+    if (!existed) {
+      const archiveDir = join8(RSP_DIR, "archive");
+      const archiveIndex = join8(archiveDir, "INDEX.md");
+      if (existsSync8(archiveIndex))
+        await buildArchiveIndex({ acquireLock: false });
+    }
+    const label = existed ? "Using" : pc.green("Created");
+    console.log(`  ${label}: ${featurePath}
+  ${pc.dim("active.d")} \u2192 ${name}
+`);
+  });
+}
+
+// src/commands/status.ts
+import { existsSync as existsSync9 } from "fs";
+import { readFile as readFile8, stat as stat2 } from "fs/promises";
+import { join as join9, relative as relative4 } from "path";
+var COL_FEATURE = 30;
+var COL_STATUS = 16;
+var COL_AGE = 7;
+var COL_PROGRESS = 10;
+async function showStatus() {
+  const featuresDir = join9(RSP_DIR, "features");
+  const activeSet = /* @__PURE__ */ new Set();
+  if (existsSync9(ACTIVE_DIR)) {
+    try {
+      const entries = await walkFiles(ACTIVE_DIR);
+      for (const entryPath of entries) {
+        const name = relative4(ACTIVE_DIR, entryPath);
+        activeSet.add(name);
+      }
+    } catch {
+    }
+  }
+  const featureFiles = existsSync9(featuresDir) ? await walkMarkdownFiles(featuresDir) : [];
+  const featureMap = {};
+  for (const fp of featureFiles) {
+    const name = featureNameFromPath(featuresDir, fp);
+    featureMap[name] = fp;
+  }
+  console.log();
+  console.log(`  ${pc.bold("RSP status")}`);
+  console.log();
+  if (activeSet.size > 0) {
+    console.log(`  ${pc.cyan("Active:")} ${[...activeSet].join(", ")}`);
+    console.log();
+  } else {
+    console.log(`  ${pc.dim("No active feature.")} Run: rsp new <name>`);
+    console.log();
+  }
+  const allNames = [.../* @__PURE__ */ new Set([...Object.keys(featureMap), ...activeSet])].sort();
+  if (allNames.length === 0) {
+    console.log(`  ${pc.dim("No features found.")} Run: rsp new <name>
+`);
+    return;
+  }
+  const records = [];
+  for (const name of allNames) {
+    const fp = featureMap[name];
+    let status = "\u2014";
+    let progress = "\u2014";
+    let depends = "\u2014";
+    let age = "\u2014";
+    const isActive = activeSet.has(name);
+    let isBlocked = false;
+    if (fp) {
+      try {
+        const content = await readFile8(fp, "utf-8");
+        const fm = parseFrontmatter(content);
+        status = fm?.status || "\u2014";
+        isBlocked = status === "blocked";
+        if (fm?.["depends-on"])
+          depends = Array.isArray(fm["depends-on"]) ? fm["depends-on"].join(", ") : String(fm["depends-on"]);
+        const cb = countCheckboxes(content);
+        progress = `${cb.done}/${cb.total}`;
+        const s = await stat2(fp);
+        const created = s.birthtime || s.mtime;
+        const diffMs = Date.now() - created.getTime();
+        age = String(Math.floor(diffMs / (1e3 * 60 * 60 * 24)));
+      } catch {
+      }
+    } else {
+      status = "(missing)";
+    }
+    records.push({ name, status, progress, age, depends, isActive, isBlocked });
+  }
+  const pad = (s, w) => s.padEnd(w);
+  console.log(`  ${pad("Feature", COL_FEATURE)} ${pad("Status", COL_STATUS)} ${pad("Age(d)", COL_AGE)} ${pad("Progress", COL_PROGRESS)} Depends On`);
+  console.log(`  ${"\u2500".repeat(COL_FEATURE)} ${"\u2500".repeat(COL_STATUS)} ${"\u2500".repeat(COL_AGE)} ${"\u2500".repeat(COL_PROGRESS)} ${"\u2500".repeat(30)}`);
+  let blockedCount = 0;
+  for (const r of records) {
+    const marker = r.isActive ? pc.cyan("*") : " ";
+    const namePadded = r.name.padEnd(COL_FEATURE - 1);
+    const statusPadded = String(r.status).padEnd(COL_STATUS);
+    const agePadded = r.age.padEnd(COL_AGE);
+    const progressPadded = r.progress.padEnd(COL_PROGRESS);
+    const nameDisplay = r.isBlocked ? pc.yellow(namePadded) : namePadded;
+    const statusDisplay = r.isBlocked ? pc.yellow(statusPadded) : statusPadded;
+    const ageDisplay = r.isActive ? pc.cyan(agePadded) : agePadded;
+    console.log(`  ${marker}${nameDisplay} ${statusDisplay} ${ageDisplay} ${progressPadded} ${r.depends}`);
+    if (r.isBlocked)
+      blockedCount++;
+  }
+  console.log();
+  const total = records.length;
+  const doneCount = records.filter((r) => r.status === "done").length;
+  console.log(`  ${pc.bold("Summary:")} ${total} feature(s), ${activeSet.size} active, ${doneCount} done, ${pc.yellow(String(blockedCount))} blocked`);
+  console.log();
+  await showArchiveTrend();
+  if (blockedCount > 0) {
+    const blocked = records.filter((r) => r.isBlocked);
+    console.log(`  ${pc.yellow("Blocked:")} ${blocked.map((r) => r.name).join(", ")}`);
+    console.log();
+  }
+}
+async function showArchiveTrend() {
+  const archiveDir = join9(RSP_DIR, "archive");
+  const indexPath = join9(archiveDir, "INDEX.md");
+  if (!existsSync9(indexPath))
+    return;
+  try {
+    const content = await readFile8(indexPath, "utf-8");
+    const dateRe = /^\| (\d{4}-\d{2})-\d{2} \|/gm;
+    const counts = {};
+    let match;
+    while ((match = dateRe.exec(content)) !== null) {
+      const month = match[1];
+      counts[month] = (counts[month] || 0) + 1;
+    }
+    const months = Object.keys(counts).sort();
+    if (months.length === 0)
+      return;
+    console.log(`  ${pc.bold("Archive trend:")}`);
+    const bar = months.map((m) => {
+      const n = counts[m];
+      return pc.dim(`${m} ${"\u2588".repeat(Math.min(n, 20))} ${n}`);
+    }).join("\n  ");
+    console.log(`  ${bar}`);
+    console.log();
+  } catch {
+  }
+}
+
+// src/cli.ts
+var initCommand = defineCommand({
+  meta: {
+    name: "init",
+    description: "Scaffold .rsp/ + AGENTS.md in current project"
+  },
+  async run() {
+    await initProject();
+  }
+});
+var newFeatureCommand = defineCommand({
+  meta: {
+    name: "new",
+    description: "Create .rsp/features/<name>.md [summary]"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Feature name",
+      required: true
+    }
+  },
+  async run({ args }) {
+    const summary = Array.isArray(args._) && args._.length > 1 ? args._.slice(1).join(" ") : "";
+    await newFeature(args.name, summary);
+  }
+});
+var closeFeatureCommand = defineCommand({
+  meta: {
+    name: "close",
+    description: "Archive to .rsp/archive/"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Feature name",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await closeFeature(args.name);
+  }
+});
+var statusCommand = defineCommand({
+  meta: {
+    name: "status",
+    description: "Show project status summary"
+  },
+  async run() {
+    await showStatus();
+  }
+});
+var checkCommand = defineCommand({
+  meta: {
+    name: "check",
+    description: "Validate features (frontmatter, sections, deps, deltas, scenarios)"
+  },
+  async run() {
+    const errors = await runCheck();
+    if (errors > 0)
+      process.exit(1);
+  }
+});
+var depsCommand = defineCommand({
+  meta: {
+    name: "deps",
+    description: "Show dependency summary (--mermaid for graph)"
+  },
+  args: {
+    mermaid: {
+      type: "boolean",
+      description: "Output as Mermaid.js graph",
+      default: false
+    }
+  },
+  async run({ args }) {
+    await showDependencies(Boolean(args.mermaid));
+  }
+});
+var archiveIndexCommand = defineCommand({
+  meta: {
+    name: "archive-index",
+    description: "Regenerate archive INDEX.md"
+  },
+  async run() {
+    await buildArchiveIndex();
+  }
+});
+async function runCli(rawArgs = process.argv.slice(2)) {
+  const version = await getVersion();
+  const main = defineCommand({
+    meta: {
+      name: "rsp",
+      version,
+      description: "RSP (Rules, Spec, Plan) workflow for AI-assisted development"
+    },
+    subCommands: {
+      "init": initCommand,
+      "new": newFeatureCommand,
+      "close": closeFeatureCommand,
+      "status": statusCommand,
+      "check": checkCommand,
+      "deps": depsCommand,
+      "archive-index": archiveIndexCommand
+    }
+  });
+  await runMain(main, { rawArgs });
+}
+var isMain = process.argv[1] && fileURLToPath2(import.meta.url) === resolve(process.argv[1]);
+if (isMain) {
+  runCli().catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`  Error: ${message}`);
+    process.exit(1);
+  });
+}
+export {
+  runCli
+};