forgedev 1.0.0

package/src/prompts.js

@@ -0,0 +1,155 @@
+import { select, confirm, checkbox, input } from '@inquirer/prompts';
+import { log } from './utils.js';
+import { formatStackSummary } from './recommender.js';
+
+const SERVICE_TYPES = [
+  { value: 'web_app', name: '1. Web app (SPA / SSR / static)', description: 'Single page app, server-rendered, or static site' },
+  { value: 'api_service', name: '2. API / backend service', description: 'REST or GraphQL API without a frontend' },
+  { value: 'full_stack', name: '3. Full-stack app (frontend + backend)', description: 'Frontend and backend in one project' },
+  { value: 'mobile', name: '4. Mobile app (cross-platform)', description: 'React Native / Expo' },
+  { value: 'cli_tool', name: '5. CLI tool / utility', description: 'Command-line tool' },
+  { value: 'ai_service', name: '6. AI/ML powered service', description: 'Service with LLM or ML integration' },
+  { value: 'desktop', name: '7. Desktop app', description: 'Tauri or Electron desktop app' },
+  { value: 'extension', name: '8. Browser extension', description: 'Chrome / Firefox extension' },
+  { value: 'microservice', name: '9. Microservice / serverless', description: 'Lambda, Cloud Functions, etc.' },
+];
+
+const LANGUAGE_CHOICES = [
+  { value: 'typescript', name: 'TypeScript' },
+  { value: 'python', name: 'Python' },
+  { value: 'go', name: 'Go' },
+  { 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)' },
+    ],
+  });
+  return mode;
+}
+
+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 ',
+  });
+  return description;
+}
+
+export async function askAdjustment() {
+  const adjustment = await input({
+    message: 'What would you like to change?',
+  });
+  return adjustment;
+}
+
+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' },
+    ],
+  });
+  return choice;
+}
+
+export async function askDoctorAction() {
+  const action = await select({
+    message: 'What would you like to do?',
+    choices: [
+      { value: 'guided', name: '🚑 Fix critical issues (guided, one at a time)' },
+      { value: 'report', name: '📋 Generate a full report (save to docs/doctor-report.md)' },
+      { value: 'autofix', name: '⚡ Auto-fix what\'s safe to auto-fix' },
+      { value: 'prompts', name: '📖 Just show me what to do (generates prompts I can run in Claude Code)' },
+    ],
+  });
+  return action;
+}
+
+export async function askServiceType() {
+  const serviceType = await select({
+    message: 'What are you building?',
+    choices: SERVICE_TYPES,
+  });
+  return serviceType;
+}
+
+export async function askRefinements(serviceType) {
+  const refinements = {};
+
+  // Q1: Language preference — adapt choices based on service type
+  if (['api_service', 'cli_tool', 'microservice'].includes(serviceType)) {
+    refinements.language = await select({
+      message: 'Language preference?',
+      choices: LANGUAGE_CHOICES,
+    });
+  } else if (['full_stack', 'ai_service'].includes(serviceType)) {
+    refinements.language = await select({
+      message: 'Backend language?',
+      choices: [
+        { value: 'typescript', name: 'TypeScript (same as frontend)' },
+        { value: 'python', name: 'Python (polyglot: Next.js + Python backend)' },
+      ],
+    });
+  } else if (['web_app'].includes(serviceType)) {
+    refinements.language = 'typescript';
+  }
+
+  // Q2: Authentication
+  if (!['cli_tool', 'describe'].includes(serviceType)) {
+    refinements.auth = await confirm({
+      message: 'Need authentication?',
+      default: false,
+    });
+  }
+
+  // Q3: Additional features (combined into one multi-select)
+  const isAI = serviceType === 'ai_service';
+  const featureChoices = [];
+  if (serviceType !== 'cli_tool') {
+    featureChoices.push({ value: 'realtime', name: 'Real-time updates (WebSockets)' });
+    featureChoices.push({ value: 'fileUploads', name: 'File uploads' });
+  }
+  featureChoices.push({ value: 'ai', name: 'AI/LLM integration', checked: isAI });
+
+  if (featureChoices.length > 0) {
+    const selected = await checkbox({
+      message: 'Additional features? (space to toggle, enter to continue)',
+      choices: featureChoices,
+    });
+    refinements.ai = selected.includes('ai');
+    refinements.fileUploads = selected.includes('fileUploads');
+    refinements.realtime = selected.includes('realtime');
+  }
+
+  // Defaults: always include Claude Code, default to docker
+  refinements.deployment = 'docker';
+  refinements.claudeCode = true;
+
+  return refinements;
+}
+
+export async function confirmStack(stackConfig) {
+  const summary = formatStackSummary(stackConfig);
+  console.log('');
+  log.info('Recommended stack:');
+  console.log(summary);
+  console.log('');
+
+  const confirmed = await confirm({
+    message: 'Proceed with this stack?',
+    default: true,
+  });
+  return confirmed;
+}

package/src/recommender.js

@@ -0,0 +1,186 @@
+import chalk from 'chalk';
+
+export const SUPPORTED_STACKS = ['nextjs-fullstack', 'fastapi-backend', 'polyglot-fullstack'];
+
+export function recommend(serviceType, refinements) {
+  const config = {
+    projectName: null, // set by caller
+    serviceType,
+    frontend: null,
+    backend: null,
+    database: null,
+    auth: null,
+    testing: { unit: null, e2e: null, backend: null },
+    ai: refinements.ai || false,
+    realtime: refinements.realtime || false,
+    fileUploads: refinements.fileUploads || false,
+    deployment: refinements.deployment || 'docker',
+    claudeCode: refinements.claudeCode !== false,
+    templateModules: [],
+    stackId: null,
+  };
+
+  const lang = refinements.language || 'typescript';
+
+  switch (serviceType) {
+    case 'web_app':
+      return buildNextjsFullstack(config, refinements);
+
+    case 'full_stack':
+      if (lang === 'python') {
+        return buildPolyglotFullstack(config, refinements);
+      }
+      return buildNextjsFullstack(config, refinements);
+
+    case 'api_service':
+      if (lang === 'python') {
+        return buildFastapiBackend(config, refinements);
+      }
+      return unsupported(serviceType, lang, 'FastAPI (Python)');
+
+    case 'ai_service':
+      if (lang === 'python') {
+        return buildPolyglotFullstack(config, { ...refinements, ai: true });
+      }
+      return buildPolyglotFullstack(config, { ...refinements, ai: true, language: 'python' });
+
+    case 'mobile':
+    case 'cli_tool':
+    case 'desktop':
+    case 'extension':
+    case 'microservice':
+    case 'describe':
+      return unsupported(serviceType, lang);
+
+    default:
+      return unsupported(serviceType, lang);
+  }
+}
+
+function buildNextjsFullstack(config, refinements) {
+  config.stackId = 'nextjs-fullstack';
+  config.frontend = { framework: 'nextjs', language: 'typescript', styling: 'tailwind', ui: 'shadcn' };
+  config.backend = { framework: 'nextjs', language: 'typescript', orm: 'prisma' };
+  config.database = { type: 'postgresql', orm: 'prisma' };
+  config.testing = { unit: 'vitest', e2e: 'playwright', backend: null };
+
+  if (refinements.auth) {
+    config.auth = 'nextauth';
+  }
+
+  config.templateModules = [
+    { path: 'base', prefix: '' },
+    { path: 'frontend/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: '' },
+  ];
+
+  if (refinements.auth) {
+    config.templateModules.push({ path: 'auth/nextauth', prefix: '' });
+  }
+
+  return config;
+}
+
+function buildFastapiBackend(config, refinements) {
+  config.stackId = 'fastapi-backend';
+  config.frontend = null;
+  config.backend = { framework: 'fastapi', language: 'python', orm: 'sqlalchemy' };
+  config.database = { type: 'postgresql', orm: 'sqlalchemy' };
+  config.testing = { unit: null, e2e: null, backend: 'pytest' };
+
+  if (refinements.auth) {
+    config.auth = 'jwt-custom';
+  }
+
+  config.templateModules = [
+    { path: 'base', prefix: '' },
+    { path: 'backend/fastapi', prefix: '' },
+    { path: 'database/sqlalchemy-postgres', prefix: '' },
+    { path: 'testing/pytest', prefix: '' },
+    { path: 'infra/docker-compose', prefix: '' },
+    { path: 'infra/github-actions', prefix: '' },
+  ];
+
+  if (refinements.auth) {
+    config.templateModules.push({ path: 'auth/jwt-custom', prefix: '' });
+  }
+
+  return config;
+}
+
+function buildPolyglotFullstack(config, refinements) {
+  config.stackId = 'polyglot-fullstack';
+  config.frontend = { framework: 'nextjs', language: 'typescript', styling: 'tailwind', ui: 'shadcn' };
+  config.backend = { framework: 'fastapi', language: 'python', orm: 'sqlalchemy' };
+  config.database = { type: 'postgresql', orm: 'both' };
+  config.testing = { unit: 'vitest', e2e: 'playwright', backend: 'pytest' };
+  config.ai = refinements.ai || false;
+
+  if (refinements.auth) {
+    config.auth = 'both';
+  }
+
+  config.templateModules = [
+    { path: 'base', prefix: '' },
+    { path: 'frontend/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: '' },
+  ];
+
+  if (refinements.auth) {
+    config.templateModules.push({ path: 'auth/nextauth', prefix: 'frontend' });
+    config.templateModules.push({ path: 'auth/jwt-custom', prefix: '' });
+  }
+
+  return config;
+}
+
+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 };
+}
+
+export function formatStackSummary(config) {
+  if (config.supported === false) {
+    return chalk.yellow(config.message);
+  }
+
+  const lines = [];
+
+  if (config.frontend) {
+    lines.push(`  ${chalk.bold('Frontend:')}  ${config.frontend.framework} + ${config.frontend.language} + ${config.frontend.styling} + ${config.frontend.ui}`);
+  }
+  if (config.backend) {
+    lines.push(`  ${chalk.bold('Backend:')}   ${config.backend.framework} + ${config.backend.language} + ${config.backend.orm}`);
+  }
+  if (config.database) {
+    lines.push(`  ${chalk.bold('Database:')}  ${config.database.type} (${config.database.orm})`);
+  }
+  if (config.auth) {
+    lines.push(`  ${chalk.bold('Auth:')}      ${config.auth}`);
+  }
+
+  const testParts = [config.testing.unit, config.testing.e2e, config.testing.backend].filter(Boolean);
+  if (testParts.length) {
+    lines.push(`  ${chalk.bold('Testing:')}   ${testParts.join(' + ')}`);
+  }
+
+  lines.push(`  ${chalk.bold('Deploy:')}    ${config.deployment}`);
+
+  if (config.ai) lines.push(`  ${chalk.bold('AI:')}        enabled`);
+  if (config.claudeCode) lines.push(`  ${chalk.bold('Claude:')}    CLAUDE.md + hooks + skills + agents + commands`);
+
+  return lines.join('\n');
+}