forgedev 1.0.0

package/src/cli.js

@@ -0,0 +1,119 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import chalk from 'chalk';
+import { log } from './utils.js';
+
+export async function parseCommand(args) {
+  if (args.includes('--version') || args.includes('-v')) {
+    const pkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
+    console.log(pkg.version);
+    process.exit(0);
+  }
+
+  if (args.includes('--help') || args.includes('-h')) {
+    showHelp();
+    process.exit(0);
+  }
+
+  const command = args[0];
+
+  if (!command) {
+    showUsage();
+    process.exit(0);
+  }
+
+  if (command === 'new') {
+    const projectName = args[1];
+    if (!projectName) {
+      log.error('Usage: devforge new <project-name>');
+      log.dim('  Example: devforge new my-app');
+      process.exit(1);
+    }
+    const { runNew } = await import('./index.js');
+    await runNew(projectName);
+    return;
+  }
+
+  if (command === 'init') {
+    const { runInit } = await import('./init-mode.js');
+    await runInit(process.cwd());
+    return;
+  }
+
+  if (command === 'doctor') {
+    const { runDoctor } = await import('./doctor.js');
+    await runDoctor(process.cwd());
+    return;
+  }
+
+  // Shorthand: devforge my-app → devforge new my-app
+  if (!command.startsWith('-')) {
+    const targetDir = path.resolve(process.cwd(), command);
+    if (fs.existsSync(targetDir)) {
+      console.log('');
+      log.warn(`"${command}" already exists. Did you mean:`);
+      console.log(`  ${chalk.bold('devforge init')}     Add dev guardrails to current project`);
+      console.log(`  ${chalk.bold('devforge doctor')}   Diagnose and optimize current project`);
+      console.log('');
+      process.exit(1);
+    }
+    const { runNew } = await import('./index.js');
+    await runNew(command);
+    return;
+  }
+
+  showUsage();
+}
+
+function showUsage() {
+  console.log(`
+  ${chalk.bold.cyan('DevForge')} — AI-first project scaffolding
+
+  ${chalk.bold('Usage:')}
+    devforge new <name>     Create a new project
+    devforge init           Add dev guardrails to current project
+    devforge doctor         Diagnose and optimize current project
+    devforge <name>         Shorthand for ${chalk.dim('devforge new <name>')}
+
+  ${chalk.bold('Options:')}
+    -h, --help              Show this help message
+    -v, --version           Show version number
+
+  Run ${chalk.cyan('devforge new --help')} for more details.
+`);
+}
+
+function showHelp() {
+  console.log(`
+  ${chalk.bold.cyan('DevForge')} — Universal, AI-first project scaffolding
+
+  ${chalk.bold('Commands:')}
+
+    ${chalk.bold('devforge new <name>')}
+      Create a new project. Choose between:
+      ${chalk.dim('• Guided mode — describe what you want in plain English')}
+      ${chalk.dim('• Developer mode — pick your stack directly')}
+
+    ${chalk.bold('devforge init')}
+      Add Claude Code infrastructure to an existing project.
+      Auto-detects your stack and installs hooks, agents, commands,
+      skills, and UAT templates. Zero questions asked.
+
+    ${chalk.bold('devforge doctor')}
+      Diagnose and optimize an existing project.
+      Checks for: oversized CLAUDE.md, unauthenticated endpoints,
+      flaky tests, dead code, duplicate code, and more.
+      Generates Claude Code prompts to fix each issue.
+
+  ${chalk.bold('Supported stacks (V1):')}
+    - Next.js full-stack (TypeScript + Prisma + PostgreSQL)
+    - FastAPI backend (Python + SQLAlchemy + PostgreSQL)
+    - Polyglot full-stack (Next.js + FastAPI monorepo)
+
+  ${chalk.bold('Examples:')}
+    devforge new my-app
+    devforge my-saas-platform
+    devforge init
+    devforge doctor
+`);
+}

package/src/composer.js

@@ -0,0 +1,214 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { ROOT_DIR, ensureDir, readTemplate, replaceVars, toPascalCase, toSnakeCase, log } from './utils.js';
+
+const TEMPLATES_DIR = path.join(ROOT_DIR, 'templates');
+
+export async function compose(outputDir, stackConfig) {
+  const variables = buildVariables(stackConfig);
+
+  ensureDir(outputDir);
+
+  for (const mod of stackConfig.templateModules) {
+    const templateDir = path.join(TEMPLATES_DIR, mod.path);
+    if (!fs.existsSync(templateDir)) {
+      log.warn(`Template module not found: ${mod.path} — skipping`);
+      continue;
+    }
+    processTemplateDir(templateDir, outputDir, variables, mod.prefix || '');
+  }
+
+  // Inject auth dependencies into package.json if auth is enabled
+  injectAuthDependencies(outputDir, stackConfig);
+}
+
+export function buildVariables(stackConfig) {
+  const vars = {
+    PROJECT_NAME: stackConfig.projectName,
+    PROJECT_NAME_PASCAL: toPascalCase(stackConfig.projectName),
+    PROJECT_NAME_SNAKE: toSnakeCase(stackConfig.projectName),
+  };
+
+  if (stackConfig.frontend) {
+    vars.FRONTEND_FRAMEWORK = stackConfig.frontend.framework;
+    vars.FRONTEND_LANGUAGE = stackConfig.frontend.language;
+    vars.FRONTEND_STYLING = stackConfig.frontend.styling;
+    vars.FRONTEND_UI = stackConfig.frontend.ui || '';
+  }
+
+  if (stackConfig.backend) {
+    vars.BACKEND_FRAMEWORK = stackConfig.backend.framework;
+    vars.BACKEND_LANGUAGE = stackConfig.backend.language;
+    vars.BACKEND_ORM = stackConfig.backend.orm;
+  }
+
+  if (stackConfig.database) {
+    vars.DATABASE_TYPE = stackConfig.database.type;
+    vars.DATABASE_ORM = stackConfig.database.orm;
+  }
+
+  vars.AUTH_TYPE = stackConfig.auth || 'none';
+  vars.DEPLOYMENT = stackConfig.deployment || 'docker';
+
+  // Commands vary by stack
+  if (stackConfig.stackId === 'nextjs-fullstack') {
+    vars.LINT_COMMAND = 'npx eslint .';
+    vars.TYPE_CHECK_COMMAND = 'npx tsc --noEmit';
+    vars.TEST_COMMAND = 'npx vitest run';
+    vars.BUILD_COMMAND = 'npm run build';
+    vars.DEV_COMMAND = 'npm run dev';
+    vars.STACK_DESCRIPTION = 'Next.js full-stack application with TypeScript, Tailwind CSS, Prisma, and PostgreSQL';
+    vars.EXTRA_IGNORES = '';
+  } else if (stackConfig.stackId === 'fastapi-backend') {
+    vars.LINT_COMMAND = 'ruff check .';
+    vars.TYPE_CHECK_COMMAND = 'pyright';
+    vars.TEST_COMMAND = 'pytest';
+    vars.BUILD_COMMAND = 'docker build -t app .';
+    vars.DEV_COMMAND = 'uvicorn app.main:app --reload';
+    vars.STACK_DESCRIPTION = 'FastAPI backend service with SQLAlchemy, PostgreSQL, and Alembic';
+    vars.EXTRA_IGNORES = '\n# Python\n__pycache__/\n*.pyc\nvenv/\n.venv/\n*.egg-info/';
+  } else if (stackConfig.stackId === 'polyglot-fullstack') {
+    vars.LINT_COMMAND = 'cd frontend && npx eslint . && cd ../backend && ruff check .';
+    vars.TYPE_CHECK_COMMAND = 'cd frontend && npx tsc --noEmit';
+    vars.TEST_COMMAND = 'cd frontend && npx vitest run && cd ../backend && pytest';
+    vars.BUILD_COMMAND = 'docker compose build';
+    vars.DEV_COMMAND = 'docker compose up';
+    vars.STACK_DESCRIPTION = 'Full-stack application with Next.js frontend and FastAPI backend';
+    vars.EXTRA_IGNORES = '\n# Python\n__pycache__/\n*.pyc\nvenv/\n.venv/\n*.egg-info/';
+  }
+
+  // Setup commands for README
+  vars.SETUP_COMMANDS = buildSetupCommands(stackConfig);
+  vars.AVAILABLE_SCRIPTS = buildAvailableScripts(stackConfig);
+
+  return vars;
+}
+
+function buildSetupCommands(config) {
+  if (config.stackId === 'nextjs-fullstack') {
+    return `npm install
+cp .env.example .env
+npx prisma db push
+npm run dev`;
+  }
+  if (config.stackId === 'fastapi-backend') {
+    return `cd backend
+python -m venv venv
+source venv/bin/activate
+pip install -r requirements.txt
+cp .env.example .env
+uvicorn app.main:app --reload`;
+  }
+  if (config.stackId === 'polyglot-fullstack') {
+    return `docker compose up -d postgres
+# Frontend
+cd frontend && npm install && npm run dev
+# Backend
+cd backend && pip install -r requirements.txt && uvicorn app.main:app --reload`;
+  }
+  return '';
+}
+
+function buildAvailableScripts(config) {
+  if (config.stackId === 'nextjs-fullstack') {
+    return `- \`npm run dev\` — Start development server
+- \`npm run build\` — Production build
+- \`npm run lint\` — Run ESLint
+- \`npx prisma studio\` — Database GUI
+- \`npx vitest\` — Run unit tests
+- \`npx playwright test\` — Run E2E tests`;
+  }
+  if (config.stackId === 'fastapi-backend') {
+    return `- \`uvicorn app.main:app --reload\` — Start dev server
+- \`pytest\` — Run tests
+- \`ruff check .\` — Run linter
+- \`alembic upgrade head\` — Run migrations`;
+  }
+  if (config.stackId === 'polyglot-fullstack') {
+    return `- \`docker compose up\` — Start all services
+- \`docker compose up -d postgres\` — Start database only
+- Frontend: \`cd frontend && npm run dev\`
+- Backend: \`cd backend && uvicorn app.main:app --reload\``;
+  }
+  return '';
+}
+
+export function processTemplateDir(templateDir, outputDir, variables, prefix) {
+  const entries = walkDir(templateDir);
+
+  for (const filePath of entries) {
+    const relativePath = path.relative(templateDir, filePath);
+    let outputRelative = prefix ? path.join(prefix, relativePath) : relativePath;
+
+    if (outputRelative.endsWith('.template')) {
+      // Process template: replace vars, strip .template extension
+      const content = readTemplate(filePath);
+      const processed = replaceVars(content, variables);
+      const outputPath = path.join(outputDir, outputRelative.replace(/\.template$/, ''));
+      ensureDir(path.dirname(outputPath));
+      fs.writeFileSync(outputPath, processed, 'utf-8');
+    } else if (path.basename(filePath) === '.gitkeep') {
+      // Create the directory but don't copy .gitkeep itself
+      ensureDir(path.join(outputDir, path.dirname(outputRelative)));
+    } else {
+      // Binary copy
+      const outputPath = path.join(outputDir, outputRelative);
+      ensureDir(path.dirname(outputPath));
+      fs.copyFileSync(filePath, outputPath);
+    }
+  }
+}
+
+function walkDir(dir) {
+  const results = [];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walkDir(fullPath));
+    } else {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+function injectAuthDependencies(outputDir, stackConfig) {
+  if (!stackConfig.auth || stackConfig.auth === 'none') return;
+
+  // Next.js projects with nextauth
+  if (stackConfig.auth === 'nextauth' || stackConfig.auth === 'both') {
+    const pkgPaths = [
+      path.join(outputDir, 'package.json'),
+      path.join(outputDir, 'frontend', 'package.json'),
+    ];
+    for (const pkgPath of pkgPaths) {
+      if (!fs.existsSync(pkgPath)) continue;
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+      pkg.dependencies = pkg.dependencies || {};
+      pkg.dependencies['next-auth'] = '^5.0.0-beta.25';
+      pkg.dependencies['@auth/prisma-adapter'] = '^2.7.4';
+      pkg.dependencies['bcryptjs'] = '^2.4.3';
+      pkg.devDependencies = pkg.devDependencies || {};
+      pkg.devDependencies['@types/bcryptjs'] = '^2.4.6';
+      fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8');
+    }
+  }
+
+  // FastAPI projects with jwt-custom
+  if (stackConfig.auth === 'jwt-custom' || stackConfig.auth === 'both') {
+    const reqPaths = [
+      path.join(outputDir, 'requirements.txt'),
+      path.join(outputDir, 'backend', 'requirements.txt'),
+    ];
+    for (const reqPath of reqPaths) {
+      if (!fs.existsSync(reqPath)) continue;
+      const content = fs.readFileSync(reqPath, 'utf-8');
+      const authDeps = ['python-jose[cryptography]', 'passlib[bcrypt]', 'python-multipart'];
+      const additions = authDeps.filter(dep => !content.includes(dep.split('[')[0]));
+      if (additions.length > 0) {
+        fs.writeFileSync(reqPath, content.trimEnd() + '\n' + additions.join('\n') + '\n', 'utf-8');
+      }
+    }
+  }
+}