@codeyam/codeyam-cli 0.1.0-staging.1 → 0.1.0-staging.103bd05

package/codeyam-cli/scripts/apply-setup.js

@@ -0,0 +1,665 @@
+#!/usr/bin/env npx tsx
+/**
+ * Apply project setup configuration from fixtures to a target project.
+ *
+ * Usage:
+ *   npx tsx codeyam-cli/scripts/apply-setup.ts --project cal.com --target /path/to/target-project
+ *
+ * This script:
+ * 1. Reads setup.json from codeyam-cli/scripts/fixtures/{project}/
+ * 2. Creates/updates .codeyam/ directory structure in target
+ * 3. Writes .codeyam/config.json
+ * 4. Copies universal mock files to .codeyam/universal-mocks/
+ * 5. Creates/updates SQLite database with project metadata
+ * 6. Creates analyzer cache and project cache at /tmp/codeyam/local-dev/{slug}/
+ * 7. Scans all source files and creates baseline entities in the database
+ * 8. Sets up Claude memory infrastructure (CLAUDE.md section, rules instructions, pre-commit hook)
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { parseArgs } from 'util';
+import { randomUUID } from 'crypto';
+import { getSqliteDatabase, createSqliteSchema, upsertProjects, upsertBranches, loadBranches, loadFiles, loadEntities, loadAnalyses, } from "../../packages/database/index.js";
+import { execSync } from 'child_process';
+import { ProjectAnalyzer } from "../../packages/analyze/index.js";
+import getFilesWithEntitiesFromRepo from "../../background/src/lib/virtualized/project/getFilesWithEntitiesFromRepo.js";
+import createEntitiesAndSortFiles from "../../background/src/lib/virtualized/project/createEntitiesAndSortFiles.js";
+import { populateEntityMetadata } from "../src/utils/entityMetadata.js";
+const SANDBOX_BASE = '/tmp/codeyam/local-dev';
+function getAnalyzerTemplatePath() {
+    // The template lives in the codeyam-cli dist directory
+    const cliRoot = path.resolve(__dirname, '..');
+    return path.join(cliRoot, 'dist', 'analyzer-template');
+}
+function getSandboxAnalyzerPath(projectSlug) {
+    return path.join(SANDBOX_BASE, projectSlug, 'codeyam');
+}
+function getSandboxProjectPath(projectSlug) {
+    return path.join(SANDBOX_BASE, projectSlug, 'project');
+}
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+async function main() {
+    const { values } = parseArgs({
+        options: {
+            project: { type: 'string', short: 'p' },
+            target: { type: 'string', short: 't' },
+        },
+    });
+    const projectName = values.project;
+    const targetPath = values.target;
+    if (!projectName || !targetPath) {
+        console.error('Usage: npx tsx apply-setup.ts --project <name> --target <path>');
+        console.error('  --project, -p  Name of the fixture to apply (e.g., "cal.com")');
+        console.error('  --target, -t   Path to the target project');
+        process.exit(1);
+    }
+    const fixturesDir = path.join(__dirname, 'fixtures', projectName);
+    const setupJsonPath = path.join(fixturesDir, 'setup.json');
+    const fixtureMocksDir = path.join(fixturesDir, 'universal-mocks');
+    const codeyamDir = path.join(targetPath, '.codeyam');
+    const configJsonPath = path.join(codeyamDir, 'config.json');
+    const targetMocksDir = path.join(codeyamDir, 'universal-mocks');
+    const dbPath = path.join(codeyamDir, 'db.sqlite3');
+    // Validate fixture exists
+    if (!fs.existsSync(setupJsonPath)) {
+        console.error(`Error: Fixture not found at ${setupJsonPath}`);
+        console.error(`Available fixtures:`);
+        const fixtures = fs.readdirSync(path.join(__dirname, 'fixtures'));
+        for (const f of fixtures) {
+            console.error(`  - ${f}`);
+        }
+        process.exit(1);
+    }
+    // Validate target exists
+    if (!fs.existsSync(targetPath)) {
+        console.error(`Error: Target path does not exist: ${targetPath}`);
+        process.exit(1);
+    }
+    console.log(`Applying fixture: ${projectName}`);
+    console.log(`Target project: ${targetPath}`);
+    // Read fixture
+    const fixture = JSON.parse(await fs.promises.readFile(setupJsonPath, 'utf-8'));
+    // Create .codeyam directory structure
+    console.log('\n1. Creating .codeyam directory structure...');
+    await fs.promises.mkdir(codeyamDir, { recursive: true });
+    await fs.promises.mkdir(path.join(codeyamDir, 'results'), {
+        recursive: true,
+    });
+    await fs.promises.mkdir(path.join(codeyamDir, 'captures'), {
+        recursive: true,
+    });
+    console.log(`   Created: ${codeyamDir}`);
+    // Write config.json
+    console.log('\n2. Writing config.json...');
+    const configJson = {
+        projectSlug: fixture.projectSlug,
+        packageManager: fixture.packageManager,
+        webapps: fixture.webapps,
+        environmentVariables: [],
+        createdAt: new Date().toISOString(),
+        branchId: null, // Will be set when branch is created
+    };
+    await fs.promises.writeFile(configJsonPath, JSON.stringify(configJson, null, 2), 'utf-8');
+    console.log(`   Wrote: ${configJsonPath}`);
+    // Copy universal mocks
+    console.log('\n3. Copying universal mocks...');
+    if (fs.existsSync(fixtureMocksDir)) {
+        // Remove existing mocks dir if it exists
+        if (fs.existsSync(targetMocksDir)) {
+            await fs.promises.rm(targetMocksDir, { recursive: true });
+        }
+        // Copy fixture mocks to target
+        await fs.promises.cp(fixtureMocksDir, targetMocksDir, { recursive: true });
+        // Count files copied
+        const countFiles = (dir) => {
+            let count = 0;
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    count += countFiles(path.join(dir, entry.name));
+                }
+                else {
+                    count++;
+                }
+            }
+            return count;
+        };
+        const fileCount = countFiles(targetMocksDir);
+        console.log(`   Copied: ${fileCount} mock file(s)`);
+    }
+    else {
+        console.log('   No universal mocks in fixture');
+    }
+    // Read mock file contents to build full universalMocks array
+    const universalMocksWithContent = await readMocksWithContent(targetMocksDir, fixture.universalMocks);
+    // Setup SQLite database
+    console.log('\n4. Setting up SQLite database...');
+    // Set the SQLITE_PATH so getSqliteDatabase knows where to look
+    process.env.SQLITE_PATH = dbPath;
+    const db = getSqliteDatabase(dbPath);
+    let finalProjectId;
+    let branchId;
+    const projectMetadata = {
+        packageManager: fixture.packageManager,
+        webapps: fixture.webapps,
+        universalMocks: universalMocksWithContent,
+        unapprovedPaths: fixture.unapprovedPaths,
+        labs: { simulations: true },
+    };
+    try {
+        // Check if tables exist, create if not
+        const tableCheck = await db
+            .selectFrom('projects')
+            .select(db.fn.count('id').as('count'))
+            .executeTakeFirst()
+            .catch(() => { });
+        if (!tableCheck) {
+            console.log('   Creating database schema...');
+            await createSqliteSchema(db);
+        }
+        // Create/update project
+        const projectId = randomUUID();
+        const project = {
+            id: projectId,
+            name: fixture.projectSlug,
+            slug: fixture.projectSlug,
+            path: `local:${targetPath}`,
+            metadata: projectMetadata,
+        };
+        // Check if project already exists
+        const existingProject = await db
+            .selectFrom('projects')
+            .selectAll()
+            .where('slug', '=', fixture.projectSlug)
+            .executeTakeFirst();
+        if (existingProject) {
+            // Update existing project's metadata
+            console.log(`   Updating existing project: ${fixture.projectSlug}`);
+            await db
+                .updateTable('projects')
+                .set({
+                metadata: JSON.stringify(project.metadata),
+                updated_at: new Date().toISOString(),
+            })
+                .where('slug', '=', fixture.projectSlug)
+                .execute();
+            finalProjectId = existingProject.id;
+        }
+        else {
+            // Insert new project
+            console.log(`   Creating new project: ${fixture.projectSlug}`);
+            await upsertProjects([project]);
+            finalProjectId = projectId;
+        }
+        // Create/update _local branch
+        console.log('\n5. Creating _local branch...');
+        const existingBranches = await loadBranches({
+            projectId: finalProjectId,
+            names: ['_local'],
+        });
+        if (existingBranches && existingBranches.length > 0) {
+            console.log('   Using existing _local branch');
+            branchId = existingBranches[0].id;
+        }
+        else {
+            console.log('   Creating new _local branch');
+            const localBranch = {
+                projectId: finalProjectId,
+                name: '_local',
+                ref: '_local',
+                primary: true,
+                activeAt: new Date().toISOString(),
+                contentChangedAt: new Date().toISOString(),
+                metadata: {
+                    contributors: [
+                        {
+                            username: 'local-dev',
+                            avatarUrl: 'https://github.com/identicons/local-dev.png',
+                        },
+                    ],
+                    commits: { total: 0, last7Days: [] },
+                    timeline: [
+                        {
+                            title: 'Local branch created',
+                            date: new Date().toISOString(),
+                            authors: [
+                                {
+                                    username: 'local-dev',
+                                    avatarUrl: 'https://github.com/identicons/local-dev.png',
+                                },
+                            ],
+                            sha: 'local-init',
+                        },
+                    ],
+                },
+            };
+            const createdBranches = await upsertBranches([localBranch]);
+            if (!createdBranches || createdBranches.length === 0) {
+                throw new Error('Failed to create _local branch');
+            }
+            branchId = createdBranches[0].id;
+        }
+        // Update config.json with the branch ID
+        configJson.branchId = branchId;
+        await fs.promises.writeFile(configJsonPath, JSON.stringify(configJson, null, 2), 'utf-8');
+        console.log(`   Updated config.json with branchId: ${branchId}`);
+        console.log('   Database updated successfully');
+    }
+    finally {
+        await db.destroy();
+    }
+    // Create analyzer cache and project cache
+    const resolvedTargetPath = path.resolve(targetPath);
+    console.log('\n6. Setting up analyzer and project cache...');
+    const templatePath = getAnalyzerTemplatePath();
+    const analyzerPath = getSandboxAnalyzerPath(fixture.projectSlug);
+    const projectCachePath = getSandboxProjectPath(fixture.projectSlug);
+    if (!fs.existsSync(templatePath)) {
+        console.error(`   Error: Analyzer template not found at ${templatePath}. Run 'pnpm cli-build' first.`);
+        process.exit(1);
+    }
+    // Finalize template if needed (install deps, Playwright, build)
+    const isFinalized = fs.existsSync(path.join(templatePath, '.finalized'));
+    if (!isFinalized) {
+        console.log('   Installing analyzer dependencies...');
+        execSync('npm install --include=dev', {
+            cwd: templatePath,
+            stdio: 'pipe',
+        });
+        console.log('   Installing Playwright chromium...');
+        execSync('npx playwright install chromium', {
+            cwd: templatePath,
+            stdio: 'pipe',
+        });
+        console.log('   Building analyzer template...');
+        execSync('npm run build', { cwd: templatePath, stdio: 'pipe' });
+        // Write finalization marker
+        fs.writeFileSync(path.join(templatePath, '.finalized'), new Date().toISOString());
+        console.log('   Analyzer template finalized');
+    }
+    // Also finalize the globally installed CLI's analyzer template
+    // The running `codeyam` server checks isAnalyzerFinalized() against the global install path
+    try {
+        const globalRoot = execSync('npm root -g', { stdio: 'pipe' })
+            .toString()
+            .trim();
+        const globalTemplatePath = path.join(globalRoot, '@codeyam', 'codeyam-cli', 'analyzer-template');
+        if (fs.existsSync(globalTemplatePath) &&
+            !fs.existsSync(path.join(globalTemplatePath, '.finalized'))) {
+            console.log('   Finalizing global CLI analyzer template...');
+            execSync('npm install --include=dev', {
+                cwd: globalTemplatePath,
+                stdio: 'pipe',
+            });
+            execSync('npx playwright install chromium', {
+                cwd: globalTemplatePath,
+                stdio: 'pipe',
+            });
+            execSync('npm run build', { cwd: globalTemplatePath, stdio: 'pipe' });
+            fs.writeFileSync(path.join(globalTemplatePath, '.finalized'), new Date().toISOString());
+            console.log('   Global CLI analyzer template finalized');
+        }
+    }
+    catch (e) {
+        console.log('   Warning: Could not finalize global CLI template:', e.message);
+    }
+    // Copy analyzer template to sandbox
+    await fs.promises.mkdir(path.dirname(analyzerPath), { recursive: true });
+    execSync(`rsync -a --delete "${templatePath}/" "${analyzerPath}/"`, {
+        stdio: 'pipe',
+    });
+    console.log(`   Analyzer cache ready at ${analyzerPath}`);
+    // Copy project to sandbox (rsync with node_modules, exclude .codeyam contents)
+    await fs.promises.mkdir(projectCachePath, { recursive: true });
+    execSync(`rsync -a --delete --filter="+ node_modules/***" --exclude=".codeyam/*" "${resolvedTargetPath}/" "${projectCachePath}/"`, { stdio: 'pipe' });
+    console.log(`   Project cache ready at ${projectCachePath}`);
+    // Create baseline entities (scan all source files)
+    console.log('\n7. Creating baseline entities...');
+    const projectForBaseline = {
+        id: finalProjectId,
+        slug: fixture.projectSlug,
+        name: fixture.projectSlug,
+        path: `local:${resolvedTargetPath}`,
+        metadata: projectMetadata,
+    };
+    const branchForBaseline = {
+        id: branchId,
+        projectId: finalProjectId,
+        name: '_local',
+    };
+    await createBaselineEntities(projectForBaseline, branchForBaseline, resolvedTargetPath);
+    // Setup Claude memory infrastructure (only for codeyam project)
+    if (projectName === 'codeyam') {
+        await setupMemoryInfrastructure(targetPath, __dirname);
+    }
+    console.log('\nSetup complete!');
+    console.log(`\nNext steps:`);
+    console.log(`  cd ${targetPath}`);
+    console.log(`  codeyam start`);
+}
+/**
+ * Scan all source files and populate the database with baseline entities.
+ * Ported from setup-simulations.ts — ensures all entities are in the DB
+ * so that the file watcher only shows actual changes.
+ */
+async function createBaselineEntities(project, branch, projectRootPath) {
+    if (!project.files) {
+        project.files = await loadFiles({ projectId: project.id });
+    }
+    // Load existing entities to preserve version tracking
+    const existingEntities = await loadEntities({
+        projectId: project.id,
+        branchId: branch.id,
+    });
+    const existingEntityMap = new Map();
+    if (existingEntities) {
+        for (const entity of existingEntities) {
+            const key = `${entity.filePath}:${entity.name}`;
+            if (!existingEntityMap.has(key)) {
+                existingEntityMap.set(key, new Map());
+            }
+            existingEntityMap.get(key).set(entity.sha, entity);
+        }
+    }
+    // Load analyses for existing entities
+    const existingAnalysesMap = new Map();
+    if (existingEntities && existingEntities.length > 0) {
+        const analyses = await loadAnalyses({
+            entityShas: existingEntities.map((e) => e.sha),
+        });
+        if (analyses) {
+            for (const analysis of analyses) {
+                if (!existingAnalysesMap.has(analysis.entitySha)) {
+                    existingAnalysesMap.set(analysis.entitySha, []);
+                }
+                existingAnalysesMap.get(analysis.entitySha).push(analysis);
+            }
+        }
+    }
+    const projectAnalyzer = ProjectAnalyzer.from({
+        project,
+        dirPath: projectRootPath,
+    });
+    await getFilesWithEntitiesFromRepo({
+        project,
+        projectAnalyzer,
+        silent: true,
+    });
+    const { entityMap } = await createEntitiesAndSortFiles({
+        project,
+        branch,
+        projectAnalyzer,
+    });
+    // Populate project.files with created entities and preserve version tracking
+    let entityCount = 0;
+    let fileCount = 0;
+    for (const file of project.files) {
+        file.entities = [];
+        if (entityMap[file.path]) {
+            // Deduplicate entities by SHA (aliases like 'default' can point to same entity)
+            const entitiesBySha = new Map();
+            Object.values(entityMap[file.path]).forEach((entity) => {
+                entitiesBySha.set(entity.sha, entity);
+            });
+            file.entities = Array.from(entitiesBySha.values());
+            for (const entity of file.entities) {
+                const key = `${entity.filePath}:${entity.name}`;
+                const existingVersions = existingEntityMap.get(key);
+                if (existingVersions) {
+                    const exactMatch = existingVersions.get(entity.sha);
+                    if (exactMatch) {
+                        entity.metadata = exactMatch.metadata;
+                        entity.analyses = existingAnalysesMap.get(exactMatch.sha) || [];
+                        continue;
+                    }
+                    const versionWithAnalyses = Array.from(existingVersions.values()).find((v) => existingAnalysesMap.has(v.sha));
+                    if (versionWithAnalyses) {
+                        entity.metadata = entity.metadata || {};
+                        entity.metadata.previousVersionWithAnalyses =
+                            versionWithAnalyses.sha;
+                        entity.metadata.previousCommittedSha =
+                            versionWithAnalyses.metadata?.isUncommitted === false
+                                ? versionWithAnalyses.sha
+                                : versionWithAnalyses.metadata?.previousCommittedSha;
+                        entity.analyses =
+                            existingAnalysesMap.get(versionWithAnalyses.sha) || [];
+                    }
+                }
+            }
+            entityCount += file.entities.length;
+            fileCount++;
+        }
+    }
+    await populateEntityMetadata(project.files, projectRootPath, projectAnalyzer);
+    console.log(`   Created ${entityCount} entities across ${fileCount} files`);
+}
+/**
+ * Setup Claude memory infrastructure (from codeyam-memory Phase 1)
+ * This sets up everything except creating new rules.
+ */
+async function setupMemoryInfrastructure(targetPath, scriptDir) {
+    const templatesDir = path.join(scriptDir, '..', 'templates');
+    const codeyamDir = path.join(targetPath, '.codeyam');
+    const claudeDir = path.join(targetPath, '.claude');
+    console.log('\n8. Setting up Claude memory infrastructure...');
+    // 6A: Add "When Confused / With Mistakes" section to CLAUDE.md
+    const claudeMdPath = path.join(targetPath, 'CLAUDE.md');
+    const confusionSection = `## Continuous Documentation
+
+As you work, think about any information that might be helpful to know in future work sessions without the user re-providing the information.
+
+This might include
+- High-level architecture for complex areas of the codebase (if not obvious)
+- Specific commands that are recommended
+- Debugging strategies for complex areas of the codebase (if not obvious)
+- Anything confusing that is encountered in the work session
+
+### Documenting Confusion / Mistakes
+
+It is very important to document any tribal knowledge, complex architectural decisions, and any confusion or mistakes you encounter in Claude Rules (\`.claude/rules\`).
+Please see \`.codeyam/rules/instructions.md\` for guidance.
+`;
+    if (fs.existsSync(claudeMdPath)) {
+        const claudeMdContent = await fs.promises.readFile(claudeMdPath, 'utf-8');
+        if (!claudeMdContent.includes('Documenting Confusion / Mistakes')) {
+            // Find a good insertion point - after the first heading or at the top
+            const lines = claudeMdContent.split('\n');
+            let insertIndex = 0;
+            // Find the first ## heading (skip the title)
+            for (let i = 0; i < lines.length; i++) {
+                if (lines[i].startsWith('# ')) {
+                    insertIndex = i + 1;
+                    // Skip any blank lines after the title
+                    while (insertIndex < lines.length && lines[insertIndex].trim() === '')
+                        insertIndex++;
+                    break;
+                }
+            }
+            const newContent = lines.slice(0, insertIndex).join('\n') +
+                '\n' +
+                confusionSection +
+                '\n' +
+                lines.slice(insertIndex).join('\n');
+            await fs.promises.writeFile(claudeMdPath, newContent, 'utf-8');
+            console.log('   Added "When Confused / With Mistakes" section to CLAUDE.md');
+        }
+        else {
+            console.log('   CLAUDE.md already has confusion section');
+        }
+    }
+    else {
+        // Create CLAUDE.md with the section
+        const newClaudeMd = `# Project\n\n${confusionSection}`;
+        await fs.promises.writeFile(claudeMdPath, newClaudeMd, 'utf-8');
+        console.log('   Created CLAUDE.md with confusion section');
+    }
+    // 6B: Copy rules instructions to .codeyam/rules/instructions.md
+    const rulesDir = path.join(codeyamDir, 'rules');
+    const instructionsPath = path.join(rulesDir, 'instructions.md');
+    const templateInstructionsPath = path.join(templatesDir, 'rules-instructions.md');
+    await fs.promises.mkdir(rulesDir, { recursive: true });
+    if (fs.existsSync(templateInstructionsPath)) {
+        await fs.promises.copyFile(templateInstructionsPath, instructionsPath);
+        console.log('   Copied rules instructions to .codeyam/rules/instructions.md');
+    }
+    else {
+        console.log('   Warning: rules-instructions.md template not found');
+    }
+    // 6C: Setup pre-commit hook
+    const binDir = path.join(codeyamDir, 'bin');
+    const memoryHookPath = path.join(binDir, 'memory-hook.sh');
+    const templateHookPath = path.join(templatesDir, 'codeyam-memory-hook.sh');
+    await fs.promises.mkdir(binDir, { recursive: true });
+    // Copy memory-hook.sh if template exists
+    if (fs.existsSync(templateHookPath)) {
+        await fs.promises.copyFile(templateHookPath, memoryHookPath);
+        await fs.promises.chmod(memoryHookPath, 0o755);
+        console.log('   Copied memory-hook.sh to .codeyam/bin/');
+    }
+    else {
+        console.log('   Warning: memory-hook.sh template not found');
+    }
+    // Copy rule-reflection-hook.py if template exists
+    const ruleReflectionHookPath = path.join(binDir, 'rule-reflection-hook.py');
+    const templateRuleReflectionHookPath = path.join(templatesDir, 'rule-reflection-hook.py');
+    if (fs.existsSync(templateRuleReflectionHookPath)) {
+        await fs.promises.copyFile(templateRuleReflectionHookPath, ruleReflectionHookPath);
+        await fs.promises.chmod(ruleReflectionHookPath, 0o755);
+        console.log('   Copied rule-reflection-hook.py to .codeyam/bin/');
+    }
+    else {
+        console.log('   Warning: rule-reflection-hook.py template not found');
+    }
+    // Copy rule-notification-hook.py if template exists
+    const ruleNotificationHookPath = path.join(binDir, 'rule-notification-hook.py');
+    const templateRuleNotificationHookPath = path.join(templatesDir, 'rule-notification-hook.py');
+    if (fs.existsSync(templateRuleNotificationHookPath)) {
+        await fs.promises.copyFile(templateRuleNotificationHookPath, ruleNotificationHookPath);
+        await fs.promises.chmod(ruleNotificationHookPath, 0o755);
+        console.log('   Copied rule-notification-hook.py to .codeyam/bin/');
+    }
+    else {
+        console.log('   Warning: rule-notification-hook.py template not found');
+    }
+    // Copy prompt templates to .codeyam/bin/prompts/
+    const promptsSrcDir = path.join(templatesDir, 'prompts');
+    const promptsDestDir = path.join(binDir, 'prompts');
+    if (fs.existsSync(promptsSrcDir)) {
+        await fs.promises.mkdir(promptsDestDir, { recursive: true });
+        const promptFiles = fs.readdirSync(promptsSrcDir);
+        for (const file of promptFiles) {
+            await fs.promises.copyFile(path.join(promptsSrcDir, file), path.join(promptsDestDir, file));
+        }
+        console.log('   Copied prompt templates to .codeyam/bin/prompts/');
+    }
+    // Setup pre-commit hook (Husky or .git/hooks)
+    const huskyDir = path.join(targetPath, '.husky');
+    const gitHooksDir = path.join(targetPath, '.git', 'hooks');
+    const hookContent = `
+# CodeYam Memory Up-To-Date Check
+if [ -f ".codeyam/bin/memory-hook.sh" ]; then
+  .codeyam/bin/memory-hook.sh
+fi
+`;
+    if (fs.existsSync(huskyDir)) {
+        // Using Husky
+        const huskyPreCommitPath = path.join(huskyDir, 'pre-commit');
+        if (fs.existsSync(huskyPreCommitPath)) {
+            const existingContent = await fs.promises.readFile(huskyPreCommitPath, 'utf-8');
+            if (!existingContent.includes('memory-hook.sh')) {
+                await fs.promises.appendFile(huskyPreCommitPath, hookContent);
+                console.log('   Appended memory hook to .husky/pre-commit');
+            }
+            else {
+                console.log('   Husky pre-commit already has memory hook');
+            }
+        }
+        else {
+            // Create the husky pre-commit file
+            await fs.promises.writeFile(huskyPreCommitPath, `#!/bin/sh\n${hookContent}`, 'utf-8');
+            await fs.promises.chmod(huskyPreCommitPath, 0o755);
+            console.log('   Created .husky/pre-commit with memory hook');
+        }
+    }
+    else if (fs.existsSync(gitHooksDir)) {
+        // Using .git/hooks directly
+        const gitPreCommitPath = path.join(gitHooksDir, 'pre-commit');
+        if (fs.existsSync(gitPreCommitPath)) {
+            const existingContent = await fs.promises.readFile(gitPreCommitPath, 'utf-8');
+            if (!existingContent.includes('memory-hook.sh')) {
+                await fs.promises.appendFile(gitPreCommitPath, hookContent);
+                console.log('   Appended memory hook to .git/hooks/pre-commit');
+            }
+            else {
+                console.log('   .git/hooks/pre-commit already has memory hook');
+            }
+        }
+        else {
+            await fs.promises.writeFile(gitPreCommitPath, `#!/bin/sh\n${hookContent}`, 'utf-8');
+            await fs.promises.chmod(gitPreCommitPath, 0o755);
+            console.log('   Created .git/hooks/pre-commit with memory hook');
+        }
+    }
+    else {
+        console.log('   Warning: No .husky/ or .git/hooks/ directory found');
+    }
+    // 6D: Create .claude/rules directory if it doesn't exist
+    const claudeRulesDir = path.join(claudeDir, 'rules');
+    await fs.promises.mkdir(claudeRulesDir, { recursive: true });
+    console.log('   Ensured .claude/rules/ directory exists');
+}
+/**
+ * Read mock files and merge content with fixture metadata
+ */
+async function readMocksWithContent(mocksDir, mockMetadata) {
+    if (!fs.existsSync(mocksDir)) {
+        return mockMetadata;
+    }
+    // Build a map of file contents by path
+    const fileContents = new Map();
+    const readAllFiles = async (dir, basePath = '') => {
+        const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            const relativePath = path.join(basePath, entry.name);
+            if (entry.isDirectory()) {
+                await readAllFiles(fullPath, relativePath);
+            }
+            else if (/\.(ts|tsx|js|jsx)$/.test(entry.name)) {
+                const content = await fs.promises.readFile(fullPath, 'utf-8');
+                // Normalize path separators
+                const normalizedPath = relativePath.replace(/\\/g, '/');
+                fileContents.set(normalizedPath, content);
+            }
+        }
+    };
+    await readAllFiles(mocksDir);
+    // Merge content into metadata
+    // For each mock, find its content by matching filePath
+    return mockMetadata.map((mock) => {
+        // The filePath in metadata might not have the full path structure
+        // Try to find matching file content
+        let content = '';
+        for (const [filePath, fileContent] of fileContents) {
+            if (filePath.endsWith(mock.filePath) ||
+                mock.filePath.endsWith(filePath)) {
+                // Extract just this entity's code from the file
+                // For now, use the full file content - the sync logic will handle extraction
+                content = fileContent;
+                break;
+            }
+        }
+        return {
+            ...mock,
+            content,
+            projectId: '', // Will be set by database
+        };
+    });
+}
+main().catch((error) => {
+    console.error('Error:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=apply-setup.js.map