@girardmedia/bootspring 2.0.21 → 2.0.23

package/src/cli/prd.ts

@@ -0,0 +1,671 @@
+/**
+ * Bootspring PRD Command
+ * Product Requirements Document management
+ *
+ * Commands:
+ *   create            Create a new PRD
+ *   list              List all PRDs
+ *   show              Show a specific PRD
+ *   import            Import PRDs from .bootspring/inputs/prd
+ *   to-tasks          Convert PRD to todo items
+ *   status            Show PRD system status
+ *
+ * @package bootspring
+ * @command prd
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Type interfaces for JS modules
+interface Colors {
+  reset: string;
+  bold: string;
+  dim: string;
+  cyan: string;
+  green: string;
+  yellow: string;
+  red: string;
+}
+
+interface PrintModule {
+  error(msg: string): void;
+  success(msg: string): void;
+  warning(msg: string): void;
+  dim(msg: string): void;
+}
+
+interface Spinner {
+  start(): Spinner;
+  stop(): void;
+  succeed(text: string): void;
+  fail(text: string): void;
+}
+
+interface UtilsModule {
+  COLORS: Colors;
+  print: PrintModule;
+  createSpinner(text: string): Spinner;
+  parseArgs(args: string[]): ParsedArgs;
+  formatRelativeTime(date: Date): string;
+}
+
+interface ConfigModule {
+  findProjectRoot(): string;
+}
+
+interface ParsedArgs {
+  _: string[];
+  name?: string | undefined;
+  title?: string | undefined;
+  description?: string | undefined;
+  force?: boolean | undefined;
+  [key: string]: string | boolean | string[] | undefined;
+}
+
+interface PrdInfo {
+  name: string;
+  title: string;
+  source: 'generated' | 'input';
+  status: string;
+  modified: Date;
+}
+
+interface IngestedPrd {
+  file: string;
+  userStories?: string[] | undefined;
+  features?: string[] | undefined;
+  requirements?: {
+    mustHave?: string[] | undefined;
+    shouldHave?: string[] | undefined;
+    niceToHave?: string[] | undefined;
+  } | undefined;
+}
+
+interface IngestModule {
+  ingestPRD(projectRoot: string): Promise<IngestedPrd[]>;
+}
+
+interface TodoModule {
+  add(options: { text: string; priority: number }): void;
+}
+
+interface Task {
+  text: string;
+  type: 'story' | 'requirement';
+  priority: number;
+}
+
+const utils = require('../core/utils') as UtilsModule;
+const config = require('../core/config') as ConfigModule;
+
+// Lazy load ingest module
+let ingest: IngestModule | null = null;
+function getIngest(): IngestModule {
+  if (!ingest) {
+    ingest = require('../core/ingest') as IngestModule;
+  }
+  return ingest;
+}
+
+/**
+ * Run PRD command
+ */
+export async function run(args: string[]): Promise<void> {
+  const parsedArgs = utils.parseArgs(args);
+  const subcommand = parsedArgs._[0] || 'status';
+
+  switch (subcommand) {
+    case 'create':
+      return prdCreate(parsedArgs);
+    case 'list':
+      return prdList(parsedArgs);
+    case 'show':
+      return prdShow(parsedArgs);
+    case 'import':
+      return prdImport(parsedArgs);
+    case 'to-tasks':
+      return prdToTasks(parsedArgs);
+    case 'status':
+      return prdStatus(parsedArgs);
+    case 'help':
+    case '-h':
+    case '--help':
+      return showHelp();
+    default:
+      utils.print.error(`Unknown subcommand: ${subcommand}`);
+      showHelp();
+  }
+}
+
+/**
+ * Create a new PRD
+ */
+function prdCreate(args: ParsedArgs): void {
+  const projectRoot = config.findProjectRoot();
+  const name = args._[1] || args.name;
+  const title = args.title;
+  const description = args.description;
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Bootspring PRD Create${utils.COLORS.reset}
+${utils.COLORS.dim}Create a new Product Requirements Document${utils.COLORS.reset}
+`);
+
+  if (!name) {
+    utils.print.error('PRD name required');
+    utils.print.dim('Usage: bootspring prd create <name> [--title="..."] [--description="..."]');
+    return;
+  }
+
+  const prdDir = path.join(projectRoot, '.bootspring', 'generated', 'prd');
+  if (!fs.existsSync(prdDir)) {
+    fs.mkdirSync(prdDir, { recursive: true });
+  }
+
+  const fileName = `${name.toLowerCase().replace(/\s+/g, '-')}.md`;
+  const filePath = path.join(prdDir, fileName);
+
+  if (fs.existsSync(filePath) && !args.force) {
+    utils.print.warning(`PRD already exists: ${fileName}`);
+    utils.print.dim('Use --force to overwrite');
+    return;
+  }
+
+  const date = new Date().toISOString().split('T')[0] || '';
+  const content = `# ${title || name}
+
+**Status:** Draft
+**Created:** ${date}
+**Author:** ${process.env.USER || 'Bootspring'}
+
+## Overview
+
+${description || 'Add description here.'}
+
+## Problem Statement
+
+Describe the problem being solved and why it matters.
+
+## Goals
+
+1. Primary goal
+2. Secondary goal
+3. Success criteria
+
+## User Stories
+
+### As a user, I want to...
+
+- [ ] User story 1
+- [ ] User story 2
+- [ ] User story 3
+
+## Requirements
+
+### Must Have (P0)
+- Requirement 1
+- Requirement 2
+
+### Should Have (P1)
+- Requirement 3
+- Requirement 4
+
+### Nice to Have (P2)
+- Requirement 5
+
+## Technical Considerations
+
+- Architecture notes
+- Dependencies
+- Performance requirements
+
+## Success Metrics
+
+| Metric | Target | Current |
+|--------|--------|---------|
+| Metric 1 | X | - |
+| Metric 2 | Y | - |
+
+## Timeline
+
+| Phase | Duration | Status |
+|-------|----------|--------|
+| Research | 1 week | Not started |
+| Design | 1 week | Not started |
+| Implementation | 2 weeks | Not started |
+| Testing | 1 week | Not started |
+
+## Open Questions
+
+1. Question 1?
+2. Question 2?
+
+## References
+
+- Link 1
+- Link 2
+
+---
+*Generated by Bootspring PRD System*
+`;
+
+  fs.writeFileSync(filePath, content);
+  utils.print.success(`Created PRD: ${fileName}`);
+
+  console.log(`
+${utils.COLORS.bold}Next steps:${utils.COLORS.reset}
+  1. Edit ${utils.COLORS.cyan}.bootspring/generated/prd/${fileName}${utils.COLORS.reset}
+  2. Run ${utils.COLORS.cyan}bootspring prd to-tasks ${name}${utils.COLORS.reset} to create todos
+`);
+}
+
+/**
+ * List all PRDs
+ */
+function prdList(_args: ParsedArgs): void {
+  const projectRoot = config.findProjectRoot();
+  const prdDir = path.join(projectRoot, '.bootspring', 'generated', 'prd');
+  const inputPrdDir = path.join(projectRoot, '.bootspring', 'inputs', 'prd');
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Bootspring PRD List${utils.COLORS.reset}
+`);
+
+  const prds: PrdInfo[] = [];
+
+  // Check generated PRDs
+  if (fs.existsSync(prdDir)) {
+    const files = fs.readdirSync(prdDir).filter(f => f.endsWith('.md'));
+    for (const file of files) {
+      const filePath = path.join(prdDir, file);
+      const stats = fs.statSync(filePath);
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const titleMatch = content.match(/^#\s+(.+)/m);
+      const statusMatch = content.match(/\*\*Status:\*\*\s*(.+)/i);
+
+      prds.push({
+        name: file.replace('.md', ''),
+        title: titleMatch?.[1] || file,
+        source: 'generated',
+        status: statusMatch?.[1]?.trim() || 'Unknown',
+        modified: stats.mtime
+      });
+    }
+  }
+
+  // Check input PRDs
+  if (fs.existsSync(inputPrdDir)) {
+    const files = fs.readdirSync(inputPrdDir).filter(f =>
+      f.endsWith('.md') || f.endsWith('.txt')
+    );
+    for (const file of files) {
+      if (file === 'README.md') continue;
+      const filePath = path.join(inputPrdDir, file);
+      const stats = fs.statSync(filePath);
+
+      prds.push({
+        name: file.replace(/\.(md|txt)$/, ''),
+        title: file,
+        source: 'input',
+        status: 'Imported',
+        modified: stats.mtime
+      });
+    }
+  }
+
+  if (prds.length === 0) {
+    utils.print.dim('No PRDs found');
+    console.log(`
+${utils.COLORS.bold}To create a PRD:${utils.COLORS.reset}
+  bootspring prd create <name> --title="My Feature"
+
+${utils.COLORS.bold}To import PRDs:${utils.COLORS.reset}
+  1. Drop files in ${utils.COLORS.cyan}.bootspring/inputs/prd/${utils.COLORS.reset}
+  2. Run ${utils.COLORS.cyan}bootspring prd import${utils.COLORS.reset}
+`);
+    return;
+  }
+
+  console.log(`${utils.COLORS.bold}PRDs:${utils.COLORS.reset}
+`);
+
+  for (const prd of prds) {
+    const modified = utils.formatRelativeTime(prd.modified);
+    const sourceIcon = prd.source === 'generated' ? utils.COLORS.green + '+' : utils.COLORS.cyan + '>';
+    console.log(`  ${sourceIcon}${utils.COLORS.reset} ${utils.COLORS.bold}${prd.name}${utils.COLORS.reset}`);
+    console.log(`    ${utils.COLORS.dim}${prd.title.slice(0, 50)}${utils.COLORS.reset}`);
+    console.log(`    ${utils.COLORS.dim}Status: ${prd.status} | Modified: ${modified}${utils.COLORS.reset}`);
+    console.log();
+  }
+
+  console.log(`${utils.COLORS.dim}Total: ${prds.length} PRDs (${prds.filter(p => p.source === 'generated').length} generated, ${prds.filter(p => p.source === 'input').length} imported)${utils.COLORS.reset}`);
+}
+
+/**
+ * Show a specific PRD
+ */
+function prdShow(args: ParsedArgs): void {
+  const projectRoot = config.findProjectRoot();
+  const name = args._[1] || args.name;
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Bootspring PRD Show${utils.COLORS.reset}
+`);
+
+  if (!name) {
+    utils.print.error('PRD name required');
+    utils.print.dim('Usage: bootspring prd show <name>');
+    return;
+  }
+
+  // Try generated first, then input
+  const paths = [
+    path.join(projectRoot, '.bootspring', 'generated', 'prd', `${name}.md`),
+    path.join(projectRoot, '.bootspring', 'inputs', 'prd', `${name}.md`),
+    path.join(projectRoot, '.bootspring', 'inputs', 'prd', name)
+  ];
+
+  let content: string | null = null;
+  let foundPath: string | null = null;
+
+  for (const p of paths) {
+    if (fs.existsSync(p)) {
+      content = fs.readFileSync(p, 'utf-8');
+      foundPath = p;
+      break;
+    }
+  }
+
+  if (!content) {
+    utils.print.error(`PRD not found: ${name}`);
+    utils.print.dim('Run "bootspring prd list" to see available PRDs');
+    return;
+  }
+
+  console.log(`${utils.COLORS.dim}File: ${foundPath}${utils.COLORS.reset}
+`);
+  console.log(content);
+}
+
+/**
+ * Import PRDs from inputs folder
+ */
+async function prdImport(_args: ParsedArgs): Promise<void> {
+  const projectRoot = config.findProjectRoot();
+  const inputPrdDir = path.join(projectRoot, '.bootspring', 'inputs', 'prd');
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Bootspring PRD Import${utils.COLORS.reset}
+${utils.COLORS.dim}Importing PRDs from .bootspring/inputs/prd${utils.COLORS.reset}
+`);
+
+  if (!fs.existsSync(inputPrdDir)) {
+    utils.print.warning('No .bootspring/inputs/prd folder found');
+    utils.print.dim('Run "bootspring seed setup" to create the folder structure');
+    return;
+  }
+
+  const spinner = utils.createSpinner('Analyzing PRD files...').start();
+
+  try {
+    const Ingest = getIngest();
+    const ingested = await Ingest.ingestPRD(projectRoot);
+
+    spinner.succeed('Analyzed PRD files');
+
+    if (!ingested || ingested.length === 0) {
+      utils.print.dim('No PRD files found in .bootspring/inputs/prd/');
+      return;
+    }
+
+    console.log(`
+${utils.COLORS.bold}Imported ${ingested.length} PRD files:${utils.COLORS.reset}
+`);
+
+    for (const prd of ingested) {
+      console.log(`  ${utils.COLORS.green}+${utils.COLORS.reset} ${prd.file}`);
+      if (prd.userStories && prd.userStories.length > 0) {
+        console.log(`    ${utils.COLORS.dim}User Stories: ${prd.userStories.length}${utils.COLORS.reset}`);
+      }
+      if (prd.features && prd.features.length > 0) {
+        console.log(`    ${utils.COLORS.dim}Features: ${prd.features.length}${utils.COLORS.reset}`);
+      }
+      if (prd.requirements?.mustHave && prd.requirements.mustHave.length > 0) {
+        console.log(`    ${utils.COLORS.dim}Requirements: ${prd.requirements.mustHave.length} must-have${utils.COLORS.reset}`);
+      }
+    }
+
+    console.log(`
+${utils.COLORS.bold}Next steps:${utils.COLORS.reset}
+  1. Run ${utils.COLORS.cyan}bootspring prd to-tasks${utils.COLORS.reset} to create todos
+  2. Run ${utils.COLORS.cyan}bootspring seed generate${utils.COLORS.reset} to update context
+`);
+  } catch (error) {
+    spinner.fail(`Import failed: ${(error as Error).message}`);
+  }
+}
+
+/**
+ * Convert PRD to tasks
+ */
+async function prdToTasks(args: ParsedArgs): Promise<void> {
+  const projectRoot = config.findProjectRoot();
+  const name = args._[1] || args.name;
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Bootspring PRD to Tasks${utils.COLORS.reset}
+${utils.COLORS.dim}Converting PRD requirements to todos${utils.COLORS.reset}
+`);
+
+  let content: string | null = null;
+
+  if (name) {
+    // Load specific PRD
+    const paths = [
+      path.join(projectRoot, '.bootspring', 'generated', 'prd', `${name}.md`),
+      path.join(projectRoot, '.bootspring', 'inputs', 'prd', `${name}.md`)
+    ];
+
+    for (const p of paths) {
+      if (fs.existsSync(p)) {
+        content = fs.readFileSync(p, 'utf-8');
+        break;
+      }
+    }
+
+    if (!content) {
+      utils.print.error(`PRD not found: ${name}`);
+      utils.print.dim('Run "bootspring prd list" to see available PRDs');
+      return;
+    }
+  } else {
+    // Load all PRDs
+    const prdDir = path.join(projectRoot, '.bootspring', 'generated', 'prd');
+    if (fs.existsSync(prdDir)) {
+      const files = fs.readdirSync(prdDir).filter(f => f.endsWith('.md'));
+      content = files.map(f => fs.readFileSync(path.join(prdDir, f), 'utf-8')).join('\n\n');
+    }
+  }
+
+  if (!content) {
+    utils.print.warning('No PRDs to process');
+    return;
+  }
+
+  // Extract tasks from content
+  const tasks: Task[] = [];
+
+  // Extract user stories (lines with - [ ])
+  const storyMatches = content.matchAll(/^\s*-\s*\[\s*\]\s*(.+)$/gm);
+  for (const match of storyMatches) {
+    const text = match[1]?.trim();
+    if (text && text.length > 5) {
+      tasks.push({ text, type: 'story', priority: 2 });
+    }
+  }
+
+  // Extract requirements from Must Have section
+  const mustHaveSection = content.match(/### Must Have.*?\n([\s\S]*?)(?=###|##|$)/i);
+  if (mustHaveSection?.[1]) {
+    const reqMatches = mustHaveSection[1].matchAll(/^\s*-\s*(.+)$/gm);
+    for (const match of reqMatches) {
+      const text = match[1]?.trim();
+      if (text && text.length > 5 && !text.startsWith('[')) {
+        tasks.push({ text, type: 'requirement', priority: 1 });
+      }
+    }
+  }
+
+  // Extract requirements from Should Have section
+  const shouldHaveSection = content.match(/### Should Have.*?\n([\s\S]*?)(?=###|##|$)/i);
+  if (shouldHaveSection?.[1]) {
+    const reqMatches = shouldHaveSection[1].matchAll(/^\s*-\s*(.+)$/gm);
+    for (const match of reqMatches) {
+      const text = match[1]?.trim();
+      if (text && text.length > 5 && !text.startsWith('[')) {
+        tasks.push({ text, type: 'requirement', priority: 2 });
+      }
+    }
+  }
+
+  if (tasks.length === 0) {
+    utils.print.warning('No actionable items found in PRD');
+    utils.print.dim('Add user stories with "- [ ] ..." or requirements with "- ..."');
+    return;
+  }
+
+  console.log(`
+${utils.COLORS.bold}Found ${tasks.length} tasks:${utils.COLORS.reset}
+`);
+
+  // Load todo module
+  const todoModule = require('./todo') as TodoModule;
+
+  let added = 0;
+  for (const task of tasks.slice(0, 20)) {
+    const prefix = task.type === 'story' ? '[Story]' : '[Req]';
+    const priority = task.priority === 1 ? 'P0' : 'P1';
+    const todoText = `${prefix} ${priority}: ${task.text.slice(0, 80)}`;
+
+    console.log(`  ${utils.COLORS.green}+${utils.COLORS.reset} ${todoText}`);
+
+    try {
+      todoModule.add({ text: todoText, priority: task.priority });
+      added++;
+    } catch {
+      // Skip if todo fails
+    }
+  }
+
+  if (tasks.length > 20) {
+    console.log(`  ${utils.COLORS.dim}... and ${tasks.length - 20} more (run with --all to add all)${utils.COLORS.reset}`);
+  }
+
+  console.log(`
+${utils.COLORS.green}${utils.COLORS.bold}Added ${added} tasks${utils.COLORS.reset}
+
+Run ${utils.COLORS.cyan}bootspring todo list${utils.COLORS.reset} to see all tasks
+`);
+}
+
+/**
+ * Show PRD status
+ */
+function prdStatus(_args: ParsedArgs): void {
+  const projectRoot = config.findProjectRoot();
+  const prdDir = path.join(projectRoot, '.bootspring', 'generated', 'prd');
+  const inputPrdDir = path.join(projectRoot, '.bootspring', 'inputs', 'prd');
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Bootspring PRD Status${utils.COLORS.reset}
+`);
+
+  const stats = {
+    generated: 0,
+    input: 0,
+    draft: 0,
+    approved: 0,
+    totalFeatures: 0,
+    totalStories: 0
+  };
+
+  // Count generated PRDs
+  if (fs.existsSync(prdDir)) {
+    const files = fs.readdirSync(prdDir).filter(f => f.endsWith('.md'));
+    stats.generated = files.length;
+
+    for (const file of files) {
+      const content = fs.readFileSync(path.join(prdDir, file), 'utf-8');
+      if (content.includes('Status:** Draft')) stats.draft++;
+      if (content.includes('Status:** Approved')) stats.approved++;
+
+      // Count user stories
+      const storyCount = (content.match(/-\s*\[\s*\]/g) || []).length;
+      stats.totalStories += storyCount;
+    }
+  }
+
+  // Count input PRDs
+  if (fs.existsSync(inputPrdDir)) {
+    const files = fs.readdirSync(inputPrdDir).filter(f =>
+      (f.endsWith('.md') || f.endsWith('.txt')) && f !== 'README.md'
+    );
+    stats.input = files.length;
+  }
+
+  console.log(`${utils.COLORS.bold}Summary:${utils.COLORS.reset}`);
+  console.log(`  Generated PRDs: ${utils.COLORS.cyan}${stats.generated}${utils.COLORS.reset}`);
+  console.log(`  Input PRDs: ${utils.COLORS.cyan}${stats.input}${utils.COLORS.reset}`);
+  console.log(`  Draft: ${stats.draft}`);
+  console.log(`  Approved: ${stats.approved}`);
+  console.log(`  Total User Stories: ${stats.totalStories}`);
+
+  const hasStructure = fs.existsSync(path.join(projectRoot, '.bootspring', 'inputs', 'prd'));
+
+  console.log(`
+${utils.COLORS.bold}Status:${utils.COLORS.reset}`);
+  console.log(`  ${hasStructure ? utils.COLORS.green + '✓' : utils.COLORS.yellow + '○'}${utils.COLORS.reset} Input folder exists`);
+  console.log(`  ${stats.generated > 0 ? utils.COLORS.green + '✓' : utils.COLORS.yellow + '○'}${utils.COLORS.reset} PRDs created`);
+
+  console.log(`
+${utils.COLORS.bold}Commands:${utils.COLORS.reset}
+  bootspring prd create <name>  ${utils.COLORS.dim}# Create new PRD${utils.COLORS.reset}
+  bootspring prd list           ${utils.COLORS.dim}# List all PRDs${utils.COLORS.reset}
+  bootspring prd show <name>    ${utils.COLORS.dim}# View a PRD${utils.COLORS.reset}
+  bootspring prd import         ${utils.COLORS.dim}# Import from inputs${utils.COLORS.reset}
+  bootspring prd to-tasks       ${utils.COLORS.dim}# Convert to todos${utils.COLORS.reset}
+`);
+}
+
+/**
+ * Show help
+ */
+function showHelp(): void {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Bootspring PRD${utils.COLORS.reset}
+${utils.COLORS.dim}Product Requirements Document management${utils.COLORS.reset}
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring prd <command> [options]
+
+${utils.COLORS.bold}Commands:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}create${utils.COLORS.reset}            Create a new PRD
+  ${utils.COLORS.cyan}list${utils.COLORS.reset}              List all PRDs
+  ${utils.COLORS.cyan}show${utils.COLORS.reset}              Show a specific PRD
+  ${utils.COLORS.cyan}import${utils.COLORS.reset}            Import PRDs from .bootspring/inputs/prd
+  ${utils.COLORS.cyan}to-tasks${utils.COLORS.reset}          Convert PRD to todo items
+  ${utils.COLORS.cyan}status${utils.COLORS.reset}            Show PRD system status (default)
+
+${utils.COLORS.bold}Create Options:${utils.COLORS.reset}
+  --title="..."       PRD title
+  --description="..." PRD description
+  --force             Overwrite existing PRD
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  bootspring prd create auth --title="User Authentication"
+  bootspring prd list
+  bootspring prd show auth
+  bootspring prd to-tasks auth
+`);
+}