myaidev-method 0.2.18 → 0.2.22

package/src/lib/workflow-installer.js

@@ -0,0 +1,512 @@
+/**
+ * MyAIDev Method - Workflow Installer
+ *
+ * Handles modular installation of workflows with dependency resolution
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { WORKFLOWS, resolveWorkflowDependencies, validateWorkflow } from '../config/workflows.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+class WorkflowInstaller {
+  constructor(options = {}) {
+    this.projectRoot = options.projectRoot || process.cwd();
+    this.claudeDir = path.join(this.projectRoot, '.claude');
+    this.manifestPath = path.join(this.projectRoot, '.myaidev-manifest.json');
+    this.verbose = options.verbose || false;
+    this.dryRun = options.dryRun || false;
+  }
+
+  /**
+   * Log message if verbose mode is enabled
+   * @param {string} message - Message to log
+   */
+  log(message) {
+    if (this.verbose) {
+      console.log(message);
+    }
+  }
+
+  /**
+   * Read installation manifest
+   * @returns {Promise<Object>} Installation manifest
+   */
+  async readManifest() {
+    try {
+      const data = await fs.readFile(this.manifestPath, 'utf8');
+      return JSON.parse(data);
+    } catch (error) {
+      // Manifest doesn't exist, return empty
+      return {
+        version: '1.0.0',
+        installedWorkflows: [],
+        installedAt: new Date().toISOString(),
+        lastModified: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * Write installation manifest
+   * @param {Object} manifest - Installation manifest
+   * @returns {Promise<void>}
+   */
+  async writeManifest(manifest) {
+    if (this.dryRun) {
+      this.log('[DRY RUN] Would write manifest to ' + this.manifestPath);
+      return;
+    }
+
+    manifest.lastModified = new Date().toISOString();
+    await fs.writeFile(
+      this.manifestPath,
+      JSON.stringify(manifest, null, 2),
+      'utf8'
+    );
+    this.log('Updated installation manifest');
+  }
+
+  /**
+   * Resolve workflow dependencies
+   * @param {string[]} workflowNames - Workflow names to install
+   * @returns {string[]} Resolved workflow names in dependency order
+   */
+  resolveWorkflows(workflowNames) {
+    const resolved = new Set();
+    const order = [];
+
+    for (const name of workflowNames) {
+      const dependencies = resolveWorkflowDependencies(name, new Set());
+      for (const dep of dependencies) {
+        if (!resolved.has(dep)) {
+          order.push(dep);
+          resolved.add(dep);
+        }
+      }
+    }
+
+    return order;
+  }
+
+  /**
+   * Install agent files
+   * @param {string[]} agents - Agent names
+   * @returns {Promise<number>} Number of agents installed
+   */
+  async installAgents(agents) {
+    if (agents.length === 0) return 0;
+
+    const agentsDir = path.join(this.claudeDir, 'agents');
+    if (!this.dryRun) {
+      await fs.mkdir(agentsDir, { recursive: true });
+    }
+
+    let installed = 0;
+    for (const agent of agents) {
+      const sourcePath = path.join(__dirname, '..', 'agents', `${agent}.md`);
+      const targetPath = path.join(agentsDir, `${agent}.md`);
+
+      try {
+        if (this.dryRun) {
+          this.log(`[DRY RUN] Would copy agent: ${agent}`);
+        } else {
+          await fs.copyFile(sourcePath, targetPath);
+          this.log(`Installed agent: ${agent}`);
+        }
+        installed++;
+      } catch (error) {
+        console.warn(`Warning: Could not install agent ${agent}: ${error.message}`);
+      }
+    }
+
+    return installed;
+  }
+
+  /**
+   * Install command files
+   * @param {string[]} commands - Command names
+   * @returns {Promise<number>} Number of commands installed
+   */
+  async installCommands(commands) {
+    if (commands.length === 0) return 0;
+
+    const commandsDir = path.join(this.claudeDir, 'commands');
+    if (!this.dryRun) {
+      await fs.mkdir(commandsDir, { recursive: true });
+    }
+
+    let installed = 0;
+    for (const command of commands) {
+      const sourcePath = path.join(__dirname, '..', 'commands', `${command}.md`);
+      const targetPath = path.join(commandsDir, `${command}.md`);
+
+      try {
+        if (this.dryRun) {
+          this.log(`[DRY RUN] Would copy command: ${command}`);
+        } else {
+          await fs.copyFile(sourcePath, targetPath);
+          this.log(`Installed command: ${command}`);
+        }
+        installed++;
+      } catch (error) {
+        console.warn(`Warning: Could not install command ${command}: ${error.message}`);
+      }
+    }
+
+    return installed;
+  }
+
+  /**
+   * Install script files
+   * @param {string[]} scripts - Script paths
+   * @returns {Promise<number>} Number of scripts installed
+   */
+  async installScripts(scripts) {
+    if (scripts.length === 0) return 0;
+
+    let installed = 0;
+    for (const script of scripts) {
+      const sourcePath = path.join(__dirname, '..', 'scripts', script);
+      const targetPath = path.join(this.projectRoot, 'scripts', script);
+      const targetDir = path.dirname(targetPath);
+
+      try {
+        if (this.dryRun) {
+          this.log(`[DRY RUN] Would copy script: ${script}`);
+        } else {
+          await fs.mkdir(targetDir, { recursive: true });
+          await fs.copyFile(sourcePath, targetPath);
+          this.log(`Installed script: ${script}`);
+        }
+        installed++;
+      } catch (error) {
+        console.warn(`Warning: Could not install script ${script}: ${error.message}`);
+      }
+    }
+
+    return installed;
+  }
+
+  /**
+   * Install library files
+   * @param {string[]} libs - Library names
+   * @returns {Promise<number>} Number of libraries installed
+   */
+  async installLibraries(libs) {
+    if (libs.length === 0) return 0;
+
+    const libsDir = path.join(this.projectRoot, 'src', 'lib');
+    if (!this.dryRun) {
+      await fs.mkdir(libsDir, { recursive: true });
+    }
+
+    let installed = 0;
+    for (const lib of libs) {
+      const sourcePath = path.join(__dirname, lib);
+      const targetPath = path.join(libsDir, lib);
+
+      try {
+        if (this.dryRun) {
+          this.log(`[DRY RUN] Would copy library: ${lib}`);
+        } else {
+          await fs.copyFile(sourcePath, targetPath);
+          this.log(`Installed library: ${lib}`);
+        }
+        installed++;
+      } catch (error) {
+        console.warn(`Warning: Could not install library ${lib}: ${error.message}`);
+      }
+    }
+
+    return installed;
+  }
+
+  /**
+   * Install documentation files
+   * @param {string[]} docs - Documentation file names
+   * @returns {Promise<number>} Number of docs installed
+   */
+  async installDocs(docs) {
+    if (docs.length === 0) return 0;
+
+    const docsDir = path.join(this.projectRoot, 'docs');
+    if (!this.dryRun) {
+      await fs.mkdir(docsDir, { recursive: true });
+    }
+
+    let installed = 0;
+    for (const doc of docs) {
+      const sourcePath = path.join(__dirname, '..', '..', 'docs', doc);
+      const targetPath = path.join(docsDir, doc);
+
+      try {
+        if (this.dryRun) {
+          this.log(`[DRY RUN] Would copy doc: ${doc}`);
+        } else {
+          await fs.copyFile(sourcePath, targetPath);
+          this.log(`Installed documentation: ${doc}`);
+        }
+        installed++;
+      } catch (error) {
+        console.warn(`Warning: Could not install doc ${doc}: ${error.message}`);
+      }
+    }
+
+    return installed;
+  }
+
+  /**
+   * Configure MCP servers
+   * @param {string[]} mcpServers - MCP server names
+   * @returns {Promise<number>} Number of MCP servers configured
+   */
+  async configureMcpServers(mcpServers) {
+    if (mcpServers.length === 0) return 0;
+
+    const mcpConfigPath = path.join(this.claudeDir, 'mcp.json');
+
+    let config = { mcpServers: {} };
+    try {
+      const data = await fs.readFile(mcpConfigPath, 'utf8');
+      config = JSON.parse(data);
+    } catch (error) {
+      // Config doesn't exist, start fresh
+    }
+
+    let configured = 0;
+    for (const server of mcpServers) {
+      if (server === 'myaidev') {
+        config.mcpServers.myaidev = {
+          command: 'node',
+          args: [path.join(__dirname, 'mcp', 'wordpress-mcp-server.js')]
+        };
+        this.log(`Configured MCP server: ${server}`);
+        configured++;
+      }
+    }
+
+    if (configured > 0 && !this.dryRun) {
+      await fs.writeFile(mcpConfigPath, JSON.stringify(config, null, 2), 'utf8');
+    } else if (this.dryRun) {
+      this.log('[DRY RUN] Would configure MCP servers');
+    }
+
+    return configured;
+  }
+
+  /**
+   * Display environment variables needed
+   * @param {string[]} envVars - Environment variable names
+   */
+  displayEnvVars(envVars) {
+    if (envVars.length === 0) return;
+
+    console.log('\n⚠️  Environment Variables Required:');
+    for (const envVar of envVars) {
+      console.log(`   - ${envVar}`);
+    }
+    console.log('\nConfigure these using: npx myaidev-method configure\n');
+  }
+
+  /**
+   * Install a single workflow
+   * @param {string} workflowName - Workflow name
+   * @returns {Promise<Object>} Installation results
+   */
+  async installWorkflow(workflowName) {
+    const workflow = WORKFLOWS[workflowName];
+    if (!workflow) {
+      throw new Error(`Unknown workflow: ${workflowName}`);
+    }
+
+    // Validate workflow definition
+    const validation = validateWorkflow(workflow);
+    if (!validation.valid) {
+      throw new Error(`Invalid workflow ${workflowName}: ${validation.errors.join(', ')}`);
+    }
+
+    this.log(`\n📦 Installing workflow: ${workflow.name}`);
+
+    const results = {
+      workflow: workflowName,
+      agents: 0,
+      commands: 0,
+      scripts: 0,
+      libs: 0,
+      docs: 0,
+      mcpServers: 0
+    };
+
+    // Install components
+    results.agents = await this.installAgents(workflow.agents);
+    results.commands = await this.installCommands(workflow.commands);
+    results.scripts = await this.installScripts(workflow.scripts);
+    results.libs = await this.installLibraries(workflow.libs);
+    results.docs = await this.installDocs(workflow.docs);
+    results.mcpServers = await this.configureMcpServers(workflow.mcpServers);
+
+    // Display environment variables
+    this.displayEnvVars(workflow.envVars);
+
+    return results;
+  }
+
+  /**
+   * Install workflows with dependencies
+   * @param {string[]} workflowNames - Workflow names to install
+   * @returns {Promise<Object>} Installation summary
+   */
+  async install(workflowNames) {
+    console.log('🚀 MyAIDev Method - Modular Installation\n');
+
+    // Resolve dependencies
+    const resolvedWorkflows = this.resolveWorkflows(workflowNames);
+    this.log(`Resolved workflows: ${resolvedWorkflows.join(', ')}`);
+
+    // Read existing manifest
+    const manifest = await this.readManifest();
+    const alreadyInstalled = manifest.installedWorkflows || [];
+
+    // Filter out already installed workflows
+    const toInstall = resolvedWorkflows.filter(w => !alreadyInstalled.includes(w));
+
+    if (toInstall.length === 0) {
+      console.log('✅ All requested workflows are already installed\n');
+      return { installed: [], alreadyInstalled };
+    }
+
+    console.log(`Installing: ${toInstall.join(', ')}\n`);
+
+    // Install each workflow
+    const results = [];
+    for (const workflowName of toInstall) {
+      try {
+        const result = await this.installWorkflow(workflowName);
+        results.push(result);
+
+        // Add to manifest
+        if (!manifest.installedWorkflows.includes(workflowName)) {
+          manifest.installedWorkflows.push(workflowName);
+        }
+      } catch (error) {
+        console.error(`❌ Failed to install ${workflowName}: ${error.message}`);
+      }
+    }
+
+    // Update manifest
+    await this.writeManifest(manifest);
+
+    // Summary
+    console.log('\n✅ Installation complete!\n');
+    console.log('Installed workflows:');
+    for (const result of results) {
+      const workflow = WORKFLOWS[result.workflow];
+      console.log(`  • ${workflow.name}`);
+      console.log(`    - ${result.agents} agents, ${result.commands} commands, ${result.scripts} scripts`);
+    }
+
+    return { installed: toInstall, alreadyInstalled, results };
+  }
+
+  /**
+   * Remove a workflow
+   * @param {string} workflowName - Workflow name to remove
+   * @returns {Promise<Object>} Removal results
+   */
+  async removeWorkflow(workflowName) {
+    const workflow = WORKFLOWS[workflowName];
+    if (!workflow) {
+      throw new Error(`Unknown workflow: ${workflowName}`);
+    }
+
+    console.log(`\n🗑️  Removing workflow: ${workflow.name}`);
+
+    const manifest = await this.readManifest();
+
+    // Check if workflow is installed
+    if (!manifest.installedWorkflows.includes(workflowName)) {
+      console.log(`⚠️  Workflow ${workflowName} is not installed`);
+      return { removed: false };
+    }
+
+    // Check if other workflows depend on this one
+    const dependents = manifest.installedWorkflows.filter(w => {
+      const wf = WORKFLOWS[w];
+      return wf && wf.dependencies.includes(workflowName);
+    });
+
+    if (dependents.length > 0) {
+      throw new Error(
+        `Cannot remove ${workflowName}: Required by ${dependents.join(', ')}`
+      );
+    }
+
+    if (this.dryRun) {
+      console.log(`[DRY RUN] Would remove workflow: ${workflowName}`);
+      return { removed: true, dryRun: true };
+    }
+
+    // Remove files (in reverse order of installation)
+    // Note: We don't actually delete files to avoid breaking other workflows
+    // Just remove from manifest
+    manifest.installedWorkflows = manifest.installedWorkflows.filter(
+      w => w !== workflowName
+    );
+
+    await this.writeManifest(manifest);
+
+    console.log(`✅ Removed workflow: ${workflow.name}\n`);
+    console.log('Note: Files were not deleted to preserve shared components');
+
+    return { removed: true };
+  }
+
+  /**
+   * List installed workflows
+   * @returns {Promise<Object>} List of installed workflows
+   */
+  async listInstalled() {
+    const manifest = await this.readManifest();
+    const installed = manifest.installedWorkflows || [];
+
+    console.log('\n📋 Installed Workflows:\n');
+
+    if (installed.length === 0) {
+      console.log('  No workflows installed yet\n');
+      return { installed: [] };
+    }
+
+    for (const workflowName of installed) {
+      const workflow = WORKFLOWS[workflowName];
+      if (workflow) {
+        console.log(`  • ${workflow.name} (${workflowName})`);
+        console.log(`    ${workflow.description}`);
+      }
+    }
+
+    console.log('');
+    return { installed };
+  }
+
+  /**
+   * Show workflow status
+   * @returns {Promise<Object>} Workflow status
+   */
+  async status() {
+    const manifest = await this.readManifest();
+    const installed = manifest.installedWorkflows || [];
+    const available = Object.keys(WORKFLOWS);
+
+    console.log('\n📊 Workflow Status:\n');
+    console.log(`Installed: ${installed.length}/${available.length}`);
+    console.log(`Last modified: ${manifest.lastModified || 'Never'}\n`);
+
+    return { installed, available, manifest };
+  }
+}
+
+export default WorkflowInstaller;