forgedev 1.2.0 → 1.4.0

package/src/menu.js

@@ -0,0 +1,178 @@
+import { select, input, Separator } from '@inquirer/prompts';
+import chalk from 'chalk';
+import fs from 'node:fs';
+
+const COMMAND_GROUPS = [
+  {
+    name: 'Getting Started',
+    commands: [
+      { value: 'new', label: 'Create a new project', description: 'Scaffold a full project with AI-powered stack selection' },
+      { value: 'init', label: 'Add guardrails to existing project', description: 'Install hooks, agents, and commands into your current codebase' },
+    ],
+  },
+  {
+    name: 'Daily Workflow',
+    commands: [
+      { value: 'status', label: '/status', description: 'Run all checks and show a project dashboard' },
+      { value: 'next', label: '/next', description: 'Figure out what to work on next' },
+      { value: 'done', label: '/done', description: 'Verify current task is actually complete before moving on' },
+      { value: 'help', label: '/help', description: 'Not sure what to do? Get guided to the right workflow' },
+    ],
+  },
+  {
+    name: 'Development',
+    commands: [
+      { value: 'plan', label: '/plan', description: 'Create a comprehensive implementation plan before writing code' },
+      { value: 'tdd', label: '/tdd', description: 'Write failing tests first, then implement (test-driven)' },
+      { value: 'build-fix', label: '/build-fix', description: 'Fix build, lint, and type errors with minimal changes' },
+      { value: 'build-ui', label: '/build-ui', description: 'Build frontend UI components with AI-powered generation' },
+      { value: 'code-review', label: '/code-review', description: 'Review uncommitted changes for issues and quality' },
+      { value: 'simplify', label: '/simplify', description: 'Find duplicate code, long files, and extract shared utilities' },
+    ],
+  },
+  {
+    name: 'Verification',
+    commands: [
+      { value: 'verify-all', label: '/verify-all', description: 'Run the full verification chain on current changes' },
+      { value: 'full-audit', label: '/full-audit', description: 'Run every audit and review agent in a single pass' },
+      { value: 'audit-spec', label: '/audit-spec', description: 'Validate code against the specification' },
+      { value: 'audit-wiring', label: '/audit-wiring', description: 'Verify API endpoints are wired between frontend and backend' },
+      { value: 'audit-security', label: '/audit-security', description: 'Run a focused security audit on changed files' },
+      { value: 'verify-intent', label: '/verify-intent', description: 'Check Intent Verification Protocol compliance' },
+    ],
+  },
+  {
+    name: 'Release',
+    commands: [
+      { value: 'pre-pr', label: '/pre-pr', description: 'Run the complete pre-PR checklist before creating a pull request' },
+      { value: 'run-uat', label: '/run-uat', description: 'Execute UAT verification against test scenarios' },
+      { value: 'live-uat', label: '/live-uat', description: 'Run live UAT by interacting with the running application' },
+    ],
+  },
+  {
+    name: 'Generation',
+    commands: [
+      { value: 'generate-prd', label: '/generate-prd', description: 'Generate a Product Requirements Document' },
+      { value: 'generate-sdd', label: '/generate-sdd', description: 'Generate a Software Design Document from the codebase' },
+      { value: 'generate-uat', label: '/generate-uat', description: 'Generate UAT test scenarios for the project' },
+      { value: 'optimize-claude-md', label: '/optimize-claude-md', description: 'Analyze and optimize the CLAUDE.md file' },
+    ],
+  },
+  {
+    name: 'Session',
+    commands: [
+      { value: 'save-session', label: '/save-session', description: 'Save current session state for later' },
+      { value: 'resume-session', label: '/resume-session', description: 'Load a saved session and pick up where you left off' },
+    ],
+  },
+  {
+    name: 'Project Tools',
+    commands: [
+      { value: 'doctor', label: 'Diagnose project', description: 'Find and fix issues like dead code, flaky tests, oversized files' },
+      { value: 'ci', label: 'CI health check', description: 'Non-interactive health checks for CI/CD pipelines' },
+      { value: 'update', label: 'Check for updates', description: 'See if a newer version of DevForge is available' },
+    ],
+  },
+];
+
+// Commands that are Claude Code slash commands (run inside Claude Code, not the terminal)
+const CLAUDE_COMMANDS = new Set([
+  'status', 'next', 'done', 'help', 'plan', 'tdd', 'build-fix', 'build-ui',
+  'code-review', 'simplify', 'verify-all', 'full-audit', 'audit-spec', 'generate-sdd',
+  'audit-wiring', 'audit-security', 'verify-intent', 'pre-pr', 'run-uat',
+  'live-uat', 'generate-prd', 'generate-uat', 'optimize-claude-md',
+  'save-session', 'resume-session',
+]);
+
+export async function showInteractiveMenu() {
+  console.log('');
+  console.log(`  ${chalk.bold.cyan('DevForge')}  ${chalk.dim('AI-first project scaffolding')}`);
+  console.log('');
+
+  // Build choices with separators for groups
+  const choices = [];
+  let recommendation = null;
+
+  // Detect recommendation based on project state
+  try {
+    if (!fs.existsSync('package.json') && !fs.existsSync('pyproject.toml')) {
+      recommendation = 'new';
+    } else if (!fs.existsSync('.claude')) {
+      recommendation = 'init';
+    }
+  } catch { /* ignore */ }
+
+  for (const group of COMMAND_GROUPS) {
+    choices.push(new Separator(chalk.dim(`  ${group.name}`)));
+    for (const cmd of group.commands) {
+      const isRecommended = cmd.value === recommendation;
+      const badge = isRecommended ? chalk.green(' recommended') : '';
+      const label = CLAUDE_COMMANDS.has(cmd.value)
+        ? chalk.cyan(cmd.label)
+        : chalk.bold(cmd.label);
+
+      choices.push({
+        value: cmd.value,
+        name: `${label}${badge}  ${chalk.dim(cmd.description)}`,
+      });
+    }
+  }
+
+  const selected = await select({
+    message: 'What would you like to do?',
+    choices,
+    pageSize: 15,
+    loop: false,
+  });
+
+  return selected;
+}
+
+export async function handleMenuSelection(selected) {
+  // CLI commands — execute directly
+  if (selected === 'new') {
+    const name = await input({ message: 'Project name:' });
+    if (!name) return;
+    const { runNew } = await import('./index.js');
+    await runNew(name);
+    return;
+  }
+
+  if (selected === 'init') {
+    const { runInit } = await import('./init-mode.js');
+    await runInit(process.cwd());
+    return;
+  }
+
+  if (selected === 'doctor') {
+    const { runDoctor } = await import('./doctor.js');
+    await runDoctor(process.cwd());
+    return;
+  }
+
+  if (selected === 'ci') {
+    const { runCI } = await import('./ci-mode.js');
+    await runCI(process.cwd());
+    return;
+  }
+
+  if (selected === 'update') {
+    const { runUpdate } = await import('./update.js');
+    await runUpdate();
+    return;
+  }
+
+  // Claude Code commands — show how to run them
+  if (CLAUDE_COMMANDS.has(selected)) {
+    console.log('');
+    console.log(`  ${chalk.cyan('/')}${chalk.bold.cyan(selected)} is a Claude Code command.`);
+    console.log('');
+    console.log(`  To use it, open ${chalk.bold('Claude Code')} in your project and type:`);
+    console.log(`  ${chalk.green(`/${selected}`)}`);
+    console.log('');
+    console.log(`  ${chalk.dim('These commands work inside Claude Code (the AI assistant).')}`);
+    console.log(`  ${chalk.dim('They run agents that analyze, review, and modify your code.')}`);
+    console.log('');
+    return;
+  }
+}

package/src/prompts.js

@@ -21,19 +21,12 @@ const LANGUAGE_CHOICES = [
   { value: 'rust', name: 'Rust' },
 ];
 
-const DEPLOYMENT_CHOICES = [
-  { value: 'docker', name: 'Docker / Docker Compose' },
-  { value: 'vercel', name: 'Vercel' },
-  { value: 'aws', name: 'AWS' },
-  { value: 'gcp', name: 'Google Cloud' },
-];
-
 export async function askNewMode() {
   const mode = await select({
     message: 'How would you like to start?',
     choices: [
       { value: 'guided', name: '💬 Describe what you want to build (recommended for beginners)' },
-      { value: 'developer', name: '⚡ I know my stack — let me pick (for developers)' },
+      { value: 'developer', name: '⚡ I know my stack, let me pick (for developers)' },
     ],
   });
   return mode;
@@ -41,7 +34,7 @@ export async function askNewMode() {
 
 export async function askDescription() {
   const description = await input({
-    message: 'Tell me about what you want to build.\n  Don\'t worry about technical details — just describe it like you\'re explaining it to a friend.\n\n ',
+    message: 'Tell me about what you want to build.\n  Don\'t worry about technical details. Just describe it like you\'re explaining it to a friend.\n\n ',
   });
   return description;
 }
@@ -57,8 +50,8 @@ export async function askGuidedConfirm() {
   const choice = await select({
     message: 'Sound right?',
     choices: [
-      { value: 'yes', name: 'Yes — create it!' },
-      { value: 'adjust', name: 'No — let me adjust' },
+      { value: 'yes', name: 'Yes, create it!' },
+      { value: 'adjust', name: 'No, let me adjust' },
     ],
   });
   return choice;
@@ -88,7 +81,7 @@ export async function askServiceType() {
 export async function askRefinements(serviceType) {
   const refinements = {};
 
-  // Q1: Language preference — adapt choices based on service type
+  // Q1: Language preference. Adapt choices based on service type
   if (['api_service', 'cli_tool', 'microservice'].includes(serviceType)) {
     refinements.language = await select({
       message: 'Language preference?',

package/src/recommender.js

@@ -1,6 +1,25 @@
 import chalk from 'chalk';
-
-export const SUPPORTED_STACKS = ['nextjs-fullstack', 'fastapi-backend', 'polyglot-fullstack'];
+import { getStackMetadata } from './utils.js';
+
+export const SUPPORTED_STACKS = Object.keys(
+  // Import the metadata keys to keep SUPPORTED_STACKS in sync automatically.
+  // getStackMetadata returns null for unknown keys, so we call it to get the map.
+  (() => {
+    const stacks = {};
+    for (const id of ['nextjs-fullstack', 'fastapi-backend', 'polyglot-fullstack', 'react-express', 'remix-fullstack', 'hono-api']) {
+      if (getStackMetadata(id)) stacks[id] = true;
+    }
+    return stacks;
+  })()
+);
+
+// Modules included in every stack
+const UNIVERSAL_MODULES = [
+  { path: 'testing/load', prefix: '' },
+  { path: 'infra/docker-compose', prefix: '' },
+  { path: 'infra/github-actions', prefix: '' },
+  { path: 'infra/k8s', prefix: '' },
+];
 
 export function recommend(serviceType, refinements) {
   const config = {
@@ -24,19 +43,25 @@ export function recommend(serviceType, refinements) {
 
   switch (serviceType) {
     case 'web_app':
+      if (refinements.framework === 'remix') {
+        return buildRemixFullstack(config, refinements);
+      }
       return buildNextjsFullstack(config, refinements);
 
     case 'full_stack':
       if (lang === 'python') {
         return buildPolyglotFullstack(config, refinements);
       }
+      if (refinements.backend === 'express') {
+        return buildReactExpress(config, refinements);
+      }
       return buildNextjsFullstack(config, refinements);
 
     case 'api_service':
       if (lang === 'python') {
         return buildFastapiBackend(config, refinements);
       }
-      return unsupported(serviceType, lang, 'FastAPI (Python)');
+      return buildHonoApi(config, refinements);
 
     case 'ai_service':
       if (lang === 'python') {
@@ -50,13 +75,42 @@ export function recommend(serviceType, refinements) {
     case 'extension':
     case 'microservice':
     case 'describe':
-      return unsupported(serviceType, lang);
+      return unsupported(serviceType);
 
     default:
-      return unsupported(serviceType, lang);
+      return unsupported(serviceType);
+  }
+}
+
+// ─── Shared tail logic for all builders ─────────────────────────────
+// Appends chainproof, auth, and AI modules so each builder only defines
+// its stack-specific modules.
+
+function finalizeConfig(config, refinements, { authModules = [], chainproofModules = ['chainproof/base'], aiModules = [] } = {}) {
+  // Auth
+  if (refinements.auth && authModules.length > 0) {
+    for (const mod of authModules) {
+      config.templateModules.push(typeof mod === 'string' ? { path: mod, prefix: '' } : mod);
+    }
+  }
+
+  // ChainProof (always)
+  for (const mod of chainproofModules) {
+    config.templateModules.push(typeof mod === 'string' ? { path: mod, prefix: '' } : mod);
+  }
+
+  // AI guardrails
+  if (refinements.ai && aiModules.length > 0) {
+    for (const mod of aiModules) {
+      config.templateModules.push(typeof mod === 'string' ? { path: mod, prefix: '' } : mod);
+    }
   }
+
+  return config;
 }
 
+// ─── Stack builders ─────────────────────────────────────────────────
+
 function buildNextjsFullstack(config, refinements) {
   config.stackId = 'nextjs-fullstack';
   config.frontend = { framework: 'nextjs', language: 'typescript', styling: 'tailwind', ui: 'shadcn' };
@@ -71,18 +125,18 @@ function buildNextjsFullstack(config, refinements) {
   config.templateModules = [
     { path: 'base', prefix: '' },
     { path: 'frontend/nextjs', prefix: '' },
+    { path: 'docs-portal/nextjs', prefix: '' },
     { path: 'database/prisma-postgres', prefix: '' },
     { path: 'testing/vitest', prefix: '' },
     { path: 'testing/playwright', prefix: '' },
-    { path: 'infra/docker-compose', prefix: '' },
-    { path: 'infra/github-actions', prefix: '' },
+    ...UNIVERSAL_MODULES,
   ];
 
-  if (refinements.auth) {
-    config.templateModules.push({ path: 'auth/nextauth', prefix: '' });
-  }
-
-  return config;
+  return finalizeConfig(config, refinements, {
+    authModules: ['auth/nextauth'],
+    chainproofModules: ['chainproof/base', 'chainproof/nextjs'],
+    aiModules: ['ai/guardrails-ts'],
+  });
 }
 
 function buildFastapiBackend(config, refinements) {
@@ -99,17 +153,17 @@ function buildFastapiBackend(config, refinements) {
   config.templateModules = [
     { path: 'base', prefix: '' },
     { path: 'backend/fastapi', prefix: '' },
+    { path: 'docs-portal/fastapi', prefix: '' },
     { path: 'database/sqlalchemy-postgres', prefix: '' },
     { path: 'testing/pytest', prefix: '' },
-    { path: 'infra/docker-compose', prefix: '' },
-    { path: 'infra/github-actions', prefix: '' },
+    ...UNIVERSAL_MODULES,
   ];
 
-  if (refinements.auth) {
-    config.templateModules.push({ path: 'auth/jwt-custom', prefix: '' });
-  }
-
-  return config;
+  return finalizeConfig(config, refinements, {
+    authModules: ['auth/jwt-custom'],
+    chainproofModules: ['chainproof/base', 'chainproof/fastapi'],
+    aiModules: ['ai/guardrails-py'],
+  });
 }
 
 function buildPolyglotFullstack(config, refinements) {
@@ -127,29 +181,107 @@ function buildPolyglotFullstack(config, refinements) {
   config.templateModules = [
     { path: 'base', prefix: '' },
     { path: 'frontend/nextjs', prefix: 'frontend' },
+    { path: 'docs-portal/nextjs', prefix: 'frontend' },
     { path: 'backend/fastapi', prefix: '' },
     { path: 'database/prisma-postgres', prefix: 'frontend' },
     { path: 'database/sqlalchemy-postgres', prefix: '' },
     { path: 'testing/vitest', prefix: 'frontend' },
     { path: 'testing/playwright', prefix: '' },
     { path: 'testing/pytest', prefix: '' },
-    { path: 'infra/docker-compose', prefix: '' },
-    { path: 'infra/github-actions', prefix: '' },
+    ...UNIVERSAL_MODULES,
   ];
 
+  return finalizeConfig(config, refinements, {
+    authModules: [{ path: 'auth/nextauth', prefix: 'frontend' }, 'auth/jwt-custom'],
+    chainproofModules: ['chainproof/base', 'chainproof/polyglot'],
+    aiModules: [{ path: 'ai/guardrails-ts', prefix: 'frontend' }, 'ai/guardrails-py'],
+  });
+}
+
+function buildReactExpress(config, refinements) {
+  config.stackId = 'react-express';
+  config.frontend = { framework: 'react', language: 'typescript', styling: 'tailwind', ui: null };
+  config.backend = { framework: 'express', language: 'typescript', orm: 'prisma' };
+  config.database = { type: 'postgresql', orm: 'prisma' };
+  config.testing = { unit: 'vitest', e2e: null, backend: 'vitest' };
+
   if (refinements.auth) {
-    config.templateModules.push({ path: 'auth/nextauth', prefix: 'frontend' });
-    config.templateModules.push({ path: 'auth/jwt-custom', prefix: '' });
+    config.auth = 'jwt-custom';
   }
 
-  return config;
+  config.templateModules = [
+    { path: 'base', prefix: '' },
+    { path: 'frontend/react', prefix: 'frontend' },
+    { path: 'backend/express', prefix: 'backend' },
+    { path: 'database/prisma-postgres', prefix: 'backend' },
+    { path: 'testing/vitest', prefix: 'frontend' },
+    { path: 'testing/vitest', prefix: 'backend' },
+    ...UNIVERSAL_MODULES,
+  ];
+
+  return finalizeConfig(config, refinements, {
+    chainproofModules: ['chainproof/base'],
+    aiModules: [{ path: 'ai/guardrails-ts', prefix: 'backend' }],
+  });
+}
+
+function buildRemixFullstack(config, refinements) {
+  config.stackId = 'remix-fullstack';
+  config.frontend = { framework: 'remix', language: 'typescript', styling: 'tailwind', ui: null };
+  config.backend = { framework: 'remix', language: 'typescript', orm: 'prisma' };
+  config.database = { type: 'postgresql', orm: 'prisma' };
+  config.testing = { unit: 'vitest', e2e: null, backend: null };
+
+  if (refinements.auth) {
+    config.auth = 'remix-auth';
+  }
+
+  config.templateModules = [
+    { path: 'base', prefix: '' },
+    { path: 'frontend/remix', prefix: '' },
+    { path: 'database/prisma-postgres', prefix: '' },
+    { path: 'testing/vitest', prefix: '' },
+    ...UNIVERSAL_MODULES,
+  ];
+
+  // No auth template module — jwt-custom is Python-only, nextauth is Next.js-only.
+  // Remix auth scaffolding is planned for a future release.
+  return finalizeConfig(config, refinements, {
+    chainproofModules: ['chainproof/base'],
+    aiModules: ['ai/guardrails-ts'],
+  });
 }
 
-function unsupported(serviceType, lang, suggestion) {
-  const msg = suggestion
-    ? `"${serviceType}" with "${lang}" is not yet supported. Try: ${suggestion}`
-    : `"${serviceType}" is not yet supported in V1. Supported: web_app, api_service (Python), full_stack, ai_service`;
-  return { supported: false, message: msg };
+function buildHonoApi(config, refinements) {
+  config.stackId = 'hono-api';
+  config.frontend = null;
+  config.backend = { framework: 'hono', language: 'typescript', orm: 'prisma' };
+  config.database = { type: 'postgresql', orm: 'prisma' };
+  config.testing = { unit: 'vitest', e2e: null, backend: 'vitest' };
+
+  if (refinements.auth) {
+    config.auth = 'jwt-custom';
+  }
+
+  config.templateModules = [
+    { path: 'base', prefix: '' },
+    { path: 'backend/hono', prefix: '' },
+    { path: 'database/prisma-postgres', prefix: '' },
+    { path: 'testing/vitest', prefix: '' },
+    ...UNIVERSAL_MODULES,
+  ];
+
+  return finalizeConfig(config, refinements, {
+    chainproofModules: ['chainproof/base'],
+    aiModules: ['ai/guardrails-ts'],
+  });
+}
+
+function unsupported(serviceType) {
+  return {
+    supported: false,
+    message: `"${serviceType}" is not yet supported in V1. Supported: web_app, full_stack, api_service, ai_service`,
+  };
 }
 
 export function formatStackSummary(config) {
@@ -160,7 +292,8 @@ export function formatStackSummary(config) {
   const lines = [];
 
   if (config.frontend) {
-    lines.push(`  ${chalk.bold('Frontend:')}  ${config.frontend.framework} + ${config.frontend.language} + ${config.frontend.styling} + ${config.frontend.ui}`);
+    const uiPart = config.frontend.ui ? ` + ${config.frontend.ui}` : '';
+    lines.push(`  ${chalk.bold('Frontend:')}  ${config.frontend.framework} + ${config.frontend.language} + ${config.frontend.styling}${uiPart}`);
   }
   if (config.backend) {
     lines.push(`  ${chalk.bold('Backend:')}   ${config.backend.framework} + ${config.backend.language} + ${config.backend.orm}`);

package/src/scanner.js

@@ -13,6 +13,7 @@ export function scanProject(projectDir) {
     testing: detectTesting(projectDir),
     deployment: detectDeployment(projectDir),
     ai: detectAI(projectDir),
+    monorepo: detectMonorepo(projectDir),
 
     infrastructure: {
       hasClaudeMd: false,
@@ -22,6 +23,7 @@ export function scanProject(projectDir) {
       hasCommands: false,
       hasSkills: false,
       hasUAT: false,
+      devforgeVersion: null,
     },
 
     files: {
@@ -88,7 +90,8 @@ function detectFrontend(projectDir) {
     result.detected = true;
     result.framework = 'nextjs';
     result.language = fileExists(projectDir, 'tsconfig.json') ? 'typescript' : 'javascript';
-    result.directory = 'src';
+    // Next.js supports both src/app and app/ at root
+    result.directory = dirExists(projectDir, 'src') ? 'src' : '.';
     return result;
   }
 
@@ -307,6 +310,49 @@ function detectAI(projectDir) {
   return false;
 }
 
+function detectMonorepo(projectDir) {
+  const result = { detected: false, type: null, workspaces: [] };
+
+  // npm/yarn workspaces
+  const pkg = readJsonSafe(projectDir, 'package.json');
+  if (pkg?.workspaces) {
+    result.detected = true;
+    result.type = 'npm-workspaces';
+    result.workspaces = Array.isArray(pkg.workspaces) ? pkg.workspaces : (pkg.workspaces.packages || []);
+    return result;
+  }
+
+  // pnpm workspaces
+  if (fileExists(projectDir, 'pnpm-workspace.yaml')) {
+    result.detected = true;
+    result.type = 'pnpm-workspaces';
+    return result;
+  }
+
+  // Turborepo
+  if (fileExists(projectDir, 'turbo.json')) {
+    result.detected = true;
+    result.type = 'turborepo';
+    return result;
+  }
+
+  // Nx
+  if (fileExists(projectDir, 'nx.json')) {
+    result.detected = true;
+    result.type = 'nx';
+    return result;
+  }
+
+  // Lerna
+  if (fileExists(projectDir, 'lerna.json')) {
+    result.detected = true;
+    result.type = 'lerna';
+    return result;
+  }
+
+  return result;
+}
+
 function detectClaudeInfra(projectDir) {
   const infra = {
     hasClaudeMd: false,
@@ -316,6 +362,8 @@ function detectClaudeInfra(projectDir) {
     hasCommands: false,
     hasSkills: false,
     hasUAT: false,
+    hasChainproof: false,
+    devforgeVersion: null,
   };
 
   if (fileExists(projectDir, 'CLAUDE.md')) {
@@ -329,6 +377,13 @@ function detectClaudeInfra(projectDir) {
   infra.hasCommands = dirHasFiles(projectDir, '.claude/commands');
   infra.hasSkills = dirHasFiles(projectDir, '.claude/skills');
   infra.hasUAT = dirExists(projectDir, 'docs/uat');
+  infra.hasChainproof = dirExists(projectDir, '.chainproof');
+
+  // Check template version
+  const versionFile = readJsonSafe(projectDir, '.claude/.devforge-version');
+  if (versionFile?.version) {
+    infra.devforgeVersion = versionFile.version;
+  }
 
   return infra;
 }
@@ -362,7 +417,7 @@ function readJsonSafe(base, file) {
   if (!fs.existsSync(p)) return null;
   try {
     return JSON.parse(fs.readFileSync(p, 'utf-8'));
-  } catch {
+  } catch { // Malformed JSON in config file
     return null;
   }
 }