agileflow 2.30.0

package/tools/cli/commands/install.js

@@ -0,0 +1,82 @@
+/**
+ * AgileFlow CLI - Install Command
+ *
+ * Installs AgileFlow to a project directory.
+ */
+
+const chalk = require('chalk');
+const path = require('node:path');
+const { Installer } = require('../installers/core/installer');
+const { IdeManager } = require('../installers/ide/manager');
+const { promptInstall, success, error, info, displaySection } = require('../lib/ui');
+
+const installer = new Installer();
+const ideManager = new IdeManager();
+
+module.exports = {
+  name: 'install',
+  description: 'Install AgileFlow to a project',
+  options: [
+    ['-d, --directory <path>', 'Installation directory (default: current directory)'],
+    ['-y, --yes', 'Skip prompts and use defaults'],
+  ],
+  action: async (options) => {
+    try {
+      let config;
+
+      if (options.yes) {
+        // Use defaults
+        config = {
+          directory: path.resolve(options.directory || '.'),
+          ides: ['claude-code'],
+          userName: 'Developer',
+          agileflowFolder: '.agileflow',
+        };
+      } else {
+        // Interactive prompts
+        config = await promptInstall();
+      }
+
+      displaySection('Installing AgileFlow', `Target: ${config.directory}`);
+
+      // Run core installation
+      const coreResult = await installer.install(config);
+
+      if (!coreResult.success) {
+        error('Core installation failed');
+        process.exit(1);
+      }
+
+      success(`Installed ${coreResult.counts.agents} agents`);
+      success(`Installed ${coreResult.counts.commands} commands`);
+      success(`Installed ${coreResult.counts.skills} skills`);
+
+      // Setup IDE configurations
+      displaySection('Configuring IDEs');
+
+      ideManager.setAgileflowFolder(config.agileflowFolder);
+
+      for (const ide of config.ides) {
+        await ideManager.setup(ide, config.directory, coreResult.path);
+      }
+
+      // Final summary
+      console.log(chalk.green('\n✨ Installation complete!\n'));
+
+      console.log(chalk.bold('Get started:'));
+      info('Open your IDE and use /agileflow:help');
+      info(`Run 'npx agileflow status' to check installation`);
+      info(`Run 'npx agileflow update' to get updates`);
+
+      console.log(chalk.dim(`\nInstalled to: ${coreResult.path}\n`));
+
+      process.exit(0);
+    } catch (err) {
+      console.error(chalk.red('\nInstallation failed:'), err.message);
+      if (process.env.DEBUG) {
+        console.error(err.stack);
+      }
+      process.exit(1);
+    }
+  },
+};

package/tools/cli/commands/status.js

@@ -0,0 +1,121 @@
+/**
+ * AgileFlow CLI - Status Command
+ *
+ * Shows installation status for the current project.
+ */
+
+const chalk = require('chalk');
+const path = require('node:path');
+const fs = require('fs-extra');
+const ora = require('ora');
+const { Installer } = require('../installers/core/installer');
+const { displayLogo, displaySection, success, warning, info } = require('../lib/ui');
+const { checkForUpdate } = require('../lib/version-checker');
+
+const installer = new Installer();
+
+module.exports = {
+  name: 'status',
+  description: 'Show AgileFlow installation status',
+  options: [
+    ['-d, --directory <path>', 'Project directory (default: current directory)'],
+  ],
+  action: async (options) => {
+    try {
+      const directory = path.resolve(options.directory || '.');
+
+      displayLogo();
+      displaySection('Installation Status');
+
+      const status = await installer.getStatus(directory);
+
+      if (!status.installed) {
+        warning('No AgileFlow installation found in this directory');
+        console.log(chalk.dim(`\nRun 'npx agileflow install' to set up AgileFlow\n`));
+        process.exit(0);
+      }
+
+      // Show installation info
+      console.log(chalk.bold('Location:    '), status.path);
+      console.log(chalk.bold('Version:     '), status.version);
+
+      // Count installed items
+      const counts = await installer.countInstalledItems(status.path);
+
+      console.log(chalk.bold('\nCore:        '), chalk.green('✓ Installed'));
+      info(`${counts.agents} agents`);
+      info(`${counts.commands} commands`);
+      info(`${counts.skills} skills`);
+
+      // Show configured IDEs
+      if (status.ides && status.ides.length > 0) {
+        console.log(chalk.bold('\nConfigured IDEs:'));
+        for (const ide of status.ides) {
+          // Check if IDE config exists
+          const ideConfigPath = getIdeConfigPath(directory, ide);
+          const exists = await fs.pathExists(ideConfigPath);
+
+          if (exists) {
+            success(formatIdeName(ide));
+          } else {
+            warning(`${formatIdeName(ide)} (config missing)`);
+          }
+        }
+      }
+
+      // Check for updates
+      const spinner = ora('Checking for updates...').start();
+      const updateInfo = await checkForUpdate();
+      spinner.stop();
+
+      if (updateInfo.updateAvailable) {
+        console.log(chalk.bold('\nUpdate Available:'));
+        console.log(chalk.yellow(`  ${updateInfo.current} → ${updateInfo.latest}`));
+        console.log(chalk.dim(`  Run 'npx agileflow update' to update\n`));
+      } else if (updateInfo.error) {
+        console.log(chalk.dim(`\n${updateInfo.error}\n`));
+      } else {
+        console.log(chalk.green('\n✓ You are on the latest version\n'));
+      }
+
+      process.exit(0);
+    } catch (err) {
+      console.error(chalk.red('Error:'), err.message);
+      if (process.env.DEBUG) {
+        console.error(err.stack);
+      }
+      process.exit(1);
+    }
+  },
+};
+
+/**
+ * Get IDE config path
+ * @param {string} projectDir - Project directory
+ * @param {string} ide - IDE name
+ * @returns {string}
+ */
+function getIdeConfigPath(projectDir, ide) {
+  const paths = {
+    'claude-code': '.claude/commands/AgileFlow',
+    'cursor': '.cursor/rules/agileflow',
+    'windsurf': '.windsurf/workflows/agileflow',
+  };
+
+  return path.join(projectDir, paths[ide] || '');
+}
+
+/**
+ * Format IDE name for display
+ * @param {string} ide - IDE name
+ * @returns {string}
+ */
+function formatIdeName(ide) {
+  const names = {
+    'claude-code': 'Claude Code',
+    'cursor': 'Cursor',
+    'windsurf': 'Windsurf',
+  };
+
+  return names[ide] || ide;
+}

package/tools/cli/commands/uninstall.js

@@ -0,0 +1,110 @@
+/**
+ * AgileFlow CLI - Uninstall Command
+ *
+ * Removes AgileFlow from a project.
+ */
+
+const chalk = require('chalk');
+const path = require('node:path');
+const fs = require('fs-extra');
+const { Installer } = require('../installers/core/installer');
+const { IdeManager } = require('../installers/ide/manager');
+const { displayLogo, displaySection, success, warning, error, confirm } = require('../lib/ui');
+
+const installer = new Installer();
+const ideManager = new IdeManager();
+
+module.exports = {
+  name: 'uninstall',
+  description: 'Remove AgileFlow from a project',
+  options: [
+    ['-d, --directory <path>', 'Project directory (default: current directory)'],
+    ['--force', 'Skip confirmation prompt'],
+  ],
+  action: async (options) => {
+    try {
+      const directory = path.resolve(options.directory || '.');
+
+      displayLogo();
+
+      // Check for existing installation
+      const status = await installer.getStatus(directory);
+
+      if (!status.installed) {
+        warning('No AgileFlow installation found');
+        process.exit(0);
+      }
+
+      displaySection('Uninstalling AgileFlow', `Location: ${status.path}`);
+
+      // Confirm uninstall
+      if (!options.force) {
+        const proceed = await confirm('Are you sure you want to uninstall AgileFlow?', false);
+        if (!proceed) {
+          console.log(chalk.dim('\nUninstall cancelled\n'));
+          process.exit(0);
+        }
+      }
+
+      console.log();
+
+      // Remove IDE configurations
+      if (status.ides && status.ides.length > 0) {
+        for (const ide of status.ides) {
+          const configPath = getIdeConfigPath(directory, ide);
+          if (await fs.pathExists(configPath)) {
+            await fs.remove(configPath);
+            success(`Removed ${formatIdeName(ide)} configuration`);
+          }
+        }
+      }
+
+      // Remove AgileFlow directory
+      if (await fs.pathExists(status.path)) {
+        await fs.remove(status.path);
+        success(`Removed ${path.basename(status.path)}/`);
+      }
+
+      console.log(chalk.green('\nAgileFlow has been uninstalled.\n'));
+
+      process.exit(0);
+    } catch (err) {
+      console.error(chalk.red('Uninstall failed:'), err.message);
+      if (process.env.DEBUG) {
+        console.error(err.stack);
+      }
+      process.exit(1);
+    }
+  },
+};
+
+/**
+ * Get IDE config path
+ * @param {string} projectDir - Project directory
+ * @param {string} ide - IDE name
+ * @returns {string}
+ */
+function getIdeConfigPath(projectDir, ide) {
+  const paths = {
+    'claude-code': '.claude/commands/AgileFlow',
+    'cursor': '.cursor/rules/agileflow',
+    'windsurf': '.windsurf/workflows/agileflow',
+  };
+
+  return path.join(projectDir, paths[ide] || '');
+}
+
+/**
+ * Format IDE name for display
+ * @param {string} ide - IDE name
+ * @returns {string}
+ */
+function formatIdeName(ide) {
+  const names = {
+    'claude-code': 'Claude Code',
+    'cursor': 'Cursor',
+    'windsurf': 'Windsurf',
+  };
+
+  return names[ide] || ide;
+}

package/tools/cli/commands/update.js

@@ -0,0 +1,99 @@
+/**
+ * AgileFlow CLI - Update Command
+ *
+ * Updates an existing AgileFlow installation.
+ */
+
+const chalk = require('chalk');
+const path = require('node:path');
+const { Installer } = require('../installers/core/installer');
+const { IdeManager } = require('../installers/ide/manager');
+const { displayLogo, displaySection, success, warning, error, info, confirm } = require('../lib/ui');
+
+const installer = new Installer();
+const ideManager = new IdeManager();
+
+module.exports = {
+  name: 'update',
+  description: 'Update existing AgileFlow installation',
+  options: [
+    ['-d, --directory <path>', 'Project directory (default: current directory)'],
+    ['--force', 'Force update, overwriting modified files'],
+  ],
+  action: async (options) => {
+    try {
+      const directory = path.resolve(options.directory || '.');
+
+      displayLogo();
+
+      // Check for existing installation
+      const status = await installer.getStatus(directory);
+
+      if (!status.installed) {
+        warning('No AgileFlow installation found');
+        console.log(chalk.dim(`\nRun 'npx agileflow install' to set up AgileFlow\n`));
+        process.exit(1);
+      }
+
+      displaySection('Updating AgileFlow', `Current version: ${status.version}`);
+
+      // Get package version
+      const packageJson = require(path.join(__dirname, '..', '..', '..', 'package.json'));
+      const newVersion = packageJson.version;
+
+      console.log(chalk.bold('Current: '), status.version);
+      console.log(chalk.bold('Latest:  '), newVersion);
+
+      if (status.version === newVersion && !options.force) {
+        success('Already on the latest version');
+        process.exit(0);
+      }
+
+      // Confirm update
+      if (!options.force) {
+        const proceed = await confirm(`Update to v${newVersion}?`);
+        if (!proceed) {
+          console.log(chalk.dim('\nUpdate cancelled\n'));
+          process.exit(0);
+        }
+      }
+
+      console.log();
+
+      // Re-run installation with existing config
+      const config = {
+        directory,
+        ides: status.ides || ['claude-code'],
+        userName: 'Developer', // Could read from existing config
+        agileflowFolder: path.basename(status.path),
+      };
+
+      // Run core installation
+      const coreResult = await installer.install(config);
+
+      if (!coreResult.success) {
+        error('Update failed');
+        process.exit(1);
+      }
+
+      success('Updated core content');
+
+      // Re-setup IDEs
+      ideManager.setAgileflowFolder(config.agileflowFolder);
+
+      for (const ide of config.ides) {
+        await ideManager.setup(ide, directory, status.path);
+      }
+
+      console.log(chalk.green(`\n✨ Update complete! (${status.version} → ${newVersion})\n`));
+
+      process.exit(0);
+    } catch (err) {
+      console.error(chalk.red('Update failed:'), err.message);
+      if (process.env.DEBUG) {
+        console.error(err.stack);
+      }
+      process.exit(1);
+    }
+  },
+};

package/tools/cli/installers/core/installer.js

@@ -0,0 +1,296 @@
+/**
+ * AgileFlow CLI - Core Installer
+ *
+ * Handles the main installation logic for AgileFlow.
+ */
+
+const path = require('node:path');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const ora = require('ora');
+const yaml = require('js-yaml');
+
+/**
+ * Get the source path for AgileFlow content
+ * @returns {string} Path to src directory
+ */
+function getSourcePath() {
+  return path.join(__dirname, '..', '..', '..', '..', 'src');
+}
+
+/**
+ * Get the package root path
+ * @returns {string} Path to package root
+ */
+function getPackageRoot() {
+  return path.join(__dirname, '..', '..', '..', '..');
+}
+
+/**
+ * Core Installer class
+ */
+class Installer {
+  constructor() {
+    this.sourcePath = getSourcePath();
+    this.packageRoot = getPackageRoot();
+  }
+
+  /**
+   * Install AgileFlow to a project
+   * @param {Object} config - Installation configuration
+   * @returns {Promise<Object>} Installation result
+   */
+  async install(config) {
+    const { directory, ides, userName, agileflowFolder } = config;
+
+    const agileflowDir = path.join(directory, agileflowFolder);
+    const spinner = ora('Installing AgileFlow...').start();
+
+    try {
+      // Create AgileFlow directory
+      await fs.ensureDir(agileflowDir);
+      spinner.text = 'Creating directory structure...';
+
+      // Create _cfg directory for manifest
+      const cfgDir = path.join(agileflowDir, '_cfg');
+      await fs.ensureDir(cfgDir);
+
+      // Copy core content
+      spinner.text = 'Installing core content...';
+      const coreSourcePath = path.join(this.sourcePath, 'core');
+
+      if (await fs.pathExists(coreSourcePath)) {
+        await this.copyContent(coreSourcePath, agileflowDir, agileflowFolder);
+      } else {
+        // Fallback: copy from old structure (commands, agents, skills at root)
+        await this.copyLegacyContent(directory, agileflowDir, agileflowFolder);
+      }
+
+      // Create config.yaml
+      spinner.text = 'Creating configuration...';
+      await this.createConfig(agileflowDir, userName, agileflowFolder);
+
+      // Create manifest
+      spinner.text = 'Creating manifest...';
+      await this.createManifest(cfgDir, ides);
+
+      // Count installed items
+      const counts = await this.countInstalledItems(agileflowDir);
+
+      spinner.succeed('Core installation complete');
+
+      return {
+        success: true,
+        path: agileflowDir,
+        projectDir: directory,
+        counts,
+      };
+    } catch (error) {
+      spinner.fail('Installation failed');
+      throw error;
+    }
+  }
+
+  /**
+   * Copy content from source to destination with placeholder replacement
+   * @param {string} source - Source directory
+   * @param {string} dest - Destination directory
+   * @param {string} agileflowFolder - AgileFlow folder name
+   */
+  async copyContent(source, dest, agileflowFolder) {
+    const entries = await fs.readdir(source, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const srcPath = path.join(source, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        await fs.ensureDir(destPath);
+        await this.copyContent(srcPath, destPath, agileflowFolder);
+      } else {
+        await this.copyFileWithReplacements(srcPath, destPath, agileflowFolder);
+      }
+    }
+  }
+
+  /**
+   * Copy legacy content structure (from root commands/agents/skills)
+   * @param {string} projectDir - Project directory
+   * @param {string} agileflowDir - AgileFlow installation directory
+   * @param {string} agileflowFolder - AgileFlow folder name
+   */
+  async copyLegacyContent(projectDir, agileflowDir, agileflowFolder) {
+    const packageRoot = this.packageRoot;
+
+    // Copy commands
+    const commandsSource = path.join(packageRoot, 'commands');
+    const commandsDest = path.join(agileflowDir, 'commands');
+    if (await fs.pathExists(commandsSource)) {
+      await fs.ensureDir(commandsDest);
+      await this.copyContent(commandsSource, commandsDest, agileflowFolder);
+    }
+
+    // Copy agents
+    const agentsSource = path.join(packageRoot, 'agents');
+    const agentsDest = path.join(agileflowDir, 'agents');
+    if (await fs.pathExists(agentsSource)) {
+      await fs.ensureDir(agentsDest);
+      await this.copyContent(agentsSource, agentsDest, agileflowFolder);
+    }
+
+    // Copy skills
+    const skillsSource = path.join(packageRoot, 'skills');
+    const skillsDest = path.join(agileflowDir, 'skills');
+    if (await fs.pathExists(skillsSource)) {
+      await fs.ensureDir(skillsDest);
+      await this.copyContent(skillsSource, skillsDest, agileflowFolder);
+    }
+
+    // Copy templates
+    const templatesSource = path.join(packageRoot, 'templates');
+    const templatesDest = path.join(agileflowDir, 'templates');
+    if (await fs.pathExists(templatesSource)) {
+      await fs.ensureDir(templatesDest);
+      await this.copyContent(templatesSource, templatesDest, agileflowFolder);
+    }
+  }
+
+  /**
+   * Copy a file with placeholder replacements
+   * @param {string} source - Source file path
+   * @param {string} dest - Destination file path
+   * @param {string} agileflowFolder - AgileFlow folder name
+   */
+  async copyFileWithReplacements(source, dest, agileflowFolder) {
+    const textExtensions = ['.md', '.yaml', '.yml', '.txt', '.json'];
+    const ext = path.extname(source).toLowerCase();
+
+    if (textExtensions.includes(ext)) {
+      let content = await fs.readFile(source, 'utf8');
+
+      // Replace placeholders
+      content = content.replace(/\{agileflow_folder\}/g, agileflowFolder);
+      content = content.replace(/\{project-root\}/g, '{project-root}'); // Keep as-is for runtime
+
+      await fs.writeFile(dest, content, 'utf8');
+    } else {
+      await fs.copy(source, dest);
+    }
+  }
+
+  /**
+   * Create configuration file
+   * @param {string} agileflowDir - AgileFlow directory
+   * @param {string} userName - User name
+   * @param {string} agileflowFolder - AgileFlow folder name
+   */
+  async createConfig(agileflowDir, userName, agileflowFolder) {
+    const config = {
+      version: require(path.join(this.packageRoot, 'package.json')).version,
+      user_name: userName,
+      agileflow_folder: agileflowFolder,
+      communication_language: 'English',
+      created_at: new Date().toISOString(),
+    };
+
+    const configPath = path.join(agileflowDir, 'config.yaml');
+    await fs.writeFile(configPath, yaml.dump(config), 'utf8');
+  }
+
+  /**
+   * Create manifest file
+   * @param {string} cfgDir - Config directory
+   * @param {string[]} ides - Selected IDEs
+   */
+  async createManifest(cfgDir, ides) {
+    const packageJson = require(path.join(this.packageRoot, 'package.json'));
+
+    const manifest = {
+      version: packageJson.version,
+      installed_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+      ides: ides,
+      modules: ['core'],
+    };
+
+    const manifestPath = path.join(cfgDir, 'manifest.yaml');
+    await fs.writeFile(manifestPath, yaml.dump(manifest), 'utf8');
+  }
+
+  /**
+   * Count installed items
+   * @param {string} agileflowDir - AgileFlow directory
+   * @returns {Promise<Object>} Counts
+   */
+  async countInstalledItems(agileflowDir) {
+    const counts = {
+      agents: 0,
+      commands: 0,
+      skills: 0,
+    };
+
+    // Count agents
+    const agentsDir = path.join(agileflowDir, 'agents');
+    if (await fs.pathExists(agentsDir)) {
+      const files = await fs.readdir(agentsDir);
+      counts.agents = files.filter((f) => f.endsWith('.md')).length;
+    }
+
+    // Count commands
+    const commandsDir = path.join(agileflowDir, 'commands');
+    if (await fs.pathExists(commandsDir)) {
+      const files = await fs.readdir(commandsDir);
+      counts.commands = files.filter((f) => f.endsWith('.md')).length;
+    }
+
+    // Count skills
+    const skillsDir = path.join(agileflowDir, 'skills');
+    if (await fs.pathExists(skillsDir)) {
+      const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+      counts.skills = entries.filter((e) => e.isDirectory()).length;
+    }
+
+    return counts;
+  }
+
+  /**
+   * Get installation status
+   * @param {string} directory - Project directory
+   * @returns {Promise<Object>} Installation status
+   */
+  async getStatus(directory) {
+    const status = {
+      installed: false,
+      path: null,
+      version: null,
+      ides: [],
+      modules: [],
+    };
+
+    // Look for AgileFlow installation
+    const possibleFolders = ['.agileflow', 'agileflow', '.aflow'];
+
+    for (const folder of possibleFolders) {
+      const agileflowDir = path.join(directory, folder);
+      const manifestPath = path.join(agileflowDir, '_cfg', 'manifest.yaml');
+
+      if (await fs.pathExists(manifestPath)) {
+        status.installed = true;
+        status.path = agileflowDir;
+
+        const manifestContent = await fs.readFile(manifestPath, 'utf8');
+        const manifest = yaml.load(manifestContent);
+
+        status.version = manifest.version;
+        status.ides = manifest.ides || [];
+        status.modules = manifest.modules || [];
+
+        break;
+      }
+    }
+
+    return status;
+  }
+}
+
+module.exports = { Installer, getSourcePath, getPackageRoot };