agileflow 2.33.0 → 2.34.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agileflow",
-  "version": "2.33.0",
+  "version": "2.34.0",
   "description": "AI-driven agile development system for Claude Code, Cursor, Windsurf, and more",
   "keywords": [
     "agile",

package/tools/cli/commands/config.js

@@ -0,0 +1,284 @@
+/**
+ * AgileFlow CLI - Config Command
+ *
+ * Manage AgileFlow configuration without re-running setup.
+ */
+
+const chalk = require('chalk');
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('js-yaml');
+const { Installer } = require('../installers/core/installer');
+const { IdeManager } = require('../installers/ide/manager');
+const { displayLogo, displaySection, success, warning, error, info } = require('../lib/ui');
+
+const installer = new Installer();
+const ideManager = new IdeManager();
+
+module.exports = {
+  name: 'config',
+  description: 'Manage AgileFlow configuration',
+  arguments: [
+    ['<subcommand>', 'Subcommand: list, get, set'],
+    ['[key]', 'Config key (for get/set)'],
+    ['[value]', 'Config value (for set)'],
+  ],
+  options: [
+    ['-d, --directory <path>', 'Project directory (default: current directory)'],
+  ],
+  action: async (subcommand, keyOrValue, valueOrUndefined, options) => {
+    try {
+      const directory = path.resolve(options.directory || '.');
+
+      // Get installation status
+      const status = await installer.getStatus(directory);
+
+      if (!status.installed) {
+        displayLogo();
+        warning('No AgileFlow installation found');
+        console.log(chalk.dim(`\nRun 'npx agileflow setup' to set up AgileFlow\n`));
+        process.exit(1);
+      }
+
+      const manifestPath = path.join(status.path, '_cfg', 'manifest.yaml');
+
+      // Handle subcommands
+      switch (subcommand) {
+        case 'list':
+          await handleList(status);
+          break;
+
+        case 'get':
+          await handleGet(status, keyOrValue);
+          break;
+
+        case 'set':
+          await handleSet(directory, status, manifestPath, keyOrValue, valueOrUndefined);
+          break;
+
+        default:
+          displayLogo();
+          console.log(chalk.bold('Usage:\n'));
+          console.log('  npx agileflow config list');
+          console.log('  npx agileflow config get <key>');
+          console.log('  npx agileflow config set <key> <value>\n');
+          console.log(chalk.bold('Keys:\n'));
+          console.log('  userName           Your name for config files');
+          console.log('  ides               Comma-separated IDE list (claude-code,cursor,windsurf)');
+          console.log('  agileflowFolder    AgileFlow folder name (e.g., .agileflow)');
+          console.log('  docsFolder         Documentation folder name (e.g., docs)\n');
+          console.log(chalk.bold('Examples:\n'));
+          console.log('  npx agileflow config get userName');
+          console.log('  npx agileflow config set userName "Jane Developer"');
+          console.log('  npx agileflow config set ides "claude-code,cursor"\n');
+          process.exit(0);
+      }
+
+      process.exit(0);
+    } catch (err) {
+      console.error(chalk.red('Error:'), err.message);
+      if (process.env.DEBUG) {
+        console.error(err.stack);
+      }
+      process.exit(1);
+    }
+  },
+};
+
+/**
+ * Handle list subcommand
+ */
+async function handleList(status) {
+  displayLogo();
+  displaySection('AgileFlow Configuration');
+
+  console.log(chalk.bold('User Settings:'));
+  console.log(`  userName:         ${chalk.cyan(status.userName || 'Developer')}`);
+  console.log();
+
+  console.log(chalk.bold('IDE Settings:'));
+  const ides = status.ides || ['claude-code'];
+  console.log(`  ides:             ${chalk.cyan(ides.join(', '))}`);
+  console.log();
+
+  console.log(chalk.bold('Folder Settings:'));
+  console.log(`  agileflowFolder:  ${chalk.cyan(status.agileflowFolder || '.agileflow')}`);
+  console.log(`  docsFolder:       ${chalk.cyan(status.docsFolder || 'docs')}`);
+  console.log();
+
+  console.log(chalk.bold('System Info:'));
+  console.log(`  version:          ${chalk.cyan(status.version || 'unknown')}`);
+  console.log(`  installed:        ${chalk.cyan(status.installedAt ? new Date(status.installedAt).toLocaleDateString() : 'unknown')}`);
+  console.log(`  updated:          ${chalk.cyan(status.updatedAt ? new Date(status.updatedAt).toLocaleDateString() : 'unknown')}`);
+  console.log();
+}
+
+/**
+ * Handle get subcommand
+ */
+async function handleGet(status, key) {
+  if (!key) {
+    error('Missing key. Usage: npx agileflow config get <key>');
+    process.exit(1);
+  }
+
+  const validKeys = ['userName', 'ides', 'agileflowFolder', 'docsFolder', 'version'];
+
+  if (!validKeys.includes(key)) {
+    error(`Invalid key: ${key}`);
+    console.log(chalk.dim(`Valid keys: ${validKeys.join(', ')}\n`));
+    process.exit(1);
+  }
+
+  let value;
+  switch (key) {
+    case 'userName':
+      value = status.userName || 'Developer';
+      break;
+    case 'ides':
+      value = (status.ides || ['claude-code']).join(',');
+      break;
+    case 'agileflowFolder':
+      value = status.agileflowFolder || '.agileflow';
+      break;
+    case 'docsFolder':
+      value = status.docsFolder || 'docs';
+      break;
+    case 'version':
+      value = status.version || 'unknown';
+      break;
+  }
+
+  console.log(value);
+}
+
+/**
+ * Handle set subcommand
+ */
+async function handleSet(directory, status, manifestPath, key, value) {
+  if (!key || value === undefined) {
+    error('Missing arguments. Usage: npx agileflow config set <key> <value>');
+    process.exit(1);
+  }
+
+  const validKeys = ['userName', 'ides', 'agileflowFolder', 'docsFolder'];
+
+  if (!validKeys.includes(key)) {
+    error(`Invalid key: ${key}`);
+    console.log(chalk.dim(`Valid keys: ${validKeys.join(', ')}\n`));
+    process.exit(1);
+  }
+
+  displayLogo();
+  displaySection('Updating Configuration');
+
+  // Read current manifest
+  const manifestContent = await fs.readFile(manifestPath, 'utf8');
+  const manifest = yaml.load(manifestContent);
+
+  // Track if we need to update IDE configs
+  let needsIdeUpdate = false;
+  const oldIdes = manifest.ides || [];
+
+  // Update the value
+  switch (key) {
+    case 'userName':
+      manifest.user_name = value;
+      info(`Setting userName to: ${chalk.cyan(value)}`);
+      break;
+
+    case 'ides':
+      const newIdes = value.split(',').map((ide) => ide.trim());
+      const validIdes = ['claude-code', 'cursor', 'windsurf'];
+
+      // Validate IDEs
+      for (const ide of newIdes) {
+        if (!validIdes.includes(ide)) {
+          error(`Invalid IDE: ${ide}`);
+          console.log(chalk.dim(`Valid IDEs: ${validIdes.join(', ')}\n`));
+          process.exit(1);
+        }
+      }
+
+      manifest.ides = newIdes;
+      needsIdeUpdate = true;
+      info(`Setting ides to: ${chalk.cyan(newIdes.join(', '))}`);
+      break;
+
+    case 'agileflowFolder':
+      warning('Changing agileflowFolder requires moving the installation directory.');
+      console.log(chalk.dim('This change will only update the config - you must move files manually.\n'));
+      manifest.agileflow_folder = value;
+      info(`Setting agileflowFolder to: ${chalk.cyan(value)}`);
+      break;
+
+    case 'docsFolder':
+      manifest.docs_folder = value;
+      info(`Setting docsFolder to: ${chalk.cyan(value)}`);
+      break;
+  }
+
+  // Update timestamp
+  manifest.updated_at = new Date().toISOString();
+
+  // Write manifest
+  await fs.writeFile(manifestPath, yaml.dump(manifest), 'utf8');
+  success('Configuration updated');
+
+  // Update IDE configs if needed
+  if (needsIdeUpdate) {
+    console.log();
+    info('Updating IDE configurations...');
+
+    ideManager.setAgileflowFolder(manifest.agileflow_folder || '.agileflow');
+    ideManager.setDocsFolder(manifest.docs_folder || 'docs');
+
+    // Remove old IDE configs
+    for (const ide of oldIdes) {
+      if (!manifest.ides.includes(ide)) {
+        const configPath = getIdeConfigPath(directory, ide);
+        if (await fs.pathExists(configPath)) {
+          await fs.remove(configPath);
+          info(`Removed ${formatIdeName(ide)} configuration`);
+        }
+      }
+    }
+
+    // Add new IDE configs
+    for (const ide of manifest.ides) {
+      await ideManager.setup(ide, directory, status.path);
+      success(`Updated ${formatIdeName(ide)} configuration`);
+    }
+
+    console.log();
+    success('IDE configurations updated');
+  }
+
+  console.log();
+}
+
+/**
+ * Get IDE config path
+ */
+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
+ */
+function formatIdeName(ide) {
+  const names = {
+    'claude-code': 'Claude Code',
+    'cursor': 'Cursor',
+    'windsurf': 'Windsurf',
+  };
+
+  return names[ide] || ide;
+}

package/tools/cli/commands/doctor.js

@@ -8,7 +8,8 @@ const chalk = require('chalk');
 const path = require('node:path');
 const fs = require('fs-extra');
 const { Installer } = require('../installers/core/installer');
-const { displayLogo, displaySection, success, warning, error, info } = require('../lib/ui');
+const { displayLogo, displaySection, success, warning, error, info, confirm } = require('../lib/ui');
+const { IdeManager } = require('../installers/ide/manager');
 const { getCurrentVersion } = require('../lib/version-checker');
 
 const installer = new Installer();
@@ -18,16 +19,18 @@ module.exports = {
   description: 'Diagnose AgileFlow installation issues',
   options: [
     ['-d, --directory <path>', 'Project directory (default: current directory)'],
+    ['--fix', 'Automatically fix detected issues'],
   ],
   action: async (options) => {
     try {
       const directory = path.resolve(options.directory || '.');
 
       displayLogo();
-      displaySection('AgileFlow Diagnostics');
+      displaySection(options.fix ? 'AgileFlow Auto-Repair' : 'AgileFlow Diagnostics');
 
       let issues = 0;
       let warnings = 0;
+      const repairs = []; // Track fixable issues
 
       // Check Node.js version
       console.log(chalk.bold('Environment:'));
@@ -57,7 +60,7 @@ module.exports = {
 
       if (!status.installed) {
         warning('No AgileFlow installation found');
-        console.log(chalk.dim(`  Run 'npx agileflow install' to set up\n`));
+        console.log(chalk.dim(`  Run 'npx agileflow setup' to set up\n`));
 
         // Summary
         printSummary(issues, warnings);
@@ -73,16 +76,44 @@ module.exports = {
       } else {
         error('manifest.yaml missing');
         issues++;
+        repairs.push({
+          type: 'missing-manifest',
+          message: 'Recreate missing manifest.yaml',
+          fix: async () => {
+            info('Recreating manifest.yaml...');
+            const packageJson = require(path.join(__dirname, '..', '..', '..', 'package.json'));
+            const cfgDir = path.join(status.path, '_cfg');
+            await fs.ensureDir(cfgDir);
+
+            const yaml = require('js-yaml');
+            const manifest = {
+              version: packageJson.version,
+              installed_at: new Date().toISOString(),
+              updated_at: new Date().toISOString(),
+              ides: status.ides || ['claude-code'],
+              modules: ['core'],
+              user_name: status.userName || 'Developer',
+              agileflow_folder: path.basename(status.path),
+              docs_folder: 'docs',
+            };
+
+            await fs.writeFile(manifestPath, yaml.dump(manifest), 'utf8');
+            success('Created manifest.yaml');
+          },
+        });
       }
 
       // Check core content
       const counts = await installer.countInstalledItems(status.path);
 
+      let missingCore = false;
+
       if (counts.agents > 0) {
         success(`Core agents: ${counts.agents} files`);
       } else {
         error('Core agents: Missing');
         issues++;
+        missingCore = true;
       }
 
       if (counts.commands > 0) {
@@ -90,6 +121,27 @@ module.exports = {
       } else {
         error('Commands: Missing');
         issues++;
+        missingCore = true;
+      }
+
+      if (missingCore) {
+        repairs.push({
+          type: 'missing-core',
+          message: 'Reinstall missing core content',
+          fix: async () => {
+            info('Reinstalling core content...');
+            const config = {
+              directory,
+              ides: status.ides || ['claude-code'],
+              userName: status.userName || 'Developer',
+              agileflowFolder: path.basename(status.path),
+              docsFolder: status.docsFolder || 'docs',
+            };
+
+            await installer.install(config);
+            success('Reinstalled core content');
+          },
+        });
       }
 
       if (counts.skills > 0) {
@@ -103,6 +155,10 @@ module.exports = {
       if (status.ides && status.ides.length > 0) {
         console.log(chalk.bold('\nIDE Configurations:'));
 
+        const ideManager = new IdeManager();
+        ideManager.setAgileflowFolder(path.basename(status.path));
+        ideManager.setDocsFolder(status.docsFolder || 'docs');
+
         for (const ide of status.ides) {
           const configPath = getIdeConfigPath(directory, ide);
           const ideName = formatIdeName(ide);
@@ -112,8 +168,17 @@ module.exports = {
             const files = await countFilesInDir(configPath);
             success(`${ideName}: ${files} files`);
           } else {
-            warning(`${ideName}: Config missing (run 'npx agileflow update')`);
+            warning(`${ideName}: Config missing`);
             warnings++;
+            repairs.push({
+              type: 'missing-ide-config',
+              message: `Reinstall ${ideName} configuration`,
+              fix: async () => {
+                info(`Reinstalling ${ideName} configuration...`);
+                await ideManager.setup(ide, directory, status.path);
+                success(`Reinstalled ${ideName} configuration`);
+              },
+            });
           }
         }
       }
@@ -127,9 +192,19 @@ module.exports = {
         if (!status.ides || !status.ides.includes(ide)) {
           const configPath = getIdeConfigPath(directory, ide);
           if (await fs.pathExists(configPath)) {
-            warning(`${formatIdeName(ide)}: Config exists but not in manifest`);
+            const ideName = formatIdeName(ide);
+            warning(`${ideName}: Config exists but not in manifest`);
             orphansFound = true;
             warnings++;
+            repairs.push({
+              type: 'orphaned-config',
+              message: `Remove orphaned ${ideName} configuration`,
+              fix: async () => {
+                info(`Removing orphaned ${ideName} configuration...`);
+                await fs.remove(configPath);
+                success(`Removed ${ideName} configuration`);
+              },
+            });
           }
         }
       }
@@ -138,6 +213,26 @@ module.exports = {
         success('No orphaned configurations');
       }
 
+      // Execute repairs if --fix is enabled
+      if (options.fix && repairs.length > 0) {
+        console.log();
+        displaySection('Applying Fixes');
+
+        for (const repair of repairs) {
+          try {
+            await repair.fix();
+          } catch (err) {
+            error(`Failed to ${repair.message.toLowerCase()}: ${err.message}`);
+          }
+        }
+
+        console.log();
+        success(`Applied ${repairs.length} fix(es)`);
+      } else if (repairs.length > 0 && !options.fix) {
+        console.log();
+        info(`Found ${repairs.length} fixable issue(s). Run with --fix to auto-repair.`);
+      }
+
       // Print summary
       printSummary(issues, warnings);
 

package/tools/cli/commands/status.js

@@ -31,7 +31,7 @@ module.exports = {
 
       if (!status.installed) {
         warning('No AgileFlow installation found in this directory');
-        console.log(chalk.dim(`\nRun 'npx agileflow install' to set up AgileFlow\n`));
+        console.log(chalk.dim(`\nRun 'npx agileflow setup' to set up AgileFlow\n`));
         process.exit(0);
       }
 

package/tools/cli/commands/update.js

@@ -6,10 +6,12 @@
 
 const chalk = require('chalk');
 const path = require('node:path');
+const semver = require('semver');
 const { Installer } = require('../installers/core/installer');
 const { IdeManager } = require('../installers/ide/manager');
 const { displayLogo, displaySection, success, warning, error, info, confirm } = require('../lib/ui');
 const { createDocsStructure, getDocsFolderName } = require('../lib/docs-setup');
+const { getLatestVersion } = require('../lib/npm-utils');
 
 const installer = new Installer();
 const ideManager = new IdeManager();
@@ -32,27 +34,55 @@ module.exports = {
 
       if (!status.installed) {
         warning('No AgileFlow installation found');
-        console.log(chalk.dim(`\nRun 'npx agileflow install' to set up AgileFlow\n`));
+        console.log(chalk.dim(`\nRun 'npx agileflow setup' to set up AgileFlow\n`));
         process.exit(1);
       }
 
       displaySection('Updating AgileFlow', `Current version: ${status.version}`);
 
-      // Get package version
+      // Get local CLI version and npm registry version
       const packageJson = require(path.join(__dirname, '..', '..', '..', 'package.json'));
-      const newVersion = packageJson.version;
+      const localCliVersion = packageJson.version;
 
-      console.log(chalk.bold('Current: '), status.version);
-      console.log(chalk.bold('Latest:  '), newVersion);
+      console.log(chalk.dim('Checking npm registry for latest version...'));
+      const npmLatestVersion = await getLatestVersion('agileflow');
 
-      if (status.version === newVersion && !options.force) {
+      if (!npmLatestVersion) {
+        warning('Could not check npm registry for latest version');
+        console.log(chalk.dim('Continuing with local CLI version...\n'));
+      }
+
+      const latestVersion = npmLatestVersion || localCliVersion;
+
+      console.log(chalk.bold('Installed:   '), status.version);
+      console.log(chalk.bold('CLI version: '), localCliVersion);
+      if (npmLatestVersion) {
+        console.log(chalk.bold('Latest (npm):'), npmLatestVersion);
+      }
+
+      // Check if CLI itself is outdated
+      if (npmLatestVersion && semver.lt(localCliVersion, npmLatestVersion)) {
+        console.log();
+        warning('Your CLI is outdated!');
+        console.log(chalk.dim(`  To update your installation, run:\n`));
+        console.log(chalk.cyan(`  npx agileflow@latest update\n`));
+
+        const useOutdated = await confirm('Continue with outdated CLI anyway?');
+        if (!useOutdated) {
+          console.log(chalk.dim('\nUpdate cancelled\n'));
+          process.exit(0);
+        }
+      }
+
+      // Check if project installation is up to date
+      if (status.version === latestVersion && !options.force) {
         success('Already on the latest version');
         process.exit(0);
       }
 
       // Confirm update
       if (!options.force) {
-        const proceed = await confirm(`Update to v${newVersion}?`);
+        const proceed = await confirm(`Update to v${latestVersion}?`);
         if (!proceed) {
           console.log(chalk.dim('\nUpdate cancelled\n'));
           process.exit(0);
@@ -64,13 +94,13 @@ module.exports = {
       // Get docs folder name from metadata (or default to 'docs')
       const docsFolder = await getDocsFolderName(directory);
 
-      // Re-run installation with existing config
+      // Re-run installation with existing config from manifest
       const config = {
         directory,
         ides: status.ides || ['claude-code'],
-        userName: 'Developer', // Could read from existing config
-        agileflowFolder: path.basename(status.path),
-        docsFolder,
+        userName: status.userName || 'Developer',
+        agileflowFolder: status.agileflowFolder || path.basename(status.path),
+        docsFolder: status.docsFolder || docsFolder,
       };
 
       // Run core installation
@@ -102,7 +132,7 @@ module.exports = {
         }
       }
 
-      console.log(chalk.green(`\n✨ Update complete! (${status.version} → ${newVersion})\n`));
+      console.log(chalk.green(`\n✨ Update complete! (${status.version} → ${latestVersion})\n`));
 
       process.exit(0);
     } catch (err) {

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

@@ -41,7 +41,7 @@ class Installer {
    * @returns {Promise<Object>} Installation result
    */
   async install(config) {
-    const { directory, ides, userName, agileflowFolder } = config;
+    const { directory, ides, userName, agileflowFolder, docsFolder } = config;
 
     const agileflowDir = path.join(directory, agileflowFolder);
     const spinner = ora('Installing AgileFlow...').start();
@@ -72,7 +72,7 @@ class Installer {
 
       // Create manifest
       spinner.text = 'Creating manifest...';
-      await this.createManifest(cfgDir, ides);
+      await this.createManifest(cfgDir, {ides, userName, agileflowFolder, docsFolder});
 
       // Count installed items
       const counts = await this.countInstalledItems(agileflowDir);
@@ -200,9 +200,10 @@ class Installer {
   /**
    * Create manifest file
    * @param {string} cfgDir - Config directory
-   * @param {string[]} ides - Selected IDEs
+   * @param {Object} config - Manifest configuration
    */
-  async createManifest(cfgDir, ides) {
+  async createManifest(cfgDir, config) {
+    const { ides, userName, agileflowFolder, docsFolder } = config;
     const packageJson = require(path.join(this.packageRoot, 'package.json'));
 
     const manifest = {
@@ -211,6 +212,9 @@ class Installer {
       updated_at: new Date().toISOString(),
       ides: ides,
       modules: ['core'],
+      user_name: userName,
+      agileflow_folder: agileflowFolder || '.agileflow',
+      docs_folder: docsFolder || 'docs',
     };
 
     const manifestPath = path.join(cfgDir, 'manifest.yaml');
@@ -265,6 +269,11 @@ class Installer {
       version: null,
       ides: [],
       modules: [],
+      userName: null,
+      agileflowFolder: null,
+      docsFolder: null,
+      installedAt: null,
+      updatedAt: null,
     };
 
     // Look for AgileFlow installation
@@ -284,6 +293,11 @@ class Installer {
         status.version = manifest.version;
         status.ides = manifest.ides || [];
         status.modules = manifest.modules || [];
+        status.userName = manifest.user_name || 'Developer';
+        status.agileflowFolder = manifest.agileflow_folder || folder;
+        status.docsFolder = manifest.docs_folder || 'docs';
+        status.installedAt = manifest.installed_at;
+        status.updatedAt = manifest.updated_at;
 
         break;
       }

package/tools/cli/lib/npm-utils.js

@@ -0,0 +1,62 @@
+/**
+ * AgileFlow CLI - npm Registry Utilities
+ *
+ * Utilities for interacting with the npm registry.
+ */
+
+const https = require('https');
+
+/**
+ * Get the latest version of a package from npm registry
+ * @param {string} packageName - Name of the package
+ * @returns {Promise<string|null>} Latest version or null if error
+ */
+async function getLatestVersion(packageName) {
+  return new Promise((resolve) => {
+    const options = {
+      hostname: 'registry.npmjs.org',
+      port: 443,
+      path: `/${packageName}/latest`,
+      method: 'GET',
+      headers: {
+        'User-Agent': 'agileflow-cli',
+      },
+    };
+
+    const req = https.request(options, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          if (res.statusCode === 200) {
+            const json = JSON.parse(data);
+            resolve(json.version || null);
+          } else {
+            resolve(null);
+          }
+        } catch (err) {
+          resolve(null);
+        }
+      });
+    });
+
+    req.on('error', () => {
+      resolve(null);
+    });
+
+    req.setTimeout(5000, () => {
+      req.destroy();
+      resolve(null);
+    });
+
+    req.end();
+  });
+}
+
+module.exports = {
+  getLatestVersion,
+};

package/tools/postinstall.js

@@ -31,6 +31,19 @@ function shouldSkipInstall() {
     return true;
   }
 
+  // Skip in CI environments
+  if (process.env.CI === 'true' || process.env.CI === '1') {
+    log('ℹ️  Skipping auto-install (CI environment detected)', 'dim');
+    return true;
+  }
+
+  // Skip if installed globally
+  if (process.env.npm_config_global === 'true') {
+    log('ℹ️  Skipping auto-install (global installation)', 'dim');
+    log('   Run "agileflow setup" in your project directory instead', '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');
@@ -90,7 +103,7 @@ function shouldSkipInstall() {
   return false;
 }
 
-function runAutoInstall() {
+async function runAutoInstall() {
   try {
     console.log(''); // Blank line for spacing
     log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', 'blue');
@@ -98,33 +111,76 @@ function runAutoInstall() {
     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');
+      log('⚠️  Could not find AgileFlow CLI. Run "npx agileflow setup" manually.', 'yellow');
       return;
     }
 
-    // Run install command with --yes flag (non-interactive)
-    execSync(`node "${cliPath}" install --yes`, {
-      stdio: 'inherit',
-      cwd: process.cwd(),
-    });
+    // Check if running in interactive mode (TTY)
+    const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+
+    if (isInteractive) {
+      // Interactive mode: ask for confirmation
+      console.log('AgileFlow can set up automatically in your project now.');
+      console.log('');
+      console.log('Options:');
+      console.log('  1) Run setup now (recommended)');
+      console.log('  2) Skip setup for now (run "npx agileflow setup" later)');
+      console.log('');
+
+      // Use readline for simple input
+      const readline = require('readline').createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      const answer = await new Promise((resolve) => {
+        readline.question('Choose an option (1 or 2): ', (ans) => {
+          readline.close();
+          resolve(ans.trim());
+        });
+      });
+
+      console.log('');
+
+      if (answer !== '1') {
+        log('ℹ️  Setup skipped. Run "npx agileflow setup" when ready.', 'dim');
+        console.log('');
+        return;
+      }
+
+      log('🚀 Setting up AgileFlow in your project...', 'green');
+      console.log('');
+
+      // Run setup command (interactive mode, no --yes flag)
+      execSync(`node "${cliPath}" setup`, {
+        stdio: 'inherit',
+        cwd: process.cwd(),
+      });
+    } else {
+      // Non-interactive mode (e.g., npm install in scripts): run with --yes
+      log('🚀 Setting up AgileFlow in your project...', 'green');
+      console.log('');
+
+      execSync(`node "${cliPath}" setup --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');
+    log('To skip auto-setup 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');
+    log('⚠️  Auto-setup encountered an issue.', 'yellow');
+    log('   You can run "npx agileflow setup" manually to complete setup.', 'yellow');
     console.log('');
 
     if (process.env.DEBUG) {
@@ -134,8 +190,10 @@ function runAutoInstall() {
 }
 
 // Main execution
-if (shouldSkipInstall()) {
-  process.exit(0);
-}
+(async () => {
+  if (shouldSkipInstall()) {
+    process.exit(0);
+  }
 
-runAutoInstall();
+  await runAutoInstall();
+})();