@girardmedia/bootspring 2.0.21 → 2.0.23

package/src/cli/business.ts

@@ -0,0 +1,508 @@
+/**
+ * Bootspring Business Command
+ * Business planning and strategy tools
+ *
+ * @package bootspring
+ * @command business
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Type interfaces for JS modules
+interface UtilsModule {
+  COLORS: Colors;
+  print: PrintModule;
+  createSpinner(text: string): Spinner;
+}
+
+interface Colors {
+  reset: string;
+  bold: string;
+  dim: string;
+  cyan: string;
+  green: string;
+  yellow: string;
+  red: string;
+  magenta: string;
+}
+
+interface PrintModule {
+  success(msg: string): void;
+  error(msg: string): void;
+  warning(msg: string): void;
+  info(msg: string): void;
+  dim(msg: string): void;
+  debug(msg: string): void;
+}
+
+interface Spinner {
+  start(): Spinner;
+  stop(): void;
+  succeed(text: string): void;
+  fail(text: string): void;
+  info(text: string): void;
+}
+
+interface ProjectStateModule {
+  PROJECT_TYPES: Record<string, string>;
+  setProjectType(projectRoot: string, type: string, metadata?: Record<string, unknown>): unknown;
+}
+
+interface CheckpointEngineModule {
+  syncCheckpoints(projectRoot: string, options?: { verbose?: boolean }): void;
+}
+
+interface ApiModule {
+  getTemplate(category: string, file: string): Promise<{ content: string }>;
+}
+
+interface AuthModule {
+  isAuthenticated(): boolean;
+}
+
+interface ApiError extends Error {
+  status?: number;
+}
+
+interface TemplateResult {
+  content?: string | undefined;
+  error?: string | undefined;
+  message?: string | undefined;
+}
+
+interface Template {
+  name: string;
+  file: string;
+  output: string;
+  description: string;
+}
+
+interface ProjectConfig {
+  projectName?: string | undefined;
+  name?: string | undefined;
+  domain?: string | undefined;
+}
+
+const utils = require('../core/utils') as UtilsModule;
+const projectState = require('../core/project-state') as ProjectStateModule;
+const checkpointEngine = require('../core/checkpoint-engine') as CheckpointEngineModule;
+const api = require('../core/api-client') as ApiModule;
+const auth = require('../core/auth') as AuthModule;
+
+/**
+ * Output directory for business docs
+ */
+const OUTPUT_DIR = 'planning';
+
+/**
+ * Available business templates
+ */
+const TEMPLATES: Record<string, Template> = {
+  plan: {
+    name: 'Business Plan',
+    file: 'business-plan.md',
+    output: 'BUSINESS_PLAN.md',
+    description: 'Comprehensive business plan template'
+  },
+  model: {
+    name: 'Business Model Canvas',
+    file: 'business-model-canvas.md',
+    output: 'BUSINESS_MODEL_CANVAS.md',
+    description: 'Visual business model framework'
+  },
+  competitors: {
+    name: 'Competitive Analysis',
+    file: 'competitive-analysis.md',
+    output: 'COMPETITIVE_ANALYSIS.md',
+    description: 'Competitor research and positioning'
+  }
+};
+
+/**
+ * Get project config if available
+ */
+function getProjectConfig(): ProjectConfig {
+  const configPath = path.join(process.cwd(), 'bootspring.config.js');
+  if (fs.existsSync(configPath)) {
+    try {
+      return require(configPath) as ProjectConfig;
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+
+/**
+ * Replace template variables
+ */
+function processTemplate(content: string, config: ProjectConfig): string {
+  const projectName = config.projectName || config.name || path.basename(process.cwd());
+  const date = new Date().toISOString().split('T')[0];
+
+  return content
+    .replace(/\{\{PROJECT_NAME\}\}/g, projectName)
+    .replace(/\{\{DATE\}\}/g, date || '')
+    .replace(/\{\{DOMAIN\}\}/g, config.domain || 'example.com');
+}
+
+/**
+ * Fetch template content from API
+ */
+async function fetchTemplate(templateFile: string): Promise<TemplateResult> {
+  if (!auth.isAuthenticated()) {
+    return { error: 'auth_required' };
+  }
+
+  try {
+    const response = await api.getTemplate('business', templateFile);
+    return response;
+  } catch (error) {
+    const apiError = error as ApiError;
+    if (apiError.status === 401) {
+      return { error: 'auth_required' };
+    }
+    if (apiError.status === 403) {
+      return { error: 'upgrade_required' };
+    }
+    return { error: 'network_error', message: apiError.message };
+  }
+}
+
+/**
+ * Initialize business planning docs
+ */
+async function businessInit(): Promise<void> {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Business Planning${utils.COLORS.reset}
+${utils.COLORS.dim}Initialize business planning documents${utils.COLORS.reset}
+`);
+
+  // Check authentication
+  if (!auth.isAuthenticated()) {
+    utils.print.error('Authentication required');
+    console.log(`${utils.COLORS.dim}Run: bootspring auth login${utils.COLORS.reset}`);
+    return;
+  }
+
+  const config = getProjectConfig();
+  const outputDir = path.join(process.cwd(), OUTPUT_DIR);
+
+  // Create output directory
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  const created: string[] = [];
+  const skipped: string[] = [];
+  const failed: Array<{ name: string; error: string }> = [];
+
+  const spinner = utils.createSpinner('Loading templates...');
+  spinner.start();
+
+  // Create all business templates
+  for (const [_key, template] of Object.entries(TEMPLATES)) {
+    const outputPath = path.join(outputDir, template.output);
+
+    if (fs.existsSync(outputPath)) {
+      skipped.push(template.name);
+      continue;
+    }
+
+    const result = await fetchTemplate(template.file);
+
+    if (result.error) {
+      failed.push({ name: template.name, error: result.error });
+      continue;
+    }
+
+    const processed = processTemplate(result.content || '', config);
+    fs.writeFileSync(outputPath, processed);
+    created.push(template.name);
+  }
+
+  spinner.stop();
+
+  if (created.length > 0) {
+    console.log(`${utils.COLORS.bold}Created:${utils.COLORS.reset}`);
+    for (const name of created) {
+      console.log(`  ${utils.COLORS.green}✓${utils.COLORS.reset} ${name}`);
+    }
+    console.log();
+  }
+
+  if (skipped.length > 0) {
+    console.log(`${utils.COLORS.bold}Skipped (already exist):${utils.COLORS.reset}`);
+    for (const name of skipped) {
+      console.log(`  ${utils.COLORS.dim}●${utils.COLORS.reset} ${name}`);
+    }
+    console.log();
+  }
+
+  if (failed.length > 0) {
+    console.log(`${utils.COLORS.bold}Failed:${utils.COLORS.reset}`);
+    for (const { name, error } of failed) {
+      console.log(`  ${utils.COLORS.red}✗${utils.COLORS.reset} ${name} (${error})`);
+    }
+    console.log();
+  }
+
+  // Auto-tag project as business type
+  try {
+    const businessType = projectState.PROJECT_TYPES.BUSINESS || 'business';
+    projectState.setProjectType(process.cwd(), businessType, {
+      autoTagged: true,
+      taggedBy: 'business-init'
+    });
+    checkpointEngine.syncCheckpoints(process.cwd(), { verbose: false });
+    utils.print.success('Project tagged as business type');
+  } catch (err) {
+    utils.print.debug(`Auto-tagging failed: ${(err as Error).message}`);
+  }
+
+  console.log(`${utils.COLORS.bold}Next Steps:${utils.COLORS.reset}`);
+  console.log(`  1. Edit ${utils.COLORS.cyan}${OUTPUT_DIR}/BUSINESS_PLAN.md${utils.COLORS.reset}`);
+  console.log(`  2. Run ${utils.COLORS.cyan}bootspring agent invoke business-strategy-expert${utils.COLORS.reset}`);
+  console.log(`  3. Run ${utils.COLORS.cyan}bootspring business status${utils.COLORS.reset} to check progress`);
+}
+
+/**
+ * Create or edit a specific business document
+ */
+async function businessCreate(templateKey: string): Promise<void> {
+  const template = TEMPLATES[templateKey];
+
+  if (!template) {
+    utils.print.error(`Unknown template: ${templateKey}`);
+    console.log(`\nAvailable templates: ${Object.keys(TEMPLATES).join(', ')}`);
+    return;
+  }
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ ${template.name}${utils.COLORS.reset}
+${utils.COLORS.dim}${template.description}${utils.COLORS.reset}
+`);
+
+  // Check authentication
+  if (!auth.isAuthenticated()) {
+    utils.print.error('Authentication required');
+    console.log(`${utils.COLORS.dim}Run: bootspring auth login${utils.COLORS.reset}`);
+    return;
+  }
+
+  const config = getProjectConfig();
+  const outputDir = path.join(process.cwd(), OUTPUT_DIR);
+  const outputPath = path.join(outputDir, template.output);
+
+  // Create output directory
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  if (fs.existsSync(outputPath)) {
+    utils.print.warning(`File already exists: ${OUTPUT_DIR}/${template.output}`);
+    console.log(`Edit it directly or use ${utils.COLORS.cyan}bootspring business show ${templateKey}${utils.COLORS.reset}`);
+    return;
+  }
+
+  const spinner = utils.createSpinner('Loading template...');
+  spinner.start();
+
+  const result = await fetchTemplate(template.file);
+
+  if (result.error === 'auth_required') {
+    spinner.fail('Authentication required');
+    console.log(`${utils.COLORS.dim}Run: bootspring auth login${utils.COLORS.reset}`);
+    return;
+  }
+
+  if (result.error === 'upgrade_required') {
+    spinner.fail('Upgrade required');
+    console.log(`${utils.COLORS.dim}This template requires a Pro subscription.${utils.COLORS.reset}`);
+    console.log(`${utils.COLORS.dim}Run: bootspring billing upgrade${utils.COLORS.reset}`);
+    return;
+  }
+
+  if (result.error) {
+    spinner.fail('Failed to load template');
+    console.log(`${utils.COLORS.dim}${result.message || 'Check your internet connection.'}${utils.COLORS.reset}`);
+    return;
+  }
+
+  spinner.succeed('Template loaded');
+
+  const processed = processTemplate(result.content || '', config);
+  fs.writeFileSync(outputPath, processed);
+
+  utils.print.success(`Created ${template.name}`);
+  console.log(`\nFile: ${utils.COLORS.cyan}${OUTPUT_DIR}/${template.output}${utils.COLORS.reset}`);
+  console.log(`\n${utils.COLORS.bold}Next Steps:${utils.COLORS.reset}`);
+  console.log('  1. Open and edit the document');
+  console.log('  2. Use AI agents for assistance:');
+  console.log(`     ${utils.COLORS.cyan}bootspring agent invoke business-strategy-expert${utils.COLORS.reset}`);
+}
+
+/**
+ * Show status of business documents
+ */
+function businessStatus(): void {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Business Planning Status${utils.COLORS.reset}
+`);
+
+  const outputDir = path.join(process.cwd(), OUTPUT_DIR);
+  let found = 0;
+  const total = Object.keys(TEMPLATES).length;
+
+  for (const [key, template] of Object.entries(TEMPLATES)) {
+    const outputPath = path.join(outputDir, template.output);
+    const exists = fs.existsSync(outputPath);
+
+    if (exists) {
+      found++;
+      const stats = fs.statSync(outputPath);
+      const modified = stats.mtime.toISOString().split('T')[0];
+      const size = Math.round(stats.size / 1024);
+
+      console.log(`  ${utils.COLORS.green}✓${utils.COLORS.reset} ${template.name}`);
+      console.log(`    ${utils.COLORS.dim}${OUTPUT_DIR}/${template.output} (${size}KB, modified ${modified})${utils.COLORS.reset}`);
+    } else {
+      console.log(`  ${utils.COLORS.yellow}○${utils.COLORS.reset} ${template.name}`);
+      console.log(`    ${utils.COLORS.dim}Not created - run: bootspring business ${key}${utils.COLORS.reset}`);
+    }
+  }
+
+  console.log();
+  console.log(`${utils.COLORS.bold}Progress:${utils.COLORS.reset} ${found}/${total} documents created`);
+
+  if (found < total) {
+    console.log(`\n${utils.COLORS.bold}Create Missing:${utils.COLORS.reset}`);
+    console.log(`  ${utils.COLORS.cyan}bootspring business init${utils.COLORS.reset} - Create all documents`);
+  }
+}
+
+/**
+ * Show a business document
+ */
+function businessShow(templateKey: string): void {
+  const template = TEMPLATES[templateKey];
+
+  if (!template) {
+    utils.print.error(`Unknown template: ${templateKey}`);
+    console.log(`\nAvailable templates: ${Object.keys(TEMPLATES).join(', ')}`);
+    return;
+  }
+
+  const outputPath = path.join(process.cwd(), OUTPUT_DIR, template.output);
+
+  if (!fs.existsSync(outputPath)) {
+    utils.print.warning(`${template.name} not created yet`);
+    console.log(`\nRun: ${utils.COLORS.cyan}bootspring business ${templateKey}${utils.COLORS.reset}`);
+    return;
+  }
+
+  const content = fs.readFileSync(outputPath, 'utf-8');
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ ${template.name}${utils.COLORS.reset}
+${utils.COLORS.dim}${OUTPUT_DIR}/${template.output}${utils.COLORS.reset}
+`);
+
+  // Show first 50 lines as preview
+  const lines = content.split('\n').slice(0, 50);
+  console.log(lines.join('\n'));
+
+  if (content.split('\n').length > 50) {
+    console.log(`\n${utils.COLORS.dim}... (${content.split('\n').length - 50} more lines)${utils.COLORS.reset}`);
+    console.log(`${utils.COLORS.dim}Open the full file to see more${utils.COLORS.reset}`);
+  }
+}
+
+/**
+ * Show help
+ */
+function showHelp(): void {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Business${utils.COLORS.reset}
+${utils.COLORS.dim}Business planning and strategy tools${utils.COLORS.reset}
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring business <command> [options]
+
+${utils.COLORS.bold}Commands:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}init${utils.COLORS.reset}           Initialize all business planning documents
+  ${utils.COLORS.cyan}plan${utils.COLORS.reset}           Create business plan
+  ${utils.COLORS.cyan}model${utils.COLORS.reset}          Create business model canvas
+  ${utils.COLORS.cyan}competitors${utils.COLORS.reset}    Create competitive analysis
+  ${utils.COLORS.cyan}status${utils.COLORS.reset}         Show status of business documents
+  ${utils.COLORS.cyan}show${utils.COLORS.reset} <type>    Preview a business document
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  bootspring business init           # Create all business docs
+  bootspring business plan           # Create business plan
+  bootspring business competitors    # Create competitive analysis
+  bootspring business status         # Check progress
+  bootspring business show plan      # Preview business plan
+
+${utils.COLORS.bold}Related Agents:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}business-strategy-expert${utils.COLORS.reset}    Strategy and positioning
+  ${utils.COLORS.cyan}financial-expert${utils.COLORS.reset}            Financial modeling
+  ${utils.COLORS.cyan}competitive-analysis-expert${utils.COLORS.reset} Market research
+  ${utils.COLORS.cyan}marketing-expert${utils.COLORS.reset}            Go-to-market strategy
+`);
+}
+
+/**
+ * Run business command
+ */
+export async function run(args: string[]): Promise<void> {
+  const subcommand = args[0] || 'help';
+
+  switch (subcommand) {
+    case 'init':
+      await businessInit();
+      break;
+
+    case 'plan':
+      await businessCreate('plan');
+      break;
+
+    case 'model':
+      await businessCreate('model');
+      break;
+
+    case 'competitors':
+    case 'competitive':
+      await businessCreate('competitors');
+      break;
+
+    case 'status':
+      businessStatus();
+      break;
+
+    case 'show':
+      if (!args[1]) {
+        utils.print.error('Please specify a document type');
+        console.log(`Usage: ${utils.COLORS.cyan}bootspring business show <plan|model|competitors>${utils.COLORS.reset}`);
+        return;
+      }
+      businessShow(args[1]);
+      break;
+
+    case 'help':
+    case '-h':
+    case '--help':
+      showHelp();
+      break;
+
+    default:
+      // Check if it's a template name
+      if (TEMPLATES[subcommand]) {
+        await businessCreate(subcommand);
+      } else {
+        utils.print.error(`Unknown subcommand: ${subcommand}`);
+        showHelp();
+      }
+  }
+}