@riotprompt/riotplan 0.0.4 → 1.0.2-dev.0

package/dist/index.js

@@ -1,58 +1,1574 @@
-const PLAN_CONVENTIONS = {
-  /** Meta-prompt file patterns */
-  metaPromptPatterns: [
-    "{code}-prompt.md",
-    "prompt-of-prompts.md",
-    "{code}.md"
-  ],
-  /** Step file pattern */
-  stepPattern: /^(\d{2})-(.+)\.md$/,
-  /** Standard files */
-  standardFiles: {
-    summary: "SUMMARY.md",
-    status: "STATUS.md",
-    executionPlan: "EXECUTION_PLAN.md",
-    readme: "README.md"
-  },
-  /** Standard directories */
-  standardDirs: {
-    plan: "plan",
-    analysis: "analysis",
-    architecture: "architecture",
-    implementation: "implementation",
-    testing: "testing"
-  },
-  /** Status emoji mapping */
-  statusEmoji: {
+import { P as PLAN_CONVENTIONS, l as loadPlan, r as renderToHtml, a as renderToJson, b as renderToMarkdown } from "./cli-BAr1IsMF.js";
+import { B, C, F, H, M, c, R, S, d, e, f, g, h, i, j, k, m, n, o, p, q, s, t, u, v, w, x, y, z, A, D, E, G, I, J, K, L, N, O, Q, T, U, V, W, X, Y, Z, _, $, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af, ag } from "./cli-BAr1IsMF.js";
+import { access, readFile, writeFile, readdir, mkdir } from "node:fs/promises";
+import { isAbsolute, resolve, relative, join, basename, dirname } from "node:path";
+import { homedir } from "node:os";
+import chalk from "chalk";
+function parseStatus(content, options = {}) {
+  const warnings = [];
+  const titleMatch = content.match(/^#\s+(.+)$/m);
+  const title = titleMatch ? titleMatch[1].trim() : "Unknown Plan";
+  const currentState = parseCurrentState(content);
+  const stepProgress = parseStepProgress(content);
+  const blockers = parseBlockers(content);
+  const issues = parseIssues(content);
+  const notes = parseNotes(content);
+  const document = {
+    title,
+    currentState,
+    stepProgress,
+    blockers,
+    issues,
+    notes
+  };
+  const completedSteps = stepProgress.filter(
+    (s2) => s2.status === "completed"
+  ).length;
+  const progress = stepProgress.length > 0 ? Math.round(completedSteps / stepProgress.length * 100) : 0;
+  const state = {
+    status: currentState.status,
+    lastUpdatedAt: currentState.lastUpdated ? new Date(currentState.lastUpdated) : /* @__PURE__ */ new Date(),
+    blockers: blockers.map(
+      (desc, i2) => ({
+        id: `blocker-${i2 + 1}`,
+        description: desc,
+        severity: "medium",
+        affectedSteps: [],
+        createdAt: /* @__PURE__ */ new Date()
+      })
+    ),
+    issues: issues.map(
+      (desc, i2) => ({
+        id: `issue-${i2 + 1}`,
+        title: desc.substring(0, 50),
+        description: desc,
+        severity: "medium",
+        createdAt: /* @__PURE__ */ new Date()
+      })
+    ),
+    progress
+  };
+  if (currentState.startedAt) {
+    state.startedAt = new Date(currentState.startedAt);
+  }
+  if (options.steps) {
+    const currentStepNum = extractStepNumber(currentState.currentStep);
+    if (currentStepNum) state.currentStep = currentStepNum;
+    const lastStepNum = extractStepNumber(currentState.lastCompleted);
+    if (lastStepNum) state.lastCompletedStep = lastStepNum;
+    if (stepProgress.length > 0 && stepProgress.length !== options.steps.length) {
+      warnings.push(
+        `Step count mismatch: STATUS.md has ${stepProgress.length}, plan has ${options.steps.length}`
+      );
+    }
+  }
+  return { document, state, warnings };
+}
+function parseCurrentState(content) {
+  const state = {
+    status: "pending"
+  };
+  const statusMatch = content.match(
+    /\|\s*\*\*Status\*\*\s*\|\s*([^|]+)/i
+  );
+  if (statusMatch) {
+    const statusText = statusMatch[1].trim();
+    const emoji = findStatusEmoji(statusText);
+    if (emoji) {
+      state.status = parseStatusEmoji(emoji);
+    } else {
+      state.status = parseStatusText(statusText);
+    }
+  }
+  const currentMatch = content.match(
+    /\|\s*\*\*Current Step\*\*\s*\|\s*([^|]+)/i
+  );
+  if (currentMatch && currentMatch[1].trim() !== "-") {
+    state.currentStep = currentMatch[1].trim();
+  }
+  const lastMatch = content.match(
+    /\|\s*\*\*Last Completed\*\*\s*\|\s*([^|]+)/i
+  );
+  if (lastMatch && lastMatch[1].trim() !== "-") {
+    state.lastCompleted = lastMatch[1].trim();
+  }
+  const startedMatch = content.match(
+    /\|\s*\*\*Started\*\*\s*\|\s*([^|]+)/i
+  );
+  if (startedMatch && startedMatch[1].trim() !== "-") {
+    state.startedAt = startedMatch[1].trim();
+  }
+  const updatedMatch = content.match(
+    /\|\s*\*\*Last Updated\*\*\s*\|\s*([^|]+)/i
+  );
+  if (updatedMatch && updatedMatch[1].trim() !== "-") {
+    state.lastUpdated = updatedMatch[1].trim();
+  }
+  return state;
+}
+const STATUS_EMOJIS = ["⬜", "🔄", "✅", "❌", "⏸️", "⏭️"];
+function findStatusEmoji(text) {
+  for (const emoji of STATUS_EMOJIS) {
+    if (text.includes(emoji)) {
+      return emoji;
+    }
+  }
+  return null;
+}
+function parseStatusEmoji(emoji) {
+  return PLAN_CONVENTIONS.emojiToStatus[emoji] || "pending";
+}
+function parseStatusText(text) {
+  const normalized = text.toLowerCase().replace(/[^a-z_]/g, "");
+  const valid = [
+    "pending",
+    "in_progress",
+    "completed",
+    "failed",
+    "blocked",
+    "skipped"
+  ];
+  if (valid.includes(normalized)) {
+    return normalized;
+  }
+  if (normalized.includes("progress") || normalized.includes("inprogress")) {
+    return "in_progress";
+  }
+  if (normalized.includes("complete") || normalized.includes("done")) {
+    return "completed";
+  }
+  if (normalized.includes("block")) {
+    return "blocked";
+  }
+  if (normalized.includes("skip")) {
+    return "skipped";
+  }
+  if (normalized.includes("fail") || normalized.includes("error")) {
+    return "failed";
+  }
+  return "pending";
+}
+function parseStepProgress(content) {
+  const steps = [];
+  const lines = content.split("\n");
+  let inTable = false;
+  let headerFound = false;
+  const tableRows = [];
+  for (const line of lines) {
+    if (!headerFound && /\|\s*Step\s*\|\s*Name\s*\|/i.test(line)) {
+      headerFound = true;
+      continue;
+    }
+    if (headerFound && !inTable && /^\|[-\s|]+\|$/.test(line)) {
+      inTable = true;
+      continue;
+    }
+    if (inTable) {
+      if (!line.trim() || /^##/.test(line)) {
+        break;
+      }
+      if (line.includes("|")) {
+        tableRows.push(line);
+      }
+    }
+  }
+  if (tableRows.length === 0) return steps;
+  for (const row of tableRows) {
+    if (row.match(/^\|[-\s|]+\|$/)) continue;
+    const cells = row.split("|").map((c2) => c2.trim()).filter((c2) => c2);
+    if (cells.length >= 3) {
+      const step = cells[0];
+      const name = cells[1];
+      const statusStr = cells[2];
+      const started = cells[3] || void 0;
+      const completed = cells[4] || void 0;
+      const notes = cells[5] || void 0;
+      const emoji = findStatusEmoji(statusStr);
+      const status = emoji ? parseStatusEmoji(emoji) : parseStatusText(statusStr);
+      steps.push({
+        step,
+        name,
+        status,
+        started: started && started !== "-" ? started : void 0,
+        completed: completed && completed !== "-" ? completed : void 0,
+        notes: notes && notes !== "-" ? notes : void 0
+      });
+    }
+  }
+  return steps;
+}
+function parseBlockers(content) {
+  const blockers = [];
+  const section = extractSection(content, "Blockers");
+  if (!section) return blockers;
+  if (section.toLowerCase().includes("none")) {
+    return blockers;
+  }
+  const listItems = section.match(/^[-*]\s+(.+)$/gm);
+  if (listItems) {
+    for (const item of listItems) {
+      const text = item.replace(/^[-*]\s+/, "").trim();
+      if (text && !text.toLowerCase().includes("none")) {
+        blockers.push(text);
+      }
+    }
+  }
+  return blockers;
+}
+function parseIssues(content) {
+  const issues = [];
+  const section = extractSection(content, "Issues");
+  if (!section) return issues;
+  if (section.toLowerCase().includes("none")) {
+    return issues;
+  }
+  const listItems = section.match(/^[-*]\s+(.+)$/gm);
+  if (listItems) {
+    for (const item of listItems) {
+      const text = item.replace(/^[-*]\s+/, "").trim();
+      if (text && !text.toLowerCase().includes("none")) {
+        issues.push(text);
+      }
+    }
+  }
+  return issues;
+}
+function parseNotes(content) {
+  const section = extractSection(content, "Notes");
+  if (!section || section.trim() === "") return void 0;
+  const trimmed = section.trim();
+  if (trimmed === "-" || trimmed.toLowerCase() === "none" || trimmed.toLowerCase() === "none currently.") {
+    return void 0;
+  }
+  return trimmed;
+}
+function extractSection(content, name) {
+  const lines = content.split("\n");
+  const sectionLines = [];
+  let inSection = false;
+  for (const line of lines) {
+    if (new RegExp(`^##\\s*${name}`, "i").test(line)) {
+      inSection = true;
+      continue;
+    }
+    if (inSection && (/^##/.test(line) || /^---/.test(line))) {
+      break;
+    }
+    if (inSection) {
+      sectionLines.push(line);
+    }
+  }
+  return sectionLines.length > 0 ? sectionLines.join("\n").trim() : void 0;
+}
+function extractStepNumber(stepRef) {
+  if (!stepRef) return void 0;
+  const match = stepRef.match(/(\d+)/);
+  return match ? parseInt(match[1]) : void 0;
+}
+function parseRelationshipsFromContent(content) {
+  const relationships = [];
+  let frontmatter = null;
+  if (content.startsWith("---\n")) {
+    const endMarker = content.indexOf("\n---", 4);
+    if (endMarker !== -1) {
+      frontmatter = content.substring(4, endMarker);
+    }
+  }
+  if (frontmatter) {
+    const spawnedFrom = frontmatter.match(/spawned-from:\s*(.+)/);
+    if (spawnedFrom) {
+      relationships.push({
+        type: "spawned-from",
+        targetPath: spawnedFrom[1].trim()
+      });
+    }
+    const blocksMatch = frontmatter.match(/blocks:\s*(.+)/);
+    if (blocksMatch) {
+      const paths = blocksMatch[1].split(",").map((p2) => p2.trim());
+      for (const path of paths) {
+        relationships.push({
+          type: "blocks",
+          targetPath: path
+        });
+      }
+    }
+    const blockedBy = frontmatter.match(/blocked-by:\s*(.+)/);
+    if (blockedBy) {
+      const paths = blockedBy[1].split(",").map((p2) => p2.trim());
+      for (const path of paths) {
+        relationships.push({
+          type: "blocked-by",
+          targetPath: path
+        });
+      }
+    }
+    const relatedMatch = frontmatter.match(/related:\s*(.+)/);
+    if (relatedMatch) {
+      const paths = relatedMatch[1].split(",").map((p2) => p2.trim());
+      for (const path of paths) {
+        relationships.push({
+          type: "related",
+          targetPath: path
+        });
+      }
+    }
+  }
+  const lines = content.split("\n");
+  const sectionLines = [];
+  let inSection = false;
+  for (const line of lines) {
+    if (/^##\s+Related\s+Plans?$/i.test(line)) {
+      inSection = true;
+      continue;
+    }
+    if (inSection && /^#/.test(line)) {
+      break;
+    }
+    if (inSection) {
+      sectionLines.push(line);
+    }
+  }
+  if (sectionLines.length > 0) {
+    const section = sectionLines.join("\n");
+    const lines2 = section.split("\n");
+    for (const line of lines2) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("-")) continue;
+      const itemContent = trimmed.slice(1).trim();
+      const typePathMatch = itemContent.match(
+        /\*\*(\w+(?:-\w+)?)\*\*:\s*([^\s]+)(?:\s+-\s+(.+))?/
+      );
+      if (typePathMatch) {
+        const [, typeStr, path, reason] = typePathMatch;
+        const type = normalizeRelationType(typeStr);
+        if (type) {
+          relationships.push({
+            type,
+            targetPath: path,
+            reason: reason?.trim()
+          });
+          continue;
+        }
+      }
+      const linkMatch = itemContent.match(
+        /\[([^\]]+)\]\(([^)]+)\)(?:\s*-\s*(.+))?/
+      );
+      if (linkMatch) {
+        const [, , path, desc] = linkMatch;
+        let type = "related";
+        let reason = desc?.trim();
+        if (desc) {
+          const typeInDesc = desc.match(
+            /\((spawned-from|spawned|blocks|blocked-by|related)\)/i
+          );
+          if (typeInDesc) {
+            type = normalizeRelationType(typeInDesc[1]) || "related";
+            reason = desc.replace(typeInDesc[0], "").trim();
+          } else if (desc.toLowerCase().includes("blocks")) {
+            type = "blocks";
+          } else if (desc.toLowerCase().includes("blocked")) {
+            type = "blocked-by";
+          } else if (desc.toLowerCase().includes("spawned from")) {
+            type = "spawned-from";
+          }
+        }
+        relationships.push({
+          type,
+          targetPath: path,
+          reason: reason || void 0
+        });
+        continue;
+      }
+      const simpleMatch = itemContent.match(
+        /([^\s(]+)\s*(?:\((\w+(?:-\w+)?)\))?(?:\s*-\s*(.+))?/
+      );
+      if (simpleMatch) {
+        const [, path, typeStr, reason] = simpleMatch;
+        const type = typeStr ? normalizeRelationType(typeStr) || "related" : "related";
+        relationships.push({
+          type,
+          targetPath: path,
+          reason: reason?.trim()
+        });
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return relationships.filter((r) => {
+    const key = `${r.type}:${r.targetPath}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function normalizeRelationType(str) {
+  const normalized = str.toLowerCase().replace(/_/g, "-");
+  const validTypes = [
+    "spawned-from",
+    "spawned",
+    "blocks",
+    "blocked-by",
+    "related"
+  ];
+  return validTypes.find((t2) => t2 === normalized) || null;
+}
+async function parseRelationshipsFromPlan(planPath) {
+  const absolutePath = resolve(planPath);
+  const relationships = [];
+  try {
+    const summaryPath = join(absolutePath, "SUMMARY.md");
+    const content = await readFile(summaryPath, "utf-8");
+    relationships.push(...parseRelationshipsFromContent(content));
+  } catch {
+  }
+  try {
+    const files = ["prompt-of-prompts.md"];
+    const planCode = absolutePath.split("/").pop();
+    if (planCode) {
+      files.push(`${planCode}-prompt.md`, `${planCode}.md`);
+    }
+    for (const file of files) {
+      try {
+        const filePath = join(absolutePath, file);
+        const content = await readFile(filePath, "utf-8");
+        relationships.push(...parseRelationshipsFromContent(content));
+      } catch {
+      }
+    }
+  } catch {
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return relationships.filter((r) => {
+    const key = `${r.type}:${r.targetPath}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+async function addRelationship(plan, options) {
+  const { type, targetPath, steps, reason } = options;
+  const resolvedTarget = isAbsolute(targetPath) ? targetPath : resolve(plan.metadata.path, targetPath);
+  let targetValid = false;
+  let targetPlan;
+  try {
+    await access(resolvedTarget);
+    const target = await loadPlan(resolvedTarget);
+    targetValid = true;
+    targetPlan = {
+      code: target.metadata.code,
+      name: target.metadata.name,
+      path: resolvedTarget
+    };
+  } catch {
+  }
+  const relationship = {
+    type,
+    planPath: targetPath,
+    // Store original path
+    steps,
+    reason,
+    createdAt: /* @__PURE__ */ new Date()
+  };
+  if (!plan.relationships) {
+    plan.relationships = [];
+  }
+  plan.relationships.push(relationship);
+  return {
+    relationship,
+    targetValid,
+    targetPlan
+  };
+}
+function removeRelationship(plan, targetPath, type) {
+  if (!plan.relationships) return [];
+  const removed = [];
+  plan.relationships = plan.relationships.filter((r) => {
+    const matches = r.planPath === targetPath && (type === void 0 || r.type === type);
+    if (matches) removed.push(r);
+    return !matches;
+  });
+  return removed;
+}
+function getRelationshipsByType(plan, type) {
+  return (plan.relationships || []).filter((r) => r.type === type);
+}
+function getInverseRelationType(type) {
+  switch (type) {
+    case "spawned-from":
+      return "spawned";
+    case "spawned":
+      return "spawned-from";
+    case "blocks":
+      return "blocked-by";
+    case "blocked-by":
+      return "blocks";
+    case "related":
+      return "related";
+  }
+}
+function createBidirectionalRelationship(sourcePlan, targetPlan, type, reason) {
+  if (!sourcePlan.relationships) {
+    sourcePlan.relationships = [];
+  }
+  sourcePlan.relationships.push({
+    type,
+    planPath: relative(sourcePlan.metadata.path, targetPlan.metadata.path),
+    reason,
+    createdAt: /* @__PURE__ */ new Date()
+  });
+  if (!targetPlan.relationships) {
+    targetPlan.relationships = [];
+  }
+  targetPlan.relationships.push({
+    type: getInverseRelationType(type),
+    planPath: relative(targetPlan.metadata.path, sourcePlan.metadata.path),
+    reason,
+    createdAt: /* @__PURE__ */ new Date()
+  });
+}
+async function validateRelationships(plan) {
+  const invalid = [];
+  const validRelationships = [];
+  if (!plan.relationships) {
+    return { valid: true, invalid: [], validRelationships: [] };
+  }
+  for (const rel of plan.relationships) {
+    const resolvedPath = isAbsolute(rel.planPath) ? rel.planPath : resolve(plan.metadata.path, rel.planPath);
+    try {
+      await access(resolvedPath);
+      await loadPlan(resolvedPath);
+      validRelationships.push(rel);
+    } catch {
+      invalid.push({
+        relationship: rel,
+        reason: `Target plan not found: ${rel.planPath}`
+      });
+    }
+  }
+  return {
+    valid: invalid.length === 0,
+    invalid,
+    validRelationships
+  };
+}
+function getBlockingPlans(plan) {
+  return getRelationshipsByType(plan, "blocked-by").map((r) => r.planPath);
+}
+function getBlockedPlans(plan) {
+  return getRelationshipsByType(plan, "blocks").map((r) => r.planPath);
+}
+function getParentPlan(plan) {
+  const spawnedFrom = getRelationshipsByType(plan, "spawned-from");
+  return spawnedFrom.length > 0 ? spawnedFrom[0].planPath : null;
+}
+function getChildPlans(plan) {
+  return getRelationshipsByType(plan, "spawned").map((r) => r.planPath);
+}
+function getRelatedPlans(plan) {
+  return getRelationshipsByType(plan, "related").map((r) => r.planPath);
+}
+function generateRelationshipsMarkdown(plan) {
+  if (!plan.relationships || plan.relationships.length === 0) {
+    return "";
+  }
+  const lines = ["## Related Plans", ""];
+  const byType = /* @__PURE__ */ new Map();
+  for (const rel of plan.relationships) {
+    const list = byType.get(rel.type) || [];
+    list.push(rel);
+    byType.set(rel.type, list);
+  }
+  const typeLabels = {
+    "spawned-from": "Spawned From",
+    spawned: "Spawned",
+    blocks: "Blocks",
+    "blocked-by": "Blocked By",
+    related: "Related"
+  };
+  for (const [type, rels] of byType) {
+    lines.push(`### ${typeLabels[type]}`);
+    lines.push("");
+    for (const rel of rels) {
+      let line = `- **${type}**: ${rel.planPath}`;
+      if (rel.reason) {
+        line += ` - ${rel.reason}`;
+      }
+      if (rel.steps && rel.steps.length > 0) {
+        line += ` (Steps: ${rel.steps.join(", ")})`;
+      }
+      lines.push(line);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function updatePlanRelationships(plan) {
+  const summaryPath = join(plan.metadata.path, "SUMMARY.md");
+  let content;
+  try {
+    content = await readFile(summaryPath, "utf-8");
+  } catch {
+    content = `# ${plan.metadata.name}
+
+${plan.metadata.description || "Plan summary."}
+
+`;
+  }
+  const lines = content.split("\n");
+  const filtered = [];
+  let inRelatedSection = false;
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    const line = lines[i2];
+    if (/^##\s+Related\s+Plans?$/i.test(line)) {
+      inRelatedSection = true;
+      continue;
+    }
+    if (inRelatedSection && /^#/.test(line)) {
+      inRelatedSection = false;
+    }
+    if (!inRelatedSection) {
+      filtered.push(line);
+    }
+  }
+  content = filtered.join("\n");
+  const relSection = generateRelationshipsMarkdown(plan);
+  if (relSection) {
+    content = content.trimEnd() + "\n\n" + relSection;
+  }
+  await writeFile(summaryPath, content);
+}
+const REGISTRY_FILENAME = ".riotplan-registry.json";
+const REGISTRY_VERSION = "1.0";
+function getDefaultRegistryPath() {
+  return join(homedir(), REGISTRY_FILENAME);
+}
+function createRegistry(searchPaths = []) {
+  return {
+    version: REGISTRY_VERSION,
+    lastUpdatedAt: /* @__PURE__ */ new Date(),
+    searchPaths: searchPaths.map((p2) => resolve(p2)),
+    plans: /* @__PURE__ */ new Map(),
+    byCode: /* @__PURE__ */ new Map(),
+    byStatus: /* @__PURE__ */ new Map()
+  };
+}
+async function loadRegistry(path) {
+  const registryPath = path || getDefaultRegistryPath();
+  try {
+    await access(registryPath);
+    const content = await readFile(registryPath, "utf-8");
+    const data = JSON.parse(content);
+    const registry = createRegistry(data.searchPaths || []);
+    registry.version = data.version || REGISTRY_VERSION;
+    registry.lastUpdatedAt = new Date(data.lastUpdatedAt);
+    if (data.plans && Array.isArray(data.plans)) {
+      for (const plan of data.plans) {
+        const entry = {
+          ...plan,
+          registeredAt: new Date(plan.registeredAt),
+          lastScannedAt: new Date(plan.lastScannedAt)
+        };
+        registry.plans.set(entry.path, entry);
+        indexPlan(registry, entry);
+      }
+    }
+    return registry;
+  } catch {
+    return null;
+  }
+}
+async function saveRegistry(registry, path) {
+  const registryPath = path || getDefaultRegistryPath();
+  registry.lastUpdatedAt = /* @__PURE__ */ new Date();
+  const data = {
+    version: registry.version,
+    lastUpdatedAt: registry.lastUpdatedAt.toISOString(),
+    searchPaths: registry.searchPaths,
+    plans: Array.from(registry.plans.values()).map((plan) => ({
+      ...plan,
+      registeredAt: plan.registeredAt.toISOString(),
+      lastScannedAt: plan.lastScannedAt.toISOString()
+    }))
+  };
+  await writeFile(registryPath, JSON.stringify(data, null, 2));
+}
+async function scanForPlans(registry, options = {}) {
+  const {
+    searchPaths = registry.searchPaths,
+    maxDepth = 3,
+    includeHidden = false,
+    excludeDirs = ["node_modules", ".git", "dist", "coverage"]
+  } = options;
+  let discovered = 0;
+  for (const searchPath of searchPaths) {
+    const absolutePath = resolve(searchPath);
+    try {
+      discovered += await scanDirectory(
+        registry,
+        absolutePath,
+        0,
+        maxDepth,
+        includeHidden,
+        excludeDirs
+      );
+    } catch {
+    }
+  }
+  for (const path of searchPaths) {
+    const absolutePath = resolve(path);
+    if (!registry.searchPaths.includes(absolutePath)) {
+      registry.searchPaths.push(absolutePath);
+    }
+  }
+  registry.lastUpdatedAt = /* @__PURE__ */ new Date();
+  return discovered;
+}
+async function scanDirectory(registry, dirPath, depth, maxDepth, includeHidden, excludeDirs) {
+  if (depth > maxDepth) return 0;
+  let discovered = 0;
+  const dirName = basename(dirPath);
+  if (excludeDirs.includes(dirName)) return 0;
+  if (!includeHidden && dirName.startsWith(".")) return 0;
+  if (await isPlanDirectory(dirPath)) {
+    try {
+      const entry = await createPlanEntry(dirPath);
+      registerPlan(registry, entry);
+      discovered++;
+    } catch {
+    }
+    return discovered;
+  }
+  try {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const subPath = join(dirPath, entry.name);
+        discovered += await scanDirectory(
+          registry,
+          subPath,
+          depth + 1,
+          maxDepth,
+          includeHidden,
+          excludeDirs
+        );
+      }
+    }
+  } catch {
+  }
+  return discovered;
+}
+async function isPlanDirectory(dirPath) {
+  const indicators = [
+    "SUMMARY.md",
+    "STATUS.md",
+    "EXECUTION_PLAN.md",
+    "plan/"
+    // plan subdirectory
+  ];
+  let matches = 0;
+  for (const indicator of indicators) {
+    try {
+      const checkPath = join(dirPath, indicator);
+      await access(checkPath);
+      matches++;
+    } catch {
+    }
+  }
+  if (matches >= 2) return true;
+  try {
+    const files = await readdir(dirPath);
+    const hasSteps = files.some((f2) => PLAN_CONVENTIONS.stepPattern.test(f2));
+    if (hasSteps) return true;
+  } catch {
+  }
+  try {
+    const planDir = join(dirPath, "plan");
+    const files = await readdir(planDir);
+    const hasSteps = files.some((f2) => PLAN_CONVENTIONS.stepPattern.test(f2));
+    if (hasSteps) return true;
+  } catch {
+  }
+  return false;
+}
+async function createPlanEntry(planPath) {
+  const plan = await loadPlan(planPath);
+  const now = /* @__PURE__ */ new Date();
+  return {
+    code: plan.metadata.code,
+    name: plan.metadata.name,
+    path: planPath,
+    status: plan.state.status,
+    progress: plan.state.progress,
+    stepCount: plan.steps.length,
+    completedSteps: plan.steps.filter((s2) => s2.status === "completed").length,
+    registeredAt: now,
+    lastScannedAt: now,
+    tags: plan.metadata.tags,
+    description: plan.metadata.description?.slice(0, 200),
+    parentPlan: plan.relationships?.find((r) => r.type === "spawned-from")?.planPath
+  };
+}
+function registerPlan(registry, entry) {
+  const existing = registry.plans.get(entry.path);
+  if (existing) {
+    removeFromIndex(registry, existing);
+  }
+  registry.plans.set(entry.path, entry);
+  indexPlan(registry, entry);
+}
+function unregisterPlan(registry, path) {
+  const entry = registry.plans.get(path);
+  if (!entry) return false;
+  removeFromIndex(registry, entry);
+  registry.plans.delete(path);
+  return true;
+}
+function indexPlan(registry, entry) {
+  const codePaths = registry.byCode.get(entry.code) || [];
+  if (!codePaths.includes(entry.path)) {
+    codePaths.push(entry.path);
+    registry.byCode.set(entry.code, codePaths);
+  }
+  const statusPaths = registry.byStatus.get(entry.status) || [];
+  if (!statusPaths.includes(entry.path)) {
+    statusPaths.push(entry.path);
+    registry.byStatus.set(entry.status, statusPaths);
+  }
+}
+function removeFromIndex(registry, entry) {
+  const codePaths = registry.byCode.get(entry.code);
+  if (codePaths) {
+    const idx = codePaths.indexOf(entry.path);
+    if (idx !== -1) {
+      codePaths.splice(idx, 1);
+      if (codePaths.length === 0) {
+        registry.byCode.delete(entry.code);
+      }
+    }
+  }
+  const statusPaths = registry.byStatus.get(entry.status);
+  if (statusPaths) {
+    const idx = statusPaths.indexOf(entry.path);
+    if (idx !== -1) {
+      statusPaths.splice(idx, 1);
+      if (statusPaths.length === 0) {
+        registry.byStatus.delete(entry.status);
+      }
+    }
+  }
+}
+async function refreshPlan(registry, path) {
+  const existing = registry.plans.get(path);
+  try {
+    const entry = await createPlanEntry(path);
+    if (existing) {
+      entry.registeredAt = existing.registeredAt;
+    }
+    registerPlan(registry, entry);
+    return entry;
+  } catch {
+    if (existing) {
+      unregisterPlan(registry, path);
+    }
+    return null;
+  }
+}
+async function refreshAllPlans(registry) {
+  let updated = 0;
+  let removed = 0;
+  const paths = Array.from(registry.plans.keys());
+  for (const path of paths) {
+    const result = await refreshPlan(registry, path);
+    if (result) {
+      updated++;
+    } else {
+      removed++;
+    }
+  }
+  registry.lastUpdatedAt = /* @__PURE__ */ new Date();
+  return { updated, removed };
+}
+function searchPlans(registry, options = {}) {
+  let results = Array.from(registry.plans.values());
+  if (options.status) {
+    const statuses = Array.isArray(options.status) ? options.status : [options.status];
+    results = results.filter((p2) => statuses.includes(p2.status));
+  }
+  if (options.codePattern) {
+    const pattern = new RegExp(options.codePattern, "i");
+    results = results.filter((p2) => pattern.test(p2.code));
+  }
+  if (options.namePattern) {
+    const pattern = new RegExp(options.namePattern, "i");
+    results = results.filter((p2) => pattern.test(p2.name));
+  }
+  if (options.tags && options.tags.length > 0) {
+    results = results.filter(
+      (p2) => options.tags.some((tag) => p2.tags?.includes(tag))
+    );
+  }
+  if (options.minProgress !== void 0) {
+    results = results.filter((p2) => p2.progress >= options.minProgress);
+  }
+  if (options.maxProgress !== void 0) {
+    results = results.filter((p2) => p2.progress <= options.maxProgress);
+  }
+  if (options.sortBy) {
+    const dir = options.sortDir === "desc" ? -1 : 1;
+    results.sort((a, b) => {
+      const aVal = a[options.sortBy];
+      const bVal = b[options.sortBy];
+      if (aVal === void 0 || aVal === null) return 1 * dir;
+      if (bVal === void 0 || bVal === null) return -1 * dir;
+      if (typeof aVal === "string" && typeof bVal === "string") {
+        return aVal.localeCompare(bVal) * dir;
+      }
+      if (typeof aVal === "number" && typeof bVal === "number") {
+        return (aVal - bVal) * dir;
+      }
+      if (aVal instanceof Date && bVal instanceof Date) {
+        return (aVal.getTime() - bVal.getTime()) * dir;
+      }
+      return 0;
+    });
+  }
+  const total = results.length;
+  if (options.offset !== void 0) {
+    results = results.slice(options.offset);
+  }
+  if (options.limit !== void 0) {
+    results = results.slice(0, options.limit);
+  }
+  return { plans: results, total };
+}
+function getPlanByCode(registry, code) {
+  const paths = registry.byCode.get(code);
+  if (!paths || paths.length === 0) return null;
+  return registry.plans.get(paths[0]) || null;
+}
+function getPlanByPath(registry, path) {
+  return registry.plans.get(resolve(path)) || null;
+}
+function getPlansByStatus(registry, status) {
+  const paths = registry.byStatus.get(status) || [];
+  return paths.map((p2) => registry.plans.get(p2)).filter((p2) => p2 !== void 0);
+}
+function getRegistryStats(registry) {
+  const plans = Array.from(registry.plans.values());
+  const byStatus = {
+    pending: 0,
+    in_progress: 0,
+    completed: 0,
+    failed: 0,
+    blocked: 0,
+    skipped: 0
+  };
+  for (const plan of plans) {
+    byStatus[plan.status]++;
+  }
+  const totalProgress = plans.reduce((sum, p2) => sum + p2.progress, 0);
+  const averageProgress = plans.length > 0 ? Math.round(totalProgress / plans.length) : 0;
+  const sortedByDate = [...plans].sort(
+    (a, b) => a.registeredAt.getTime() - b.registeredAt.getTime()
+  );
+  return {
+    totalPlans: plans.length,
+    byStatus,
+    averageProgress,
+    oldestPlan: sortedByDate[0],
+    newestPlan: sortedByDate[sortedByDate.length - 1],
+    searchPathCount: registry.searchPaths.length
+  };
+}
+function generateRetrospective(plan, options) {
+  const steps = plan.steps || [];
+  const completedSteps = steps.filter((s2) => s2.status === "completed");
+  const skippedSteps = steps.filter((s2) => s2.status === "skipped");
+  let duration;
+  if (plan.state.startedAt && plan.state.completedAt) {
+    const start = plan.state.startedAt instanceof Date ? plan.state.startedAt.getTime() : new Date(plan.state.startedAt).getTime();
+    const end = plan.state.completedAt instanceof Date ? plan.state.completedAt.getTime() : new Date(plan.state.completedAt).getTime();
+    duration = end - start;
+  }
+  const whatWentWell = options?.whatWentWell || generateWhatWentWell(plan);
+  const whatCouldImprove = options?.whatCouldImprove || generateWhatCouldImprove(plan);
+  const keyLearnings = options?.keyLearnings || [];
+  const actionItems = options?.actionItems || [];
+  return {
+    planName: plan.metadata.name,
+    planCode: plan.metadata.code,
+    startedAt: plan.state.startedAt,
+    completedAt: plan.state.completedAt,
+    duration,
+    totalSteps: steps.length,
+    completedSteps: completedSteps.length,
+    skippedSteps: skippedSteps.length,
+    whatWentWell,
+    whatCouldImprove,
+    keyLearnings,
+    actionItems,
+    stepsSummary: steps.map((s2) => ({
+      number: s2.number,
+      title: s2.title,
+      status: s2.status,
+      duration: s2.duration,
+      notes: s2.notes
+    }))
+  };
+}
+function generateWhatWentWell(plan) {
+  const items = [];
+  const steps = plan.steps || [];
+  const completed = steps.filter((s2) => s2.status === "completed").length;
+  const rate = steps.length > 0 ? completed / steps.length * 100 : 0;
+  if (rate === 100) {
+    items.push("All steps completed successfully");
+  } else if (rate >= 90) {
+    items.push(`High completion rate (${rate.toFixed(0)}%)`);
+  }
+  if (plan.state.blockers.length === 0) {
+    items.push("No blockers encountered");
+  }
+  if (plan.feedback && plan.feedback.length > 0) {
+    items.push(`Successfully incorporated ${plan.feedback.length} feedback item(s)`);
+  }
+  return items;
+}
+function generateWhatCouldImprove(plan) {
+  const items = [];
+  const steps = plan.steps || [];
+  const skipped = steps.filter((s2) => s2.status === "skipped");
+  if (skipped.length > 0) {
+    items.push(`${skipped.length} step(s) were skipped - review if necessary`);
+  }
+  if (plan.state.blockers.length > 0) {
+    items.push(
+      `Address recurring blockers: ${plan.state.blockers.map((b) => b.description).join(", ")}`
+    );
+  }
+  if (plan.state.issues.length > 0) {
+    items.push(`Resolve outstanding issues before next iteration`);
+  }
+  return items;
+}
+function generateRetrospectiveMarkdown(retro) {
+  const lines = [];
+  lines.push(`# Retrospective: ${retro.planName}
+`);
+  lines.push(`**Plan Code:** ${retro.planCode}
+`);
+  if (retro.startedAt) {
+    lines.push(`**Started:** ${formatDate(retro.startedAt)}`);
+  }
+  if (retro.completedAt) {
+    lines.push(`**Completed:** ${formatDate(retro.completedAt)}`);
+  }
+  if (retro.duration) {
+    lines.push(`**Duration:** ${formatDuration(retro.duration)}`);
+  }
+  lines.push("");
+  lines.push("## Summary\n");
+  lines.push(`| Metric | Value |`);
+  lines.push(`|--------|-------|`);
+  lines.push(`| Total Steps | ${retro.totalSteps} |`);
+  lines.push(`| Completed | ${retro.completedSteps} |`);
+  lines.push(`| Skipped | ${retro.skippedSteps} |`);
+  lines.push(
+    `| Completion Rate | ${(retro.completedSteps / retro.totalSteps * 100).toFixed(0)}% |`
+  );
+  lines.push("");
+  lines.push("## What Went Well\n");
+  if (retro.whatWentWell.length > 0) {
+    for (const item of retro.whatWentWell) {
+      lines.push(`- ✅ ${item}`);
+    }
+  } else {
+    lines.push("*No entries yet. Add your insights here.*");
+  }
+  lines.push("");
+  lines.push("## What Could Improve\n");
+  if (retro.whatCouldImprove.length > 0) {
+    for (const item of retro.whatCouldImprove) {
+      lines.push(`- 🔄 ${item}`);
+    }
+  } else {
+    lines.push("*No entries yet. Add your insights here.*");
+  }
+  lines.push("");
+  lines.push("## Key Learnings\n");
+  if (retro.keyLearnings.length > 0) {
+    for (const item of retro.keyLearnings) {
+      lines.push(`- 💡 ${item}`);
+    }
+  } else {
+    lines.push("*What did you learn? Document it here.*");
+  }
+  lines.push("");
+  lines.push("## Action Items\n");
+  if (retro.actionItems.length > 0) {
+    for (const item of retro.actionItems) {
+      lines.push(`- [ ] ${item}`);
+    }
+  } else {
+    lines.push("*Any follow-up tasks? Add them here.*");
+  }
+  lines.push("");
+  lines.push("## Steps Summary\n");
+  lines.push(`| # | Title | Status | Notes |`);
+  lines.push(`|---|-------|--------|-------|`);
+  for (const step of retro.stepsSummary) {
+    const status = formatStepStatus(step.status);
+    const notes = step.notes || "-";
+    lines.push(`| ${step.number} | ${step.title} | ${status} | ${notes} |`);
+  }
+  lines.push("");
+  lines.push("---");
+  lines.push(`*Generated on ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}*`);
+  return lines.join("\n");
+}
+async function createRetrospective(plan, options) {
+  const retro = generateRetrospective(plan, options);
+  const content = generateRetrospectiveMarkdown(retro);
+  const retroPath = join(plan.metadata.path, "RETROSPECTIVE.md");
+  await writeFile(retroPath, content, "utf-8");
+  return retroPath;
+}
+function formatDate(date) {
+  if (typeof date === "string") return date;
+  return date.toISOString().split("T")[0];
+}
+function formatDuration(ms) {
+  const hours = Math.floor(ms / (1e3 * 60 * 60));
+  const minutes = Math.floor(ms % (1e3 * 60 * 60) / (1e3 * 60));
+  const days = Math.floor(hours / 24);
+  if (days > 0) {
+    return `${days} day(s), ${hours % 24} hour(s)`;
+  }
+  if (hours > 0) {
+    return `${hours} hour(s), ${minutes} minute(s)`;
+  }
+  return `${minutes} minute(s)`;
+}
+function formatStepStatus(status) {
+  const emojis = {
+    completed: "✅",
+    skipped: "⏭️",
+    pending: "⬜",
+    in_progress: "🔄",
+    blocked: "⏸️"
+  };
+  return `${emojis[status] || ""} ${status}`;
+}
+const HISTORY_FILE = ".history/HISTORY.json";
+function initHistory(initialVersion = "0.1") {
+  return {
+    revisions: [
+      {
+        version: initialVersion,
+        createdAt: /* @__PURE__ */ new Date(),
+        message: "Initial version"
+      }
+    ],
+    currentVersion: initialVersion,
+    milestones: []
+  };
+}
+async function loadHistory(planPath) {
+  const historyPath = join(planPath, HISTORY_FILE);
+  let history;
+  try {
+    const content = await readFile(historyPath, "utf-8");
+    const data = JSON.parse(content);
+    history = {
+      ...data,
+      revisions: data.revisions.map((r) => ({
+        ...r,
+        createdAt: new Date(r.createdAt)
+      })),
+      milestones: data.milestones?.map((m2) => ({
+        ...m2,
+        createdAt: new Date(m2.createdAt)
+      }))
+    };
+  } catch {
+    history = initHistory();
+  }
+  return createHistoryManager(history, historyPath);
+}
+async function saveHistory(history, planPath) {
+  const historyPath = join(planPath, HISTORY_FILE);
+  await mkdir(dirname(historyPath), { recursive: true });
+  const data = {
+    ...history,
+    revisions: history.revisions.map((r) => ({
+      ...r,
+      createdAt: r.createdAt instanceof Date ? r.createdAt.toISOString() : r.createdAt
+    })),
+    milestones: history.milestones?.map((m2) => ({
+      ...m2,
+      createdAt: m2.createdAt instanceof Date ? m2.createdAt.toISOString() : m2.createdAt
+    }))
+  };
+  await writeFile(historyPath, JSON.stringify(data, null, 2), "utf-8");
+}
+function createHistoryManager(history, path) {
+  return {
+    history,
+    path,
+    async save() {
+      const planPath = dirname(dirname(path));
+      await saveHistory(history, planPath);
+    },
+    async reload() {
+      const planPath = dirname(dirname(path));
+      const reloaded = await loadHistory(planPath);
+      Object.assign(history, reloaded.history);
+    }
+  };
+}
+function createRevision(history, message, options) {
+  const currentVersion = history.currentVersion;
+  const [major, minor] = currentVersion.split(".").map(Number);
+  const newVersion = `${major}.${minor + 1}`;
+  const revision = {
+    version: newVersion,
+    createdAt: /* @__PURE__ */ new Date(),
+    message,
+    author: options?.author,
+    feedbackId: options?.feedbackId
+  };
+  history.revisions.push(revision);
+  history.currentVersion = newVersion;
+  return revision;
+}
+function getRevision(history, version) {
+  const index = history.revisions.findIndex((r) => r.version === version);
+  if (index === -1) return void 0;
+  const revision = history.revisions[index];
+  return {
+    ...revision,
+    index,
+    isCurrent: revision.version === history.currentVersion
+  };
+}
+function listRevisions(history) {
+  return history.revisions.map((r, index) => ({
+    ...r,
+    index,
+    isCurrent: r.version === history.currentVersion
+  }));
+}
+function compareRevisions(history, fromVersion, toVersion) {
+  const from = getRevision(history, fromVersion);
+  const to = getRevision(history, toVersion);
+  if (!from || !to) return void 0;
+  const fromTime = from.createdAt instanceof Date ? from.createdAt.getTime() : new Date(from.createdAt).getTime();
+  const toTime = to.createdAt instanceof Date ? to.createdAt.getTime() : new Date(to.createdAt).getTime();
+  return {
+    from,
+    to,
+    timeDiff: toTime - fromTime,
+    revisionCount: Math.abs(to.index - from.index)
+  };
+}
+function getLatestRevision(history) {
+  if (history.revisions.length === 0) return void 0;
+  const index = history.revisions.length - 1;
+  const revision = history.revisions[index];
+  return {
+    ...revision,
+    index,
+    isCurrent: true
+  };
+}
+function nextVersion(currentVersion) {
+  const [major, minor] = currentVersion.split(".").map(Number);
+  return `${major}.${minor + 1}`;
+}
+function createMilestone(history, name, description) {
+  const milestone = {
+    name,
+    version: history.currentVersion,
+    createdAt: /* @__PURE__ */ new Date(),
+    description
+  };
+  if (!history.milestones) {
+    history.milestones = [];
+  }
+  history.milestones.push(milestone);
+  return milestone;
+}
+function getMilestone(history, name) {
+  if (!history.milestones) return void 0;
+  const index = history.milestones.findIndex((m2) => m2.name === name);
+  if (index === -1) return void 0;
+  return {
+    ...history.milestones[index],
+    index
+  };
+}
+function listMilestones(history) {
+  if (!history.milestones) return [];
+  return history.milestones.map((m2, index) => ({
+    ...m2,
+    index
+  }));
+}
+function rollbackToMilestone(history, milestoneName) {
+  const milestone = getMilestone(history, milestoneName);
+  if (!milestone) {
+    return {
+      success: false,
+      error: `Milestone not found: ${milestoneName}`
+    };
+  }
+  const currentIndex = history.revisions.findIndex(
+    (r) => r.version === history.currentVersion
+  );
+  const targetIndex = history.revisions.findIndex(
+    (r) => r.version === milestone.version
+  );
+  if (targetIndex === -1) {
+    return {
+      success: false,
+      error: `Revision not found for milestone: ${milestone.version}`
+    };
+  }
+  const revisionsRolledBack = currentIndex - targetIndex;
+  history.currentVersion = milestone.version;
+  return {
+    success: true,
+    milestone,
+    newVersion: milestone.version,
+    revisionsRolledBack
+  };
+}
+function getLatestMilestone(history) {
+  if (!history.milestones || history.milestones.length === 0) {
+    return void 0;
+  }
+  const index = history.milestones.length - 1;
+  return {
+    ...history.milestones[index],
+    index
+  };
+}
+function renderPlan(plan, options) {
+  try {
+    let content;
+    switch (options.format) {
+      case "markdown":
+        content = renderToMarkdown(plan, options);
+        break;
+      case "json":
+        content = renderToJson(plan, options);
+        break;
+      case "html":
+        content = renderToHtml(plan, options);
+        break;
+      default:
+        return {
+          success: false,
+          error: `Unknown format: ${options.format}`
+        };
+    }
+    return {
+      success: true,
+      content,
+      format: options.format
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown render error"
+    };
+  }
+}
+class MockStepExecutor {
+  delay;
+  shouldFail;
+  constructor(options) {
+    this.delay = options?.delay ?? 100;
+    this.shouldFail = options?.shouldFail ?? false;
+  }
+  async execute(context) {
+    await new Promise((resolve2) => setTimeout(resolve2, this.delay));
+    context.onProgress?.(`Executing step ${context.step.number}...`);
+    if (this.shouldFail) {
+      return {
+        success: false,
+        step: context.step.number,
+        error: new Error("Mock execution failed"),
+        duration: 0
+      };
+    }
+    return {
+      success: true,
+      step: context.step.number,
+      output: `Completed step ${context.step.number}: ${context.step.title}`,
+      duration: 0
+    };
+  }
+}
+function createExecutor(config) {
+  switch (config.type) {
+    case "mock":
+      return new MockStepExecutor();
+    case "anthropic":
+    case "openai":
+    case "gemini":
+      throw new Error(
+        `Provider '${config.type}' requires @riotprompt/execution-${config.type} package. Import and configure it directly for LLM-powered execution.`
+      );
+    default:
+      throw new Error(`Unknown provider: ${config.type}`);
+  }
+}
+async function executeStep$1(executor, plan, stepNumber, options) {
+  const step = plan.steps?.find((s2) => s2.number === stepNumber);
+  if (!step) {
+    return {
+      success: false,
+      step: stepNumber,
+      error: new Error(`Step ${stepNumber} not found`),
+      duration: 0
+    };
+  }
+  const context = {
+    plan,
+    step,
+    provider: options?.provider ?? { type: "mock" },
+    workingDirectory: options?.workingDirectory,
+    env: options?.env,
+    onProgress: options?.onProgress,
+    onComplete: options?.onComplete
+  };
+  const result = await executor.execute(context);
+  options?.onComplete?.(result);
+  return result;
+}
+async function executePendingSteps(executor, plan, options) {
+  const results = [];
+  const pendingSteps = plan.steps?.filter((s2) => s2.status === "pending") ?? [];
+  for (const step of pendingSteps) {
+    const result = await executeStep$1(executor, plan, step.number, {
+      provider: options?.provider,
+      onProgress: (msg) => options?.onProgress?.(step.number, msg),
+      onComplete: (res) => options?.onStepComplete?.(step.number, res)
+    });
+    results.push(result);
+    if (!result.success && options?.stopOnError) {
+      break;
+    }
+  }
+  return results;
+}
+function outputSuccess(message) {
+  console.log(chalk.green("✓") + " " + message);
+}
+function outputError(message) {
+  console.error(chalk.red("✗") + " " + message);
+}
+function outputWarning(message) {
+  console.log(chalk.yellow("⚠") + " " + message);
+}
+function outputInfo(message) {
+  console.log(chalk.blue("ℹ") + " " + message);
+}
+function getStatusIcon(status) {
+  const icons = {
     pending: "⬜",
     in_progress: "🔄",
     completed: "✅",
     failed: "❌",
     blocked: "⏸️",
     skipped: "⏭️"
+  };
+  return icons[status] || "⬜";
+}
+function formatStatus(status) {
+  const colors = {
+    pending: chalk.dim,
+    in_progress: chalk.yellow,
+    completed: chalk.green,
+    failed: chalk.red,
+    blocked: chalk.magenta,
+    skipped: chalk.gray
+  };
+  const color = colors[status] || chalk.white;
+  return color(status.replace("_", " "));
+}
+function outputStepList(steps) {
+  for (const step of steps) {
+    const num = String(step.number).padStart(2, "0");
+    const icon = getStatusIcon(step.status);
+    const status = formatStatus(step.status);
+    console.log(
+      `  ${icon} ${chalk.bold(num)} ${step.title} ${chalk.dim(`[${status}]`)}`
+    );
   }
-};
-const VERSION = "0.0.1";
-async function loadPlan(_path) {
-  throw new Error(
-    "riotplan.loadPlan is not yet implemented. Coming in v0.1.0!"
-  );
 }
-async function createPlan(_config) {
-  throw new Error(
-    "riotplan.createPlan is not yet implemented. Coming in v0.1.0!"
+function outputPlanSummary(plan) {
+  const { metadata, state, steps } = plan;
+  const completedCount = steps.filter((s2) => s2.status === "completed").length;
+  console.log();
+  console.log(chalk.bold(metadata.name));
+  console.log(chalk.dim(`Code: ${metadata.code}`));
+  console.log();
+  console.log(
+    `Status: ${getStatusIcon(state.status)} ${formatStatus(state.status)}`
   );
-}
-function parseStatus(_content) {
-  throw new Error(
-    "riotplan.parseStatus is not yet implemented. Coming in v0.1.0!"
+  console.log(
+    `Progress: ${state.progress}% (${completedCount}/${steps.length} steps)`
   );
+  if (state.currentStep) {
+    const currentStep = steps.find((s2) => s2.number === state.currentStep);
+    if (currentStep) {
+      console.log(
+        `Current: Step ${state.currentStep} - ${currentStep.title}`
+      );
+    }
+  }
+  if (state.blockers.length > 0) {
+    console.log();
+    console.log(chalk.yellow(`Blockers: ${state.blockers.length}`));
+    for (const blocker of state.blockers) {
+      console.log(chalk.dim(`  - ${blocker.description}`));
+    }
+  }
 }
-function generateStatus(_plan) {
-  throw new Error(
-    "riotplan.generateStatus is not yet implemented. Coming in v0.1.0!"
-  );
+function outputJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+class CliError extends Error {
+  constructor(message, code, exitCode = 1) {
+    super(message);
+    this.code = code;
+    this.exitCode = exitCode;
+    this.name = "CliError";
+  }
+}
+function handleError(error) {
+  if (error instanceof CliError) {
+    console.error(chalk.red(`Error [${error.code}]: ${error.message}`));
+    process.exit(error.exitCode);
+  }
+  if (error instanceof Error) {
+    console.error(chalk.red(`Error: ${error.message}`));
+    if (process.env.DEBUG) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+  console.error(chalk.red("An unknown error occurred"));
+  process.exit(1);
+}
+function notImplemented(feature) {
+  console.log(chalk.yellow(`⚠ ${feature} is not yet implemented.`));
+  console.log(chalk.dim("Check back in a future version!"));
+  process.exit(0);
 }
+const VERSION = "0.0.1";
 async function executeStep(_plan, _stepNumber, _context) {
   throw new Error(
     "riotplan.executeStep is not yet implemented. Coming in v0.1.0!"
@@ -69,14 +1585,144 @@ function updatePlanState(_plan, _stepNumber, _result) {
   );
 }
 export {
+  B as BasicTemplate,
+  C as CRITERIA_PATTERNS,
+  CliError,
+  F as FeatureTemplate,
+  H as HEALTH_THRESHOLDS,
+  M as MigrationTemplate,
+  MockStepExecutor,
   PLAN_CONVENTIONS,
+  c as PRIORITY_WEIGHTS,
+  R as RefactoringTemplate,
+  S as SprintTemplate,
   VERSION,
-  createPlan,
+  addRelationship,
+  d as applyTemplate,
+  e as archiveCommand,
+  f as blockStep,
+  g as buildDependencyGraph,
+  h as buildDependencyGraphFromMap,
+  i as checkCompletion,
+  j as checkCoverage,
+  compareRevisions,
+  k as completeStep,
+  m as computeExecutionOrder,
+  n as createAnalysisDirectory,
+  createBidirectionalRelationship,
+  createExecutor,
+  o as createFeedback,
+  createMilestone,
+  p as createPlan,
+  q as createProgram,
+  createRegistry,
+  createRetrospective,
+  createRevision,
+  executePendingSteps,
   executeStep,
-  generateStatus,
+  executeStep$1 as executeStepWithExecutor,
+  s as failStep,
+  t as findCriticalPath,
+  formatStatus,
+  generateRelationshipsMarkdown,
+  generateRetrospective,
+  generateRetrospectiveMarkdown,
+  u as generateStatus,
+  getBlockedPlans,
+  v as getBlockedSteps,
+  getBlockingPlans,
+  getChildPlans,
+  w as getCriteriaSummary,
+  getDefaultRegistryPath,
+  x as getDependencyChain,
+  y as getFeedback,
+  getInverseRelationType,
+  getLatestMilestone,
+  getLatestRevision,
+  getMilestone,
+  getParentPlan,
+  getPlanByCode,
+  getPlanByPath,
+  getPlansByStatus,
+  z as getReadySteps,
+  getRegistryStats,
+  getRelatedPlans,
+  getRelationshipsByType,
+  getRevision,
+  getStatusIcon,
+  A as getTemplate,
+  handleError,
+  D as hasAnalysis,
+  E as initCommand,
+  initHistory,
+  G as insertStep,
+  I as listFeedback,
+  listMilestones,
+  listRevisions,
+  J as listTemplates,
+  K as listTemplatesByCategory,
+  L as loadAmendmentPrompts,
+  N as loadAnalysis,
+  O as loadElaborationPrompts,
+  loadHistory,
   loadPlan,
+  loadRegistry,
+  Q as moveStep,
+  nextVersion,
+  notImplemented,
+  outputError,
+  outputInfo,
+  outputJson,
+  outputPlanSummary,
+  outputStepList,
+  outputSuccess,
+  outputWarning,
+  T as parseAllDependencies,
+  U as parseCriteria,
+  V as parseCriteriaFromContent,
+  W as parseDependenciesFromContent,
+  X as parseDependenciesFromFile,
+  parseRelationshipsFromContent,
+  parseRelationshipsFromPlan,
   parseStatus,
+  refreshAllPlans,
+  refreshPlan,
+  registerPlan,
+  Y as registerPlanCommands,
+  Z as registerRenderCommands,
+  _ as registerTemplate,
+  removeRelationship,
+  $ as removeStep,
+  a0 as renderCommand,
+  renderPlan,
+  renderToHtml,
+  renderToJson,
+  renderToMarkdown,
   resumePlan,
-  updatePlanState
+  rollbackToMilestone,
+  a1 as saveAmendmentPrompt,
+  a2 as saveElaborationPrompt,
+  saveHistory,
+  a3 as saveInitialPrompt,
+  saveRegistry,
+  scanForPlans,
+  searchPlans,
+  a4 as searchTemplatesByTag,
+  a5 as skipStep,
+  a6 as startStep,
+  a7 as templateCommand,
+  a8 as templateListCommand,
+  a9 as templateShowCommand,
+  aa as templateUseCommand,
+  ab as unblockStep,
+  unregisterPlan,
+  updatePlanRelationships,
+  updatePlanState,
+  ac as updateStatus,
+  ad as updateStepDependencies,
+  ae as validateCommand,
+  af as validateDependencies,
+  ag as validatePlan,
+  validateRelationships
 };
 //# sourceMappingURL=index.js.map