lean-spec 0.2.7 → 0.2.9-dev.20251205030455

package/dist/chunk-H5MCUMBK.js

@@ -0,0 +1,741 @@
+import { loadConfig, getSpec, loadAllSpecs } from './chunk-RF5PKL6L.js';
+import { updateFrontmatter } from './chunk-VN5BUHTV.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { Command } from 'commander';
+import { execSync } from 'child_process';
+import matter from 'gray-matter';
+
+function isGitRepository() {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", {
+      stdio: "ignore",
+      encoding: "utf-8"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getFirstCommitTimestamp(filePath) {
+  try {
+    const timestamp = execSync(
+      `git log --follow --format="%aI" --diff-filter=A -- "${filePath}" | tail -1`,
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
+    ).trim();
+    return timestamp || null;
+  } catch {
+    return null;
+  }
+}
+function getLastCommitTimestamp(filePath) {
+  try {
+    const timestamp = execSync(
+      `git log --format="%aI" -n 1 -- "${filePath}"`,
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
+    ).trim();
+    return timestamp || null;
+  } catch {
+    return null;
+  }
+}
+function getCompletionTimestamp(filePath) {
+  try {
+    const gitLog = execSync(
+      `git log --format="%H|%aI" -p -- "${filePath}"`,
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
+    );
+    const commits = gitLog.split("\ndiff --git").map((section) => section.trim());
+    for (const commit of commits) {
+      if (!commit) continue;
+      const headerMatch = commit.match(/^([a-f0-9]{40})\|([^\n]+)/);
+      if (!headerMatch) continue;
+      const [, , timestamp] = headerMatch;
+      if (/^\+status:\s*['"]?complete['"]?/m.test(commit) || /^\+\*\*Status\*\*:.*complete/mi.test(commit)) {
+        return timestamp;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getFirstCommitAuthor(filePath) {
+  try {
+    const author = execSync(
+      `git log --follow --format="%an" --diff-filter=A -- "${filePath}" | tail -1`,
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
+    ).trim();
+    return author || null;
+  } catch {
+    return null;
+  }
+}
+function parseStatusTransitions(filePath) {
+  const transitions = [];
+  try {
+    const gitLog = execSync(
+      `git log --format="%H|%aI" -p --reverse -- "${filePath}"`,
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
+    );
+    const commits = gitLog.split("\ndiff --git").map((section) => section.trim());
+    const validStatuses = ["planned", "in-progress", "complete", "archived"];
+    for (const commit of commits) {
+      if (!commit) continue;
+      const headerMatch = commit.match(/^([a-f0-9]{40})\|([^\n]+)/);
+      if (!headerMatch) continue;
+      const [, , timestamp] = headerMatch;
+      const statusMatch = commit.match(/^\+status:\s*['"]?(\w+(?:-\w+)?)['"]?/m);
+      if (statusMatch) {
+        const status = statusMatch[1];
+        if (validStatuses.includes(status)) {
+          const lastTransition = transitions[transitions.length - 1];
+          if (!lastTransition || lastTransition.status !== status) {
+            transitions.push({ status, at: timestamp });
+          }
+        }
+      }
+    }
+    return transitions;
+  } catch {
+    return [];
+  }
+}
+function extractGitTimestamps(filePath, options = {}) {
+  const data = {};
+  data.created_at = getFirstCommitTimestamp(filePath) ?? void 0;
+  data.updated_at = getLastCommitTimestamp(filePath) ?? void 0;
+  data.completed_at = getCompletionTimestamp(filePath) ?? void 0;
+  if (options.includeAssignee) {
+    const author = getFirstCommitAuthor(filePath);
+    if (author) {
+      data.assignee = author;
+    }
+  }
+  if (options.includeTransitions) {
+    const transitions = parseStatusTransitions(filePath);
+    if (transitions.length > 0) {
+      data.transitions = transitions;
+    }
+  }
+  return data;
+}
+function fileExistsInGit(filePath) {
+  try {
+    execSync(
+      `git log -n 1 -- "${filePath}"`,
+      { stdio: "ignore", encoding: "utf-8" }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createSpecDirPattern() {
+  return /(?:^|\D)(\d{2,4})-[^0-9-]/i;
+}
+async function getGlobalNextSeq(specsDir, digits) {
+  try {
+    const seqNumbers = [];
+    const specPattern = createSpecDirPattern();
+    async function scanDirectory(dir) {
+      try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory()) continue;
+          const match = entry.name.match(specPattern);
+          if (match) {
+            const seqNum = parseInt(match[1], 10);
+            if (!isNaN(seqNum) && seqNum > 0) {
+              seqNumbers.push(seqNum);
+            }
+          }
+          if (entry.name === "archived") continue;
+          const subDir = path.join(dir, entry.name);
+          await scanDirectory(subDir);
+        }
+      } catch {
+      }
+    }
+    await scanDirectory(specsDir);
+    if (seqNumbers.length === 0) {
+      return "1".padStart(digits, "0");
+    }
+    const maxSeq = Math.max(...seqNumbers);
+    return String(maxSeq + 1).padStart(digits, "0");
+  } catch {
+    return "1".padStart(digits, "0");
+  }
+}
+async function resolveSpecPath(specPath, cwd, specsDir) {
+  if (path.isAbsolute(specPath)) {
+    try {
+      await fs.access(specPath);
+      return specPath;
+    } catch {
+      return null;
+    }
+  }
+  const cwdPath = path.resolve(cwd, specPath);
+  try {
+    await fs.access(cwdPath);
+    return cwdPath;
+  } catch {
+  }
+  const specsPath = path.join(specsDir, specPath);
+  try {
+    await fs.access(specsPath);
+    return specsPath;
+  } catch {
+  }
+  const seqMatch = specPath.match(/^0*(\d+)$/);
+  if (seqMatch) {
+    const seqNum = parseInt(seqMatch[1], 10);
+    const result2 = await searchBySequence(specsDir, seqNum);
+    if (result2) return result2;
+  }
+  const specName = specPath.replace(/^.*\//, "");
+  const result = await searchInAllDirectories(specsDir, specName);
+  return result;
+}
+async function searchBySequence(specsDir, seqNum) {
+  const specPattern = createSpecDirPattern();
+  async function scanDirectory(dir) {
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const match = entry.name.match(specPattern);
+        if (match) {
+          const entrySeq = parseInt(match[1], 10);
+          if (entrySeq === seqNum) {
+            return path.join(dir, entry.name);
+          }
+        }
+        const subDir = path.join(dir, entry.name);
+        const result = await scanDirectory(subDir);
+        if (result) return result;
+      }
+    } catch {
+    }
+    return null;
+  }
+  return scanDirectory(specsDir);
+}
+async function searchInAllDirectories(specsDir, specName) {
+  async function scanDirectory(dir) {
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (entry.name === specName) {
+          return path.join(dir, entry.name);
+        }
+        const subDir = path.join(dir, entry.name);
+        const result = await scanDirectory(subDir);
+        if (result) return result;
+      }
+    } catch {
+    }
+    return null;
+  }
+  return scanDirectory(specsDir);
+}
+async function loadSpecsForBootstrap(specsDir, options = {}) {
+  const specs = [];
+  const config = await loadConfig();
+  const specPattern = /^(\d{2,})-/;
+  async function scanDirectory(dir, relativePath = "") {
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (entry.name === "archived" && relativePath === "") continue;
+        const entryPath = path.join(dir, entry.name);
+        const entryRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+        if (specPattern.test(entry.name)) {
+          if (options.targetSpecs && options.targetSpecs.length > 0) {
+            const matches = options.targetSpecs.some((target) => {
+              const targetNum = target.match(/^0*(\d+)$/)?.[1];
+              const entryNum = entry.name.match(/^(\d+)/)?.[1];
+              return entry.name === target || entry.name.includes(target) || targetNum && entryNum && parseInt(targetNum, 10) === parseInt(entryNum, 10);
+            });
+            if (!matches) continue;
+          }
+          const specFile = path.join(entryPath, config.structure.defaultFile);
+          try {
+            await fs.access(specFile);
+            const specInfo = await analyzeSpecFile(specFile, entryPath, entryRelativePath, entry.name);
+            specs.push(specInfo);
+          } catch {
+          }
+        } else {
+          await scanDirectory(entryPath, entryRelativePath);
+        }
+      }
+    } catch {
+    }
+  }
+  await scanDirectory(specsDir);
+  if (options.includeArchived) {
+    const archivedPath = path.join(specsDir, "archived");
+    await scanDirectory(archivedPath, "archived");
+  }
+  specs.sort((a, b) => {
+    const aNum = parseInt(a.name.match(/^(\d+)/)?.[1] || "0", 10);
+    const bNum = parseInt(b.name.match(/^(\d+)/)?.[1] || "0", 10);
+    return bNum - aNum;
+  });
+  return specs;
+}
+async function analyzeSpecFile(filePath, fullPath, relativePath, name) {
+  const content = await fs.readFile(filePath, "utf-8");
+  let hasFrontmatter = false;
+  let hasValidFrontmatter = false;
+  let existingFrontmatter;
+  try {
+    const parsed = matter(content);
+    if (parsed.data && Object.keys(parsed.data).length > 0) {
+      hasFrontmatter = true;
+      existingFrontmatter = parsed.data;
+      hasValidFrontmatter = !!(parsed.data.status && parsed.data.created);
+    }
+  } catch {
+  }
+  const inferredStatus = inferStatusFromContent(content) || inferStatusFromGit(filePath) || "planned";
+  const inferredCreated = inferCreatedFromContent(content) || inferCreatedFromGit(filePath) || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return {
+    path: relativePath,
+    fullPath,
+    filePath,
+    name,
+    content,
+    hasFrontmatter,
+    hasValidFrontmatter,
+    existingFrontmatter,
+    inferredStatus: existingFrontmatter?.status || inferredStatus,
+    inferredCreated: existingFrontmatter?.created || inferredCreated
+  };
+}
+function inferStatusFromContent(content) {
+  const inlineMatch = content.match(/\*\*Status\*\*:\s*(?:✅\s*|📅\s*|⏳\s*|📦\s*)?(\w+(?:-\w+)?)/i);
+  if (inlineMatch) {
+    return normalizeStatus(inlineMatch[1]);
+  }
+  const simpleMatch = content.match(/^Status:\s*(\w+(?:-\w+)?)/mi);
+  if (simpleMatch) {
+    return normalizeStatus(simpleMatch[1]);
+  }
+  if (/^\s*-\s*\[x\]\s*(done|complete|finished)/mi.test(content)) {
+    return "complete";
+  }
+  const adrMatch = content.match(/^##?\s*Status\s*\n+\s*(\w+)/mi);
+  if (adrMatch) {
+    const adrStatus = adrMatch[1].toLowerCase();
+    if (["accepted", "approved", "done"].includes(adrStatus)) {
+      return "complete";
+    }
+    if (["proposed", "pending", "draft"].includes(adrStatus)) {
+      return "planned";
+    }
+    if (["superseded", "deprecated", "rejected"].includes(adrStatus)) {
+      return "archived";
+    }
+  }
+  return null;
+}
+function inferStatusFromGit(filePath) {
+  if (!fileExistsInGit(filePath)) {
+    return null;
+  }
+  try {
+    const transitions = parseStatusTransitions(filePath);
+    if (transitions.length > 0) {
+      return transitions[transitions.length - 1].status;
+    }
+  } catch {
+  }
+  return null;
+}
+function normalizeStatus(status) {
+  const normalized = status.toLowerCase().trim().replace(/\s+/g, "-");
+  const statusMap = {
+    // Standard statuses
+    "planned": "planned",
+    "in-progress": "in-progress",
+    "inprogress": "in-progress",
+    "in_progress": "in-progress",
+    "wip": "in-progress",
+    "working": "in-progress",
+    "active": "in-progress",
+    "complete": "complete",
+    "completed": "complete",
+    "done": "complete",
+    "finished": "complete",
+    "implemented": "complete",
+    "archived": "archived",
+    "deprecated": "archived",
+    "superseded": "archived",
+    "rejected": "archived",
+    // ADR statuses
+    "accepted": "complete",
+    "approved": "complete",
+    "proposed": "planned",
+    "pending": "planned",
+    "draft": "planned"
+  };
+  return statusMap[normalized] || "planned";
+}
+function inferCreatedFromContent(content) {
+  const inlineMatch = content.match(/\*\*Created\*\*:\s*(\d{4}-\d{2}-\d{2})/);
+  if (inlineMatch) {
+    return inlineMatch[1];
+  }
+  const simpleMatch = content.match(/^Created:\s*(\d{4}-\d{2}-\d{2})/mi);
+  if (simpleMatch) {
+    return simpleMatch[1];
+  }
+  const dateMatch = content.match(/^Date:\s*(\d{4}-\d{2}-\d{2})/mi);
+  if (dateMatch) {
+    return dateMatch[1];
+  }
+  const adrMatch = content.match(/^##?\s*Date\s*\n+\s*(\w+\s+\d{1,2},?\s+\d{4})/mi);
+  if (adrMatch) {
+    try {
+      const date = new Date(adrMatch[1]);
+      if (!isNaN(date.getTime())) {
+        return date.toISOString().split("T")[0];
+      }
+    } catch {
+    }
+  }
+  const anyDateMatch = content.match(/(\d{4}-\d{2}-\d{2})/);
+  if (anyDateMatch) {
+    return anyDateMatch[1];
+  }
+  return null;
+}
+function inferCreatedFromGit(filePath) {
+  const timestamp = getFirstCommitTimestamp(filePath);
+  if (timestamp) {
+    return timestamp.split("T")[0];
+  }
+  return null;
+}
+
+// src/commands/backfill.ts
+function backfillCommand() {
+  return new Command("backfill").description("Backfill timestamps from git history").argument("[specs...]", "Specific specs to backfill (optional)").option("--dry-run", "Show what would be updated without making changes").option("--force", "Overwrite existing timestamp values").option("--assignee", "Include assignee from first commit author").option("--transitions", "Include full status transition history").option("--all", "Include all optional fields (assignee + transitions)").option("--bootstrap", "Create frontmatter for files without valid frontmatter").option("--json", "Output as JSON").action(async (specs, options) => {
+    await backfillTimestamps({
+      dryRun: options.dryRun,
+      force: options.force,
+      includeAssignee: options.assignee || options.all,
+      includeTransitions: options.transitions || options.all,
+      specs: specs && specs.length > 0 ? specs : void 0,
+      json: options.json,
+      bootstrap: options.bootstrap
+    });
+  });
+}
+async function backfillTimestamps(options = {}) {
+  const results = [];
+  if (!isGitRepository()) {
+    console.error("\x1B[31mError:\x1B[0m Not in a git repository");
+    console.error("Git history is required for backfilling timestamps");
+    process.exit(1);
+  }
+  const config = await loadConfig();
+  const cwd = process.cwd();
+  const specsDir = path.join(cwd, config.specsDir);
+  if (options.bootstrap) {
+    console.log("\x1B[36m\u{1F527} Bootstrap mode - will create frontmatter for files without it\x1B[0m\n");
+    const bootstrapSpecs = await loadSpecsForBootstrap(specsDir, {
+      includeArchived: true,
+      targetSpecs: options.specs
+    });
+    if (bootstrapSpecs.length === 0) {
+      console.log("No specs found to bootstrap");
+      return results;
+    }
+    console.log(`Analyzing git history for ${bootstrapSpecs.length} spec${bootstrapSpecs.length === 1 ? "" : "s"}...
+`);
+    for (const spec of bootstrapSpecs) {
+      const result = await bootstrapSpec(spec, options);
+      results.push(result);
+    }
+    printSummary(results, options);
+    return results;
+  }
+  let specs;
+  if (options.specs && options.specs.length > 0) {
+    specs = [];
+    for (const specPath of options.specs) {
+      const resolved = await resolveSpecPath(specPath, cwd, specsDir);
+      if (!resolved) {
+        console.warn(`\x1B[33mWarning:\x1B[0m Spec not found: ${specPath}`);
+        continue;
+      }
+      const spec = await getSpec(resolved);
+      if (spec) {
+        specs.push(spec);
+      }
+    }
+  } else {
+    specs = await loadAllSpecs({ includeArchived: true });
+  }
+  if (specs.length === 0) {
+    console.log("No specs found to backfill");
+    console.log("\x1B[36m\u2139\x1B[0m  Use --bootstrap to create frontmatter for files without it");
+    return results;
+  }
+  if (options.dryRun) {
+    console.log("\x1B[36m\u{1F50D} Dry run mode - no changes will be made\x1B[0m\n");
+  }
+  console.log(`Analyzing git history for ${specs.length} spec${specs.length === 1 ? "" : "s"}...
+`);
+  for (const spec of specs) {
+    const result = await backfillSpecTimestamps(spec, options);
+    results.push(result);
+  }
+  printSummary(results, options);
+  return results;
+}
+async function backfillSpecTimestamps(spec, options) {
+  const result = {
+    specPath: spec.path,
+    specName: spec.name,
+    source: "skipped"
+  };
+  if (!spec.frontmatter.status || !spec.frontmatter.created) {
+    result.reason = "Missing required frontmatter (status or created)";
+    console.log(`\x1B[33m\u2298\x1B[0m ${spec.name} - Missing required frontmatter`);
+    return result;
+  }
+  if (!fileExistsInGit(spec.filePath)) {
+    result.reason = "Not in git history";
+    console.log(`\x1B[33m\u2298\x1B[0m ${spec.name} - Not in git history`);
+    return result;
+  }
+  const gitData = extractGitTimestamps(spec.filePath, {
+    includeAssignee: options.includeAssignee,
+    includeTransitions: options.includeTransitions
+  });
+  const updates = {};
+  let hasUpdates = false;
+  if (gitData.created_at && (options.force || !spec.frontmatter.created_at)) {
+    updates.created_at = gitData.created_at;
+    result.created_at = gitData.created_at;
+    result.source = "git";
+    hasUpdates = true;
+  } else if (spec.frontmatter.created_at) {
+    result.created_at = spec.frontmatter.created_at;
+    result.source = "existing";
+  }
+  if (gitData.updated_at && (options.force || !spec.frontmatter.updated_at)) {
+    updates.updated_at = gitData.updated_at;
+    result.updated_at = gitData.updated_at;
+    result.source = "git";
+    hasUpdates = true;
+  } else if (spec.frontmatter.updated_at) {
+    result.updated_at = spec.frontmatter.updated_at;
+    result.source = "existing";
+  }
+  if (gitData.completed_at && (options.force || !spec.frontmatter.completed_at)) {
+    updates.completed_at = gitData.completed_at;
+    result.completed_at = gitData.completed_at;
+    result.source = "git";
+    hasUpdates = true;
+  } else if (spec.frontmatter.completed_at) {
+    result.completed_at = spec.frontmatter.completed_at;
+    result.source = "existing";
+  }
+  if (options.includeAssignee && gitData.assignee && (options.force || !spec.frontmatter.assignee)) {
+    updates.assignee = gitData.assignee;
+    result.assignee = gitData.assignee;
+    result.source = "git";
+    hasUpdates = true;
+  } else if (spec.frontmatter.assignee) {
+    result.assignee = spec.frontmatter.assignee;
+  }
+  if (options.includeTransitions && gitData.transitions && gitData.transitions.length > 0) {
+    if (options.force || !spec.frontmatter.transitions || spec.frontmatter.transitions.length === 0) {
+      updates.transitions = gitData.transitions;
+      result.transitionsCount = gitData.transitions.length;
+      result.source = "git";
+      hasUpdates = true;
+    } else {
+      result.transitionsCount = spec.frontmatter.transitions.length;
+    }
+  }
+  if (updates.updated_at && !updates.updated) {
+    updates.updated = updates.updated_at.split("T")[0];
+  }
+  if (!hasUpdates) {
+    result.reason = "Already has complete data";
+    console.log(`\x1B[90m\u2713\x1B[0m ${spec.name} - Already complete`);
+    return result;
+  }
+  if (!options.dryRun) {
+    try {
+      await updateFrontmatter(spec.filePath, updates);
+      console.log(`\x1B[32m\u2713\x1B[0m ${spec.name} - Updated`);
+    } catch (error) {
+      result.source = "skipped";
+      result.reason = `Error: ${error instanceof Error ? error.message : String(error)}`;
+      console.log(`\x1B[31m\u2717\x1B[0m ${spec.name} - Failed: ${result.reason}`);
+    }
+  } else {
+    console.log(`\x1B[36m\u2192\x1B[0m ${spec.name} - Would update`);
+    if (updates.created_at) console.log(`  created_at:   ${updates.created_at} (git)`);
+    if (updates.updated_at) console.log(`  updated_at:   ${updates.updated_at} (git)`);
+    if (updates.completed_at) console.log(`  completed_at: ${updates.completed_at} (git)`);
+    if (updates.assignee) console.log(`  assignee:     ${updates.assignee} (git)`);
+    if (updates.transitions) console.log(`  transitions:  ${updates.transitions.length} status changes (git)`);
+  }
+  return result;
+}
+async function bootstrapSpec(spec, options) {
+  const result = {
+    specPath: spec.path,
+    specName: spec.name,
+    source: "skipped",
+    bootstrapped: false
+  };
+  if (spec.hasValidFrontmatter && !options.force) {
+    result.reason = "Already has valid frontmatter";
+    console.log(`\x1B[90m\u2713\x1B[0m ${spec.name} - Already valid`);
+    return result;
+  }
+  const frontmatter = {
+    ...spec.existingFrontmatter || {},
+    status: spec.inferredStatus || "planned",
+    created: spec.inferredCreated || (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+  };
+  if (fileExistsInGit(spec.filePath)) {
+    const gitData = extractGitTimestamps(spec.filePath, {
+      includeAssignee: options.includeAssignee,
+      includeTransitions: options.includeTransitions
+    });
+    if (gitData.created_at) {
+      frontmatter.created_at = gitData.created_at;
+      result.created_at = gitData.created_at;
+    }
+    if (gitData.updated_at) {
+      frontmatter.updated_at = gitData.updated_at;
+      result.updated_at = gitData.updated_at;
+    }
+    if (gitData.completed_at) {
+      frontmatter.completed_at = gitData.completed_at;
+      result.completed_at = gitData.completed_at;
+    }
+    if (options.includeAssignee && gitData.assignee) {
+      frontmatter.assignee = gitData.assignee;
+      result.assignee = gitData.assignee;
+    }
+    if (options.includeTransitions && gitData.transitions && gitData.transitions.length > 0) {
+      frontmatter.transitions = gitData.transitions;
+      result.transitionsCount = gitData.transitions.length;
+    }
+  }
+  const statusSource = spec.existingFrontmatter?.status ? "existing" : spec.content.match(/\*\*Status\*\*/i) ? "content" : "default";
+  const createdSource = spec.existingFrontmatter?.created ? "existing" : spec.content.match(/\*\*Created\*\*/i) ? "content" : fileExistsInGit(spec.filePath) ? "git" : "default";
+  if (!options.dryRun) {
+    try {
+      await writeBootstrapFrontmatter(spec.filePath, spec.content, frontmatter);
+      result.source = "bootstrapped";
+      result.bootstrapped = true;
+      console.log(`\x1B[32m\u2713\x1B[0m ${spec.name} - Bootstrapped`);
+      console.log(`  status: ${frontmatter.status} (${statusSource})`);
+      console.log(`  created: ${frontmatter.created} (${createdSource})`);
+    } catch (error) {
+      result.source = "skipped";
+      result.reason = `Error: ${error instanceof Error ? error.message : String(error)}`;
+      console.log(`\x1B[31m\u2717\x1B[0m ${spec.name} - Failed: ${result.reason}`);
+    }
+  } else {
+    result.source = "bootstrapped";
+    result.bootstrapped = true;
+    console.log(`\x1B[36m\u2192\x1B[0m ${spec.name} - Would bootstrap`);
+    console.log(`  status: ${frontmatter.status} (${statusSource})`);
+    console.log(`  created: ${frontmatter.created} (${createdSource})`);
+    if (frontmatter.created_at) console.log(`  created_at: ${frontmatter.created_at} (git)`);
+    if (frontmatter.updated_at) console.log(`  updated_at: ${frontmatter.updated_at} (git)`);
+    if (frontmatter.completed_at) console.log(`  completed_at: ${frontmatter.completed_at} (git)`);
+    if (frontmatter.assignee) console.log(`  assignee: ${frontmatter.assignee} (git)`);
+    if (frontmatter.transitions) console.log(`  transitions: ${frontmatter.transitions.length} (git)`);
+  }
+  return result;
+}
+async function writeBootstrapFrontmatter(filePath, originalContent, frontmatter) {
+  const matter2 = await import('gray-matter');
+  const parsed = matter2.default(originalContent);
+  const newData = { ...parsed.data, ...frontmatter };
+  const newContent = matter2.default.stringify(parsed.content, newData);
+  await fs.writeFile(filePath, newContent, "utf-8");
+}
+function printSummary(results, options) {
+  console.log("\n" + "\u2500".repeat(60));
+  console.log("\x1B[1mSummary:\x1B[0m\n");
+  const total = results.length;
+  const updated = results.filter((r) => r.source === "git").length;
+  const bootstrapped = results.filter((r) => r.source === "bootstrapped").length;
+  const existing = results.filter((r) => r.source === "existing").length;
+  const skipped = results.filter((r) => r.source === "skipped").length;
+  const timestampUpdates = results.filter(
+    (r) => (r.source === "git" || r.source === "bootstrapped") && (r.created_at || r.updated_at || r.completed_at)
+  ).length;
+  const assigneeUpdates = results.filter(
+    (r) => (r.source === "git" || r.source === "bootstrapped") && r.assignee
+  ).length;
+  const transitionUpdates = results.filter(
+    (r) => (r.source === "git" || r.source === "bootstrapped") && r.transitionsCount
+  ).length;
+  console.log(`  ${total} specs analyzed`);
+  if (options.dryRun) {
+    if (options.bootstrap) {
+      console.log(`  ${bootstrapped} would be bootstrapped`);
+    }
+    console.log(`  ${updated} would be updated`);
+    if (timestampUpdates > 0) {
+      console.log(`    \u2514\u2500 ${timestampUpdates} with timestamps`);
+    }
+    if (options.includeAssignee && assigneeUpdates > 0) {
+      console.log(`    \u2514\u2500 ${assigneeUpdates} with assignee`);
+    }
+    if (options.includeTransitions && transitionUpdates > 0) {
+      console.log(`    \u2514\u2500 ${transitionUpdates} with transitions`);
+    }
+  } else {
+    if (options.bootstrap) {
+      console.log(`  ${bootstrapped} bootstrapped`);
+    }
+    console.log(`  ${updated} updated`);
+  }
+  console.log(`  ${existing} already complete`);
+  console.log(`  ${skipped} skipped`);
+  const skipReasons = results.filter((r) => r.source === "skipped" && r.reason).map((r) => r.reason);
+  if (skipReasons.length > 0) {
+    console.log("\n\x1B[33mSkipped reasons:\x1B[0m");
+    const uniqueReasons = [...new Set(skipReasons)];
+    for (const reason of uniqueReasons) {
+      const count = skipReasons.filter((r) => r === reason).length;
+      console.log(`  - ${reason} (${count})`);
+    }
+  }
+  if (options.dryRun) {
+    console.log("\n\x1B[36m\u2139\x1B[0m  Run without --dry-run to apply changes");
+    if (!options.includeAssignee || !options.includeTransitions) {
+      console.log("\x1B[36m\u2139\x1B[0m  Use --all to include optional fields (assignee, transitions)");
+    }
+    if (!options.bootstrap && skipped > 0) {
+      console.log("\x1B[36m\u2139\x1B[0m  Use --bootstrap to create frontmatter for files without it");
+    }
+  } else if (updated > 0 || bootstrapped > 0) {
+    console.log("\n\x1B[32m\u2713\x1B[0m Backfill complete!");
+    console.log("  Run \x1B[36mlean-spec stats\x1B[0m to see velocity metrics");
+  }
+}
+
+export { backfillCommand, backfillTimestamps, createSpecDirPattern, getGlobalNextSeq, resolveSpecPath };
+//# sourceMappingURL=chunk-H5MCUMBK.js.map
+//# sourceMappingURL=chunk-H5MCUMBK.js.map