@girardmedia/bootspring 1.2.0 → 2.0.3

package/cli/workspace.js

@@ -0,0 +1,607 @@
+/**
+ * Bootspring Workspace Command
+ * Multi-project workspace management and cross-project workflows
+ *
+ * @package bootspring
+ * @command workspace
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const config = require('../core/config');
+const utils = require('../core/utils');
+const telemetry = require('../core/telemetry');
+
+// Colors
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  blue: '\x1b[34m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m',
+  magenta: '\x1b[35m'
+};
+
+// Workspace config location
+const WORKSPACE_DIR = '.bootspring-workspace';
+const WORKSPACE_FILE = 'workspace.json';
+
+/**
+ * Workspace class for managing multiple projects
+ */
+class Workspace {
+  constructor(workspaceRoot) {
+    this.workspaceRoot = workspaceRoot;
+    this.configPath = path.join(workspaceRoot, WORKSPACE_DIR, WORKSPACE_FILE);
+    this.config = this.loadConfig();
+  }
+
+  loadConfig() {
+    try {
+      if (fs.existsSync(this.configPath)) {
+        return JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+      }
+    } catch {
+      // Return defaults
+    }
+
+    return {
+      name: path.basename(this.workspaceRoot),
+      version: '1.0.0',
+      projects: [],
+      settings: {
+        parallelWorkflows: true,
+        sharedConfig: false,
+        crossProjectDeps: true
+      },
+      createdAt: new Date().toISOString(),
+      lastUpdated: new Date().toISOString()
+    };
+  }
+
+  save() {
+    const dir = path.dirname(this.configPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    this.config.lastUpdated = new Date().toISOString();
+    fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+  }
+
+  /**
+   * Initialize workspace
+   */
+  init(name) {
+    this.config.name = name || this.config.name;
+    this.config.createdAt = new Date().toISOString();
+    this.save();
+
+    return {
+      path: this.configPath,
+      name: this.config.name
+    };
+  }
+
+  /**
+   * Add a project to the workspace
+   */
+  addProject(projectPath, options = {}) {
+    const absolutePath = path.resolve(this.workspaceRoot, projectPath);
+
+    // Validate project exists
+    if (!fs.existsSync(absolutePath)) {
+      throw new Error(`Project path does not exist: ${absolutePath}`);
+    }
+
+    // Check if it's a valid bootspring project
+    const bootspringConfig = path.join(absolutePath, 'bootspring.config.js');
+    const packageJson = path.join(absolutePath, 'package.json');
+
+    const isBootspring = fs.existsSync(bootspringConfig);
+    const hasPackageJson = fs.existsSync(packageJson);
+
+    // Get project name
+    let projectName = options.name;
+    if (!projectName && hasPackageJson) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(packageJson, 'utf-8'));
+        projectName = pkg.name;
+      } catch {
+        projectName = path.basename(absolutePath);
+      }
+    }
+    projectName = projectName || path.basename(absolutePath);
+
+    // Check for duplicates
+    const existing = this.config.projects.find(
+      p => p.path === projectPath || p.name === projectName
+    );
+    if (existing) {
+      throw new Error(`Project already in workspace: ${existing.name}`);
+    }
+
+    // Add project
+    const project = {
+      name: projectName,
+      path: projectPath,
+      absolutePath,
+      isBootspring,
+      tags: options.tags || [],
+      addedAt: new Date().toISOString()
+    };
+
+    this.config.projects.push(project);
+    this.save();
+
+    return project;
+  }
+
+  /**
+   * Remove a project from workspace
+   */
+  removeProject(nameOrPath) {
+    const index = this.config.projects.findIndex(
+      p => p.name === nameOrPath || p.path === nameOrPath
+    );
+
+    if (index === -1) {
+      throw new Error(`Project not found: ${nameOrPath}`);
+    }
+
+    const removed = this.config.projects.splice(index, 1)[0];
+    this.save();
+
+    return removed;
+  }
+
+  /**
+   * List all projects
+   */
+  listProjects() {
+    return this.config.projects.map(p => ({
+      ...p,
+      exists: fs.existsSync(p.absolutePath),
+      health: this.getProjectHealth(p)
+    }));
+  }
+
+  /**
+   * Get project health summary
+   */
+  getProjectHealth(project) {
+    try {
+      const healthPath = path.join(project.absolutePath, '.bootspring', 'health.json');
+      if (fs.existsSync(healthPath)) {
+        const health = JSON.parse(fs.readFileSync(healthPath, 'utf-8'));
+        return health.score || 0;
+      }
+
+      // Calculate basic health
+      const todoPath = path.join(project.absolutePath, 'todo.md');
+      const claudePath = path.join(project.absolutePath, 'CLAUDE.md');
+
+      let score = 50; // Base score
+      if (fs.existsSync(claudePath)) score += 20;
+      if (fs.existsSync(todoPath)) score += 10;
+      if (project.isBootspring) score += 20;
+
+      return Math.min(100, score);
+    } catch {
+      return 0;
+    }
+  }
+
+  /**
+   * Run a workflow across all projects
+   */
+  async runWorkflow(workflowName, options = {}) {
+    const projects = this.listProjects().filter(p => p.exists);
+    const results = [];
+
+    if (projects.length === 0) {
+      throw new Error('No valid projects in workspace');
+    }
+
+    const filteredProjects = options.filter
+      ? projects.filter(p => p.tags?.includes(options.filter) || p.name.includes(options.filter))
+      : projects;
+
+    if (this.config.settings.parallelWorkflows && !options.sequential) {
+      // Run in parallel
+      const promises = filteredProjects.map(project =>
+        this.runWorkflowForProject(project, workflowName, options)
+      );
+
+      const settled = await Promise.allSettled(promises);
+
+      for (let i = 0; i < settled.length; i++) {
+        results.push({
+          project: filteredProjects[i].name,
+          ...settled[i]
+        });
+      }
+    } else {
+      // Run sequentially
+      for (const project of filteredProjects) {
+        try {
+          const result = await this.runWorkflowForProject(project, workflowName, options);
+          results.push({ project: project.name, status: 'fulfilled', value: result });
+        } catch (error) {
+          results.push({ project: project.name, status: 'rejected', reason: error });
+        }
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Run workflow for a single project
+   */
+  async runWorkflowForProject(project, workflowName, options = {}) {
+    const command = `bootspring ${workflowName}`;
+
+    return new Promise((resolve, reject) => {
+      try {
+        const output = execSync(command, {
+          cwd: project.absolutePath,
+          encoding: 'utf-8',
+          timeout: options.timeout || 300000, // 5 minute default
+          stdio: options.verbose ? 'inherit' : 'pipe'
+        });
+
+        resolve({ success: true, output });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Get workspace summary
+   */
+  getSummary() {
+    const projects = this.listProjects();
+
+    return {
+      name: this.config.name,
+      projectCount: projects.length,
+      healthyProjects: projects.filter(p => p.health >= 70).length,
+      bootspringProjects: projects.filter(p => p.isBootspring).length,
+      missingProjects: projects.filter(p => !p.exists).length,
+      averageHealth: projects.length > 0
+        ? Math.round(projects.reduce((sum, p) => sum + p.health, 0) / projects.length)
+        : 0,
+      lastUpdated: this.config.lastUpdated
+    };
+  }
+
+  /**
+   * Export workspace config
+   */
+  export() {
+    return {
+      ...this.config,
+      projects: this.listProjects()
+    };
+  }
+}
+
+/**
+ * Find workspace root
+ */
+function findWorkspaceRoot(startPath = process.cwd()) {
+  let current = startPath;
+
+  while (current !== path.dirname(current)) {
+    const workspaceDir = path.join(current, WORKSPACE_DIR);
+    if (fs.existsSync(workspaceDir)) {
+      return current;
+    }
+    current = path.dirname(current);
+  }
+
+  return startPath; // Use start path if no workspace found
+}
+
+/**
+ * Initialize workspace
+ */
+function initWorkspace(name, options = {}) {
+  const workspaceRoot = options.path || process.cwd();
+  const workspace = new Workspace(workspaceRoot);
+  const result = workspace.init(name);
+
+  console.log(`
+${c.green}✓${c.reset} Workspace initialized: ${c.bold}${result.name}${c.reset}
+${c.dim}Config: ${result.path}${c.reset}
+
+${c.bold}Next steps:${c.reset}
+  1. Add projects: ${c.cyan}bootspring workspace add ./project-a${c.reset}
+  2. List projects: ${c.cyan}bootspring workspace list${c.reset}
+  3. Run workflows: ${c.cyan}bootspring workspace run analyze${c.reset}
+`);
+
+  telemetry.emitEvent('workspace:init', { name: result.name });
+}
+
+/**
+ * Add project to workspace
+ */
+function addProject(projectPath, options = {}) {
+  const workspaceRoot = findWorkspaceRoot();
+  const workspace = new Workspace(workspaceRoot);
+
+  try {
+    const project = workspace.addProject(projectPath, options);
+
+    console.log(`
+${c.green}✓${c.reset} Added project: ${c.bold}${project.name}${c.reset}
+${c.dim}Path: ${project.absolutePath}${c.reset}
+${c.dim}Bootspring: ${project.isBootspring ? 'Yes' : 'No'}${c.reset}
+`);
+
+    telemetry.emitEvent('workspace:add', { project: project.name });
+  } catch (error) {
+    console.log(`${c.red}Error:${c.reset} ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Remove project from workspace
+ */
+function removeProject(nameOrPath) {
+  const workspaceRoot = findWorkspaceRoot();
+  const workspace = new Workspace(workspaceRoot);
+
+  try {
+    const removed = workspace.removeProject(nameOrPath);
+    console.log(`${c.green}✓${c.reset} Removed project: ${c.bold}${removed.name}${c.reset}`);
+
+    telemetry.emitEvent('workspace:remove', { project: removed.name });
+  } catch (error) {
+    console.log(`${c.red}Error:${c.reset} ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * List projects in workspace
+ */
+function listProjects(options = {}) {
+  const workspaceRoot = findWorkspaceRoot();
+  const workspace = new Workspace(workspaceRoot);
+  const summary = workspace.getSummary();
+  const projects = workspace.listProjects();
+
+  if (options.json) {
+    console.log(JSON.stringify(workspace.export(), null, 2));
+    return;
+  }
+
+  console.log(`
+${c.cyan}${c.bold}⚡ Workspace: ${summary.name}${c.reset}
+${c.dim}Projects: ${summary.projectCount} | Healthy: ${summary.healthyProjects} | Avg Health: ${summary.averageHealth}%${c.reset}
+`);
+
+  if (projects.length === 0) {
+    console.log(`${c.dim}No projects in workspace. Add one with:${c.reset}`);
+    console.log('  bootspring workspace add ./path-to-project');
+    return;
+  }
+
+  console.log(`${c.bold}Projects${c.reset}\n`);
+
+  for (const project of projects) {
+    const statusIcon = !project.exists ? `${c.red}✗${c.reset}` :
+      project.health >= 70 ? `${c.green}●${c.reset}` :
+        project.health >= 50 ? `${c.yellow}●${c.reset}` :
+          `${c.red}●${c.reset}`;
+
+    const bootspringBadge = project.isBootspring ? `${c.cyan}[bs]${c.reset}` : '';
+
+    console.log(`  ${statusIcon} ${c.bold}${project.name}${c.reset} ${bootspringBadge}`);
+    console.log(`    ${c.dim}${project.path}${c.reset}`);
+    console.log(`    ${c.dim}Health: ${project.health}%${c.reset}`);
+
+    if (project.tags?.length > 0) {
+      console.log(`    ${c.dim}Tags: ${project.tags.join(', ')}${c.reset}`);
+    }
+
+    console.log();
+  }
+}
+
+/**
+ * Run workflow across workspace
+ */
+async function runWorkflow(workflowName, options = {}) {
+  const workspaceRoot = findWorkspaceRoot();
+  const workspace = new Workspace(workspaceRoot);
+
+  console.log(`
+${c.cyan}${c.bold}⚡ Running: ${workflowName}${c.reset}
+${c.dim}Workspace: ${workspace.config.name}${c.reset}
+`);
+
+  try {
+    const results = await workspace.runWorkflow(workflowName, options);
+
+    console.log(`\n${c.bold}Results${c.reset}\n`);
+
+    let successCount = 0;
+    let failCount = 0;
+
+    for (const result of results) {
+      if (result.status === 'fulfilled') {
+        console.log(`  ${c.green}✓${c.reset} ${result.project}`);
+        successCount++;
+      } else {
+        console.log(`  ${c.red}✗${c.reset} ${result.project}`);
+        if (options.verbose) {
+          console.log(`    ${c.dim}${result.reason?.message || 'Unknown error'}${c.reset}`);
+        }
+        failCount++;
+      }
+    }
+
+    console.log(`
+${c.bold}Summary${c.reset}
+  Success: ${c.green}${successCount}${c.reset}
+  Failed: ${c.red}${failCount}${c.reset}
+`);
+
+    telemetry.emitEvent('workspace:run', {
+      workflow: workflowName,
+      success: successCount,
+      failed: failCount
+    });
+
+  } catch (error) {
+    console.log(`${c.red}Error:${c.reset} ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Show workspace status
+ */
+function showStatus() {
+  const workspaceRoot = findWorkspaceRoot();
+  const workspace = new Workspace(workspaceRoot);
+  const summary = workspace.getSummary();
+
+  console.log(`
+${c.cyan}${c.bold}⚡ Workspace Status${c.reset}
+
+${c.bold}Name${c.reset}:      ${summary.name}
+${c.bold}Projects${c.reset}: ${summary.projectCount}
+${c.bold}Healthy${c.reset}:  ${summary.healthyProjects}/${summary.projectCount}
+${c.bold}Health${c.reset}:   ${summary.averageHealth}%
+${c.bold}Updated${c.reset}:  ${summary.lastUpdated}
+
+${c.bold}Settings${c.reset}
+  Parallel Workflows: ${workspace.config.settings.parallelWorkflows ? 'Yes' : 'No'}
+  Shared Config: ${workspace.config.settings.sharedConfig ? 'Yes' : 'No'}
+  Cross-Project Deps: ${workspace.config.settings.crossProjectDeps ? 'Yes' : 'No'}
+`);
+}
+
+/**
+ * Show help
+ */
+function showHelp() {
+  console.log(`
+${c.cyan}${c.bold}⚡ Bootspring Workspace${c.reset}
+${c.dim}Multi-project workspace management${c.reset}
+
+${c.bold}Usage:${c.reset}
+  bootspring workspace <command> [options]
+
+${c.bold}Commands:${c.reset}
+  ${c.cyan}init [name]${c.reset}           Initialize workspace in current directory
+  ${c.cyan}add <path>${c.reset}            Add a project to workspace
+  ${c.cyan}remove <name>${c.reset}         Remove a project from workspace
+  ${c.cyan}list${c.reset}                  List all projects
+  ${c.cyan}status${c.reset}                Show workspace status
+  ${c.cyan}run <workflow>${c.reset}        Run workflow across all projects
+
+${c.bold}Options:${c.reset}
+  --name <name>         Project name (for add)
+  --tags <tags>         Comma-separated tags (for add)
+  --filter <pattern>    Filter projects (for run)
+  --sequential          Run workflows sequentially
+  --verbose             Show detailed output
+  --json                Output as JSON
+
+${c.bold}Workflows:${c.reset}
+  analyze, audit, health, generate, deploy
+
+${c.bold}Examples:${c.reset}
+  bootspring workspace init my-workspace
+  bootspring workspace add ../project-a --tags=frontend
+  bootspring workspace add ../project-b --tags=backend
+  bootspring workspace list
+  bootspring workspace run analyze
+  bootspring workspace run health --filter=frontend
+`);
+}
+
+/**
+ * Run workspace command
+ */
+async function run(args) {
+  const parsedArgs = utils.parseArgs(args);
+  const subcommand = parsedArgs._[0];
+
+  if (!subcommand || subcommand === 'help' || parsedArgs.help || parsedArgs.h) {
+    showHelp();
+    return;
+  }
+
+  switch (subcommand) {
+    case 'init':
+      initWorkspace(parsedArgs._[1], { path: parsedArgs.path });
+      break;
+
+    case 'add':
+      if (!parsedArgs._[1]) {
+        console.log(`${c.red}Error:${c.reset} Project path required`);
+        process.exit(1);
+      }
+      addProject(parsedArgs._[1], {
+        name: parsedArgs.name,
+        tags: parsedArgs.tags?.split(',').map(t => t.trim())
+      });
+      break;
+
+    case 'remove':
+    case 'rm':
+      if (!parsedArgs._[1]) {
+        console.log(`${c.red}Error:${c.reset} Project name or path required`);
+        process.exit(1);
+      }
+      removeProject(parsedArgs._[1]);
+      break;
+
+    case 'list':
+    case 'ls':
+      listProjects({ json: parsedArgs.json });
+      break;
+
+    case 'status':
+      showStatus();
+      break;
+
+    case 'run':
+    case 'exec':
+      if (!parsedArgs._[1]) {
+        console.log(`${c.red}Error:${c.reset} Workflow name required`);
+        process.exit(1);
+      }
+      await runWorkflow(parsedArgs._[1], {
+        filter: parsedArgs.filter,
+        sequential: parsedArgs.sequential,
+        verbose: parsedArgs.verbose,
+        timeout: parseInt(parsedArgs.timeout, 10) || 300000
+      });
+      break;
+
+    default:
+      console.log(`${c.red}Error:${c.reset} Unknown command: ${subcommand}`);
+      showHelp();
+      process.exit(1);
+  }
+}
+
+module.exports = {
+  run,
+  Workspace,
+  findWorkspaceRoot
+};