agileflow 2.30.0

package/tools/cli/installers/ide/windsurf.js

@@ -0,0 +1,192 @@
+/**
+ * AgileFlow CLI - Windsurf IDE Installer
+ *
+ * Installs AgileFlow workflows for Windsurf IDE.
+ * Windsurf uses markdown files in .windsurf/workflows/
+ */
+
+const path = require('node:path');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const { BaseIdeSetup } = require('./_base-ide');
+
+/**
+ * Windsurf IDE setup handler
+ */
+class WindsurfSetup extends BaseIdeSetup {
+  constructor() {
+    super('windsurf', 'Windsurf', true);
+    this.configDir = '.windsurf';
+    this.workflowsDir = 'workflows';
+  }
+
+  /**
+   * Setup Windsurf IDE configuration
+   * @param {string} projectDir - Project directory
+   * @param {string} agileflowDir - AgileFlow installation directory
+   * @param {Object} options - Setup options
+   */
+  async setup(projectDir, agileflowDir, options = {}) {
+    console.log(chalk.cyan(`  Setting up ${this.displayName}...`));
+
+    // Clean up old installation first
+    await this.cleanup(projectDir);
+
+    // Create .windsurf/workflows/agileflow directory
+    const windsurfDir = path.join(projectDir, this.configDir);
+    const workflowsDir = path.join(windsurfDir, this.workflowsDir);
+    const agileflowWorkflowsDir = path.join(workflowsDir, 'agileflow');
+
+    await this.ensureDir(agileflowWorkflowsDir);
+
+    // Get commands from AgileFlow installation
+    const commandsSource = path.join(agileflowDir, 'commands');
+    let commandCount = 0;
+
+    if (await this.exists(commandsSource)) {
+      const commands = await this.scanDirectory(commandsSource, '.md');
+
+      for (const command of commands) {
+        // Create workflow file
+        const workflowContent = await this.createCommandWorkflow(command, agileflowDir, projectDir);
+        const targetPath = path.join(agileflowWorkflowsDir, `${command.name}.md`);
+
+        await this.writeFile(targetPath, workflowContent);
+        commandCount++;
+      }
+    }
+
+    // Create agents subdirectory
+    const agileflowAgentsDir = path.join(agileflowWorkflowsDir, 'agents');
+    await this.ensureDir(agileflowAgentsDir);
+
+    // Get agents from AgileFlow installation
+    const agentsSource = path.join(agileflowDir, 'agents');
+    let agentCount = 0;
+
+    if (await this.exists(agentsSource)) {
+      const agents = await this.scanDirectory(agentsSource, '.md');
+
+      for (const agent of agents) {
+        // Create workflow file
+        const workflowContent = await this.createAgentWorkflow(agent, agileflowDir, projectDir);
+        const targetPath = path.join(agileflowAgentsDir, `${agent.name}.md`);
+
+        await this.writeFile(targetPath, workflowContent);
+        agentCount++;
+      }
+    }
+
+    console.log(chalk.green(`  ✓ ${this.displayName} configured:`));
+    console.log(chalk.dim(`    - ${commandCount} workflows installed`));
+    console.log(chalk.dim(`    - ${agentCount} agent workflows installed`));
+    console.log(chalk.dim(`    - Path: ${path.relative(projectDir, agileflowWorkflowsDir)}`));
+
+    return {
+      success: true,
+      commands: commandCount,
+      agents: agentCount,
+    };
+  }
+
+  /**
+   * Cleanup old AgileFlow installation
+   * @param {string} projectDir - Project directory
+   */
+  async cleanup(projectDir) {
+    const agileflowPath = path.join(projectDir, this.configDir, this.workflowsDir, 'agileflow');
+    if (await this.exists(agileflowPath)) {
+      await fs.remove(agileflowPath);
+      console.log(chalk.dim(`    Removed old AgileFlow workflows from ${this.displayName}`));
+    }
+  }
+
+  /**
+   * Create a workflow file for a command
+   * @param {Object} command - Command info
+   * @param {string} agileflowDir - AgileFlow directory
+   * @param {string} projectDir - Project directory
+   * @returns {Promise<string>} Workflow content
+   */
+  async createCommandWorkflow(command, agileflowDir, projectDir) {
+    // Read the original command file
+    const content = await this.readFile(command.path);
+
+    // Extract description from frontmatter if present
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    let description = command.name;
+
+    if (frontmatterMatch) {
+      const descMatch = frontmatterMatch[1].match(/description:\s*["']?([^"'\n]+)["']?/);
+      if (descMatch) {
+        description = descMatch[1];
+      }
+    }
+
+    // Create Windsurf workflow format
+    const relativePath = path.relative(projectDir, command.path);
+
+    return `---
+description: ${description}
+auto_execution_mode: 2
+---
+
+# AgileFlow: ${command.name}
+
+Load and execute the AgileFlow command.
+
+## Instructions
+
+Read and follow the full command from: \`${relativePath}\`
+
+Execute the command according to its specifications.
+`;
+  }
+
+  /**
+   * Create a workflow file for an agent
+   * @param {Object} agent - Agent info
+   * @param {string} agileflowDir - AgileFlow directory
+   * @param {string} projectDir - Project directory
+   * @returns {Promise<string>} Workflow content
+   */
+  async createAgentWorkflow(agent, agileflowDir, projectDir) {
+    // Read the original agent file
+    const content = await this.readFile(agent.path);
+
+    // Extract metadata from frontmatter
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    let description = agent.name;
+    let name = agent.name;
+
+    if (frontmatterMatch) {
+      const descMatch = frontmatterMatch[1].match(/description:\s*["']?([^"'\n]+)["']?/);
+      const nameMatch = frontmatterMatch[1].match(/name:\s*["']?([^"'\n]+)["']?/);
+
+      if (descMatch) description = descMatch[1];
+      if (nameMatch) name = nameMatch[1];
+    }
+
+    // Create Windsurf workflow format
+    const relativePath = path.relative(projectDir, agent.path);
+
+    return `---
+description: ${description}
+auto_execution_mode: 3
+---
+
+# AgileFlow Agent: ${name}
+
+Activate the AgileFlow agent.
+
+## Instructions
+
+1. Read the full agent definition from: \`${relativePath}\`
+2. Adopt the agent's persona and communication style
+3. Follow all instructions and use the specified tools
+4. Maintain the agent's character throughout the session
+`;
+  }
+}
+
+module.exports = { WindsurfSetup };

package/tools/cli/lib/ui.js

@@ -0,0 +1,203 @@
+/**
+ * AgileFlow CLI - UI Utilities
+ *
+ * Provides interactive prompts and display utilities for the CLI.
+ */
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const path = require('node:path');
+const fs = require('node:fs');
+
+// Load package.json for version
+const packageJsonPath = path.join(__dirname, '..', '..', '..', 'package.json');
+const packageJson = require(packageJsonPath);
+
+/**
+ * Display the AgileFlow ASCII logo
+ */
+function displayLogo() {
+  const logo = `
+   _____         _ __    ________
+  /  _  \\   ____/  |  \\_/   ____/
+ /  /_\\  \\ / ___\\  |  |\\____  \\  ____  _  __
+/    |    \\  \\___|__|__/       \\/ __ \\/ \\/ /
+\\____|____/\\____/____ /_______/\\____/ \\__/
+                                              `;
+  console.log(chalk.cyan(logo));
+  console.log(chalk.dim(`  AgileFlow v${packageJson.version} - AI-Driven Agile Development\n`));
+}
+
+/**
+ * Display a section header
+ * @param {string} title - Section title
+ * @param {string} subtitle - Optional subtitle
+ */
+function displaySection(title, subtitle = null) {
+  console.log(chalk.bold.cyan(`\n${title}`));
+  if (subtitle) {
+    console.log(chalk.dim(subtitle));
+  }
+  console.log();
+}
+
+/**
+ * Display a success message
+ * @param {string} message - Success message
+ */
+function success(message) {
+  console.log(chalk.green(`✓ ${message}`));
+}
+
+/**
+ * Display a warning message
+ * @param {string} message - Warning message
+ */
+function warning(message) {
+  console.log(chalk.yellow(`⚠ ${message}`));
+}
+
+/**
+ * Display an error message
+ * @param {string} message - Error message
+ */
+function error(message) {
+  console.log(chalk.red(`✗ ${message}`));
+}
+
+/**
+ * Display an info message
+ * @param {string} message - Info message
+ */
+function info(message) {
+  console.log(chalk.dim(`  ${message}`));
+}
+
+/**
+ * Available IDE configurations
+ */
+const IDE_CHOICES = [
+  {
+    name: 'Claude Code',
+    value: 'claude-code',
+    checked: true,
+    configDir: '.claude/commands',
+    description: 'Anthropic\'s Claude Code IDE',
+  },
+  {
+    name: 'Cursor',
+    value: 'cursor',
+    checked: false,
+    configDir: '.cursor/rules',
+    description: 'AI-powered code editor',
+  },
+  {
+    name: 'Windsurf',
+    value: 'windsurf',
+    checked: false,
+    configDir: '.windsurf/workflows',
+    description: 'Codeium\'s AI IDE',
+  },
+];
+
+/**
+ * Prompt for installation configuration
+ * @returns {Promise<Object>} Installation configuration
+ */
+async function promptInstall() {
+  displayLogo();
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'directory',
+      message: 'Where would you like to install AgileFlow?',
+      default: '.',
+      validate: (input) => {
+        const resolved = path.resolve(input);
+        const parent = path.dirname(resolved);
+        if (!fs.existsSync(parent)) {
+          return `Parent directory does not exist: ${parent}`;
+        }
+        return true;
+      },
+    },
+    {
+      type: 'checkbox',
+      name: 'ides',
+      message: 'Select your IDE(s):',
+      choices: IDE_CHOICES,
+      validate: (input) => {
+        if (input.length === 0) {
+          return 'Please select at least one IDE';
+        }
+        return true;
+      },
+    },
+    {
+      type: 'input',
+      name: 'userName',
+      message: 'What should agents call you?',
+      default: 'Developer',
+    },
+    {
+      type: 'input',
+      name: 'agileflowFolder',
+      message: 'AgileFlow installation folder name:',
+      default: '.agileflow',
+      validate: (input) => {
+        if (!/^[a-zA-Z0-9._-]+$/.test(input)) {
+          return 'Folder name can only contain letters, numbers, dots, underscores, and hyphens';
+        }
+        return true;
+      },
+    },
+  ]);
+
+  return {
+    directory: path.resolve(answers.directory),
+    ides: answers.ides,
+    userName: answers.userName,
+    agileflowFolder: answers.agileflowFolder,
+  };
+}
+
+/**
+ * Prompt for confirmation
+ * @param {string} message - Confirmation message
+ * @param {boolean} defaultValue - Default value
+ * @returns {Promise<boolean>}
+ */
+async function confirm(message, defaultValue = true) {
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmed',
+      message,
+      default: defaultValue,
+    },
+  ]);
+  return confirmed;
+}
+
+/**
+ * Get IDE configuration by name
+ * @param {string} ideName - IDE name
+ * @returns {Object|null}
+ */
+function getIdeConfig(ideName) {
+  return IDE_CHOICES.find((ide) => ide.value === ideName) || null;
+}
+
+module.exports = {
+  displayLogo,
+  displaySection,
+  success,
+  warning,
+  error,
+  info,
+  promptInstall,
+  confirm,
+  getIdeConfig,
+  IDE_CHOICES,
+};

package/tools/cli/lib/version-checker.js

@@ -0,0 +1,95 @@
+/**
+ * AgileFlow CLI - Version Checker
+ *
+ * Checks for updates from npm registry.
+ */
+
+const https = require('node:https');
+const semver = require('semver');
+const path = require('node:path');
+
+// Load package.json for current version
+const packageJsonPath = path.join(__dirname, '..', '..', '..', 'package.json');
+const packageJson = require(packageJsonPath);
+
+/**
+ * Get the latest version from npm registry
+ * @param {string} packageName - Package name
+ * @returns {Promise<string|null>} Latest version or null
+ */
+async function getLatestVersion(packageName = 'agileflow') {
+  return new Promise((resolve) => {
+    const url = `https://registry.npmjs.org/${packageName}/latest`;
+
+    const req = https.get(url, { timeout: 5000 }, (res) => {
+      if (res.statusCode !== 200) {
+        resolve(null);
+        return;
+      }
+
+      let data = '';
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          resolve(json.version || null);
+        } catch {
+          resolve(null);
+        }
+      });
+    });
+
+    req.on('error', () => {
+      resolve(null);
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(null);
+    });
+  });
+}
+
+/**
+ * Check if an update is available
+ * @returns {Promise<Object>} Update info
+ */
+async function checkForUpdate() {
+  const currentVersion = packageJson.version;
+  const latestVersion = await getLatestVersion();
+
+  if (!latestVersion) {
+    return {
+      current: currentVersion,
+      latest: null,
+      updateAvailable: false,
+      error: 'Could not check for updates',
+    };
+  }
+
+  const updateAvailable = semver.gt(latestVersion, currentVersion);
+
+  return {
+    current: currentVersion,
+    latest: latestVersion,
+    updateAvailable,
+    error: null,
+  };
+}
+
+/**
+ * Get current version
+ * @returns {string}
+ */
+function getCurrentVersion() {
+  return packageJson.version;
+}
+
+module.exports = {
+  getLatestVersion,
+  checkForUpdate,
+  getCurrentVersion,
+};

package/tools/postinstall.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+
+/**
+ * AgileFlow Postinstall Script
+ *
+ * Automatically runs AgileFlow installation after npm install.
+ * Includes smart detection to avoid running in inappropriate contexts.
+ */
+
+const { execSync } = require('node:child_process');
+const path = require('node:path');
+const fs = require('node:fs');
+
+// ANSI color codes for terminal output
+const colors = {
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[36m',
+  dim: '\x1b[2m',
+  reset: '\x1b[0m',
+};
+
+function log(message, color = 'reset') {
+  console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+function shouldSkipInstall() {
+  // Skip if environment variable is set
+  if (process.env.AGILEFLOW_SKIP_INSTALL === 'true') {
+    log('ℹ️  Skipping auto-install (AGILEFLOW_SKIP_INSTALL=true)', 'dim');
+    return true;
+  }
+
+  // Skip if running in npm cache or npx temp directory
+  if (__dirname.includes('_npx') || __dirname.includes('.npm')) {
+    log('ℹ️  Skipping auto-install (npm cache or npx temp directory)', 'dim');
+    return true;
+  }
+
+  // Skip if we're in the AgileFlow monorepo itself (development mode)
+  // Check for monorepo structure: packages/cli/tools/postinstall.js
+  // __dirname is tools/ so ../ goes to packages/cli/
+  const packageJsonPath = path.join(__dirname, '..', 'package.json');
+
+  if (fs.existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+
+    if (packageJson.name === 'agileflow') {
+      // Check multiple indicators of monorepo development:
+      // 1. Parent directory structure (packages/cli pattern)
+      const isInPackagesDir = __dirname.includes('/packages/cli/');
+
+      // 2. Workspace root package.json exists
+      // Path from tools/ -> packages/cli -> packages -> AgileFlow
+      const rootPackageJson = path.join(__dirname, '..', '..', '..', 'package.json');
+      let isWorkspaceRoot = false;
+      if (fs.existsSync(rootPackageJson)) {
+        try {
+          const rootPkg = JSON.parse(fs.readFileSync(rootPackageJson, 'utf-8'));
+          isWorkspaceRoot = rootPkg.name === 'agileflow-monorepo' || Boolean(rootPkg.workspaces);
+        } catch (e) {
+          // Ignore parse errors
+        }
+      }
+
+      // 3. Git repository check (look for .git in monorepo root)
+      // Path from tools/ -> packages/cli -> packages -> AgileFlow -> .git
+      const gitDir = path.join(__dirname, '..', '..', '..', '.git');
+      const isGitRepo = fs.existsSync(gitDir);
+
+      if (isInPackagesDir || isWorkspaceRoot || isGitRepo) {
+        log('ℹ️  Skipping auto-install (running in development/monorepo)', 'dim');
+        return true;
+      }
+    }
+  }
+
+  // Get the installation directory (user's project root)
+  const installDir = process.cwd();
+
+  // Skip if .agileflow or .claude/commands/AgileFlow folder already exists
+  const agileflowPath = path.join(installDir, '.agileflow');
+  const claudeAgileflowPath = path.join(installDir, '.claude', 'commands', 'AgileFlow');
+
+  if (fs.existsSync(agileflowPath) || fs.existsSync(claudeAgileflowPath)) {
+    log('ℹ️  AgileFlow already installed in this project', 'dim');
+    return true;
+  }
+
+  return false;
+}
+
+function runAutoInstall() {
+  try {
+    console.log(''); // Blank line for spacing
+    log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', 'blue');
+    log('  AgileFlow Auto-Setup', 'blue');
+    log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', 'blue');
+    console.log('');
+
+    log('🚀 Setting up AgileFlow in your project...', 'green');
+    console.log('');
+
+    // Path to the CLI
+    const cliPath = path.join(__dirname, 'cli', 'agileflow-cli.js');
+
+    if (!fs.existsSync(cliPath)) {
+      log('⚠️  Could not find AgileFlow CLI. Run "npx agileflow install" manually.', 'yellow');
+      return;
+    }
+
+    // Run install command with --yes flag (non-interactive)
+    execSync(`node "${cliPath}" install --yes`, {
+      stdio: 'inherit',
+      cwd: process.cwd(),
+    });
+
+    console.log('');
+    log('✨ AgileFlow is ready to use!', 'green');
+    console.log('');
+    log('To skip auto-install in the future, set: AGILEFLOW_SKIP_INSTALL=true', 'dim');
+    console.log('');
+
+  } catch (error) {
+    console.log('');
+    log('⚠️  Auto-installation encountered an issue.', 'yellow');
+    log('   You can run "npx agileflow install" manually to complete setup.', 'yellow');
+    console.log('');
+
+    if (process.env.DEBUG) {
+      console.error(error);
+    }
+  }
+}
+
+// Main execution
+if (shouldSkipInstall()) {
+  process.exit(0);
+}
+
+runAutoInstall();