contextforge-cli-ai-prompt-pirates 0.4.0

package/src/detectors/architecture.js

@@ -0,0 +1,117 @@
+const PATTERNS = [
+  {
+    pattern: 'mvc',
+    label: 'MVC',
+    confidence: 'high',
+    test: (dirs) =>
+      dirs.has('controllers') && dirs.has('models') && (dirs.has('routes') || dirs.has('views')),
+  },
+  {
+    pattern: 'feature-based',
+    label: 'Feature-based',
+    confidence: 'high',
+    test: (dirs) => dirs.has('features') || dirs.has('modules'),
+  },
+  {
+    pattern: 'next-app-router',
+    label: 'Next.js App Router',
+    confidence: 'high',
+    test: (dirs, paths) =>
+      dirs.has('app') && paths.some((p) => p.startsWith('app/') && /layout\.(tsx?|jsx?)$/.test(p)),
+  },
+  {
+    pattern: 'pages-router',
+    label: 'Next.js Pages Router',
+    confidence: 'medium',
+    test: (dirs) => dirs.has('pages') && !dirs.has('app'),
+  },
+  {
+    pattern: 'layered',
+    label: 'Layered (services/controllers)',
+    confidence: 'medium',
+    test: (dirs) =>
+      (dirs.has('services') && dirs.has('controllers')) ||
+      (dirs.has('services') && dirs.has('routes')),
+  },
+  {
+    pattern: 'monolith',
+    label: 'Monolithic single-package',
+    confidence: 'low',
+    test: (dirs) => dirs.has('src') && !dirs.has('packages'),
+  },
+  {
+    pattern: 'microservices',
+    label: 'Multi-package / microservices',
+    confidence: 'medium',
+    test: (_dirs, paths) => {
+      const servicePackages = paths.filter(
+        (p) => /^services\/[^/]+\/package\.json$/i.test(p) || /^packages\/[^/]+\/package\.json$/i.test(p)
+      );
+      return servicePackages.length >= 2;
+    },
+  },
+  {
+    pattern: 'clean-architecture',
+    label: 'Clean Architecture',
+    confidence: 'medium',
+    test: (dirs) =>
+      dirs.has('domain') || dirs.has('use-cases') || dirs.has('infrastructure'),
+  },
+];
+
+/**
+ * @param {string[]} relativePaths
+ */
+export function analyzeArchitecture(relativePaths) {
+  const dirs = new Set();
+  const normalized = relativePaths.map((p) => p.replace(/\\/g, '/'));
+
+  for (const p of normalized) {
+    const top = p.split('/')[0];
+    if (top && !top.includes('.')) dirs.add(top);
+    const parts = p.split('/');
+    if (parts.length >= 2 && !parts[1].includes('.')) {
+      dirs.add(parts[1]);
+    }
+  }
+
+  const matches = [];
+
+  for (const { pattern, label, confidence, test } of PATTERNS) {
+    if (test(dirs, normalized)) {
+      matches.push({ pattern, label, confidence });
+    }
+  }
+
+  const primary = matches[0] || {
+    pattern: 'unknown',
+    label: 'Standard src-based layout',
+    confidence: 'low',
+  };
+
+  const folderHierarchy = [...dirs].sort().slice(0, 20);
+
+  let apiFlow = null;
+  if (matches.some((m) => m.pattern === 'mvc' || m.pattern === 'layered')) {
+    apiFlow = 'Client → Route → Controller → Service → Database';
+  } else if (matches.some((m) => m.pattern === 'next-app-router')) {
+    apiFlow = 'Browser → app/ routes → Server Components / API routes → Data layer';
+  }
+
+  return {
+    primary: {
+      pattern: primary.pattern,
+      label: primary.label,
+      confidence: primary.confidence,
+      displayLabel: `Likely ${primary.label}`,
+    },
+    allMatches: matches.map((m) => ({
+      ...m,
+      displayLabel: `Likely ${m.label}`,
+    })),
+    folderHierarchy,
+    apiFlow,
+    dependencyFlow: null,
+    signals: matches.map((m) => m.pattern),
+  };
+}

package/src/detectors/auth-deploy.js

@@ -0,0 +1,51 @@
+/**
+ * @param {ReturnType<import('./tech-stack.js').detectTechStack>} techStack
+ * @param {Awaited<ReturnType<import('../scanner/config-files.js').findConfigFiles>>} configFiles
+ * @param {string[]} relativePaths
+ */
+export function detectAuthAndDeploy(techStack, configFiles, relativePaths) {
+  const auth = [...(techStack.auth || [])];
+  const deploy = [...(techStack.deploy || [])];
+  const hints = [];
+
+  const paths = relativePaths.map((p) => p.replace(/\\/g, '/').toLowerCase());
+
+  if (paths.some((p) => p.includes('middleware') && p.includes('auth'))) {
+    hints.push('Auth middleware detected in project structure');
+  }
+
+  if (paths.some((p) => p.includes('passport'))) {
+    if (!auth.includes('Passport')) auth.push('Passport');
+  }
+
+  if (paths.some((p) => /vercel\.json/i.test(p))) {
+    deploy.push('Vercel');
+    hints.push('vercel.json configuration found');
+  }
+
+  if (paths.some((p) => /netlify\.toml/i.test(p))) {
+    deploy.push('Netlify');
+  }
+
+  if (configFiles.parsed.dockerfile || configFiles.parsed.dockerCompose) {
+    if (!deploy.includes('Docker')) deploy.push('Docker');
+  }
+
+  if (configFiles.parsed.nginx) {
+    if (!deploy.includes('Nginx')) deploy.push('Nginx');
+  }
+
+  const sessionPatterns = paths.filter((p) =>
+    p.includes('session') || p.includes('cookie')
+  );
+  if (sessionPatterns.length && !auth.length) {
+    auth.push('Session-based auth (possible)');
+    hints.push('Session/cookie related files detected');
+  }
+
+  return {
+    authentication: [...new Set(auth)],
+    deployment: [...new Set(deploy)],
+    hints,
+  };
+}

package/src/detectors/database.js

@@ -0,0 +1,127 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+
+function parsePrismaSchema(content) {
+  const models = [];
+  const enums = [];
+  let provider = null;
+
+  const datasourceMatch = content.match(/datasource\s+\w+\s*\{[^}]*provider\s*=\s*"([^"]+)"/s);
+  if (datasourceMatch) provider = datasourceMatch[1];
+
+  const modelRegex = /model\s+(\w+)\s*\{([^}]*)\}/gs;
+  let match;
+  while ((match = modelRegex.exec(content)) !== null) {
+    const name = match[1];
+    const body = match[2];
+    const fields = [];
+    for (const line of body.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('@@')) continue;
+      const fieldMatch = trimmed.match(/^(\w+)\s+/);
+      if (fieldMatch && !['model', 'enum'].includes(fieldMatch[1])) {
+        fields.push(fieldMatch[1]);
+      }
+    }
+    const relationFields = [];
+    for (const line of body.split('\n')) {
+      const relMatch = line.match(/(\w+)\s+.*@relation/);
+      if (relMatch) relationFields.push(relMatch[1]);
+    }
+    const relations = body.match(/@relation/g) || [];
+    models.push({
+      name,
+      fields: fields.slice(0, 15),
+      relationCount: relations.length,
+      relations: relationFields,
+    });
+  }
+
+  const enumRegex = /enum\s+(\w+)/g;
+  let enumMatch;
+  while ((enumMatch = enumRegex.exec(content)) !== null) {
+    enums.push(enumMatch[1]);
+  }
+
+  return { provider, models, enums };
+}
+
+function parseMongooseStub(content, filename) {
+  const schemaMatch = content.match(/mongoose\.Schema\s*\(\s*\{([^}]+)\}/s);
+  if (!schemaMatch) return null;
+  const fields = [...schemaMatch[1].matchAll(/(\w+)\s*:/g)].map((m) => m[1]);
+  const name = path.basename(filename).replace(/\.(js|ts)$/, '');
+  return { name, fields: fields.slice(0, 15), source: filename };
+}
+
+/**
+ * @param {string} projectRoot
+ * @param {string[]} relativePaths
+ */
+export async function extractDatabaseInfo(projectRoot, relativePaths) {
+  const result = {
+    orm: null,
+    provider: null,
+    models: [],
+    enums: [],
+    migrations: [],
+    textDiagram: null,
+  };
+
+  const prismaPaths = relativePaths.filter((p) =>
+    p.replace(/\\/g, '/').endsWith('schema.prisma')
+  );
+
+  for (const rel of prismaPaths) {
+    const full = path.join(projectRoot, rel);
+    try {
+      const content = await fs.readFile(full, 'utf8');
+      const parsed = parsePrismaSchema(content);
+      result.orm = 'Prisma';
+      result.provider = parsed.provider;
+      result.models.push(...parsed.models);
+      result.enums.push(...parsed.enums);
+    } catch {
+      /* skip */
+    }
+  }
+
+  const migrationDirs = relativePaths.filter((p) =>
+    /migrations?\/|prisma\/migrations/i.test(p)
+  );
+  result.migrations = migrationDirs.slice(0, 10);
+
+  const modelFiles = relativePaths.filter((p) =>
+    /models?\/.*\.(js|ts)$/i.test(p) && !p.includes('node_modules')
+  );
+
+  for (const rel of modelFiles.slice(0, 15)) {
+    const full = path.join(projectRoot, rel);
+    try {
+      const content = await fs.readFile(full, 'utf8');
+      if (content.includes('mongoose')) {
+        const stub = parseMongooseStub(content, rel);
+        if (stub) {
+          result.orm = result.orm || 'Mongoose';
+          result.models.push(stub);
+        }
+      }
+    } catch {
+      /* skip */
+    }
+  }
+
+  if (result.models.length > 0) {
+    result.textDiagram = result.models
+      .map((m) => {
+        const lines = (m.fields || []).map((f) => ` ├── ${f}`);
+        if (m.relations?.length) {
+          lines.push(` └── relations: ${m.relations.join(', ')}`);
+        }
+        return `${m.name}\n${lines.join('\n') || ' ├── (fields)'}`;
+      })
+      .join('\n\n');
+  }
+
+  return result;
+}

package/src/detectors/tech-stack.js

@@ -0,0 +1,180 @@
+const DEP_MAP = {
+  react: { label: 'React', category: 'frontend' },
+  'react-dom': { label: 'React', category: 'frontend' },
+  next: { label: 'Next.js', category: 'frontend' },
+  vue: { label: 'Vue', category: 'frontend' },
+  nuxt: { label: 'Nuxt', category: 'frontend' },
+  '@angular/core': { label: 'Angular', category: 'frontend' },
+  vite: { label: 'Vite', category: 'frontend' },
+  express: { label: 'Express.js', category: 'backend' },
+  '@nestjs/core': { label: 'NestJS', category: 'backend' },
+  fastify: { label: 'Fastify', category: 'backend' },
+  koa: { label: 'Koa', category: 'backend' },
+  mongoose: { label: 'Mongoose', category: 'database' },
+  mongodb: { label: 'MongoDB', category: 'database' },
+  pg: { label: 'PostgreSQL', category: 'database' },
+  mysql2: { label: 'MySQL', category: 'database' },
+  'better-sqlite3': { label: 'SQLite', category: 'database' },
+  ioredis: { label: 'Redis', category: 'database' },
+  redis: { label: 'Redis', category: 'database' },
+  '@prisma/client': { label: 'Prisma', category: 'orm' },
+  prisma: { label: 'Prisma', category: 'orm' },
+  sequelize: { label: 'Sequelize', category: 'orm' },
+  typeorm: { label: 'TypeORM', category: 'orm' },
+  tailwindcss: { label: 'TailwindCSS', category: 'styling' },
+  bootstrap: { label: 'Bootstrap', category: 'styling' },
+  '@mui/material': { label: 'Material UI', category: 'styling' },
+  '@chakra-ui/react': { label: 'Chakra UI', category: 'styling' },
+  '@reduxjs/toolkit': { label: 'Redux Toolkit', category: 'state' },
+  redux: { label: 'Redux', category: 'state' },
+  zustand: { label: 'Zustand', category: 'state' },
+  mobx: { label: 'MobX', category: 'state' },
+  jsonwebtoken: { label: 'JWT', category: 'auth' },
+  passport: { label: 'Passport', category: 'auth' },
+  '@clerk/clerk-sdk-node': { label: 'Clerk', category: 'auth' },
+  '@auth0/auth0-react': { label: 'Auth0', category: 'auth' },
+  'firebase-admin': { label: 'Firebase Auth', category: 'auth' },
+  axios: { label: 'Axios', category: 'http' },
+  'simple-git': { label: 'Git (simple-git)', category: 'backend' },
+  'fs-extra': { label: 'fs-extra', category: 'backend' },
+  glob: { label: 'glob', category: 'backend' },
+  commander: { label: 'CLI (commander)', category: 'backend' },
+  chokidar: { label: 'File watcher (chokidar)', category: 'backend' },
+  vitest: { label: 'Vitest', category: 'testing' },
+  jest: { label: 'Jest', category: 'testing' },
+  mocha: { label: 'Mocha', category: 'testing' },
+  '@playwright/test': { label: 'Playwright', category: 'testing' },
+  cypress: { label: 'Cypress', category: 'testing' },
+  'react-router-dom': { label: 'React Router', category: 'frontend' },
+  '@tanstack/react-query': { label: 'TanStack Query', category: 'frontend' },
+  hono: { label: 'Hono', category: 'backend' },
+  '@hono/node-server': { label: 'Hono', category: 'backend' },
+  'socket.io': { label: 'Socket.io', category: 'backend' },
+  ws: { label: 'WebSocket (ws)', category: 'backend' },
+  cors: { label: 'CORS', category: 'backend' },
+  bcryptjs: { label: 'bcrypt', category: 'auth' },
+  bcrypt: { label: 'bcrypt', category: 'auth' },
+  'cookie-parser': { label: 'Cookie sessions', category: 'auth' },
+  'express-session': { label: 'Express sessions', category: 'auth' },
+  supabase: { label: 'Supabase', category: 'database' },
+  '@supabase/supabase-js': { label: 'Supabase', category: 'database' },
+  firebase: { label: 'Firebase', category: 'database' },
+  'drizzle-orm': { label: 'Drizzle ORM', category: 'orm' },
+  '@drizzle-team/kit': { label: 'Drizzle ORM', category: 'orm' },
+  knex: { label: 'Knex', category: 'orm' },
+  'react-native': { label: 'React Native', category: 'frontend' },
+  electron: { label: 'Electron', category: 'frontend' },
+  svelte: { label: 'Svelte', category: 'frontend' },
+  '@sveltejs/kit': { label: 'SvelteKit', category: 'frontend' },
+  remix: { label: 'Remix', category: 'frontend' },
+  '@remix-run/node': { label: 'Remix', category: 'frontend' },
+  turbo: { label: 'Turborepo', category: 'deploy' },
+  nx: { label: 'Nx monorepo', category: 'deploy' },
+  lerna: { label: 'Lerna monorepo', category: 'deploy' },
+  dotenv: { label: 'dotenv', category: 'backend' },
+  openai: { label: 'OpenAI SDK', category: 'backend' },
+  '@anthropic-ai/sdk': { label: 'Anthropic SDK', category: 'backend' },
+};
+
+const CONFIG_SIGNALS = [
+  { key: 'vite', label: 'Vite', category: 'frontend' },
+  { key: 'next', label: 'Next.js', category: 'frontend' },
+  { key: 'tailwind', label: 'TailwindCSS', category: 'styling' },
+  { key: 'prisma', label: 'Prisma', category: 'orm' },
+  { key: 'dockerfile', label: 'Docker', category: 'deploy' },
+  { key: 'dockerCompose', label: 'Docker Compose', category: 'deploy' },
+  { key: 'nginx', label: 'Nginx', category: 'deploy' },
+];
+
+function addUnique(arr, item) {
+  if (!arr.includes(item)) arr.push(item);
+}
+
+/**
+ * @param {import('../scanner/config-files.js').findConfigFiles extends Function ? Awaited<ReturnType<typeof import('../scanner/config-files.js').findConfigFiles>> : never} configFiles
+ * @param {string[]} relativePaths
+ */
+export function detectTechStack(configFiles, relativePaths) {
+  const stack = {
+    frontend: [],
+    backend: [],
+    database: [],
+    orm: [],
+    styling: [],
+    state: [],
+    auth: [],
+    deploy: [],
+    http: [],
+    testing: [],
+    confidence: 'medium',
+    signals: [],
+    packageJsonCount: 0,
+  };
+
+  const pkg = configFiles.packageJson;
+  const allDeps = { ...(configFiles.mergedDependencies || {}) };
+
+  if (!Object.keys(allDeps).length && pkg) {
+    Object.assign(allDeps, pkg.dependencies || {}, pkg.devDependencies || {}, pkg.peerDependencies || {});
+  }
+
+  const pkgJsonPaths = relativePaths.filter((p) =>
+    p.replace(/\\/g, '/').endsWith('package.json')
+  );
+  stack.packageJsonCount = Math.max(1, pkgJsonPaths.length);
+
+  if (pkg) {
+    if (pkg.name) stack.projectName = pkg.name;
+    if (pkg.description) stack.description = pkg.description;
+    stack.confidence = 'high';
+
+    if (pkg.bin || pkg.type === 'module') {
+      addUnique(stack.backend, 'Node.js');
+      stack.signals.push('package:node-cli');
+    }
+    if (pkg.engines?.node) {
+      addUnique(stack.backend, 'Node.js');
+    }
+  }
+
+  for (const [dep, meta] of Object.entries(DEP_MAP)) {
+    if (allDeps[dep]) {
+      const cat = meta.category in stack ? meta.category : 'backend';
+      addUnique(stack[cat], meta.label);
+      stack.signals.push(`dependency:${dep}`);
+    }
+  }
+
+  for (const depName of Object.keys(allDeps)) {
+    if (DEP_MAP[depName]) continue;
+    const lower = depName.toLowerCase();
+    if (/^@types\//.test(depName)) continue;
+    if (lower.includes('eslint') || lower.includes('prettier')) continue;
+    if (lower.includes('typescript') && lower !== 'typescript') continue;
+    stack.signals.push(`dependency:unmapped:${depName}`);
+  }
+
+  for (const { key, label, category } of CONFIG_SIGNALS) {
+    if (configFiles.parsed[key]) {
+      const cat = category in stack ? category : 'frontend';
+      addUnique(stack[cat], label);
+      stack.signals.push(`config:${key}`);
+    }
+  }
+
+  const normalizedPaths = relativePaths.map((p) => p.replace(/\\/g, '/'));
+  if (normalizedPaths.some((p) => p.startsWith('app/') && p.includes('layout.'))) {
+    addUnique(stack.frontend, 'Next.js App Router');
+    stack.signals.push('folder:app-router');
+  }
+
+  if (stack.frontend.length && stack.backend.length) {
+    stack.confidence = 'high';
+  } else if (stack.frontend.length || stack.backend.length) {
+    stack.confidence = 'medium';
+  } else {
+    stack.confidence = 'low';
+  }
+
+  return stack;
+}

package/src/generators/artifacts.js

@@ -0,0 +1,44 @@
+import fs from 'fs-extra';
+import { getOutputPath, OUTPUT_FILES } from '../core/paths.js';
+
+/**
+ * @param {string} projectRoot
+ * @param {ReturnType<import('./context-json.js').buildContextSnapshot>} snapshot
+ */
+export async function writeArtifacts(projectRoot, snapshot) {
+  await fs.writeJson(
+    getOutputPath(projectRoot, OUTPUT_FILES.contextJson),
+    snapshot,
+    { spaces: 2 }
+  );
+
+  await fs.writeJson(
+    getOutputPath(projectRoot, OUTPUT_FILES.architectureJson),
+    {
+      generatedAt: snapshot.generatedAt,
+      primary: snapshot.architecture.primary,
+      allMatches: snapshot.architecture.allMatches,
+      apiFlow: snapshot.architecture.apiFlow,
+      folderHierarchy: snapshot.architecture.folderHierarchy,
+    },
+    { spaces: 2 }
+  );
+
+  await fs.writeJson(
+    getOutputPath(projectRoot, OUTPUT_FILES.gitInsightsJson),
+    {
+      generatedAt: snapshot.generatedAt,
+      ...snapshot.git,
+    },
+    { spaces: 2 }
+  );
+
+  await fs.writeJson(
+    getOutputPath(projectRoot, OUTPUT_FILES.bugsReportJson),
+    {
+      generatedAt: snapshot.generatedAt,
+      ...snapshot.bugs,
+    },
+    { spaces: 2 }
+  );
+}

package/src/generators/changes-markdown.js

@@ -0,0 +1,72 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+import { getContextForgeRoot } from '../core/paths.js';
+
+/**
+ * Write standalone CHANGES.md for change tracking over time.
+ */
+export async function writeChangesMarkdown(projectRoot, changelog, history) {
+  const outPath = path.join(getContextForgeRoot(projectRoot), 'CHANGES.md');
+
+  let md = `# ContextForge — Change Log
+
+> Auto-updated when you run \`generate\` or \`watch\`.  
+> Last run: **${changelog.runAt}**
+
+---
+
+## Latest run
+
+**Status:** ${changelog.hasChanges ? 'Changes detected' : 'No changes'}
+
+${changelog.summary}
+
+`;
+
+  if (changelog.previousRunAt) {
+    md += `**Previous run:** ${changelog.previousRunAt}\n\n`;
+  }
+
+  if (changelog.addedFiles?.length) {
+    md += `### New files (${changelog.addedFiles.length})\n\n`;
+    md += changelog.addedFiles.slice(0, 30).map((f) => `- \`${f}\``).join('\n');
+    if (changelog.addedFiles.length > 30) md += `\n- _...and ${changelog.addedFiles.length - 30} more_`;
+    md += '\n\n';
+  }
+
+  if (changelog.modifiedFiles?.length) {
+    md += `### Modified files (${changelog.modifiedFiles.length})\n\n`;
+    md += changelog.modifiedFiles.slice(0, 30).map((f) => `- \`${f}\``).join('\n');
+    if (changelog.modifiedFiles.length > 30) md += `\n- _...and ${changelog.modifiedFiles.length - 30} more_`;
+    md += '\n\n';
+  }
+
+  if (changelog.removedFiles?.length) {
+    md += `### Removed files (${changelog.removedFiles.length})\n\n`;
+    md += changelog.removedFiles.slice(0, 20).map((f) => `- \`${f}\``).join('\n');
+    md += '\n\n';
+  }
+
+  if (changelog.techStackChanged?.length) {
+    md += `### Tech stack\n\n${changelog.techStackChanged.map((t) => `- ${t}`).join('\n')}\n\n`;
+  }
+
+  if (changelog.architectureChanged) {
+    md += `### Architecture\n\n- ${changelog.architectureChanged}\n\n`;
+  }
+
+  if (history?.runs?.length > 1) {
+    md += `## Run history\n\n| When | Changed? | Summary |\n|------|----------|----------|\n`;
+    for (const run of history.runs.slice(0, 15)) {
+      const when = run.runAt?.slice(0, 19).replace('T', ' ') || '';
+      const flag = run.hasChanges ? 'Yes' : 'No';
+      md += `| ${when} | ${flag} | ${(run.summary || '').replace(/\|/g, '/').slice(0, 60)} |\n`;
+    }
+    md += '\n';
+  }
+
+  md += `---\n\nRegenerate: \`npx contextforge generate\` · Watch: \`npx contextforge watch\`\n`;
+
+  await fs.writeFile(outPath, md, 'utf8');
+  return outPath;
+}

package/src/generators/context-json.js

@@ -0,0 +1,91 @@
+const VERSION = '1.0.0';
+
+/**
+ * @param {object} data
+ */
+export function buildContextSnapshot(data) {
+  const {
+    projectRoot,
+    config,
+    scanResult,
+    configFiles,
+    techStack,
+    architecture,
+    database,
+    authDeploy,
+    folderTree,
+    git,
+    dependencies,
+    codeInsights,
+    bugs,
+    aiEnrichment,
+    ast,
+    changelog,
+    confidence,
+    projectMeta,
+    astFull,
+  } = data;
+
+  return {
+    version: VERSION,
+    generatedAt: new Date().toISOString(),
+    projectRoot,
+    projectName: techStack.projectName || pathBasename(projectRoot),
+    description: techStack.description || null,
+    techStack: {
+      frontend: techStack.frontend,
+      backend: techStack.backend,
+      database: techStack.database,
+      orm: techStack.orm,
+      styling: techStack.styling,
+      state: techStack.state,
+      auth: techStack.auth,
+      deploy: techStack.deploy,
+      http: techStack.http,
+      testing: techStack.testing || [],
+      confidence: techStack.confidence,
+      signals: techStack.signals,
+      packageJsonCount: techStack.packageJsonCount || 1,
+    },
+    architecture: {
+      primary: architecture.primary,
+      allMatches: architecture.allMatches,
+      folderHierarchy: architecture.folderHierarchy,
+      apiFlow: architecture.apiFlow,
+      dependencyFlow: architecture.dependencyFlow,
+      signals: architecture.signals,
+    },
+    folderTree,
+    database,
+    authDeploy,
+    git,
+    dependencies,
+    codeInsights,
+    bugs,
+    aiEnrichment: aiEnrichment || null,
+    ast: astFull || (ast ? { available: ast.available, routesCount: ast.routes?.length, filesParsed: ast.filesParsed, routes: ast.routes?.slice(0, 50) } : null),
+    projectMeta: projectMeta || null,
+    changelog: changelog || null,
+    confidence: confidence || null,
+    detectionQuality: data.detectionQuality || null,
+    configFiles: configFiles.paths,
+    filesScanned: scanResult.files.length,
+    filesSignature: data.filesSignature || null,
+    projectDirs: scanResult.projectDirs || [],
+    config: {
+      watch: config.watch,
+      detectBugs: config.detectBugs,
+      includeGitHistory: config.includeGitHistory,
+      ai: {
+        enabled: config.ai?.enabled,
+        provider: config.ai?.provider,
+        background: config.ai?.background,
+      },
+    },
+  };
+}
+
+function pathBasename(p) {
+  const parts = p.replace(/\\/g, '/').split('/');
+  return parts[parts.length - 1] || 'project';
+}