forgedev 1.3.0 → 1.4.1

package/src/uat-generator.js

@@ -8,13 +8,13 @@ export async function generateUAT(outputDir, stackConfig) {
   generateBusinessRulesPlaceholder(outputDir, stackConfig);
 }
 
-function buildScenarios(config) {
-  const scenarios = [];
-  let id = 1;
+function nextId(counter) {
+  return `UAT-${String(counter.id++).padStart(3, '0')}`;
+}
 
-  // Health check: every project gets this
-  scenarios.push({
-    id: `UAT-${String(id++).padStart(3, '0')}`,
+function healthScenarios(counter) {
+  return [{
+    id: nextId(counter),
     feature: 'Health Check',
     priority: 'P0',
     preconditions: 'Application is running',
@@ -24,44 +24,46 @@ function buildScenarios(config) {
       'Verify response body contains status: "ok"',
     ],
     expected: 'Health endpoint responds with 200 and status "ok"',
-  });
+  }];
+}
 
-  // Database connectivity
-  if (config.database) {
-    scenarios.push({
-      id: `UAT-${String(id++).padStart(3, '0')}`,
-      feature: 'Database Connectivity',
-      priority: 'P0',
-      preconditions: 'Application and database are running',
-      steps: [
-        'Send GET request to deep health endpoint (/healthz)',
-        'Verify response includes database status',
-        'Verify database status is "connected"',
-      ],
-      expected: 'Deep health check confirms database connectivity',
-    });
-  }
+function databaseScenarios(counter, config) {
+  if (!config.database) return [];
+  return [{
+    id: nextId(counter),
+    feature: 'Database Connectivity',
+    priority: 'P0',
+    preconditions: 'Application and database are running',
+    steps: [
+      'Send GET request to deep health endpoint (/healthz)',
+      'Verify response includes database status',
+      'Verify database status is "connected"',
+    ],
+    expected: 'Deep health check confirms database connectivity',
+  }];
+}
 
-  // Homepage (frontend projects)
-  if (config.frontend) {
-    scenarios.push({
-      id: `UAT-${String(id++).padStart(3, '0')}`,
-      feature: 'Home Page Load',
-      priority: 'P0',
-      preconditions: 'Application is running',
-      steps: [
-        'Navigate to the application root URL',
-        'Verify the page loads without errors',
-        'Verify the page title is correct',
-      ],
-      expected: 'Home page loads successfully with correct title',
-    });
-  }
+function frontendScenarios(counter, config) {
+  if (!config.frontend) return [];
+  return [{
+    id: nextId(counter),
+    feature: 'Home Page Load',
+    priority: 'P0',
+    preconditions: 'Application is running',
+    steps: [
+      'Navigate to the application root URL',
+      'Verify the page loads without errors',
+      'Verify the page title is correct',
+    ],
+    expected: 'Home page loads successfully with correct title',
+  }];
+}
 
-  // Authentication
-  if (config.auth) {
-    scenarios.push({
-      id: `UAT-${String(id++).padStart(3, '0')}`,
+function authScenarios(counter, config) {
+  if (!config.auth) return [];
+  const scenarios = [
+    {
+      id: nextId(counter),
       feature: 'User Registration',
       priority: 'P0',
       preconditions: 'Application is running, no existing test user',
@@ -72,10 +74,9 @@ function buildScenarios(config) {
         'Verify account is created successfully',
       ],
       expected: 'User account is created and user is authenticated',
-    });
-
-    scenarios.push({
-      id: `UAT-${String(id++).padStart(3, '0')}`,
+    },
+    {
+      id: nextId(counter),
       feature: 'User Login',
       priority: 'P0',
       preconditions: 'Test user account exists',
@@ -86,10 +87,9 @@ function buildScenarios(config) {
         'Verify user is redirected to dashboard/home',
       ],
       expected: 'User is authenticated and redirected appropriately',
-    });
-
-    scenarios.push({
-      id: `UAT-${String(id++).padStart(3, '0')}`,
+    },
+    {
+      id: nextId(counter),
       feature: 'Invalid Login',
       priority: 'P1',
       preconditions: 'Application is running',
@@ -100,55 +100,67 @@ function buildScenarios(config) {
         'Verify error message is displayed',
       ],
       expected: 'User sees a generic error message, no sensitive info leaked',
-    });
+    },
+  ];
 
-    if (config.frontend) {
-      scenarios.push({
-        id: `UAT-${String(id++).padStart(3, '0')}`,
-        feature: 'Protected Route Access',
-        priority: 'P1',
-        preconditions: 'User is not authenticated',
-        steps: [
-          'Navigate to a protected route (e.g., /dashboard)',
-          'Verify redirect to login page',
-          'Log in with valid credentials',
-          'Verify redirect back to protected route',
-        ],
-        expected: 'Unauthenticated users are redirected to login, then back after auth',
-      });
-    }
+  if (config.frontend) {
+    scenarios.push({
+      id: nextId(counter),
+      feature: 'Protected Route Access',
+      priority: 'P1',
+      preconditions: 'User is not authenticated',
+      steps: [
+        'Navigate to a protected route (e.g., /dashboard)',
+        'Verify redirect to login page',
+        'Log in with valid credentials',
+        'Verify redirect back to protected route',
+      ],
+      expected: 'Unauthenticated users are redirected to login, then back after auth',
+    });
   }
 
-  // Error handling
-  scenarios.push({
-    id: `UAT-${String(id++).padStart(3, '0')}`,
-    feature: 'Structured Error Response',
-    priority: 'P1',
-    preconditions: 'Application is running',
-    steps: [
-      'Send a request to a non-existent endpoint',
-      'Verify response has structured error format',
-      'Verify no stack traces or internal details are leaked',
-    ],
-    expected: 'Error response follows format: { error: { code, message } }',
-  });
+  return scenarios;
+}
 
-  // Graceful shutdown
-  scenarios.push({
-    id: `UAT-${String(id).padStart(3, '0')}`,
-    feature: 'Graceful Shutdown',
-    priority: 'P1',
-    preconditions: 'Application is running with active connections',
-    steps: [
-      'Send SIGTERM to the application process',
-      'Verify in-flight requests complete',
-      'Verify database connections are closed',
-      'Verify process exits with code 0',
-    ],
-    expected: 'Application shuts down gracefully without dropping requests',
-  });
+function errorAndShutdownScenarios(counter) {
+  return [
+    {
+      id: nextId(counter),
+      feature: 'Structured Error Response',
+      priority: 'P1',
+      preconditions: 'Application is running',
+      steps: [
+        'Send a request to a non-existent endpoint',
+        'Verify response has structured error format',
+        'Verify no stack traces or internal details are leaked',
+      ],
+      expected: 'Error response follows format: { error: { code, message } }',
+    },
+    {
+      id: nextId(counter),
+      feature: 'Graceful Shutdown',
+      priority: 'P1',
+      preconditions: 'Application is running with active connections',
+      steps: [
+        'Send SIGTERM to the application process',
+        'Verify in-flight requests complete',
+        'Verify database connections are closed',
+        'Verify process exits with code 0',
+      ],
+      expected: 'Application shuts down gracefully without dropping requests',
+    },
+  ];
+}
 
-  return scenarios;
+function buildScenarios(config) {
+  const counter = { id: 1 };
+  return [
+    ...healthScenarios(counter),
+    ...databaseScenarios(counter, config),
+    ...frontendScenarios(counter, config),
+    ...authScenarios(counter, config),
+    ...errorAndShutdownScenarios(counter),
+  ];
 }
 
 function generateUATTemplate(outputDir, config, scenarios) {

package/src/update.js

@@ -1,6 +1,40 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import chalk from 'chalk';
-import { log } from './utils.js';
-import { checkForUpdate } from './update-check.js';
+import { log, ROOT_DIR } from './utils.js';
+import { checkForUpdate, compareVersions } from './update-check.js';
+
+/**
+ * Check if the current directory has stale DevForge infrastructure.
+ * Returns { stale, installedVersion, cliVersion } or null if no infrastructure found.
+ */
+function checkInfrastructure(projectDir) {
+  const versionFile = path.join(projectDir, '.claude', '.devforge-version');
+  if (!fs.existsSync(versionFile)) {
+    return null;
+  }
+
+  let pkg;
+  try {
+    pkg = JSON.parse(fs.readFileSync(path.join(ROOT_DIR, 'package.json'), 'utf-8'));
+  } catch {
+    return null;
+  }
+
+  try {
+    const installed = JSON.parse(fs.readFileSync(versionFile, 'utf-8'));
+    if (typeof installed.version !== 'string') return null;
+    const stale = compareVersions(pkg.version, installed.version) > 0;
+    return {
+      stale,
+      installedVersion: installed.version,
+      cliVersion: pkg.version,
+    };
+  } catch {
+    // Corrupted version file — treat as stale
+    return { stale: true, installedVersion: 'unknown', cliVersion: pkg.version };
+  }
+}
 
 export async function runUpdate() {
   console.log('');
@@ -18,16 +52,26 @@ export async function runUpdate() {
   if (!result.updateAvailable) {
     log.success(`  ✓ You're on the latest version (${result.current})`);
     console.log('');
-    return;
+  } else {
+    log.warn(`  Update available: ${result.current} → ${result.latest}`);
+    console.log('');
+    console.log('  To update:');
+    console.log(`    ${chalk.bold('npm install -g forgedev@latest')}   ${chalk.dim('(if installed globally)')}`);
+    console.log(`    ${chalk.bold('npx forgedev@latest new my-app')}  ${chalk.dim('(one-time use)')}`);
+    console.log('');
   }
 
-  log.warn(`  Update available: ${result.current} → ${result.latest}`);
-  console.log('');
-  console.log('  To update:');
-  console.log(`    ${chalk.bold('npm install -g forgedev@latest')}   ${chalk.dim('(if installed globally)')}`);
-  console.log(`    ${chalk.bold('npx forgedev@latest new my-app')}  ${chalk.dim('(one-time use)')}`);
-  console.log('');
-  log.dim('  To update an existing project\'s Claude Code infrastructure:');
-  log.dim('    cd my-project && npx forgedev@latest init');
-  console.log('');
+  // Check if current directory has stale DevForge infrastructure
+  const infra = checkInfrastructure(process.cwd());
+  if (infra && infra.stale) {
+    console.log(chalk.yellow('  ⚠ ') + chalk.bold('Project infrastructure is outdated'));
+    console.log(chalk.dim(`    Installed: v${infra.installedVersion}  →  CLI: v${infra.cliVersion}`));
+    console.log('');
+    console.log('  New commands, agents, and hooks are available but not deployed here.');
+    console.log(`  Run ${chalk.bold.cyan('npx forgedev init')} to sync this project's .claude/ infrastructure.`);
+    console.log('');
+  } else if (infra && !infra.stale) {
+    log.success(`  ✓ Project infrastructure is up to date (v${infra.installedVersion})`);
+    console.log('');
+  }
 }