agileflow 2.33.1 → 2.35.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();
@@ -19,7 +21,7 @@ module.exports = {
   description: 'Update existing AgileFlow installation',
   options: [
     ['-d, --directory <path>', 'Project directory (default: current directory)'],
-    ['--force', 'Force update, overwriting modified files'],
+    ['--force', 'Force reinstall (skip prompts; overwrites local changes)'],
   ],
   action: async (options) => {
     try {
@@ -38,21 +40,49 @@ module.exports = {
 
       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 = options.force ? true : 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,17 +94,17 @@ 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
-      const coreResult = await installer.install(config);
+      const coreResult = await installer.install(config, { force: options.force });
 
       if (!coreResult.success) {
         error('Update failed');
@@ -82,6 +112,20 @@ module.exports = {
       }
 
       success('Updated core content');
+      if (coreResult.fileOps) {
+        info(
+          `Files: ${coreResult.fileOps.created} added, ${coreResult.fileOps.updated} updated, ${coreResult.fileOps.preserved} preserved`
+        );
+        if (coreResult.fileOps.updatesPath) {
+          info(`Preserved-file updates saved to: ${coreResult.fileOps.updatesPath}`);
+        }
+        if (coreResult.fileOps.backupPath) {
+          info(`Backup saved to: ${coreResult.fileOps.backupPath}`);
+        }
+        if (coreResult.fileOps.preserved > 0 && !options.force) {
+          warning('Some local changes were preserved; use --force to overwrite them.');
+        }
+      }
 
       // Re-setup IDEs
       ideManager.setAgileflowFolder(config.agileflowFolder);
@@ -92,8 +136,8 @@ module.exports = {
       }
 
       // Create/update docs structure (idempotent - only creates missing files)
-      displaySection('Updating Documentation Structure', `Folder: ${docsFolder}/`);
-      const docsResult = await createDocsStructure(directory, docsFolder);
+      displaySection('Updating Documentation Structure', `Folder: ${config.docsFolder}/`);
+      const docsResult = await createDocsStructure(directory, config.docsFolder, { updateGitignore: false });
 
       if (!docsResult.success) {
         warning('Failed to update docs structure');
@@ -102,7 +146,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

@@ -5,11 +5,26 @@
  */
 
 const path = require('node:path');
+const crypto = require('node:crypto');
 const fs = require('fs-extra');
 const chalk = require('chalk');
 const ora = require('ora');
 const yaml = require('js-yaml');
 
+const TEXT_EXTENSIONS = new Set(['.md', '.yaml', '.yml', '.txt', '.json']);
+
+function sha256Hex(data) {
+  return crypto.createHash('sha256').update(data).digest('hex');
+}
+
+function toPosixPath(filePath) {
+  return filePath.split(path.sep).join('/');
+}
+
+function safeTimestampForPath(date = new Date()) {
+  return date.toISOString().replace(/[:.]/g, '-');
+}
+
 /**
  * Get the source path for AgileFlow content
  * @returns {string} Path to src directory
@@ -38,10 +53,13 @@ class Installer {
   /**
    * Install AgileFlow to a project
    * @param {Object} config - Installation configuration
+   * @param {Object} options - Installation options
+   * @param {boolean} options.force - Overwrite local changes
    * @returns {Promise<Object>} Installation result
    */
-  async install(config) {
-    const { directory, ides, userName, agileflowFolder } = config;
+  async install(config, options = {}) {
+    const { directory, ides, userName, agileflowFolder, docsFolder } = config;
+    const requestedForce = Boolean(options.force);
 
     const agileflowDir = path.join(directory, agileflowFolder);
     const spinner = ora('Installing AgileFlow...').start();
@@ -55,24 +73,76 @@ class Installer {
       const cfgDir = path.join(agileflowDir, '_cfg');
       await fs.ensureDir(cfgDir);
 
+      const manifestPath = path.join(cfgDir, 'manifest.yaml');
+      const fileIndexPath = path.join(cfgDir, 'files.json');
+
+      const hasManifest = await fs.pathExists(manifestPath);
+      const existingFileIndex = await this.readFileIndex(fileIndexPath);
+      const hasValidFileIndex = Boolean(existingFileIndex);
+
+      // Migration: installation predates file indexing
+      const isMigration = hasManifest && !hasValidFileIndex;
+      const effectiveForce = requestedForce || isMigration;
+
+      const timestamp = safeTimestampForPath();
+      let backupPath = null;
+      if (isMigration) {
+        spinner.text = 'Backing up existing installation...';
+        backupPath = await this.createBackup(agileflowDir, cfgDir, timestamp);
+      }
+
+      const fileIndex = existingFileIndex || { schema: 1, files: {} };
+      if (!fileIndex.files || typeof fileIndex.files !== 'object') {
+        fileIndex.files = {};
+      }
+
+      const fileOps = {
+        created: 0,
+        updated: 0,
+        preserved: 0,
+        stashed: 0,
+        backupPath,
+        updatesPath: null,
+        isMigration,
+        force: effectiveForce,
+      };
+
       // 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);
+        await this.copyContent(coreSourcePath, agileflowDir, agileflowFolder, {
+          agileflowDir,
+          cfgDir,
+          fileIndex,
+          fileOps,
+          force: effectiveForce,
+          timestamp,
+        });
       } else {
         // Fallback: copy from old structure (commands, agents, skills at root)
-        await this.copyLegacyContent(directory, agileflowDir, agileflowFolder);
+        await this.copyLegacyContent(directory, agileflowDir, agileflowFolder, {
+          agileflowDir,
+          cfgDir,
+          fileIndex,
+          fileOps,
+          force: effectiveForce,
+          timestamp,
+        });
       }
 
       // Create config.yaml
       spinner.text = 'Creating configuration...';
-      await this.createConfig(agileflowDir, userName, agileflowFolder);
+      await this.createConfig(agileflowDir, userName, agileflowFolder, { force: effectiveForce });
 
       // Create manifest
       spinner.text = 'Creating manifest...';
-      await this.createManifest(cfgDir, ides);
+      await this.createManifest(cfgDir, { ides, userName, agileflowFolder, docsFolder }, { force: effectiveForce });
+
+      // Persist file index (used for safe future updates)
+      spinner.text = 'Writing file index...';
+      await this.writeFileIndex(fileIndexPath, fileIndex);
 
       // Count installed items
       const counts = await this.countInstalledItems(agileflowDir);
@@ -84,6 +154,7 @@ class Installer {
         path: agileflowDir,
         projectDir: directory,
         counts,
+        fileOps,
       };
     } catch (error) {
       spinner.fail('Installation failed');
@@ -96,8 +167,9 @@ class Installer {
    * @param {string} source - Source directory
    * @param {string} dest - Destination directory
    * @param {string} agileflowFolder - AgileFlow folder name
+   * @param {Object|null} policy - Copy policy (safe update behavior)
    */
-  async copyContent(source, dest, agileflowFolder) {
+  async copyContent(source, dest, agileflowFolder, policy = null) {
     const entries = await fs.readdir(source, { withFileTypes: true });
 
     for (const entry of entries) {
@@ -106,9 +178,13 @@ class Installer {
 
       if (entry.isDirectory()) {
         await fs.ensureDir(destPath);
-        await this.copyContent(srcPath, destPath, agileflowFolder);
+        await this.copyContent(srcPath, destPath, agileflowFolder, policy);
       } else {
-        await this.copyFileWithReplacements(srcPath, destPath, agileflowFolder);
+        if (policy) {
+          await this.copyFileWithPolicy(srcPath, destPath, agileflowFolder, policy);
+        } else {
+          await this.copyFileWithReplacements(srcPath, destPath, agileflowFolder);
+        }
       }
     }
   }
@@ -118,8 +194,9 @@ class Installer {
    * @param {string} projectDir - Project directory
    * @param {string} agileflowDir - AgileFlow installation directory
    * @param {string} agileflowFolder - AgileFlow folder name
+   * @param {Object|null} policy - Copy policy (safe update behavior)
    */
-  async copyLegacyContent(projectDir, agileflowDir, agileflowFolder) {
+  async copyLegacyContent(projectDir, agileflowDir, agileflowFolder, policy = null) {
     const packageRoot = this.packageRoot;
 
     // Copy commands
@@ -127,7 +204,7 @@ class Installer {
     const commandsDest = path.join(agileflowDir, 'commands');
     if (await fs.pathExists(commandsSource)) {
       await fs.ensureDir(commandsDest);
-      await this.copyContent(commandsSource, commandsDest, agileflowFolder);
+      await this.copyContent(commandsSource, commandsDest, agileflowFolder, policy);
     }
 
     // Copy agents
@@ -135,7 +212,7 @@ class Installer {
     const agentsDest = path.join(agileflowDir, 'agents');
     if (await fs.pathExists(agentsSource)) {
       await fs.ensureDir(agentsDest);
-      await this.copyContent(agentsSource, agentsDest, agileflowFolder);
+      await this.copyContent(agentsSource, agentsDest, agileflowFolder, policy);
     }
 
     // Copy skills
@@ -143,7 +220,7 @@ class Installer {
     const skillsDest = path.join(agileflowDir, 'skills');
     if (await fs.pathExists(skillsSource)) {
       await fs.ensureDir(skillsDest);
-      await this.copyContent(skillsSource, skillsDest, agileflowFolder);
+      await this.copyContent(skillsSource, skillsDest, agileflowFolder, policy);
     }
 
     // Copy templates
@@ -151,7 +228,7 @@ class Installer {
     const templatesDest = path.join(agileflowDir, 'templates');
     if (await fs.pathExists(templatesSource)) {
       await fs.ensureDir(templatesDest);
-      await this.copyContent(templatesSource, templatesDest, agileflowFolder);
+      await this.copyContent(templatesSource, templatesDest, agileflowFolder, policy);
     }
   }
 
@@ -162,10 +239,9 @@ class Installer {
    * @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)) {
+    if (TEXT_EXTENSIONS.has(ext)) {
       let content = await fs.readFile(source, 'utf8');
 
       // Replace placeholders
@@ -178,43 +254,289 @@ class Installer {
     }
   }
 
+  /**
+   * Copy a file with safe update behavior.
+   * - If the destination file is unchanged since the last install, overwrite.
+   * - If it has local changes, preserve and write the new version to _cfg/updates/<timestamp>/...
+   * - If --force is set, overwrite all.
+   * @param {string} source - Source file path
+   * @param {string} dest - Destination file path
+   * @param {string} agileflowFolder - AgileFlow folder name
+   * @param {Object} policy - Copy policy
+   */
+  async copyFileWithPolicy(source, dest, agileflowFolder, policy) {
+    const { agileflowDir, cfgDir, fileIndex, fileOps, force, timestamp } = policy;
+
+    const relativePath = toPosixPath(path.relative(agileflowDir, dest));
+    const maybeRecord = fileIndex.files[relativePath];
+    const existingRecord = maybeRecord && typeof maybeRecord === 'object' ? maybeRecord : null;
+
+    const ext = path.extname(source).toLowerCase();
+    const isText = TEXT_EXTENSIONS.has(ext);
+
+    let newContent;
+    if (isText) {
+      let content = await fs.readFile(source, 'utf8');
+      content = content.replace(/\{agileflow_folder\}/g, agileflowFolder);
+      content = content.replace(/\{project-root\}/g, '{project-root}');
+      newContent = content;
+    } else {
+      newContent = await fs.readFile(source);
+    }
+
+    const newHash = sha256Hex(newContent);
+    const destExists = await fs.pathExists(dest);
+
+    if (!destExists) {
+      await fs.ensureDir(path.dirname(dest));
+      if (isText) {
+        await fs.writeFile(dest, newContent, 'utf8');
+      } else {
+        await fs.copy(source, dest);
+      }
+
+      fileIndex.files[relativePath] = { sha256: newHash, protected: false };
+      fileOps.created++;
+      return;
+    }
+
+    if (force) {
+      if (isText) {
+        await fs.writeFile(dest, newContent, 'utf8');
+      } else {
+        await fs.copy(source, dest);
+      }
+
+      fileIndex.files[relativePath] = { sha256: newHash, protected: false };
+      fileOps.updated++;
+      return;
+    }
+
+    const currentHash = await this.hashFile(dest);
+
+    // Respect previously protected files unless they now match upstream.
+    if (existingRecord && existingRecord.protected) {
+      if (currentHash === newHash) {
+        fileIndex.files[relativePath] = { sha256: newHash, protected: false };
+        return;
+      }
+
+      await this.writeStash(cfgDir, timestamp, relativePath, isText, newContent, source, fileOps);
+      fileIndex.files[relativePath] = { sha256: currentHash, protected: true };
+      fileOps.preserved++;
+      return;
+    }
+
+    // If we have a baseline hash and the file is unchanged since last install, we can update in place.
+    if (existingRecord && existingRecord.sha256 === currentHash) {
+      if (currentHash !== newHash) {
+        if (isText) {
+          await fs.writeFile(dest, newContent, 'utf8');
+        } else {
+          await fs.copy(source, dest);
+        }
+        fileOps.updated++;
+      }
+
+      fileIndex.files[relativePath] = { sha256: newHash, protected: false };
+      return;
+    }
+
+    // Unknown or locally modified file: preserve and stash the new version for manual merge.
+    if (currentHash === newHash) {
+      fileIndex.files[relativePath] = { sha256: newHash, protected: false };
+      return;
+    }
+
+    await this.writeStash(cfgDir, timestamp, relativePath, isText, newContent, source, fileOps);
+    fileIndex.files[relativePath] = { sha256: currentHash, protected: true };
+    fileOps.preserved++;
+  }
+
+  async writeStash(cfgDir, timestamp, relativePath, isText, newContent, source, fileOps) {
+    const updatesRoot = path.join(cfgDir, 'updates', timestamp);
+    const stashPath = path.join(updatesRoot, relativePath);
+
+    await fs.ensureDir(path.dirname(stashPath));
+    if (isText) {
+      await fs.writeFile(stashPath, newContent, 'utf8');
+    } else {
+      await fs.copy(source, stashPath);
+    }
+
+    fileOps.stashed++;
+    fileOps.updatesPath = updatesRoot;
+  }
+
+  async hashFile(filePath) {
+    const data = await fs.readFile(filePath);
+    return sha256Hex(data);
+  }
+
+  async readFileIndex(fileIndexPath) {
+    if (!(await fs.pathExists(fileIndexPath))) return null;
+    try {
+      const index = await fs.readJson(fileIndexPath);
+      if (!index || typeof index !== 'object') return null;
+      if (index.schema !== 1) return null;
+      if (!index.files || typeof index.files !== 'object') return null;
+      return index;
+    } catch {
+      return null;
+    }
+  }
+
+  async writeFileIndex(fileIndexPath, fileIndex) {
+    const packageJson = require(path.join(this.packageRoot, 'package.json'));
+    const nextIndex = {
+      schema: 1,
+      generated_at: new Date().toISOString(),
+      version: packageJson.version,
+      files: fileIndex.files || {},
+    };
+
+    await fs.writeJson(fileIndexPath, nextIndex, { spaces: 2 });
+  }
+
+  async createBackup(agileflowDir, cfgDir, timestamp) {
+    const backupRoot = path.join(cfgDir, 'backups', timestamp);
+    await fs.ensureDir(backupRoot);
+
+    const candidates = ['agents', 'commands', 'skills', 'templates', 'config.yaml'];
+    for (const name of candidates) {
+      const srcPath = path.join(agileflowDir, name);
+      if (await fs.pathExists(srcPath)) {
+        await fs.copy(srcPath, path.join(backupRoot, name));
+      }
+    }
+
+    const manifestPath = path.join(cfgDir, 'manifest.yaml');
+    if (await fs.pathExists(manifestPath)) {
+      await fs.copy(manifestPath, path.join(backupRoot, 'manifest.yaml'));
+    }
+
+    return backupRoot;
+  }
+
   /**
    * Create configuration file
    * @param {string} agileflowDir - AgileFlow directory
    * @param {string} userName - User name
    * @param {string} agileflowFolder - AgileFlow folder name
+   * @param {Object} options - Options
+   * @param {boolean} options.force - Overwrite existing file
    */
-  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(),
-    };
-
+  async createConfig(agileflowDir, userName, agileflowFolder, options = {}) {
     const configPath = path.join(agileflowDir, 'config.yaml');
-    await fs.writeFile(configPath, yaml.dump(config), 'utf8');
+    const packageJson = require(path.join(this.packageRoot, 'package.json'));
+
+    if (!(await fs.pathExists(configPath))) {
+      const config = {
+        version: packageJson.version,
+        user_name: userName,
+        agileflow_folder: agileflowFolder,
+        communication_language: 'English',
+        created_at: new Date().toISOString(),
+      };
+
+      await fs.writeFile(configPath, yaml.dump(config), 'utf8');
+      return;
+    }
+
+    try {
+      const existingContent = await fs.readFile(configPath, 'utf8');
+      const loaded = yaml.load(existingContent);
+      const existing = loaded && typeof loaded === 'object' && !Array.isArray(loaded) ? loaded : {};
+
+      const next = {
+        ...existing,
+        version: packageJson.version,
+        user_name: userName,
+        agileflow_folder: agileflowFolder,
+        created_at: existing.created_at || new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+      };
+
+      await fs.writeFile(configPath, yaml.dump(next), 'utf8');
+    } catch {
+      if (options.force) {
+        const config = {
+          version: packageJson.version,
+          user_name: userName,
+          agileflow_folder: agileflowFolder,
+          communication_language: 'English',
+          created_at: new Date().toISOString(),
+        };
+
+        await fs.writeFile(configPath, yaml.dump(config), 'utf8');
+      }
+    }
   }
 
   /**
    * Create manifest file
    * @param {string} cfgDir - Config directory
-   * @param {string[]} ides - Selected IDEs
+   * @param {Object} config - Manifest configuration
+   * @param {Object} options - Options
+   * @param {boolean} options.force - Overwrite existing file
    */
-  async createManifest(cfgDir, ides) {
+  async createManifest(cfgDir, config, options = {}) {
+    const { ides, userName, agileflowFolder, docsFolder } = config;
     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');
+    const now = new Date().toISOString();
+
+    if (!(await fs.pathExists(manifestPath))) {
+      const manifest = {
+        version: packageJson.version,
+        installed_at: now,
+        updated_at: now,
+        ides: ides,
+        modules: ['core'],
+        user_name: userName,
+        agileflow_folder: agileflowFolder || '.agileflow',
+        docs_folder: docsFolder || 'docs',
+      };
+
+      await fs.writeFile(manifestPath, yaml.dump(manifest), 'utf8');
+      return;
+    }
+
+    try {
+      const existingContent = await fs.readFile(manifestPath, 'utf8');
+      const loaded = yaml.load(existingContent);
+      const existing = loaded && typeof loaded === 'object' && !Array.isArray(loaded) ? loaded : {};
+
+      const manifest = {
+        ...existing,
+        version: packageJson.version,
+        installed_at: existing.installed_at || now,
+        updated_at: now,
+        ides: ides,
+        modules: existing.modules || ['core'],
+        user_name: userName,
+        agileflow_folder: agileflowFolder || existing.agileflow_folder || '.agileflow',
+        docs_folder: docsFolder || existing.docs_folder || 'docs',
+      };
+
+      await fs.writeFile(manifestPath, yaml.dump(manifest), 'utf8');
+    } catch {
+      if (options.force) {
+        const manifest = {
+          version: packageJson.version,
+          installed_at: now,
+          updated_at: now,
+          ides: ides,
+          modules: ['core'],
+          user_name: userName,
+          agileflow_folder: agileflowFolder || '.agileflow',
+          docs_folder: docsFolder || 'docs',
+        };
+
+        await fs.writeFile(manifestPath, yaml.dump(manifest), 'utf8');
+      }
+    }
   }
 
   /**
@@ -265,6 +587,11 @@ class Installer {
       version: null,
       ides: [],
       modules: [],
+      userName: null,
+      agileflowFolder: null,
+      docsFolder: null,
+      installedAt: null,
+      updatedAt: null,
     };
 
     // Look for AgileFlow installation
@@ -284,6 +611,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/installers/ide/claude-code.js

@@ -26,7 +26,7 @@ class ClaudeCodeSetup extends BaseIdeSetup {
    * @param {Object} options - Setup options
    */
   async setup(projectDir, agileflowDir, options = {}) {
-    console.log(chalk.hex('#C15F3C')(`  Setting up ${this.displayName}...`));
+    console.log(chalk.hex('#e8683a')(`  Setting up ${this.displayName}...`));
 
     // Clean up old installation first
     await this.cleanup(projectDir);