@girardmedia/bootspring 2.0.21 → 2.0.23

package/src/cli/seed.ts

@@ -0,0 +1,1224 @@
+/**
+ * Bootspring Seed Command
+ * Project scaffolding and configuration management
+ *
+ * Commands:
+ *   setup             Create .bootspring/inputs folder structure
+ *   init              Full Q&A, generate SEED.md
+ *   synthesize        Create SEED.md from preseed documents
+ *   generate          Ingest files and generate documents
+ *   scaffold          Generate project structure from SEED.md
+ *   build             Build from seed docs (--loop for continuous)
+ *   update            Re-run questionnaire, update SEED.md
+ *   status            Show current seed configuration
+ *   export            Export seed config as JSON/YAML
+ *
+ * @package bootspring
+ * @command seed
+ */
+
+import * as path from 'path';
+import * as fs from 'fs';
+import * as readline from 'readline';
+import type { ParsedArgs } from './types';
+
+// Module interfaces
+interface Utils {
+  parseArgs: (args: string[]) => ParsedArgs;
+  COLORS: {
+    cyan: string;
+    bold: string;
+    reset: string;
+    dim: string;
+    green: string;
+    yellow: string;
+    red: string;
+  };
+  createSpinner: (text: string) => Spinner;
+  print: {
+    dim: (msg: string) => void;
+    warning: (msg: string) => void;
+    error: (msg: string) => void;
+    success: (msg: string) => void;
+    info: (msg: string) => void;
+    debug: (msg: string) => void;
+  };
+  fileExists: (path: string) => boolean;
+  writeFile: (path: string, content: string) => boolean;
+  formatRelativeTime: (date: Date) => string;
+}
+
+interface Spinner {
+  start: () => Spinner;
+  succeed: (text?: string) => Spinner;
+  fail: (text?: string) => Spinner;
+  warn: (text?: string) => Spinner;
+}
+
+interface Config {
+  findProjectRoot: () => string;
+  load: () => ProjectConfig | null;
+  save: (config: ProjectConfig, path: string) => boolean;
+}
+
+interface ProjectConfig {
+  _preset?: string | undefined;
+  project?: {
+    name?: string | undefined;
+    description?: string | undefined;
+    version?: string | undefined;
+    status?: string | undefined;
+  } | undefined;
+  stack?: {
+    framework?: string | undefined;
+    language?: string | undefined;
+    database?: string | undefined;
+    hosting?: string | undefined;
+  } | undefined;
+  frontend?: {
+    uiLibrary?: string | undefined;
+    styling?: string | undefined;
+  } | undefined;
+  backend?: {
+    orm?: string | undefined;
+    auth?: string | undefined;
+  } | undefined;
+}
+
+interface Scaffold {
+  getPresets: () => string[];
+  getPresetConfig: (preset: string) => ProjectConfig;
+  getPresetInfo: (preset: string) => { description: string } | null;
+  planScaffold: (config: ProjectConfig, projectRoot: string) => ScaffoldPlan;
+  execute: (plan: ScaffoldPlan, projectRoot: string) => Promise<ScaffoldResult>;
+}
+
+interface ScaffoldPlan {
+  preset?: string | undefined;
+  directories: string[];
+  files: { path: string; content?: string }[];
+}
+
+interface ScaffoldResult {
+  filesCreated: number;
+  dirsCreated: number;
+  warnings: string[];
+}
+
+interface SeedTemplate {
+  generate: (config: ProjectConfig) => string;
+}
+
+interface ProjectState {
+  PROJECT_TYPES: { DEVELOPMENT: string };
+  setProjectType: (root: string, type: string, meta: Record<string, unknown>) => void;
+}
+
+interface CheckpointEngine {
+  syncCheckpoints: (root: string, options: { verbose: boolean }) => void;
+}
+
+interface TierEnforcement {
+  requireSeedAccess: (command: string) => void;
+}
+
+interface Questionnaire {
+  runQuestionnaire: (preset: string) => Promise<ProjectConfig>;
+}
+
+interface TechStack {
+  framework?: string | undefined;
+  language?: string | undefined;
+  database?: string | undefined;
+  hosting?: string | undefined;
+  uiLibrary?: string | undefined;
+  styling?: string | undefined;
+  orm?: string | undefined;
+  auth?: string | undefined;
+}
+
+interface AIContextResults {
+  claudeMd?: boolean | undefined;
+  agentsMd?: boolean | undefined;
+  planningAgentsMd?: boolean | undefined;
+}
+
+interface SeedBuilders {
+  generateAIContextFiles: (root: string, config: ProjectConfig) => AIContextResults;
+  generateSeedFromPreseed: (docs: Record<string, string>, config: Record<string, unknown>) => string;
+}
+
+interface SeedFolders {
+  createSeedFolders: (root: string) => number;
+}
+
+interface SeedExtractors {
+  extractTechStack: (docs: Record<string, string>) => TechStack;
+  extractProjectName: (docs: Record<string, string>) => string | null;
+  extractTagline: (docs: Record<string, string>) => string | null;
+}
+
+interface IngestModule {
+  ingestAll: (root: string) => Promise<IngestedData>;
+  generateDocuments: (ingested: IngestedData, config: ProjectConfig, root: string) => Promise<Record<string, string>>;
+  updateContextIndex: (root: string, ingested: IngestedData) => Promise<void>;
+}
+
+interface IngestedData {
+  mvp?: { files?: unknown[] } | undefined;
+  business?: unknown[] | undefined;
+  prd?: unknown[] | undefined;
+  designs?: { files?: unknown[] } | undefined;
+  api?: unknown[] | undefined;
+  data?: unknown[] | undefined;
+}
+
+interface TierError extends Error {
+  code?: string | undefined;
+  upgradePrompt?: string | undefined;
+}
+
+// Lazy-loaded modules
+let _utils: Utils | null = null;
+let _config: Config | null = null;
+let _scaffold: Scaffold | null = null;
+let _seedTemplate: SeedTemplate | null = null;
+let _projectState: ProjectState | null = null;
+let _checkpointEngine: CheckpointEngine | null = null;
+let _tierEnforcement: TierEnforcement | null = null;
+let _questionnaire: Questionnaire | null = null;
+let _ingest: IngestModule | null = null;
+let _yaml: { stringify: (obj: unknown) => string; parse: (str: string) => unknown } | null = null;
+
+function getUtils(): Utils {
+  if (!_utils) {
+    _utils = require('../core/utils') as Utils;
+  }
+  return _utils;
+}
+
+function getConfig(): Config {
+  if (!_config) {
+    _config = require('../core/config') as Config;
+  }
+  return _config;
+}
+
+function getScaffold(): Scaffold {
+  if (!_scaffold) {
+    _scaffold = require('../core/scaffold') as Scaffold;
+  }
+  return _scaffold;
+}
+
+function getSeedTemplate(): SeedTemplate {
+  if (!_seedTemplate) {
+    _seedTemplate = require('../generators/templates/seed.template') as SeedTemplate;
+  }
+  return _seedTemplate;
+}
+
+function getProjectState(): ProjectState {
+  if (!_projectState) {
+    _projectState = require('../core/project-state') as ProjectState;
+  }
+  return _projectState;
+}
+
+function getCheckpointEngine(): CheckpointEngine {
+  if (!_checkpointEngine) {
+    _checkpointEngine = require('../core/checkpoint-engine') as CheckpointEngine;
+  }
+  return _checkpointEngine;
+}
+
+function getTierEnforcement(): TierEnforcement {
+  if (!_tierEnforcement) {
+    _tierEnforcement = require('../core/tier-enforcement') as TierEnforcement;
+  }
+  return _tierEnforcement;
+}
+
+function getQuestionnaire(): Questionnaire {
+  if (!_questionnaire) {
+    _questionnaire = require('../generators/questionnaire') as Questionnaire;
+  }
+  return _questionnaire;
+}
+
+function getIngest(): IngestModule {
+  if (!_ingest) {
+    _ingest = require('../core/ingest') as IngestModule;
+  }
+  return _ingest;
+}
+
+function getYaml(): { stringify: (obj: unknown) => string; parse: (str: string) => unknown } {
+  if (!_yaml) {
+    _yaml = require('yaml') as { stringify: (obj: unknown) => string; parse: (str: string) => unknown };
+  }
+  return _yaml;
+}
+
+// Import extracted modules
+function getSeedBuilders(): SeedBuilders {
+  const aiContextBuilder = require('./seed/builders/ai-context-builder') as { generateAIContextFiles: SeedBuilders['generateAIContextFiles'] };
+  const seedBuilder = require('./seed/builders/seed-builder') as { generateSeedFromPreseed: SeedBuilders['generateSeedFromPreseed'] };
+  return {
+    generateAIContextFiles: aiContextBuilder.generateAIContextFiles,
+    generateSeedFromPreseed: seedBuilder.generateSeedFromPreseed
+  };
+}
+
+function getSeedFolders(): SeedFolders {
+  return require('./seed/utils/folder-structure') as SeedFolders;
+}
+
+function getSeedExtractors(): SeedExtractors {
+  return require('./seed/extractors') as SeedExtractors;
+}
+
+/**
+ * Run seed command
+ * @param args - Command arguments
+ */
+export async function run(args: string[]): Promise<void> {
+  const utils = getUtils();
+  const tierEnforcement = getTierEnforcement();
+
+  const parsedArgs = utils.parseArgs(args);
+  const subcommand = (parsedArgs._ as string[])[0] || 'status';
+
+  // Check tier access for paid commands
+  const paidCommands = ['scaffold', 'synthesize', 'from-preseed', 'generate', 'build'];
+  if (paidCommands.includes(subcommand)) {
+    // Map aliases to actual command names for tier check
+    const commandMap: Record<string, string> = {
+      'from-preseed': 'synthesize',
+    };
+    const actualCommand = commandMap[subcommand] || subcommand;
+
+    try {
+      tierEnforcement.requireSeedAccess(actualCommand);
+    } catch (error) {
+      const tierError = error as TierError;
+      if (tierError.code === 'TIER_REQUIRED') {
+        console.log(tierError.upgradePrompt);
+        return;
+      }
+      throw error;
+    }
+  }
+
+  switch (subcommand) {
+    case 'setup':
+      return seedSetup(parsedArgs);
+    case 'init':
+      return seedInit(parsedArgs);
+    case 'generate':
+      return seedGenerate(parsedArgs);
+    case 'scaffold':
+      return seedScaffold(parsedArgs);
+    case 'build':
+      return seedBuild(parsedArgs);
+    case 'update':
+      return seedUpdate(parsedArgs);
+    case 'status':
+      return seedStatus(parsedArgs);
+    case 'export':
+      return seedExport(parsedArgs);
+    case 'synthesize':
+    case 'from-preseed':
+      return seedSynthesize(parsedArgs);
+    case 'help':
+    case '-h':
+    case '--help':
+      return showHelp();
+    default:
+      utils.print.error(`Unknown subcommand: ${subcommand}`);
+      showHelp();
+  }
+}
+
+/**
+ * Setup .bootspring/inputs folder structure
+ */
+async function seedSetup(_args: ParsedArgs): Promise<void> {
+  const utils = getUtils();
+  const config = getConfig();
+  const { createSeedFolders } = getSeedFolders();
+
+  const projectRoot = config.findProjectRoot();
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Bootspring Seed Setup${utils.COLORS.reset}
+${utils.COLORS.dim}Creating input folder structure${utils.COLORS.reset}
+`);
+
+  const spinner = utils.createSpinner('Creating folder structure...').start();
+  const dirsCreated = createSeedFolders(projectRoot);
+  spinner.succeed(`Created ${dirsCreated} folders`);
+
+  console.log(`
+${utils.COLORS.green}${utils.COLORS.bold}Setup complete!${utils.COLORS.reset}
+
+${utils.COLORS.bold}Folder structure:${utils.COLORS.reset}
+  .bootspring/
+  ├── inputs/           ${utils.COLORS.dim}# Your files go here${utils.COLORS.reset}
+  │   ├── mvp/source/   ${utils.COLORS.dim}# MVP code from Lovable, Bolt, V0${utils.COLORS.reset}
+  │   ├── business/     ${utils.COLORS.dim}# Business plans, pitch decks${utils.COLORS.reset}
+  │   ├── prd/          ${utils.COLORS.dim}# Product requirements${utils.COLORS.reset}
+  │   ├── designs/      ${utils.COLORS.dim}# Figma exports, wireframes${utils.COLORS.reset}
+  │   ├── legal/        ${utils.COLORS.dim}# Terms, privacy policies${utils.COLORS.reset}
+  │   ├── api/          ${utils.COLORS.dim}# OpenAPI specs${utils.COLORS.reset}
+  │   └── data/         ${utils.COLORS.dim}# Sample data, schemas${utils.COLORS.reset}
+  ├── generated/        ${utils.COLORS.dim}# Bootspring output${utils.COLORS.reset}
+  ├── context/          ${utils.COLORS.dim}# AI context index${utils.COLORS.reset}
+  └── logs/             ${utils.COLORS.dim}# Action history${utils.COLORS.reset}
+
+${utils.COLORS.bold}Next steps:${utils.COLORS.reset}
+  1. Drop your files in ${utils.COLORS.cyan}.bootspring/inputs/${utils.COLORS.reset} subfolders
+  2. Run ${utils.COLORS.cyan}bootspring seed generate${utils.COLORS.reset} to process them
+`);
+}
+
+/**
+ * Generate documents from input files
+ */
+async function seedGenerate(_args: ParsedArgs): Promise<void> {
+  const utils = getUtils();
+  const config = getConfig();
+
+  const projectRoot = config.findProjectRoot();
+  const inputsDir = path.join(projectRoot, '.bootspring', 'inputs');
+  const generatedDir = path.join(projectRoot, '.bootspring', 'generated');
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Bootspring Seed Generate${utils.COLORS.reset}
+${utils.COLORS.dim}Processing input files and generating documents${utils.COLORS.reset}
+`);
+
+  // Check if inputs folder exists
+  if (!fs.existsSync(inputsDir)) {
+    utils.print.warning('.bootspring/inputs folder not found');
+    utils.print.dim('Run "bootspring seed setup" first');
+    return;
+  }
+
+  // Ensure generated folder exists
+  if (!fs.existsSync(generatedDir)) {
+    fs.mkdirSync(generatedDir, { recursive: true });
+  }
+
+  try {
+    const Ingest = getIngest();
+    const spinner = utils.createSpinner('Analyzing input files...').start();
+
+    // Ingest all input files
+    const ingested = await Ingest.ingestAll(projectRoot);
+
+    spinner.succeed('Analyzed input files');
+
+    // Show what was found
+    console.log(`
+${utils.COLORS.bold}Files Found:${utils.COLORS.reset}`);
+
+    const counts = {
+      mvp: ingested.mvp?.files?.length || 0,
+      business: ingested.business?.length || 0,
+      prd: ingested.prd?.length || 0,
+      designs: ingested.designs?.files?.length || 0,
+      api: ingested.api?.length || 0,
+      data: ingested.data?.length || 0
+    };
+
+    console.log(`  MVP code: ${counts.mvp > 0 ? utils.COLORS.green + counts.mvp + ' files' : utils.COLORS.dim + 'none'}${utils.COLORS.reset}`);
+    console.log(`  Business docs: ${counts.business > 0 ? utils.COLORS.green + counts.business + ' files' : utils.COLORS.dim + 'none'}${utils.COLORS.reset}`);
+    console.log(`  PRD docs: ${counts.prd > 0 ? utils.COLORS.green + counts.prd + ' files' : utils.COLORS.dim + 'none'}${utils.COLORS.reset}`);
+    console.log(`  Design files: ${counts.designs > 0 ? utils.COLORS.green + counts.designs + ' files' : utils.COLORS.dim + 'none'}${utils.COLORS.reset}`);
+    console.log(`  API specs: ${counts.api > 0 ? utils.COLORS.green + counts.api + ' files' : utils.COLORS.dim + 'none'}${utils.COLORS.reset}`);
+    console.log(`  Data files: ${counts.data > 0 ? utils.COLORS.green + counts.data + ' files' : utils.COLORS.dim + 'none'}${utils.COLORS.reset}`);
+
+    // Load SEED.md config if exists
+    const seedPath = path.join(projectRoot, 'SEED.md');
+    let seedConfig: ProjectConfig = {};
+    if (fs.existsSync(seedPath)) {
+      seedConfig = parseSeedFile(seedPath) || {};
+    }
+
+    // Generate documents
+    console.log(`
+${utils.COLORS.bold}Generating documents...${utils.COLORS.reset}`);
+
+    const generateSpinner = utils.createSpinner('Generating...').start();
+    const outputs = await Ingest.generateDocuments(ingested, seedConfig, projectRoot);
+    generateSpinner.succeed('Generated documents');
+
+    // Show what was generated
+    let generatedCount = 0;
+    for (const [name, content] of Object.entries(outputs)) {
+      if (content) {
+        generatedCount++;
+        console.log(`  ${utils.COLORS.green}+${utils.COLORS.reset} ${name}`);
+      }
+    }
+
+    // Update context index
+    const contextSpinner = utils.createSpinner('Updating context index...').start();
+    await Ingest.updateContextIndex(projectRoot, ingested);
+    contextSpinner.succeed('Updated context index');
+
+    console.log(`
+${utils.COLORS.green}${utils.COLORS.bold}Generation complete!${utils.COLORS.reset}
+
+Generated ${generatedCount} documents in ${utils.COLORS.cyan}.bootspring/generated/${utils.COLORS.reset}
+
+${utils.COLORS.bold}Next steps:${utils.COLORS.reset}
+  1. Review generated documents
+  2. Run ${utils.COLORS.cyan}bootspring seed scaffold${utils.COLORS.reset} to create project structure
+  3. Your CLAUDE.md is updated with context
+`);
+  } catch (error) {
+    utils.print.error(`Generation failed: ${(error as Error).message}`);
+    if (process.env.DEBUG) {
+      console.error((error as Error).stack);
+    }
+  }
+}
+
+/**
+ * Initialize seed - run questionnaire and generate SEED.md
+ */
+async function seedInit(args: ParsedArgs): Promise<void> {
+  const utils = getUtils();
+  const config = getConfig();
+  const seedTemplate = getSeedTemplate();
+  const projectState = getProjectState();
+  const checkpointEngine = getCheckpointEngine();
+  const { runQuestionnaire } = getQuestionnaire();
+  const { createSeedFolders } = getSeedFolders();
+  const { generateAIContextFiles } = getSeedBuilders();
+
+  const projectRoot = config.findProjectRoot();
+  const seedPath = path.join(projectRoot, 'SEED.md');
+  const force = args.force || args.f;
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Seed Init${utils.COLORS.reset}
+${utils.COLORS.dim}Interactive project configuration${utils.COLORS.reset}
+`);
+
+  // Auto-create folder structure
+  const setupSpinner = utils.createSpinner('Setting up folder structure...').start();
+  createSeedFolders(projectRoot);
+  setupSpinner.succeed('Folder structure ready');
+
+  // Check if SEED.md already exists
+  if (utils.fileExists(seedPath) && !force) {
+    utils.print.warning('SEED.md already exists');
+    utils.print.dim('Use --force to regenerate, or "bootspring seed update" to modify');
+    return;
+  }
+
+  // Determine preset
+  const preset = (args.preset as string) || 'standard';
+  const validPresets = ['minimal', 'standard', 'full', 'startup', 'api'];
+
+  if (!validPresets.includes(preset)) {
+    utils.print.error(`Invalid preset: ${preset}`);
+    utils.print.dim(`Valid presets: ${validPresets.join(', ')}`);
+    return;
+  }
+
+  try {
+    // Run questionnaire
+    const projectConfig = await runQuestionnaire(preset);
+    projectConfig._preset = preset;
+
+    // Generate SEED.md
+    const seedContent = seedTemplate.generate(projectConfig);
+    const spinner = utils.createSpinner('Generating SEED.md').start();
+
+    if (utils.writeFile(seedPath, seedContent)) {
+      spinner.succeed('Created SEED.md');
+    } else {
+      spinner.fail('Failed to create SEED.md');
+      return;
+    }
+
+    // Also save config if not exists
+    const configPath = path.join(projectRoot, 'bootspring.config.js');
+    if (!utils.fileExists(configPath)) {
+      const configSpinner = utils.createSpinner('Creating bootspring.config.js').start();
+      if (config.save(projectConfig, configPath)) {
+        configSpinner.succeed('Created bootspring.config.js');
+      } else {
+        configSpinner.warn('Could not create bootspring.config.js');
+      }
+    }
+
+    // Auto-tag project as development type
+    try {
+      projectState.setProjectType(projectRoot, projectState.PROJECT_TYPES.DEVELOPMENT, {
+        autoTagged: true,
+        taggedBy: 'seed'
+      });
+      checkpointEngine.syncCheckpoints(projectRoot, { verbose: false });
+      utils.print.success('Project tagged as development type');
+    } catch (err) {
+      utils.print.debug(`Auto-tagging failed: ${(err as Error).message}`);
+    }
+
+    // Generate AI context files
+    const aiSpinner = utils.createSpinner('Generating AI context files...').start();
+    const aiResults = generateAIContextFiles(projectRoot, projectConfig);
+    const aiFilesGenerated: string[] = [];
+    if (aiResults.claudeMd) aiFilesGenerated.push('CLAUDE.md');
+    if (aiResults.agentsMd) aiFilesGenerated.push('AGENTS.md');
+    if (aiFilesGenerated.length > 0) {
+      aiSpinner.succeed(`Generated ${aiFilesGenerated.join(', ')}`);
+    } else {
+      aiSpinner.warn('Could not generate AI context files');
+    }
+
+    console.log(`
+${utils.COLORS.green}${utils.COLORS.bold}✓ Seed initialized successfully!${utils.COLORS.reset}
+
+${utils.COLORS.bold}Generated Files:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}SEED.md${utils.COLORS.reset}             - Project specification
+  ${utils.COLORS.cyan}bootspring.config.js${utils.COLORS.reset} - Configuration
+  ${utils.COLORS.cyan}CLAUDE.md${utils.COLORS.reset}           - Claude Code context
+  ${utils.COLORS.cyan}AGENTS.md${utils.COLORS.reset}           - Codex/Cursor/Amp context
+
+${utils.COLORS.bold}Next steps:${utils.COLORS.reset}
+  1. Review ${utils.COLORS.cyan}SEED.md${utils.COLORS.reset} for your project configuration
+  2. Run ${utils.COLORS.cyan}bootspring seed scaffold${utils.COLORS.reset} to generate project structure
+  3. Or run ${utils.COLORS.cyan}bootspring seed scaffold --preset=nextjs${utils.COLORS.reset} for a preset
+`);
+  } catch (error) {
+    utils.print.error(`Seed init failed: ${(error as Error).message}`);
+  }
+}
+
+/**
+ * Scaffold project from SEED.md or preset
+ */
+async function seedScaffold(args: ParsedArgs): Promise<void> {
+  const utils = getUtils();
+  const config = getConfig();
+  const scaffold = getScaffold();
+  const { generateAIContextFiles } = getSeedBuilders();
+
+  const projectRoot = config.findProjectRoot();
+  const preset = (args.preset || args.p) as string | undefined;
+  const fromConfig = args['from-config'] || args.c;
+  const dryRun = args['dry-run'] || args.d;
+  const skipConfirm = args.yes || args.y;
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Scaffold${utils.COLORS.reset}
+${utils.COLORS.dim}Generate project structure${utils.COLORS.reset}
+`);
+
+  let scaffoldConfig: ProjectConfig;
+  let detectedPreset: string | null = null;
+
+  if (preset) {
+    // Use preset
+    const validPresets = scaffold.getPresets();
+    if (!validPresets.includes(preset)) {
+      utils.print.error(`Invalid preset: ${preset}`);
+      utils.print.dim(`Valid presets: ${validPresets.join(', ')}`);
+      return;
+    }
+
+    utils.print.info(`Using preset: ${preset}`);
+    scaffoldConfig = scaffold.getPresetConfig(preset);
+    detectedPreset = preset;
+  } else if (fromConfig) {
+    // Load from bootspring.config.js
+    const cfg = config.load();
+    if (!cfg) {
+      utils.print.error('No bootspring.config.js found');
+      utils.print.dim('Run "bootspring seed init" first');
+      return;
+    }
+    scaffoldConfig = cfg;
+  } else {
+    // Try to load from SEED.md
+    const seedPath = path.join(projectRoot, 'SEED.md');
+    if (!utils.fileExists(seedPath)) {
+      utils.print.warning('No SEED.md found');
+      utils.print.info('Choose a preset or run "bootspring seed init" first');
+
+      console.log(`
+${utils.COLORS.bold}Available presets:${utils.COLORS.reset}
+`);
+      const presets = scaffold.getPresets();
+      for (const p of presets) {
+        const info = scaffold.getPresetInfo(p);
+        console.log(`  ${utils.COLORS.cyan}${p}${utils.COLORS.reset} - ${info?.description || ''}`);
+      }
+      console.log(`
+${utils.COLORS.dim}Example: bootspring seed scaffold --preset=nextjs${utils.COLORS.reset}
+`);
+      return;
+    }
+
+    // Parse SEED.md
+    const parsed = parseSeedFile(seedPath);
+    if (!parsed) {
+      utils.print.error('Could not parse SEED.md');
+      return;
+    }
+    scaffoldConfig = parsed;
+  }
+
+  // Show what will be created
+  const plan = scaffold.planScaffold(scaffoldConfig, projectRoot);
+  detectedPreset = plan.preset || null;
+
+  console.log(`
+${utils.COLORS.bold}Scaffold Plan:${utils.COLORS.reset}
+  Framework: ${scaffoldConfig.stack?.framework || 'nextjs'}
+  Language: ${scaffoldConfig.stack?.language || 'typescript'}
+  UI: ${scaffoldConfig.frontend?.uiLibrary || 'shadcn'}
+  Styling: ${scaffoldConfig.frontend?.styling || 'tailwind'}
+`);
+
+  console.log(`${utils.COLORS.bold}Directories to create:${utils.COLORS.reset}`);
+  for (const dir of plan.directories.slice(0, 10)) {
+    console.log(`  ${utils.COLORS.dim}+${utils.COLORS.reset} ${dir}`);
+  }
+  if (plan.directories.length > 10) {
+    console.log(`  ${utils.COLORS.dim}... and ${plan.directories.length - 10} more${utils.COLORS.reset}`);
+  }
+
+  console.log(`\n${utils.COLORS.bold}Files to create:${utils.COLORS.reset}`);
+  for (const file of plan.files.slice(0, 10)) {
+    console.log(`  ${utils.COLORS.dim}+${utils.COLORS.reset} ${file.path}`);
+  }
+  if (plan.files.length > 10) {
+    console.log(`  ${utils.COLORS.dim}... and ${plan.files.length - 10} more${utils.COLORS.reset}`);
+  }
+
+  if (dryRun) {
+    console.log(`
+${utils.COLORS.yellow}Dry run - no files created${utils.COLORS.reset}
+`);
+    return;
+  }
+
+  // Show detected preset and ask for confirmation
+  const presetInfo = scaffold.getPresetInfo(detectedPreset || 'nextjs');
+  console.log(`
+${utils.COLORS.bold}Detected preset:${utils.COLORS.reset} ${utils.COLORS.cyan}${detectedPreset || 'nextjs'}${utils.COLORS.reset}
+${utils.COLORS.dim}${presetInfo?.description || ''}${utils.COLORS.reset}
+`);
+
+  if (!skipConfirm) {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    const answer = await new Promise<string>((resolve) => {
+      rl.question(`Proceed with ${utils.COLORS.cyan}${detectedPreset || 'nextjs'}${utils.COLORS.reset} preset? [Y/n] `, (ans) => {
+        rl.close();
+        resolve(ans.trim().toLowerCase());
+      });
+    });
+
+    if (answer === 'n' || answer === 'no') {
+      console.log(`
+${utils.COLORS.dim}Scaffold cancelled. To use a different preset:${utils.COLORS.reset}
+  bootspring seed scaffold --preset=<preset>
+
+${utils.COLORS.bold}Available presets:${utils.COLORS.reset}`);
+      const presets = scaffold.getPresets();
+      for (const p of presets) {
+        const info = scaffold.getPresetInfo(p);
+        console.log(`  ${utils.COLORS.cyan}${p}${utils.COLORS.reset} - ${info?.description || ''}`);
+      }
+      console.log('');
+      return;
+    }
+  }
+
+  // Execute scaffold
+  console.log('');
+  const spinner = utils.createSpinner('Scaffolding project...').start();
+
+  try {
+    const result = await scaffold.execute(plan, projectRoot);
+    spinner.succeed(`Scaffolded ${result.filesCreated} files, ${result.dirsCreated} directories`);
+
+    if (result.warnings.length > 0) {
+      console.log(`\n${utils.COLORS.yellow}Warnings:${utils.COLORS.reset}`);
+      for (const warning of result.warnings) {
+        console.log(`  ${utils.COLORS.dim}!${utils.COLORS.reset} ${warning}`);
+      }
+    }
+
+    // Generate AI context files (CLAUDE.md and AGENTS.md)
+    const aiSpinner = utils.createSpinner('Generating AI context files...').start();
+    const aiResults = generateAIContextFiles(projectRoot, scaffoldConfig);
+
+    const aiFilesGenerated: string[] = [];
+    if (aiResults.claudeMd) aiFilesGenerated.push('CLAUDE.md');
+    if (aiResults.agentsMd) aiFilesGenerated.push('AGENTS.md');
+    if (aiResults.planningAgentsMd) aiFilesGenerated.push('planning/AGENTS.md');
+
+    if (aiFilesGenerated.length > 0) {
+      aiSpinner.succeed(`Generated ${aiFilesGenerated.join(', ')}`);
+    } else {
+      aiSpinner.warn('Could not generate AI context files');
+    }
+
+    console.log(`
+${utils.COLORS.green}${utils.COLORS.bold}✓ Scaffold complete!${utils.COLORS.reset}
+
+${utils.COLORS.bold}Generated Files:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}CLAUDE.md${utils.COLORS.reset}  - Context for Claude Code
+  ${utils.COLORS.cyan}AGENTS.md${utils.COLORS.reset}  - Context for Codex, Cursor, Amp, Kilo
+
+${utils.COLORS.bold}Next steps:${utils.COLORS.reset}
+  1. Run ${utils.COLORS.cyan}npm install${utils.COLORS.reset} to install dependencies
+  2. Copy ${utils.COLORS.cyan}.env.example${utils.COLORS.reset} to ${utils.COLORS.cyan}.env.local${utils.COLORS.reset}
+  3. Run ${utils.COLORS.cyan}npm run dev${utils.COLORS.reset} to start development
+  4. Run ${utils.COLORS.cyan}bootspring build${utils.COLORS.reset} to start building tasks
+`);
+  } catch (error) {
+    spinner.fail(`Scaffold failed: ${(error as Error).message}`);
+  }
+}
+
+/**
+ * Build from seed documents - redirects to interactive build command
+ */
+async function seedBuild(args: ParsedArgs): Promise<void> {
+  // Just run the interactive build command
+  const build = require('./build') as { run: (args: string[]) => Promise<void> };
+  await build.run(((args._ as string[])?.slice(1)) || []);
+}
+
+/**
+ * Update existing SEED.md
+ */
+async function seedUpdate(args: ParsedArgs): Promise<void> {
+  const utils = getUtils();
+  const config = getConfig();
+  const seedTemplate = getSeedTemplate();
+  const { runQuestionnaire } = getQuestionnaire();
+
+  const projectRoot = config.findProjectRoot();
+  const seedPath = path.join(projectRoot, 'SEED.md');
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Seed Update${utils.COLORS.reset}
+${utils.COLORS.dim}Update project configuration${utils.COLORS.reset}
+`);
+
+  if (!utils.fileExists(seedPath)) {
+    utils.print.warning('No SEED.md found');
+    utils.print.dim('Run "bootspring seed init" to create one');
+    return;
+  }
+
+  // Load existing config
+  const existingConfig = parseSeedFile(seedPath);
+  const preset = (args.preset as string) || existingConfig?._preset || 'standard';
+
+  try {
+    // Run questionnaire with existing values as defaults
+    const projectConfig = await runQuestionnaire(preset);
+    projectConfig._preset = preset;
+
+    // Generate updated SEED.md
+    const seedContent = seedTemplate.generate(projectConfig);
+    const spinner = utils.createSpinner('Updating SEED.md').start();
+
+    if (utils.writeFile(seedPath, seedContent)) {
+      spinner.succeed('Updated SEED.md');
+    } else {
+      spinner.fail('Failed to update SEED.md');
+      return;
+    }
+
+    // Update bootspring.config.js
+    const configPath = path.join(projectRoot, 'bootspring.config.js');
+    const configSpinner = utils.createSpinner('Updating bootspring.config.js').start();
+    if (config.save(projectConfig, configPath)) {
+      configSpinner.succeed('Updated bootspring.config.js');
+    } else {
+      configSpinner.warn('Could not update bootspring.config.js');
+    }
+
+    utils.print.success('Seed configuration updated');
+  } catch (error) {
+    utils.print.error(`Seed update failed: ${(error as Error).message}`);
+  }
+}
+
+/**
+ * Show current seed status
+ */
+function seedStatus(_args: ParsedArgs): void {
+  const utils = getUtils();
+  const config = getConfig();
+  const scaffold = getScaffold();
+
+  const projectRoot = config.findProjectRoot();
+  const seedPath = path.join(projectRoot, 'SEED.md');
+  const configPath = path.join(projectRoot, 'bootspring.config.js');
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Seed Status${utils.COLORS.reset}
+`);
+
+  // Check SEED.md
+  if (utils.fileExists(seedPath)) {
+    const stats = fs.statSync(seedPath);
+    const modified = utils.formatRelativeTime(stats.mtime);
+    console.log(`${utils.COLORS.green}✓${utils.COLORS.reset} SEED.md exists (modified ${modified})`);
+
+    // Parse and show summary
+    const seedConfig = parseSeedFile(seedPath);
+    if (seedConfig) {
+      console.log(`
+${utils.COLORS.bold}Configuration:${utils.COLORS.reset}
+  Project: ${seedConfig.project?.name || 'unknown'}
+  Framework: ${seedConfig.stack?.framework || 'unknown'}
+  Language: ${seedConfig.stack?.language || 'unknown'}
+  Database: ${seedConfig.stack?.database || 'none'}
+  Preset: ${seedConfig._preset || 'unknown'}
+`);
+    }
+  } else {
+    console.log(`${utils.COLORS.yellow}○${utils.COLORS.reset} SEED.md not found`);
+  }
+
+  // Check bootspring.config.js
+  if (utils.fileExists(configPath)) {
+    console.log(`${utils.COLORS.green}✓${utils.COLORS.reset} bootspring.config.js exists`);
+  } else {
+    console.log(`${utils.COLORS.yellow}○${utils.COLORS.reset} bootspring.config.js not found`);
+  }
+
+  // Show available presets
+  console.log(`
+${utils.COLORS.bold}Available Presets:${utils.COLORS.reset}
+`);
+  const presets = scaffold.getPresets();
+  for (const p of presets) {
+    const info = scaffold.getPresetInfo(p);
+    console.log(`  ${utils.COLORS.cyan}${p}${utils.COLORS.reset} - ${info?.description || ''}`);
+  }
+
+  console.log(`
+${utils.COLORS.bold}Commands:${utils.COLORS.reset}
+  bootspring seed init              ${utils.COLORS.dim}# Create SEED.md${utils.COLORS.reset}
+  bootspring seed scaffold          ${utils.COLORS.dim}# Generate project structure${utils.COLORS.reset}
+  bootspring seed scaffold --preset=nextjs
+`);
+}
+
+/**
+ * Export seed config
+ */
+function seedExport(args: ParsedArgs): void {
+  const utils = getUtils();
+  const config = getConfig();
+  const yaml = getYaml();
+
+  const projectRoot = config.findProjectRoot();
+  const seedPath = path.join(projectRoot, 'SEED.md');
+  const format = (args.format || args.f || 'json') as string;
+  const output = (args.output || args.o) as string | undefined;
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Seed Export${utils.COLORS.reset}
+`);
+
+  if (!utils.fileExists(seedPath)) {
+    utils.print.error('No SEED.md found');
+    utils.print.dim('Run "bootspring seed init" first');
+    return;
+  }
+
+  const seedConfig = parseSeedFile(seedPath);
+  if (!seedConfig) {
+    utils.print.error('Could not parse SEED.md');
+    return;
+  }
+
+  let exported: string;
+  if (format === 'yaml' || format === 'yml') {
+    exported = yaml.stringify(seedConfig);
+  } else {
+    exported = JSON.stringify(seedConfig, null, 2);
+  }
+
+  if (output) {
+    const outputPath = path.resolve(projectRoot, output);
+    if (utils.writeFile(outputPath, exported)) {
+      utils.print.success(`Exported to ${outputPath}`);
+    } else {
+      utils.print.error('Export failed');
+    }
+  } else {
+    console.log(exported);
+  }
+}
+
+/**
+ * Synthesize SEED.md from preseed documents
+ */
+async function seedSynthesize(args: ParsedArgs): Promise<void> {
+  const utils = getUtils();
+  const config = getConfig();
+  const { generateAIContextFiles, generateSeedFromPreseed } = getSeedBuilders();
+  const { extractTechStack, extractProjectName, extractTagline } = getSeedExtractors();
+
+  const projectRoot = config.findProjectRoot();
+  const preseedDir = path.join(projectRoot, '.bootspring', 'preseed');
+  const seedPath = path.join(projectRoot, 'SEED.md');
+  const force = args.force || args.f;
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Seed Synthesize${utils.COLORS.reset}
+${utils.COLORS.dim}Create SEED.md from your preseed documents${utils.COLORS.reset}
+`);
+
+  // Check for preseed documents
+  if (!fs.existsSync(preseedDir)) {
+    utils.print.error('No preseed documents found');
+    console.log(`\nRun ${utils.COLORS.cyan}bootspring preseed start${utils.COLORS.reset} first`);
+    return;
+  }
+
+  // Valid preseed document names (only these should be synthesized)
+  const validPreseedDocs = [
+    'VISION.md',
+    'AUDIENCE.md',
+    'MARKET.md',
+    'COMPETITORS.md',
+    'BUSINESS_MODEL.md',
+    'PRD.md',
+    'TECHNICAL_SPEC.md',
+    'ROADMAP.md'
+  ];
+
+  // Find all preseed docs (only valid ones, exclude MERGE_INSTRUCTIONS etc)
+  const preseedFiles = fs.readdirSync(preseedDir).filter(f =>
+    validPreseedDocs.includes(f)
+  );
+
+  if (preseedFiles.length === 0) {
+    utils.print.error('No preseed documents found');
+    console.log(`\nRun ${utils.COLORS.cyan}bootspring preseed init${utils.COLORS.reset} first`);
+    return;
+  }
+
+  console.log(`${utils.COLORS.bold}Found ${preseedFiles.length} preseed documents:${utils.COLORS.reset}`);
+  for (const file of preseedFiles) {
+    console.log(`  ${utils.COLORS.green}✓${utils.COLORS.reset} ${file}`);
+  }
+
+  // Check if SEED.md already exists
+  if (fs.existsSync(seedPath) && !force) {
+    utils.print.warning('SEED.md already exists');
+    console.log(`\nUse ${utils.COLORS.cyan}--force${utils.COLORS.reset} to overwrite`);
+    return;
+  }
+
+  // Read all preseed docs
+  const docs: Record<string, string> = {};
+  for (const file of preseedFiles) {
+    const filePath = path.join(preseedDir, file);
+    docs[file.replace('.md', '')] = fs.readFileSync(filePath, 'utf-8');
+  }
+
+  // Also try to read PRESEED_CONFIG.json
+  let preseedConfig: Record<string, unknown> = {};
+  const preseedConfigPath = path.join(preseedDir, 'PRESEED_CONFIG.json');
+  if (fs.existsSync(preseedConfigPath)) {
+    try {
+      preseedConfig = JSON.parse(fs.readFileSync(preseedConfigPath, 'utf-8')) as Record<string, unknown>;
+    } catch {
+      // Ignore parse errors
+    }
+  }
+
+  // Generate SEED.md from preseed docs
+  const spinner = utils.createSpinner('Synthesizing SEED.md...').start();
+
+  try {
+    const seedContent = generateSeedFromPreseed(docs, preseedConfig);
+    fs.writeFileSync(seedPath, seedContent);
+    spinner.succeed('Created SEED.md');
+
+    // Extract tech stack for AI context files
+    const techStack = extractTechStack(docs);
+    const identity = preseedConfig.identity as { name?: string } | undefined;
+    const projectName = extractProjectName(docs) || identity?.name || 'My Project';
+    const tagline = extractTagline(docs) || '';
+
+    const synthConfig: ProjectConfig = {
+      project: {
+        name: projectName,
+        description: tagline,
+        version: '0.1.0',
+        status: 'development'
+      },
+      stack: {
+        framework: techStack.framework,
+        language: techStack.language,
+        database: techStack.database,
+        hosting: techStack.hosting
+      },
+      frontend: {
+        uiLibrary: techStack.uiLibrary,
+        styling: techStack.styling
+      },
+      backend: {
+        orm: techStack.orm,
+        auth: techStack.auth
+      }
+    };
+
+    // Generate AI context files
+    const aiSpinner = utils.createSpinner('Generating AI context files...').start();
+    const aiResults = generateAIContextFiles(projectRoot, synthConfig);
+    const aiFilesGenerated: string[] = [];
+    if (aiResults.claudeMd) aiFilesGenerated.push('CLAUDE.md');
+    if (aiResults.agentsMd) aiFilesGenerated.push('AGENTS.md');
+    if (aiFilesGenerated.length > 0) {
+      aiSpinner.succeed(`Generated ${aiFilesGenerated.join(', ')}`);
+    } else {
+      aiSpinner.warn('Could not generate AI context files');
+    }
+
+    // Also create bootspring.config.js for CLI compatibility
+    const configPath = path.join(projectRoot, 'bootspring.config.js');
+    if (!fs.existsSync(configPath)) {
+      const configSpinner = utils.createSpinner('Creating bootspring.config.js...').start();
+      if (config.save(synthConfig, configPath)) {
+        configSpinner.succeed('Created bootspring.config.js');
+      } else {
+        configSpinner.warn('Could not create bootspring.config.js');
+      }
+    }
+
+    console.log(`
+${utils.COLORS.green}${utils.COLORS.bold}✓ SEED.md synthesized successfully!${utils.COLORS.reset}
+
+${utils.COLORS.bold}Extracted from:${utils.COLORS.reset}
+${preseedFiles.map(f => `  • ${f}`).join('\n')}
+
+${utils.COLORS.bold}Generated Files:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}SEED.md${utils.COLORS.reset}             - Project specification
+  ${utils.COLORS.cyan}bootspring.config.js${utils.COLORS.reset} - Configuration
+  ${utils.COLORS.cyan}CLAUDE.md${utils.COLORS.reset}           - Claude Code context
+  ${utils.COLORS.cyan}AGENTS.md${utils.COLORS.reset}           - Codex/Cursor/Amp context
+
+${utils.COLORS.bold}Next steps:${utils.COLORS.reset}
+  1. Review ${utils.COLORS.cyan}SEED.md${utils.COLORS.reset} - your project spec is ready
+  2. Run ${utils.COLORS.cyan}bootspring seed scaffold --preset=nextjs${utils.COLORS.reset} to generate project
+  3. Or run ${utils.COLORS.cyan}bootspring build${utils.COLORS.reset} to start building tasks
+`);
+  } catch (error) {
+    spinner.fail(`Synthesis failed: ${(error as Error).message}`);
+  }
+}
+
+/**
+ * Parse SEED.md file
+ */
+function parseSeedFile(seedPath: string): ProjectConfig | null {
+  const yaml = getYaml();
+
+  try {
+    const content = fs.readFileSync(seedPath, 'utf-8');
+    const seedConfig: Record<string, unknown> = {};
+
+    // Extract YAML blocks from markdown
+    const yamlBlocks = content.matchAll(/```yaml\n([\s\S]*?)```/g);
+
+    for (const match of yamlBlocks) {
+      const yamlContent = match[1];
+      if (yamlContent) {
+        try {
+          const parsed = yaml.parse(yamlContent) as Record<string, unknown>;
+          Object.assign(seedConfig, parsed);
+        } catch {
+          // Skip invalid YAML blocks
+        }
+      }
+    }
+
+    return Object.keys(seedConfig).length > 0 ? seedConfig as ProjectConfig : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Show help
+ */
+function showHelp(): void {
+  const utils = getUtils();
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Seed${utils.COLORS.reset}
+${utils.COLORS.dim}Project scaffolding and configuration${utils.COLORS.reset}
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring seed <command> [options]
+
+${utils.COLORS.bold}Commands:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}setup${utils.COLORS.reset}             Create .bootspring/inputs folder structure
+  ${utils.COLORS.cyan}init${utils.COLORS.reset}              Run questionnaire, create SEED.md
+  ${utils.COLORS.cyan}synthesize${utils.COLORS.reset}        Create SEED.md from preseed documents ${utils.COLORS.yellow}[PRO]${utils.COLORS.reset}
+  ${utils.COLORS.cyan}generate${utils.COLORS.reset}          Ingest input files and generate documents ${utils.COLORS.yellow}[PRO]${utils.COLORS.reset}
+  ${utils.COLORS.cyan}scaffold${utils.COLORS.reset}          Generate project structure ${utils.COLORS.yellow}[PRO]${utils.COLORS.reset}
+  ${utils.COLORS.cyan}build${utils.COLORS.reset}             Build from seed docs (--loop for continuous) ${utils.COLORS.yellow}[PRO]${utils.COLORS.reset}
+  ${utils.COLORS.cyan}update${utils.COLORS.reset}            Re-run questionnaire, update SEED.md
+  ${utils.COLORS.cyan}status${utils.COLORS.reset}            Show current configuration (default)
+  ${utils.COLORS.cyan}export${utils.COLORS.reset}            Export config as JSON/YAML
+
+${utils.COLORS.bold}Init Options:${utils.COLORS.reset}
+  --preset=<preset>   Questionnaire preset (minimal, standard, full, startup, api)
+  --force             Overwrite existing SEED.md
+
+${utils.COLORS.bold}Scaffold Options:${utils.COLORS.reset}
+  --preset=<preset>   Use preset instead of SEED.md (nextjs, react, node, fullstack)
+  --from-config       Use bootspring.config.js instead of SEED.md
+  --dry-run           Show plan without creating files
+
+${utils.COLORS.bold}Build Options:${utils.COLORS.reset}
+  --loop              Start continuous build loop until MVP complete
+  --iterations=<n>    Max iterations for loop (default: 50)
+  --force             Reinitialize existing build state
+  --live              Stream AI output in real-time
+  --verbose           Show detailed output
+
+${utils.COLORS.bold}Export Options:${utils.COLORS.reset}
+  --format=<fmt>      Output format: json (default), yaml
+  --output=<file>     Write to file instead of stdout
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  bootspring seed setup                    # Create input folder structure
+  bootspring seed generate                 # Process input files
+  bootspring seed init --preset=startup    # Full questionnaire
+  ${utils.COLORS.green}bootspring seed synthesize${utils.COLORS.reset}              # Create SEED.md from preseed docs
+  bootspring seed scaffold --preset=nextjs # Generate project
+  ${utils.COLORS.green}bootspring seed build --loop${utils.COLORS.reset}            # Start autonomous build
+  bootspring seed export --format=yaml     # Export config
+
+${utils.COLORS.bold}Complete Workflow:${utils.COLORS.reset}
+  1. ${utils.COLORS.cyan}bootspring preseed start${utils.COLORS.reset}   # Capture your idea
+  2. ${utils.COLORS.cyan}bootspring seed synthesize${utils.COLORS.reset} # Create SEED.md from preseed
+  3. ${utils.COLORS.cyan}bootspring seed scaffold${utils.COLORS.reset}   # Generate project code
+`);
+}