proagents 1.0.16 → 1.0.18

package/lib/commands/doctor.js

@@ -0,0 +1,305 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import yaml from 'js-yaml';
+
+// Platform file mapping
+const PLATFORM_FILES = {
+  claude: 'CLAUDE.md',
+  cursor: '.cursorrules',
+  windsurf: '.windsurfrules',
+  copilot: '.github/copilot-instructions.md',
+  chatgpt: 'CHATGPT.md',
+  gemini: 'GEMINI.md',
+  bolt: 'BOLT.md',
+  lovable: 'LOVABLE.md',
+  replit: 'REPLIT.md',
+  kiro: 'KIRO.md',
+  groq: 'GROQ.md',
+  antigravity: 'ANTIGRAVITY.md'
+};
+
+/**
+ * Check if ProAgents is installed
+ */
+function checkInstallation(targetDir) {
+  const proagentsDir = join(targetDir, 'proagents');
+  const configPath = join(targetDir, 'proagents.config.yaml');
+
+  const checks = [];
+
+  // Check proagents folder
+  if (existsSync(proagentsDir)) {
+    checks.push({ name: 'ProAgents folder', status: 'ok', message: './proagents/ exists' });
+  } else {
+    checks.push({ name: 'ProAgents folder', status: 'error', message: './proagents/ not found. Run: npx proagents init' });
+  }
+
+  // Check config file
+  if (existsSync(configPath)) {
+    checks.push({ name: 'Config file', status: 'ok', message: 'proagents.config.yaml exists' });
+  } else {
+    checks.push({ name: 'Config file', status: 'warning', message: 'proagents.config.yaml not found' });
+  }
+
+  return checks;
+}
+
+/**
+ * Check config validity
+ */
+function checkConfig(targetDir) {
+  const configPath = join(targetDir, 'proagents.config.yaml');
+  const checks = [];
+
+  if (!existsSync(configPath)) {
+    return [{ name: 'Config validation', status: 'skip', message: 'No config file to validate' }];
+  }
+
+  try {
+    const content = readFileSync(configPath, 'utf-8');
+    const config = yaml.load(content);
+
+    if (config && typeof config === 'object') {
+      checks.push({ name: 'Config syntax', status: 'ok', message: 'YAML is valid' });
+
+      // Check required sections
+      if (config.project?.name) {
+        checks.push({ name: 'Project name', status: 'ok', message: `"${config.project.name}"` });
+      } else {
+        checks.push({ name: 'Project name', status: 'warning', message: 'Not set' });
+      }
+
+      if (config.project?.type) {
+        checks.push({ name: 'Project type', status: 'ok', message: `"${config.project.type}"` });
+      } else {
+        checks.push({ name: 'Project type', status: 'warning', message: 'Not set' });
+      }
+    }
+  } catch (error) {
+    checks.push({ name: 'Config syntax', status: 'error', message: `Invalid YAML: ${error.message}` });
+  }
+
+  return checks;
+}
+
+/**
+ * Check AI platform files sync
+ */
+function checkPlatformSync(targetDir) {
+  const configPath = join(targetDir, 'proagents.config.yaml');
+  const checks = [];
+
+  let configPlatforms = [];
+
+  // Read platforms from config
+  if (existsSync(configPath)) {
+    try {
+      const content = readFileSync(configPath, 'utf-8');
+      const config = yaml.load(content);
+      configPlatforms = config?.platforms || config?.ai_platforms || [];
+    } catch { }
+  }
+
+  // Check each platform file
+  const existingFiles = [];
+  const missingFiles = [];
+
+  for (const [platformId, fileName] of Object.entries(PLATFORM_FILES)) {
+    const filePath = join(targetDir, fileName);
+    const inConfig = configPlatforms.includes(platformId);
+    const fileExists = existsSync(filePath);
+
+    if (fileExists) {
+      existingFiles.push(platformId);
+      if (!inConfig) {
+        checks.push({ name: `${platformId}`, status: 'warning', message: `${fileName} exists but not in config` });
+      }
+    } else if (inConfig) {
+      missingFiles.push(platformId);
+      checks.push({ name: `${platformId}`, status: 'warning', message: `In config but ${fileName} missing` });
+    }
+  }
+
+  if (checks.length === 0 && existingFiles.length > 0) {
+    checks.push({ name: 'Platform sync', status: 'ok', message: `${existingFiles.length} platforms synced` });
+  } else if (existingFiles.length === 0) {
+    checks.push({ name: 'Platform files', status: 'warning', message: 'No AI platform files found' });
+  }
+
+  return checks;
+}
+
+/**
+ * Check for lock file
+ */
+function checkLockFile(targetDir) {
+  const lockPath = join(targetDir, 'proagents', '.lock');
+  const checks = [];
+
+  if (existsSync(lockPath)) {
+    try {
+      const content = readFileSync(lockPath, 'utf-8');
+      const lock = yaml.load(content);
+
+      const expiresAt = new Date(lock.expires);
+      const now = new Date();
+
+      if (expiresAt < now) {
+        const lockedBy = lock.model ? `${lock.locked_by}:${lock.model}` : lock.locked_by;
+        checks.push({ name: 'Lock file', status: 'warning', message: `Expired lock by ${lockedBy}. Consider removing.` });
+      } else {
+        const lockedBy = lock.model ? `${lock.locked_by}:${lock.model}` : lock.locked_by;
+        checks.push({ name: 'Lock file', status: 'info', message: `Locked by ${lockedBy} for "${lock.task}"` });
+      }
+    } catch {
+      checks.push({ name: 'Lock file', status: 'warning', message: 'Lock file exists but is invalid' });
+    }
+  } else {
+    checks.push({ name: 'Lock file', status: 'ok', message: 'No active lock' });
+  }
+
+  return checks;
+}
+
+/**
+ * Check version
+ */
+async function checkVersion() {
+  const checks = [];
+
+  try {
+    // Get current version from package.json
+    const packagePath = new URL('../../package.json', import.meta.url);
+    const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+    const currentVersion = packageJson.version;
+
+    checks.push({ name: 'Installed version', status: 'info', message: `v${currentVersion}` });
+
+    // Try to fetch latest version from npm (with timeout)
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 3000);
+
+      const response = await fetch('https://registry.npmjs.org/proagents/latest', {
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+
+      if (response.ok) {
+        const data = await response.json();
+        const latestVersion = data.version;
+
+        if (currentVersion === latestVersion) {
+          checks.push({ name: 'Latest version', status: 'ok', message: 'Up to date' });
+        } else {
+          checks.push({ name: 'Latest version', status: 'warning', message: `v${latestVersion} available. Run: npm update -g proagents` });
+        }
+      }
+    } catch {
+      checks.push({ name: 'Version check', status: 'skip', message: 'Could not check npm registry' });
+    }
+  } catch {
+    checks.push({ name: 'Version', status: 'error', message: 'Could not read version' });
+  }
+
+  return checks;
+}
+
+/**
+ * Print check results
+ */
+function printChecks(title, checks) {
+  console.log(chalk.bold(`\n${title}`));
+  console.log(chalk.gray('─'.repeat(40)));
+
+  for (const check of checks) {
+    let icon, color;
+    switch (check.status) {
+      case 'ok':
+        icon = '✓';
+        color = chalk.green;
+        break;
+      case 'error':
+        icon = '✗';
+        color = chalk.red;
+        break;
+      case 'warning':
+        icon = '⚠';
+        color = chalk.yellow;
+        break;
+      case 'info':
+        icon = 'ℹ';
+        color = chalk.blue;
+        break;
+      case 'skip':
+        icon = '○';
+        color = chalk.gray;
+        break;
+      default:
+        icon = '•';
+        color = chalk.white;
+    }
+
+    console.log(`  ${color(icon)} ${check.name}: ${color(check.message)}`);
+  }
+}
+
+/**
+ * Doctor command - check health of ProAgents installation
+ */
+export async function doctorCommand() {
+  const targetDir = process.cwd();
+
+  console.log(chalk.bold('\nProAgents Doctor'));
+  console.log(chalk.gray('================'));
+  console.log(chalk.gray(`Checking: ${targetDir}\n`));
+
+  let hasErrors = false;
+  let hasWarnings = false;
+
+  // Run all checks
+  const installChecks = checkInstallation(targetDir);
+  printChecks('Installation', installChecks);
+
+  const configChecks = checkConfig(targetDir);
+  printChecks('Configuration', configChecks);
+
+  const platformChecks = checkPlatformSync(targetDir);
+  printChecks('AI Platforms', platformChecks);
+
+  const lockChecks = checkLockFile(targetDir);
+  printChecks('Lock Status', lockChecks);
+
+  const versionChecks = await checkVersion();
+  printChecks('Version', versionChecks);
+
+  // Count issues
+  const allChecks = [...installChecks, ...configChecks, ...platformChecks, ...lockChecks, ...versionChecks];
+  const errors = allChecks.filter(c => c.status === 'error').length;
+  const warnings = allChecks.filter(c => c.status === 'warning').length;
+
+  // Summary
+  console.log(chalk.bold('\nSummary'));
+  console.log(chalk.gray('─'.repeat(40)));
+
+  if (errors === 0 && warnings === 0) {
+    console.log(chalk.green('  ✓ All checks passed!\n'));
+  } else {
+    if (errors > 0) {
+      console.log(chalk.red(`  ✗ ${errors} error(s) found`));
+    }
+    if (warnings > 0) {
+      console.log(chalk.yellow(`  ⚠ ${warnings} warning(s) found`));
+    }
+    console.log('');
+
+    if (errors > 0) {
+      console.log(chalk.gray('Run `npx proagents init` to fix installation issues.'));
+    }
+    if (platformChecks.some(c => c.status === 'warning')) {
+      console.log(chalk.gray('Run `pa:ai-sync` to fix platform sync issues.'));
+    }
+    console.log('');
+  }
+}

package/lib/commands/init.js

@@ -191,6 +191,115 @@ const PROJECT_TYPES = [
   }
 ];
 
+// Project templates - pre-configured settings for common stacks
+const PROJECT_TEMPLATES = {
+  'nextjs-saas': {
+    name: 'Next.js SaaS Starter',
+    description: 'Full-stack SaaS with authentication, database, and payments',
+    project: { type: 'nextjs' },
+    techStack: {
+      api_style: 'rest',
+      state_management: 'zustand',
+      styling: 'tailwind',
+      database: 'postgresql',
+      orm: 'prisma',
+      auth_method: 'nextauth',
+      test_framework: 'vitest'
+    },
+    platforms: ['claude', 'cursor', 'copilot']
+  },
+  'react-spa': {
+    name: 'React Single Page App',
+    description: 'Frontend-focused React application with modern tooling',
+    project: { type: 'react' },
+    techStack: {
+      api_style: 'rest',
+      state_management: 'zustand',
+      styling: 'tailwind',
+      database: 'none',
+      orm: 'none',
+      auth_method: 'jwt',
+      test_framework: 'vitest'
+    },
+    platforms: ['claude', 'cursor']
+  },
+  'react-native-app': {
+    name: 'React Native Mobile App',
+    description: 'Cross-platform mobile app with Expo',
+    project: { type: 'react-native' },
+    techStack: {
+      api_style: 'rest',
+      state_management: 'zustand',
+      styling: 'tailwind',
+      database: 'supabase',
+      orm: 'none',
+      auth_method: 'supabase',
+      test_framework: 'jest'
+    },
+    platforms: ['claude', 'cursor']
+  },
+  'express-api': {
+    name: 'Express.js REST API',
+    description: 'Backend API with Express, PostgreSQL, and JWT auth',
+    project: { type: 'express' },
+    techStack: {
+      api_style: 'rest',
+      state_management: 'none',
+      styling: 'none',
+      database: 'postgresql',
+      orm: 'prisma',
+      auth_method: 'jwt',
+      test_framework: 'jest'
+    },
+    platforms: ['claude', 'cursor']
+  },
+  'nestjs-api': {
+    name: 'NestJS Enterprise API',
+    description: 'Enterprise-grade API with NestJS and TypeORM',
+    project: { type: 'nestjs' },
+    techStack: {
+      api_style: 'rest',
+      state_management: 'none',
+      styling: 'none',
+      database: 'postgresql',
+      orm: 'typeorm',
+      auth_method: 'jwt',
+      test_framework: 'jest'
+    },
+    platforms: ['claude', 'cursor']
+  },
+  'vue-spa': {
+    name: 'Vue.js Single Page App',
+    description: 'Vue 3 with Composition API and Pinia',
+    project: { type: 'vue' },
+    techStack: {
+      api_style: 'rest',
+      state_management: 'none',
+      styling: 'tailwind',
+      database: 'none',
+      orm: 'none',
+      auth_method: 'jwt',
+      test_framework: 'vitest'
+    },
+    platforms: ['claude', 'cursor']
+  },
+  'python-fastapi': {
+    name: 'Python FastAPI',
+    description: 'Modern Python API with FastAPI and SQLAlchemy',
+    project: { type: 'python' },
+    techStack: {
+      api_style: 'rest',
+      state_management: 'none',
+      styling: 'none',
+      database: 'postgresql',
+      orm: 'none',
+      auth_method: 'jwt',
+      test_framework: 'pytest'
+    },
+    platforms: ['claude', 'cursor']
+  }
+};
+
 // Tech stack configuration options
 const TECH_STACK_OPTIONS = {
   api_style: {
@@ -592,6 +701,41 @@ async function promptProjectConfig(targetDir) {
   };
 }
 
+/**
+ * List available templates
+ */
+export function listTemplates() {
+  console.log(chalk.bold('\nAvailable Project Templates'));
+  console.log(chalk.gray('─'.repeat(50)));
+
+  for (const [id, template] of Object.entries(PROJECT_TEMPLATES)) {
+    console.log(`\n  ${chalk.cyan(id)}`);
+    console.log(`    ${template.name}`);
+    console.log(chalk.gray(`    ${template.description}`));
+  }
+
+  console.log(chalk.gray('\n\nUsage: npx proagents init --template <name>\n'));
+}
+
+/**
+ * Apply a project template
+ */
+function applyTemplate(templateId, targetDir) {
+  const template = PROJECT_TEMPLATES[templateId];
+  if (!template) {
+    return null;
+  }
+
+  // Return config object that matches what promptProjectConfig returns
+  return {
+    name: basename(targetDir),
+    type: template.project.type,
+    typeName: PROJECT_TYPES.find(t => t.id === template.project.type)?.name || template.project.type,
+    techStack: template.techStack,
+    platforms: template.platforms
+  };
+}
+
 /**
  * Save project config to proagents.config.yaml
  */
@@ -777,8 +921,27 @@ No releases yet. Use \`pa:release\` to generate release notes.
       console.log(chalk.green('✓ Created RELEASE_NOTES.md'));
     }
 
-    // Interactive project configuration
-    const projectConfig = await promptProjectConfig(targetDir);
+    // Project configuration - either from template or interactive prompt
+    let projectConfig;
+
+    if (options.listTemplates) {
+      listTemplates();
+      return;
+    }
+
+    if (options.template) {
+      // Use template
+      projectConfig = applyTemplate(options.template, targetDir);
+      if (!projectConfig) {
+        console.log(chalk.red(`\nError: Template "${options.template}" not found.`));
+        listTemplates();
+        return;
+      }
+      console.log(chalk.green(`\n✓ Using template: ${PROJECT_TEMPLATES[options.template].name}`));
+    } else {
+      // Interactive prompts
+      projectConfig = await promptProjectConfig(targetDir);
+    }
 
     // Add ProAgents section to README.md (AI tools auto-read this)
     const readmePath = join(targetDir, 'README.md');
@@ -812,8 +975,14 @@ For detailed commands, see \`./proagents/PROAGENTS.md\`
       console.log(chalk.green('✓ Created README.md with ProAgents commands'));
     }
 
-    // Interactive AI platform selection
-    const selectedPlatforms = await selectPlatforms();
+    // AI platform selection - from template or interactive
+    let selectedPlatforms;
+    if (options.template && projectConfig.platforms) {
+      selectedPlatforms = projectConfig.platforms;
+      console.log(chalk.gray(`  Using template platforms: ${selectedPlatforms.join(', ')}`));
+    } else {
+      selectedPlatforms = await selectPlatforms();
+    }
 
     // Copy AI instruction files for selected platforms (merges with existing files)
     const aiResults = copyPlatformFiles(selectedPlatforms, sourceDir, targetDir);

package/lib/commands/upgrade.js

@@ -0,0 +1,180 @@
+import { existsSync, readFileSync, writeFileSync, cpSync, mkdirSync, rmSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+import { createInterface } from 'readline';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Files to preserve during upgrade (user customizations)
+const PRESERVE_FILES = [
+  'proagents.config.yaml',
+  'activity.log',
+  'handoff.md',
+  '.lock',
+  'active-features/_index.json',
+  'active-features/.gitkeep'
+];
+
+// Folders to preserve (user data)
+const PRESERVE_FOLDERS = [
+  'active-features'
+];
+
+/**
+ * Backup user files before upgrade
+ */
+function backupUserFiles(targetDir) {
+  const backups = {};
+
+  for (const file of PRESERVE_FILES) {
+    const filePath = join(targetDir, 'proagents', file);
+    if (existsSync(filePath)) {
+      try {
+        backups[file] = readFileSync(filePath, 'utf-8');
+      } catch { }
+    }
+  }
+
+  return backups;
+}
+
+/**
+ * Restore user files after upgrade
+ */
+function restoreUserFiles(targetDir, backups) {
+  for (const [file, content] of Object.entries(backups)) {
+    const filePath = join(targetDir, 'proagents', file);
+    try {
+      // Ensure directory exists
+      mkdirSync(dirname(filePath), { recursive: true });
+      writeFileSync(filePath, content);
+    } catch (error) {
+      console.log(chalk.yellow(`  ⚠ Could not restore ${file}: ${error.message}`));
+    }
+  }
+}
+
+/**
+ * Get current installed version
+ */
+function getCurrentVersion(targetDir) {
+  // Try to read version from a marker file or package
+  const markerPath = join(targetDir, 'proagents', '.version');
+  if (existsSync(markerPath)) {
+    try {
+      return readFileSync(markerPath, 'utf-8').trim();
+    } catch { }
+  }
+  return 'unknown';
+}
+
+/**
+ * Get package version
+ */
+function getPackageVersion() {
+  try {
+    const packagePath = join(__dirname, '..', '..', 'package.json');
+    const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+    return packageJson.version;
+  } catch {
+    return 'unknown';
+  }
+}
+
+/**
+ * Upgrade command - upgrade proagents folder to latest version
+ */
+export async function upgradeCommand(options = {}) {
+  const targetDir = process.cwd();
+  const proagentsDir = join(targetDir, 'proagents');
+  const sourceDir = join(__dirname, '..', '..', 'proagents');
+
+  console.log(chalk.bold('\nProAgents Upgrade'));
+  console.log(chalk.gray('=================\n'));
+
+  // Check if proagents folder exists
+  if (!existsSync(proagentsDir)) {
+    console.log(chalk.red('Error: ProAgents not found in this project.'));
+    console.log(chalk.gray('Run `npx proagents init` to initialize.\n'));
+    return;
+  }
+
+  const currentVersion = getCurrentVersion(targetDir);
+  const packageVersion = getPackageVersion();
+
+  console.log(`Current version: ${chalk.yellow(currentVersion)}`);
+  console.log(`Package version: ${chalk.green(packageVersion)}`);
+  console.log('');
+
+  // Confirm upgrade unless --force
+  if (!options.force) {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    const answer = await new Promise(resolve => {
+      rl.question(chalk.yellow('Upgrade proagents folder? (y/N) '), resolve);
+    });
+    rl.close();
+
+    if (answer.toLowerCase() !== 'y') {
+      console.log(chalk.gray('\nUpgrade cancelled.\n'));
+      return;
+    }
+  }
+
+  console.log('');
+
+  // Step 1: Backup user files
+  console.log(chalk.cyan('Backing up user files...'));
+  const backups = backupUserFiles(targetDir);
+  const backedUpCount = Object.keys(backups).length;
+  console.log(chalk.gray(`  Backed up ${backedUpCount} file(s)`));
+
+  // Step 2: Remove old proagents folder (except active-features)
+  console.log(chalk.cyan('Removing old files...'));
+  try {
+    // We'll do a selective removal to preserve active-features folder structure
+    rmSync(proagentsDir, { recursive: true, force: true });
+    console.log(chalk.gray('  Old proagents folder removed'));
+  } catch (error) {
+    console.log(chalk.yellow(`  ⚠ Could not remove old folder: ${error.message}`));
+  }
+
+  // Step 3: Copy new proagents folder
+  console.log(chalk.cyan('Installing new version...'));
+  try {
+    cpSync(sourceDir, proagentsDir, { recursive: true });
+    console.log(chalk.gray('  New proagents folder installed'));
+  } catch (error) {
+    console.log(chalk.red(`  ✗ Error: ${error.message}`));
+    return;
+  }
+
+  // Step 4: Restore user files
+  console.log(chalk.cyan('Restoring user files...'));
+  restoreUserFiles(targetDir, backups);
+  console.log(chalk.gray(`  Restored ${backedUpCount} file(s)`));
+
+  // Step 5: Write version marker
+  try {
+    writeFileSync(join(proagentsDir, '.version'), packageVersion);
+  } catch { }
+
+  // Summary
+  console.log(chalk.bold('\nUpgrade Complete'));
+  console.log(chalk.gray('─'.repeat(40)));
+  console.log(chalk.green(`  ✓ Upgraded to v${packageVersion}`));
+  console.log('');
+
+  console.log(chalk.bold('Preserved files:'));
+  for (const file of Object.keys(backups)) {
+    console.log(chalk.gray(`  • ${file}`));
+  }
+  console.log('');
+
+  console.log(chalk.gray('Run `npx proagents doctor` to verify installation.\n'));
+}

package/package.json

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