proagents 1.6.12 → 1.6.13

package/lib/commands/upgrade.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync, cpSync, mkdirSync, rmSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, cpSync, mkdirSync, rmSync, readdirSync, statSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import chalk from 'chalk';
@@ -14,26 +14,112 @@ const PRESERVE_FILES = [
   'handoff.md',
   '.lock',
   'active-features/_index.json',
-  'active-features/.gitkeep'
+  'active-features/.gitkeep',
+  // Changelog user data
+  'changelog/_recent.md',
+  // Worklog user data
+  'worklog/_context.md',
+  'worklog/ai-stats.json'
 ];
 
-// Folders to preserve (user data)
+// Folders to preserve (user data) - year folders detected dynamically
 const PRESERVE_FOLDERS = [
-  'active-features'
+  'active-features',
+  'changelog/modules',
+  'changelog/features',
+  'worklog'
 ];
 
+/**
+ * Detect year folders (YYYY format) in changelog directory
+ */
+function detectYearFolders(proagentsDir) {
+  const changelogDir = join(proagentsDir, 'changelog');
+  const yearFolders = [];
+
+  if (!existsSync(changelogDir)) return yearFolders;
+
+  try {
+    const entries = readdirSync(changelogDir, { withFileTypes: true });
+    for (const entry of entries) {
+      // Match 4-digit year folders (2020-2099)
+      if (entry.isDirectory() && /^20[2-9][0-9]$/.test(entry.name)) {
+        yearFolders.push(`changelog/${entry.name}`);
+      }
+    }
+  } catch {
+    // Changelog directory doesn't exist or unreadable
+  }
+
+  return yearFolders;
+}
+
+/**
+ * Recursively read all files in a directory
+ */
+function readDirRecursive(dir, baseDir = dir) {
+  const files = {};
+
+  if (!existsSync(dir)) return files;
+
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      const relativePath = fullPath.replace(baseDir + '/', '');
+
+      if (entry.isDirectory()) {
+        Object.assign(files, readDirRecursive(fullPath, baseDir));
+      } else {
+        try {
+          files[relativePath] = readFileSync(fullPath, 'utf-8');
+        } catch {
+          // Skip unreadable files (binary, permissions, etc.)
+        }
+      }
+    }
+  } catch {
+    // Directory read failed - return what we have
+  }
+
+  return files;
+}
+
 /**
  * Backup user files before upgrade
  */
 function backupUserFiles(targetDir) {
   const backups = {};
+  const proagentsDir = join(targetDir, '.proagents');
 
+  // Backup individual files
   for (const file of PRESERVE_FILES) {
-    const filePath = join(targetDir, 'proagents', file);
+    const filePath = join(proagentsDir, file);
     if (existsSync(filePath)) {
       try {
         backups[file] = readFileSync(filePath, 'utf-8');
-      } catch { }
+      } catch {
+        // Skip unreadable files
+      }
+    }
+  }
+
+  // Backup folders recursively
+  for (const folder of PRESERVE_FOLDERS) {
+    const folderPath = join(proagentsDir, folder);
+    if (existsSync(folderPath)) {
+      const folderFiles = readDirRecursive(folderPath, proagentsDir);
+      Object.assign(backups, folderFiles);
+    }
+  }
+
+  // Backup dynamically detected year folders (changelog/2024, changelog/2025, etc.)
+  const yearFolders = detectYearFolders(proagentsDir);
+  for (const folder of yearFolders) {
+    const folderPath = join(proagentsDir, folder);
+    if (existsSync(folderPath)) {
+      const folderFiles = readDirRecursive(folderPath, proagentsDir);
+      Object.assign(backups, folderFiles);
     }
   }
 
@@ -44,8 +130,10 @@ function backupUserFiles(targetDir) {
  * Restore user files after upgrade
  */
 function restoreUserFiles(targetDir, backups) {
+  const proagentsDir = join(targetDir, '.proagents');
+
   for (const [file, content] of Object.entries(backups)) {
-    const filePath = join(targetDir, 'proagents', file);
+    const filePath = join(proagentsDir, file);
     try {
       // Ensure directory exists
       mkdirSync(dirname(filePath), { recursive: true });
@@ -61,11 +149,13 @@ function restoreUserFiles(targetDir, backups) {
  */
 function getCurrentVersion(targetDir) {
   // Try to read version from a marker file or package
-  const markerPath = join(targetDir, 'proagents', '.version');
+  const markerPath = join(targetDir, '.proagents', '.version');
   if (existsSync(markerPath)) {
     try {
       return readFileSync(markerPath, 'utf-8').trim();
-    } catch { }
+    } catch {
+      // Version file unreadable
+    }
   }
   return 'unknown';
 }
@@ -162,7 +252,9 @@ export async function upgradeCommand(options = {}) {
   // Step 5: Write version marker
   try {
     writeFileSync(join(proagentsDir, '.version'), packageVersion);
-  } catch { }
+  } catch {
+    // Non-critical: version marker write failed
+  }
 
   // Summary
   console.log(chalk.bold('\nUpgrade Complete'));

package/lib/commands/version.js

@@ -0,0 +1,140 @@
+import { existsSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Get CLI version from package.json
+ */
+function getCliVersion() {
+  try {
+    const packagePath = join(__dirname, '..', '..', 'package.json');
+    const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+    return packageJson.version;
+  } catch (error) {
+    console.error(chalk.yellow(`Warning: Could not read CLI version: ${error.message}`));
+    return 'unknown';
+  }
+}
+
+/**
+ * Get installed version in current project
+ */
+function getProjectVersion(targetDir) {
+  const versionPath = join(targetDir, '.proagents', '.version');
+
+  if (!existsSync(versionPath)) {
+    return null;
+  }
+
+  try {
+    return readFileSync(versionPath, 'utf-8').trim();
+  } catch (error) {
+    console.error(chalk.yellow(`Warning: Could not read project version: ${error.message}`));
+    return 'unknown';
+  }
+}
+
+/**
+ * Fetch latest version from npm
+ */
+async function getLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+
+    const response = await fetch('https://registry.npmjs.org/proagents/latest', {
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+
+    if (response.ok) {
+      const data = await response.json();
+      return data.version;
+    }
+    return null;
+  } catch (error) {
+    // Network error or timeout - not critical
+    return null;
+  }
+}
+
+/**
+ * Compare semantic versions
+ * Returns: -1 if v1 < v2, 0 if equal, 1 if v1 > v2
+ */
+function compareVersions(v1, v2) {
+  const parts1 = v1.split('.').map(Number);
+  const parts2 = v2.split('.').map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    const p1 = parts1[i] || 0;
+    const p2 = parts2[i] || 0;
+    if (p1 < p2) return -1;
+    if (p1 > p2) return 1;
+  }
+  return 0;
+}
+
+/**
+ * Version command - show detailed version information
+ */
+export async function versionCommand(options = {}) {
+  const targetDir = process.cwd();
+
+  console.log(chalk.bold('\nProAgents Version Info'));
+  console.log(chalk.gray('======================\n'));
+
+  // CLI Version
+  const cliVersion = getCliVersion();
+  console.log(`  ${chalk.cyan('CLI Version:')}      ${chalk.white('v' + cliVersion)}`);
+
+  // Project Version
+  const projectVersion = getProjectVersion(targetDir);
+  if (projectVersion) {
+    const versionMatch = projectVersion === cliVersion;
+    const projectVersionColor = versionMatch ? chalk.green : chalk.yellow;
+    console.log(`  ${chalk.cyan('Project Version:')}  ${projectVersionColor('v' + projectVersion)}`);
+
+    if (!versionMatch) {
+      console.log(chalk.yellow(`                    ↳ Run 'npx proagents init' to update`));
+    }
+  } else {
+    console.log(`  ${chalk.cyan('Project Version:')}  ${chalk.gray('Not installed in this directory')}`);
+  }
+
+  // Latest Version (from npm)
+  if (!options.offline) {
+    process.stdout.write(`  ${chalk.cyan('Latest Version:')}   `);
+    const latestVersion = await getLatestVersion();
+
+    if (latestVersion) {
+      const comparison = compareVersions(cliVersion, latestVersion);
+
+      if (comparison >= 0) {
+        console.log(chalk.green('v' + latestVersion + ' (up to date)'));
+      } else {
+        console.log(chalk.yellow('v' + latestVersion + ' (update available)'));
+        console.log(chalk.yellow(`                    ↳ Run 'npm update -g proagents' to update`));
+      }
+    } else {
+      console.log(chalk.gray('Could not fetch (offline or npm unavailable)'));
+    }
+  }
+
+  // Additional info
+  console.log('');
+  console.log(`  ${chalk.cyan('Node.js:')}          ${chalk.white(process.version)}`);
+  console.log(`  ${chalk.cyan('Platform:')}         ${chalk.white(process.platform + ' ' + process.arch)}`);
+  console.log('');
+
+  // Quick tips
+  if (projectVersion && projectVersion !== cliVersion) {
+    console.log(chalk.bold('Tip:'));
+    console.log(chalk.gray('  Your project has an older ProAgents version.'));
+    console.log(chalk.gray('  Run `npx proagents init` to update framework files.\n'));
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "proagents",
-  "version": "1.6.12",
+  "version": "1.6.13",
   "description": "AI-agnostic development workflow framework that automates the full software development lifecycle",
   "type": "module",
   "main": "lib/index.js",