agileflow 2.33.1 → 2.35.0

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

@@ -6,9 +6,11 @@
 
 const chalk = require('chalk');
 const path = require('node:path');
+const crypto = require('node:crypto');
 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 +20,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:'));
@@ -73,16 +77,98 @@ 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 safe update tracking and pending preserved updates
+      console.log(chalk.bold('\nSafe Updates:'));
+      const cfgDir = path.join(status.path, '_cfg');
+      const fileIndexPath = path.join(cfgDir, 'files.json');
+      let fileIndex = null;
+
+      if (await fs.pathExists(fileIndexPath)) {
+        try {
+          fileIndex = await fs.readJson(fileIndexPath);
+          if (!fileIndex || fileIndex.schema !== 1 || !fileIndex.files || typeof fileIndex.files !== 'object') {
+            throw new Error('invalid format');
+          }
+          success('files.json present');
+
+          const protectedCount = countProtectedFiles(fileIndex);
+          if (protectedCount > 0) {
+            warning(`Protected files: ${protectedCount} (local changes preserved)`);
+            warnings++;
+          }
+        } catch (err) {
+          warning(`files.json invalid (${err.message})`);
+          warnings++;
+          repairs.push({
+            type: 'invalid-file-index',
+            message: 'Recreate files.json safe-update index',
+            fix: async () => {
+              await createProtectedFileIndex(status.path, fileIndexPath);
+              success('Recreated files.json (all files protected)');
+            },
+          });
+        }
+      } else {
+        warning('files.json missing (safe updates disabled)');
+        warnings++;
+        repairs.push({
+          type: 'missing-file-index',
+          message: 'Create files.json safe-update index',
+          fix: async () => {
+            await createProtectedFileIndex(status.path, fileIndexPath);
+            success('Created files.json (all files protected)');
+          },
+        });
+      }
+
+      const updatesDir = path.join(cfgDir, 'updates');
+      const updateSets = await listSubdirectories(updatesDir);
+      if (updateSets.length > 0) {
+        warning(`Pending preserved updates: ${updateSets.length} set(s)`);
+        warnings++;
+        info(`Review: ${updatesDir}/`);
+      } else {
+        success('No pending preserved updates');
       }
 
       // 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 +176,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 +210,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 +223,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 +247,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 +268,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);
 
@@ -241,3 +391,70 @@ function printSummary(issues, warnings) {
     console.log(chalk.red(`${issues} issue(s), ${warnings} warning(s) found.\n`));
   }
 }
+
+function sha256Hex(data) {
+  return crypto.createHash('sha256').update(data).digest('hex');
+}
+
+function toPosixPath(filePath) {
+  return filePath.split(path.sep).join('/');
+}
+
+function countProtectedFiles(fileIndex) {
+  if (!fileIndex || !fileIndex.files || typeof fileIndex.files !== 'object') return 0;
+  return Object.values(fileIndex.files).filter((record) => record && record.protected).length;
+}
+
+async function listSubdirectories(dirPath) {
+  if (!(await fs.pathExists(dirPath))) return [];
+  const entries = await fs.readdir(dirPath, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
+}
+
+async function createProtectedFileIndex(agileflowDir, fileIndexPath) {
+  const candidates = ['agents', 'commands', 'skills', 'templates', 'config.yaml'];
+  const files = {};
+
+  for (const candidate of candidates) {
+    const candidatePath = path.join(agileflowDir, candidate);
+    if (!(await fs.pathExists(candidatePath))) continue;
+
+    const stat = await fs.stat(candidatePath);
+    if (stat.isFile()) {
+      const data = await fs.readFile(candidatePath);
+      const relativePath = toPosixPath(path.relative(agileflowDir, candidatePath));
+      files[relativePath] = { sha256: sha256Hex(data), protected: true };
+      continue;
+    }
+
+    await indexDirectory(candidatePath, agileflowDir, files);
+  }
+
+  const index = {
+    schema: 1,
+    generated_at: new Date().toISOString(),
+    version: getCurrentVersion(),
+    files,
+  };
+
+  await fs.ensureDir(path.dirname(fileIndexPath));
+  await fs.writeJson(fileIndexPath, index, { spaces: 2 });
+}
+
+async function indexDirectory(dirPath, rootDir, filesOut) {
+  const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const entryPath = path.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      await indexDirectory(entryPath, rootDir, filesOut);
+      continue;
+    }
+
+    if (entry.isFile()) {
+      const data = await fs.readFile(entryPath);
+      const relativePath = toPosixPath(path.relative(rootDir, entryPath));
+      filesOut[relativePath] = { sha256: sha256Hex(data), protected: true };
+    }
+  }
+}

package/tools/cli/commands/setup.js

@@ -33,6 +33,7 @@ module.exports = {
           userName: 'Developer',
           agileflowFolder: '.agileflow',
           docsFolder: 'docs',
+          updateGitignore: true,
         };
       } else {
         // Interactive prompts
@@ -65,7 +66,9 @@ module.exports = {
 
       // Create docs structure
       displaySection('Creating Documentation Structure', `Folder: ${config.docsFolder}/`);
-      const docsResult = await createDocsStructure(config.directory, config.docsFolder);
+      const docsResult = await createDocsStructure(config.directory, config.docsFolder, {
+        updateGitignore: config.updateGitignore,
+      });
 
       if (!docsResult.success) {
         error('Failed to create docs structure');