repomap-cli 0.1.0

package/dist/generator/claude-md.js

@@ -0,0 +1,656 @@
+import fs from 'fs';
+import path from 'path';
+// ─── README parsing ──────────────────────────────────────────────────────────
+function parseReadmeDescription(rootDir) {
+    const readmePaths = ['README.md', 'readme.md', 'README.MD', 'Readme.md'];
+    for (const name of readmePaths) {
+        const p = path.join(rootDir, name);
+        if (!fs.existsSync(p))
+            continue;
+        try {
+            const content = fs.readFileSync(p, 'utf-8');
+            const lines = content.split('\n');
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                if (trimmed.startsWith('#'))
+                    continue;
+                if (trimmed.startsWith('![') || trimmed.startsWith('[!['))
+                    continue;
+                if (trimmed.includes('shields.io') || trimmed.includes('badge'))
+                    continue;
+                if (trimmed.length < 10)
+                    continue;
+                const text = trimmed.startsWith('> ') ? trimmed.slice(2).trim() : trimmed;
+                return text.replace(/\*\*/g, '').slice(0, 120);
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return '';
+}
+// ─── Stack formatter ─────────────────────────────────────────────────────────
+function formatStackOneLine(stack) {
+    const priorityOrder = [
+        'next.js', 'react', 'vue', 'nuxt', 'svelte', 'astro', 'remix',
+        'express', 'fastify', 'hono', 'nestjs',
+    ];
+    const skip = new Set(['vitest', 'jest', 'playwright', 'cypress', 'webpack', 'vite', 'turbopack']);
+    const parts = [];
+    for (const fw of priorityOrder) {
+        if (stack.frameworks.includes(fw))
+            parts.push(fw);
+    }
+    for (const fw of stack.frameworks) {
+        if (!priorityOrder.includes(fw) && !skip.has(fw) && !parts.includes(fw)) {
+            parts.push(fw);
+        }
+    }
+    if (stack.languages.includes('typescript') && !parts.includes('typescript')) {
+        parts.push('TypeScript');
+    }
+    else if (stack.languages.includes('python')) {
+        parts.push('Python');
+    }
+    else if (stack.languages.includes('go')) {
+        parts.push('Go');
+    }
+    return parts.slice(0, 8).join(', ');
+}
+function detectArchitecture(rootDir, files, stack) {
+    // Monorepo / pattern
+    let pattern = 'monolith';
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(rootDir, 'package.json'), 'utf-8'));
+        if (pkg.workspaces)
+            pattern = 'monorepo';
+    }
+    catch { /* ignore */ }
+    if (fs.existsSync(path.join(rootDir, 'turbo.json')))
+        pattern = 'monorepo (turborepo)';
+    if (fs.existsSync(path.join(rootDir, 'apps')) && fs.existsSync(path.join(rootDir, 'packages'))) {
+        if (pattern === 'monolith')
+            pattern = 'monorepo';
+    }
+    // Routing
+    let routing = '';
+    const hasAppRouter = files.some((f) => /^(src\/)?app\/(layout|page)\.(tsx?|jsx?)/.test(f.relativePath));
+    const hasPagesRouter = files.some((f) => /^(src\/)?pages\//.test(f.relativePath));
+    if (hasAppRouter)
+        routing = 'Next.js App Router';
+    else if (hasPagesRouter)
+        routing = 'Next.js Pages Router';
+    else if (stack.frameworks.includes('nestjs'))
+        routing = 'NestJS controllers';
+    else if (stack.frameworks.includes('fastify'))
+        routing = 'Fastify routes';
+    else if (stack.frameworks.includes('hono'))
+        routing = 'Hono routes';
+    else if (stack.frameworks.includes('express'))
+        routing = 'Express routes';
+    // Data pattern
+    let dataPattern = '';
+    const hasActionsDir = files.some((f) => f.relativePath.includes('/actions/') || f.relativePath.endsWith('actions.ts'));
+    const hasApiRoutes = files.some((f) => /\/(api|routes?)\//.test(f.relativePath) &&
+        (f.relativePath.endsWith('route.ts') || f.relativePath.endsWith('route.js') || f.relativePath.includes('[')));
+    if (stack.frameworks.includes('trpc'))
+        dataPattern = 'tRPC';
+    else if (hasActionsDir && hasAppRouter)
+        dataPattern = 'Server Actions + API routes';
+    else if (hasApiRoutes)
+        dataPattern = 'REST API routes';
+    else if (stack.frameworks.includes('graphql'))
+        dataPattern = 'GraphQL';
+    // Auth
+    let auth = '';
+    if (stack.frameworks.includes('supabase'))
+        auth = 'Supabase Auth';
+    else if (stack.frameworks.includes('clerk'))
+        auth = 'Clerk';
+    else if (stack.frameworks.includes('auth.js'))
+        auth = 'Auth.js (NextAuth)';
+    // ORM / DB
+    let orm = '';
+    if (stack.frameworks.includes('prisma'))
+        orm = 'Prisma';
+    else if (stack.frameworks.includes('drizzle'))
+        orm = 'Drizzle ORM';
+    else if (stack.frameworks.includes('supabase') && !auth.includes('Supabase'))
+        orm = 'Supabase (PostgreSQL)';
+    else if (stack.frameworks.includes('supabase'))
+        orm = 'Supabase (PostgreSQL)';
+    // Testing
+    let testing = '';
+    if (stack.frameworks.includes('vitest'))
+        testing = 'Vitest';
+    else if (stack.frameworks.includes('jest'))
+        testing = 'Jest';
+    if (files.some((f) => /playwright|e2e/.test(f.relativePath)))
+        testing += (testing ? ' + ' : '') + 'Playwright';
+    if (files.some((f) => /cypress/.test(f.relativePath)))
+        testing += (testing ? ' + ' : '') + 'Cypress';
+    return { pattern, routing, dataPattern, auth, orm, testing };
+}
+// ─── Directory tree with descriptions ────────────────────────────────────────
+const DIR_DESCRIPTIONS = {
+    app: 'Next.js App Router — pages, layouts, API routes',
+    pages: 'Next.js Pages Router',
+    src: 'source root',
+    components: 'React components',
+    ui: 'UI component library',
+    lib: 'utilities and shared logic',
+    utils: 'utility functions',
+    hooks: 'React hooks',
+    api: 'API handlers',
+    types: 'TypeScript types',
+    styles: 'CSS / styling',
+    public: 'static assets',
+    tests: 'test files',
+    __tests__: 'test files',
+    e2e: 'end-to-end tests',
+    config: 'configuration',
+    scripts: 'utility scripts',
+    docs: 'documentation',
+    prisma: 'Prisma schema + migrations',
+    drizzle: 'Drizzle schema + migrations',
+    migrations: 'database migrations',
+    middleware: 'request middleware',
+    store: 'state management',
+    context: 'React context providers',
+    server: 'server-side code',
+    client: 'client-side code',
+    providers: 'context / service providers',
+    actions: 'Server Actions',
+    emails: 'email templates',
+    packages: 'monorepo packages',
+    apps: 'monorepo applications',
+    features: 'feature modules',
+    modules: 'domain modules',
+};
+function inferDirDescription(dirName, files) {
+    if (DIR_DESCRIPTIONS[dirName])
+        return DIR_DESCRIPTIONS[dirName];
+    const dirFiles = files.filter((f) => f.relativePath.startsWith(dirName + '/'));
+    if (dirFiles.length === 0)
+        return '';
+    const typeCounts = {};
+    for (const f of dirFiles)
+        typeCounts[f.type] = (typeCounts[f.type] ?? 0) + 1;
+    const dominant = Object.entries(typeCounts).sort((a, b) => b[1] - a[1])[0]?.[0];
+    const map = {
+        component: 'React components',
+        hook: 'React hooks',
+        api: 'API handlers',
+        page: 'pages',
+        types: 'type definitions',
+        utility: 'utility functions',
+        config: 'configuration',
+    };
+    return map[dominant ?? ''] ?? `${dirFiles.length} files`;
+}
+function buildDirectoryTree(files) {
+    const topDirSet = new Set();
+    for (const f of files) {
+        const parts = f.relativePath.split('/');
+        if (parts.length > 1)
+            topDirSet.add(parts[0]);
+    }
+    const topDirs = [...topDirSet].slice(0, 12);
+    const lines = ['```'];
+    lines.push('.');
+    for (let i = 0; i < topDirs.length; i++) {
+        const dir = topDirs[i];
+        const isLast = i === topDirs.length - 1;
+        const prefix = isLast ? '└── ' : '├── ';
+        const desc = inferDirDescription(dir, files);
+        lines.push(`${prefix}${dir}/  ${desc ? `← ${desc}` : ''}`);
+        // Add up to 3 important subdirs
+        const subDirSet = new Set();
+        for (const f of files) {
+            const parts = f.relativePath.split('/');
+            if (parts[0] === dir && parts.length > 2)
+                subDirSet.add(parts[1]);
+        }
+        const subDirs = [...subDirSet].slice(0, 3);
+        if (subDirs.length > 0 && lines.length < 30) {
+            const connector = isLast ? '    ' : '│   ';
+            for (let j = 0; j < subDirs.length; j++) {
+                const sub = subDirs[j];
+                const subIsLast = j === subDirs.length - 1;
+                const subPrefix = subIsLast ? '└── ' : '├── ';
+                const subDesc = inferDirDescription(sub, files);
+                lines.push(`${connector}${subPrefix}${sub}/  ${subDesc ? `← ${subDesc}` : ''}`);
+            }
+        }
+    }
+    lines.push('```');
+    return lines;
+}
+function computeFileHeat(files) {
+    const heatMap = new Map();
+    for (const file of files) {
+        const basename = path.basename(file.relativePath, path.extname(file.relativePath));
+        for (const other of files) {
+            if (other.relativePath === file.relativePath)
+                continue;
+            if (other.imports.some((imp) => imp.includes(basename) || imp.endsWith(file.relativePath))) {
+                heatMap.set(file.relativePath, (heatMap.get(file.relativePath) ?? 0) + 1);
+            }
+        }
+    }
+    return heatMap;
+}
+function getTopModules(files) {
+    const heatMap = computeFileHeat(files);
+    const moduleMap = new Map();
+    for (const file of files) {
+        const parts = file.relativePath.split('/');
+        let moduleName = parts[0];
+        if (['src', 'app', 'pages', 'lib', 'components'].includes(parts[0]) && parts.length >= 3) {
+            moduleName = parts[1];
+        }
+        if (!moduleMap.has(moduleName))
+            moduleMap.set(moduleName, { files: [], totalHeat: 0 });
+        const mod = moduleMap.get(moduleName);
+        mod.files.push(file);
+        mod.totalHeat += heatMap.get(file.relativePath) ?? 0;
+    }
+    return [...moduleMap.entries()]
+        .sort((a, b) => b[1].totalHeat - a[1].totalHeat)
+        .slice(0, 5)
+        .map(([name, data]) => {
+        const hottest = [...data.files].sort((a, b) => (heatMap.get(b.relativePath) ?? 0) - (heatMap.get(a.relativePath) ?? 0))[0];
+        return {
+            name,
+            keyFile: hottest?.relativePath ?? '',
+            description: inferDirDescription(name, data.files),
+            fileCount: data.files.length,
+            heat: data.totalHeat,
+        };
+    });
+}
+// ─── Statistical convention detection ────────────────────────────────────────
+function detectConventions(files) {
+    const conventions = [];
+    // App Router vs Pages Router
+    const hasAppRouter = files.some((f) => /^(src\/)?app\//.test(f.relativePath));
+    const hasPagesRouter = files.some((f) => /^(src\/)?pages\//.test(f.relativePath));
+    if (hasAppRouter)
+        conventions.push("Next.js App Router — Server Components by default, 'use client' for interactive");
+    if (hasPagesRouter)
+        conventions.push('Next.js Pages Router');
+    // Import alias analysis (sample 30 files × 10 imports)
+    let absoluteCount = 0;
+    let relativeCount = 0;
+    for (const f of files.slice(0, 30)) {
+        for (const imp of f.importDetails.slice(0, 10)) {
+            if (!imp.isExternal) {
+                if (imp.source.startsWith('@/') || imp.source.startsWith('~/') || imp.source.startsWith('#')) {
+                    absoluteCount++;
+                }
+                else if (imp.source.startsWith('.')) {
+                    relativeCount++;
+                }
+            }
+        }
+    }
+    if (absoluteCount > relativeCount && absoluteCount > 0) {
+        conventions.push(`Absolute imports (@/ alias) — ${absoluteCount} occurrences`);
+    }
+    else if (relativeCount > 0) {
+        conventions.push('Relative imports (./, ../)');
+    }
+    // Named vs default exports
+    let namedCount = 0;
+    let defaultCount = 0;
+    for (const f of files.slice(0, 40)) {
+        for (const exp of f.exportDetails) {
+            if (exp.type === 'default')
+                defaultCount++;
+            else
+                namedCount++;
+        }
+    }
+    if (namedCount > defaultCount * 2) {
+        conventions.push('Named exports preferred over default exports');
+    }
+    else if (defaultCount > namedCount) {
+        conventions.push('Default exports for pages/components, named for utilities');
+    }
+    // Barrel files
+    const barrelCount = files.filter((f) => /index\.(ts|tsx|js|jsx)$/.test(f.relativePath)).length;
+    if (barrelCount > 3)
+        conventions.push(`Barrel exports via index files (${barrelCount} found)`);
+    // TypeScript ratio
+    const tsCount = files.filter((f) => f.language === 'typescript').length;
+    if (tsCount / Math.max(files.length, 1) > 0.7) {
+        conventions.push('TypeScript strict — avoid `any`, use explicit types');
+    }
+    // Feature-based org
+    if (files.some((f) => /\/(features|modules|domain)\//.test(f.relativePath))) {
+        conventions.push('Feature-based module organization');
+    }
+    return conventions.slice(0, 6);
+}
+// ─── Commands from package.json ───────────────────────────────────────────────
+function getCommands(rootDir) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(rootDir, 'package.json'), 'utf-8'));
+        const scripts = pkg.scripts ?? {};
+        const result = {};
+        const wanted = ['dev', 'start', 'build', 'test', 'lint', 'typecheck', 'type-check', 'format'];
+        for (const key of wanted) {
+            if (scripts[key])
+                result[key] = scripts[key];
+        }
+        return result;
+    }
+    catch {
+        return {};
+    }
+}
+function detectApiEndpoints(files) {
+    const endpoints = [];
+    for (const file of files) {
+        // App Router: app/api/**/route.ts
+        const appRoute = file.relativePath.match(/^(?:src\/)?app\/(api\/.+)\/route\.(ts|js)$/);
+        if (appRoute) {
+            const routePath = '/' + appRoute[1].replace(/\[([^\]]+)\]/g, ':$1');
+            const methods = file.exportDetails
+                .filter((e) => ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'].includes(e.name))
+                .map((e) => e.name);
+            if (methods.length === 0) {
+                endpoints.push({ method: 'GET', path: routePath, file: file.relativePath });
+            }
+            else {
+                for (const method of methods) {
+                    endpoints.push({ method, path: routePath, file: file.relativePath });
+                }
+            }
+            continue;
+        }
+        // Pages Router: pages/api/*.ts
+        const pagesApi = file.relativePath.match(/^(?:src\/)?pages\/(api\/.+)\.(ts|js)$/);
+        if (pagesApi) {
+            const routePath = '/' + pagesApi[1].replace(/\[([^\]]+)\]/g, ':$1');
+            endpoints.push({ method: 'GET|POST', path: routePath, file: file.relativePath });
+        }
+    }
+    return endpoints.slice(0, 40);
+}
+function detectComponents(files) {
+    const components = [];
+    for (const file of files) {
+        if (!['component', 'page', 'layout'].includes(file.type))
+            continue;
+        const defaultExp = file.exportDetails.find((e) => e.type === 'default');
+        const name = defaultExp?.name ?? path.basename(file.relativePath, path.extname(file.relativePath));
+        const props = defaultExp?.params.slice(0, 5) ?? file.functions[0]?.params.slice(0, 5) ?? [];
+        components.push({
+            name,
+            file: file.relativePath,
+            props,
+            isLayout: file.type === 'layout',
+            isPage: file.type === 'page',
+        });
+    }
+    return components
+        .sort((a, b) => {
+        if (a.isLayout !== b.isLayout)
+            return a.isLayout ? -1 : 1;
+        if (a.isPage !== b.isPage)
+            return a.isPage ? -1 : 1;
+        return 0;
+    })
+        .slice(0, 25);
+}
+// ─── Main generator ───────────────────────────────────────────────────────────
+export function generateClaudeMd(opts) {
+    const { rootDir, projectName, stack, files } = opts;
+    const description = parseReadmeDescription(rootDir);
+    const stackLine = formatStackOneLine(stack);
+    const arch = detectArchitecture(rootDir, files, stack);
+    const conventions = detectConventions(files);
+    const commands = getCommands(rootDir);
+    const topModules = getTopModules(files);
+    const dirTree = buildDirectoryTree(files);
+    const apiEndpoints = detectApiEndpoints(files);
+    const components = detectComponents(files);
+    const lines = [];
+    // Header
+    lines.push(`# ${projectName}`);
+    lines.push('');
+    if (description) {
+        lines.push(description);
+        lines.push('');
+    }
+    // Stack — one line
+    lines.push('## Stack');
+    lines.push(stackLine);
+    lines.push('');
+    // Structure — tree with descriptions
+    lines.push('## Structure');
+    for (const treeLine of dirTree)
+        lines.push(treeLine);
+    lines.push('');
+    // Architecture
+    lines.push('## Architecture');
+    if (arch.pattern)
+        lines.push(`- Pattern: ${arch.pattern}`);
+    if (arch.routing)
+        lines.push(`- Routing: ${arch.routing}`);
+    if (arch.dataPattern)
+        lines.push(`- Data: ${arch.dataPattern}`);
+    if (arch.auth)
+        lines.push(`- Auth: ${arch.auth}`);
+    if (arch.orm)
+        lines.push(`- DB: ${arch.orm}`);
+    if (arch.testing)
+        lines.push(`- Testing: ${arch.testing}`);
+    lines.push('');
+    // Modules — top 5 by heat
+    if (topModules.length > 0) {
+        lines.push('## Modules');
+        for (const mod of topModules.slice(0, 5)) {
+            const desc = mod.description ? ` — ${mod.description}` : '';
+            const key = mod.keyFile ? ` (key: \`${mod.keyFile}\`)` : '';
+            lines.push(`- **${mod.name}/**${desc}${key}`);
+        }
+        lines.push('');
+    }
+    // Conventions — real, detected
+    if (conventions.length > 0) {
+        lines.push('## Conventions');
+        for (const c of conventions)
+            lines.push(`- ${c}`);
+        lines.push('');
+    }
+    // Commands
+    const cmdEntries = Object.entries(commands);
+    if (cmdEntries.length > 0) {
+        lines.push('## Commands');
+        for (const [cmd, script] of cmdEntries) {
+            lines.push(`- \`npm run ${cmd}\` — \`${script}\``);
+        }
+        lines.push('');
+    }
+    // Extended docs
+    const hasApis = apiEndpoints.length > 0;
+    const hasFrontend = files.some((f) => ['component', 'page', 'layout'].includes(f.type));
+    lines.push('## More context');
+    lines.push('- `.repomap/docs/architecture.md` — dependency graph, data flow, error handling');
+    lines.push('- `.repomap/docs/conventions.md` — naming, imports, file organization, testing');
+    if (hasApis)
+        lines.push('- `.repomap/docs/api-reference.md` — all API endpoints');
+    if (hasFrontend)
+        lines.push('- `.repomap/docs/components.md` — component hierarchy and props');
+    lines.push('');
+    // Enforce ≤ 80 lines
+    const main = lines.slice(0, 80).join('\n');
+    // ── Overflow: architecture.md ─────────────────────────────────────────────
+    const archLines = ['# Architecture', ''];
+    archLines.push(`## Pattern: ${arch.pattern}`, '');
+    if (arch.routing)
+        archLines.push(`**Routing:** ${arch.routing}`);
+    if (arch.dataPattern)
+        archLines.push(`**Data:** ${arch.dataPattern}`);
+    if (arch.auth)
+        archLines.push(`**Auth:** ${arch.auth}`);
+    if (arch.orm)
+        archLines.push(`**DB/ORM:** ${arch.orm}`);
+    archLines.push('');
+    archLines.push('## Module Heat Map', '');
+    archLines.push('(Files imported by the most other files = highest heat)', '');
+    for (const mod of topModules) {
+        archLines.push(`### ${mod.name}/ — ${mod.fileCount} files, heat: ${mod.heat}`);
+        if (mod.description)
+            archLines.push(mod.description);
+        if (mod.keyFile)
+            archLines.push(`Key file: \`${mod.keyFile}\``);
+        archLines.push('');
+    }
+    archLines.push('## Data Flow', '');
+    if (arch.routing.includes('App Router')) {
+        archLines.push('1. HTTP request → Next.js middleware (if any)');
+        archLines.push('2. → Server Component — fetch data inline');
+        if (arch.dataPattern.includes('Server Actions'))
+            archLines.push('3. → Server Actions for mutations');
+        if (arch.dataPattern.includes('API'))
+            archLines.push('3. → API route handlers for external/client calls');
+        if (arch.orm)
+            archLines.push(`4. → ${arch.orm} → database`);
+    }
+    else if (arch.routing.includes('Express') || arch.routing.includes('Fastify') || arch.routing.includes('Hono') || arch.routing.includes('NestJS')) {
+        archLines.push('1. HTTP request → middleware chain');
+        archLines.push('2. → route handler / controller');
+        if (arch.orm)
+            archLines.push(`3. → ${arch.orm} → database`);
+        archLines.push('4. → JSON response');
+    }
+    else {
+        archLines.push('See route handlers for data flow details.');
+    }
+    archLines.push('');
+    archLines.push('## Error Handling', '');
+    if (files.some((f) => /error\.(tsx?|jsx?)/.test(f.relativePath))) {
+        archLines.push('- Next.js error.tsx boundaries (per-route)');
+    }
+    if (files.some((f) => f.relativePath.includes('not-found'))) {
+        archLines.push('- Custom 404 not-found page');
+    }
+    archLines.push('- Check route handlers for try/catch patterns');
+    // ── Overflow: conventions.md ──────────────────────────────────────────────
+    const convLines = ['# Conventions', '', '## Detected Patterns', ''];
+    for (const conv of conventions)
+        convLines.push(`- ${conv}`);
+    convLines.push('');
+    convLines.push('## Naming', '');
+    const tsxNames = files.filter((f) => f.relativePath.endsWith('.tsx')).map((f) => path.basename(f.relativePath));
+    const utilNames = files.filter((f) => f.type === 'utility').map((f) => path.basename(f.relativePath));
+    const hasPascal = tsxNames.filter((n) => /^[A-Z]/.test(n)).length > tsxNames.length / 2;
+    const hasKebab = utilNames.filter((n) => n.includes('-')).length > utilNames.length / 2;
+    if (hasPascal)
+        convLines.push('- Components: PascalCase (Button.tsx, UserCard.tsx)');
+    if (hasKebab)
+        convLines.push('- Utilities: kebab-case (use-auth.ts, format-date.ts)');
+    convLines.push('- Variables/functions: camelCase');
+    convLines.push('- TypeScript types/interfaces: PascalCase');
+    convLines.push('');
+    convLines.push('## Imports', '');
+    const sampleImports = files.slice(0, 25).flatMap((f) => f.importDetails.slice(0, 5));
+    const hasAlias = sampleImports.some((i) => i.source.startsWith('@/') || i.source.startsWith('~/'));
+    convLines.push(hasAlias ? '- Path alias: `@/` maps to source root' : '- Relative imports: ./ and ../');
+    convLines.push('- External packages by bare name (react, next, etc.)');
+    convLines.push('');
+    convLines.push('## File Organization', '');
+    const hasSrc = files.some((f) => f.relativePath.startsWith('src/'));
+    convLines.push(hasSrc ? '- Source files under `src/`' : '- Source files at project root');
+    const barrelCount = files.filter((f) => /index\.(ts|tsx|js|jsx)$/.test(f.relativePath)).length;
+    if (barrelCount > 2)
+        convLines.push(`- ${barrelCount} barrel files (index.ts) for module re-exports`);
+    convLines.push('');
+    if (arch.testing) {
+        convLines.push('## Testing', '');
+        convLines.push(`- Framework: ${arch.testing}`);
+        const testFiles = files.filter((f) => /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(f.relativePath));
+        convLines.push(`- ${testFiles.length} test files detected`);
+        const hasCollocated = testFiles.some((f) => {
+            const dir = path.dirname(f.relativePath);
+            return files.some((o) => o !== f && path.dirname(o.relativePath) === dir);
+        });
+        convLines.push(hasCollocated ? '- Tests colocated with source files' : '- Tests in separate directory');
+    }
+    // ── Overflow: api-reference.md ────────────────────────────────────────────
+    const apiLines = ['# API Reference', ''];
+    if (apiEndpoints.length > 0) {
+        apiLines.push(`${apiEndpoints.length} endpoint(s) detected.`, '');
+        const grouped = new Map();
+        for (const ep of apiEndpoints) {
+            const base = ep.path.split('/').slice(0, 3).join('/') || '/';
+            if (!grouped.has(base))
+                grouped.set(base, []);
+            grouped.get(base).push(ep);
+        }
+        for (const [base, eps] of grouped.entries()) {
+            apiLines.push(`## ${base}`);
+            for (const ep of eps) {
+                apiLines.push(`- \`${ep.method} ${ep.path}\` → \`${ep.file}\``);
+            }
+            apiLines.push('');
+        }
+    }
+    else {
+        apiLines.push('No API routes detected.');
+    }
+    // ── Overflow: components.md ───────────────────────────────────────────────
+    const compLines = ['# Components', ''];
+    const layouts = components.filter((c) => c.isLayout);
+    const pages = components.filter((c) => c.isPage && !c.isLayout);
+    const uiComps = components.filter((c) => !c.isLayout && !c.isPage);
+    if (layouts.length > 0) {
+        compLines.push('## Layout Hierarchy', '');
+        for (const l of layouts) {
+            compLines.push(`### ${l.name}`);
+            compLines.push(`File: \`${l.file}\``);
+            if (l.props.length > 0)
+                compLines.push(`Props: ${l.props.join(', ')}`);
+            compLines.push('');
+        }
+    }
+    if (pages.length > 0) {
+        compLines.push('## Pages', '');
+        for (const p of pages.slice(0, 20)) {
+            compLines.push(`- \`${p.file}\` — ${p.name}`);
+        }
+        compLines.push('');
+    }
+    if (uiComps.length > 0) {
+        compLines.push('## UI Components', '');
+        for (const comp of uiComps.slice(0, 25)) {
+            const propsStr = comp.props.length > 0 ? ` (${comp.props.join(', ')})` : '';
+            compLines.push(`- **${comp.name}**${propsStr} — \`${comp.file}\``);
+        }
+    }
+    return {
+        main,
+        overflow: {
+            'architecture.md': archLines.join('\n'),
+            'conventions.md': convLines.join('\n'),
+            'api-reference.md': apiLines.join('\n'),
+            'components.md': compLines.join('\n'),
+        },
+    };
+}
+export function writeClaudeMd(rootDir, content) {
+    const claudeMdPath = path.join(rootDir, 'CLAUDE.md');
+    fs.writeFileSync(claudeMdPath, content.main, 'utf-8');
+    const docsDir = path.join(rootDir, '.repomap', 'docs');
+    fs.mkdirSync(docsDir, { recursive: true });
+    for (const [filename, fileContent] of Object.entries(content.overflow)) {
+        fs.writeFileSync(path.join(docsDir, filename), fileContent, 'utf-8');
+    }
+}
+//# sourceMappingURL=claude-md.js.map