specforge-mcp 0.12.0 → 0.13.0

package/dist/engine/skill-generator.test.js

@@ -1,742 +0,0 @@
-// SpecForge — Skill & Rules Generator Engine Tests
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('node:fs/promises', () => ({
-    readFile: vi.fn(),
-}));
-import { readFile } from 'node:fs/promises';
-import { generateSkill, generateRules, getAgentConfig, detectAgentPlatform, } from './skill-generator.js';
-const mockedReadFile = vi.mocked(readFile);
-// === Helper factories ===
-function makeKnowledge(overrides = {}) {
-    return {
-        projectId: 'proj-1',
-        projectPath: '/home/user/my-project',
-        locale: 'en',
-        experienceLevel: 'intermediate',
-        language: 'typescript',
-        framework: 'express',
-        packageManager: 'npm',
-        buildCommand: 'npm run build',
-        testCommand: 'npm test',
-        stack: ['typescript', 'express', 'postgresql'],
-        database: 'postgresql',
-        architecture: {
-            primary: 'layered',
-            secondary: [],
-            layers: [
-                { name: 'API', directories: ['src/routes'], responsibility: 'HTTP handling', dependsOn: ['Service'], neverDependsOn: ['Database'] },
-                { name: 'Service', directories: ['src/services'], responsibility: 'Business logic', dependsOn: [], neverDependsOn: [] },
-            ],
-            boundaries: [
-                { name: 'Auth', directories: ['src/auth'], publicApi: ['src/auth/index.ts'], internalOnly: [] },
-            ],
-            communicationPatterns: ['REST'],
-            deploymentUnits: ['docker'],
-        },
-        apps: [],
-        conventions: { 'naming-files': 'kebab-case', 'naming-variables': 'camelCase' },
-        layers: ['routes', 'services'],
-        environments: ['development'],
-        apiContracts: [],
-        specLocation: 'docs/sdd/specs',
-        envSetup: {
-            projectId: 'proj-1',
-            variables: [],
-            missing: [],
-            security: { gitignoreHasEnv: true, noSecretsInCode: true, noEnvInGit: true, noSecretsInLogs: true, usesSecretManager: false, issues: [] },
-            setupSteps: [],
-        },
-        linting: {
-            projectId: 'proj-1',
-            language: 'typescript',
-            detectedLinters: [],
-            missingRecommended: [],
-            rulesConflicts: [],
-            customRulesFromProject: [],
-            maturityScore: 0.5,
-        },
-        availableMcps: [],
-        docsRegistry: {},
-        qualityProfile: {
-            enabledCategories: ['solid', 'clean-code'],
-            customRules: [],
-            principles: ['SOLID', 'DRY'],
-            strictness: 'strict',
-        },
-        lastAnalyzed: '2025-01-01T00:00:00Z',
-        ...overrides,
-    };
-}
-function makePlatformsConfig() {
-    return {
-        platforms: {
-            'claude-code': {
-                name: 'Claude Code',
-                rulesFile: 'CLAUDE.md',
-                skillsDir: '.claude/skills/',
-                format: 'markdown',
-                capabilities: ['mcp', 'file-edit', 'bash'],
-                mcpSupport: true,
-            },
-            cursor: {
-                name: 'Cursor',
-                rulesFile: '.cursorrules',
-                skillsDir: null,
-                format: 'markdown',
-                capabilities: ['file-edit'],
-                mcpSupport: false,
-            },
-            windsurf: {
-                name: 'Windsurf',
-                rulesFile: '.windsurfrules',
-                skillsDir: null,
-                format: 'markdown',
-                capabilities: ['file-edit'],
-                mcpSupport: false,
-            },
-            aider: {
-                name: 'Aider',
-                rulesFile: '.aider.conf.yml',
-                skillsDir: null,
-                format: 'yaml',
-                capabilities: ['file-edit'],
-                mcpSupport: false,
-            },
-            copilot: {
-                name: 'GitHub Copilot',
-                rulesFile: '.github/copilot-instructions.md',
-                skillsDir: null,
-                format: 'markdown',
-                capabilities: ['completion'],
-                mcpSupport: false,
-            },
-            cline: {
-                name: 'Cline',
-                rulesFile: '.clinerules',
-                skillsDir: null,
-                format: 'markdown',
-                capabilities: ['file-edit', 'bash'],
-                mcpSupport: true,
-            },
-            continue: {
-                name: 'Continue.dev',
-                rulesFile: '.continue/config.json',
-                skillsDir: null,
-                format: 'json',
-                capabilities: ['completion'],
-                mcpSupport: false,
-            },
-        },
-        subAgentFrameworks: {},
-    };
-}
-function makeConstitution() {
-    return {
-        projectId: 'proj-1',
-        principles: [
-            {
-                id: 'p-1',
-                category: 'architecture',
-                principle: 'Use layered architecture',
-                rationale: 'Separation of concerns',
-                enforceLevel: 'strict',
-                autoEnforceable: true,
-                source: 'auto-detected',
-                immutable: false,
-            },
-            {
-                id: 'p-2',
-                category: 'security',
-                principle: 'No hardcoded secrets',
-                rationale: 'Security best practice',
-                enforceLevel: 'recommended',
-                autoEnforceable: true,
-                source: 'user-defined',
-                immutable: true,
-            },
-        ],
-        createdAt: '2025-01-01T00:00:00Z',
-        updatedAt: '2025-01-01T00:00:00Z',
-        version: 1,
-    };
-}
-// === Setup ===
-function setupConfigMock() {
-    mockedReadFile.mockResolvedValue(JSON.stringify(makePlatformsConfig()));
-}
-beforeEach(() => {
-    vi.resetAllMocks();
-});
-// === Tests for generateSkill ===
-describe('generateSkill', () => {
-    describe('unsupported platform', () => {
-        it('returns error for unknown platform', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateSkill('nonexistent-platform', 'project-rules', 'My Rules', 'Some description', knowledge);
-            expect(result.files).toEqual([]);
-            expect(result.message).toContain('Unknown platform');
-            expect(result.installInstructions).toContain('not yet supported');
-        });
-    });
-    describe('project-rules skill type', () => {
-        it('generates project rules for claude-code', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateSkill('claude-code', 'project-rules', 'My Project Rules', 'Rules for the project', knowledge);
-            expect(result.platform).toBe('claude-code');
-            expect(result.files).toHaveLength(1);
-            expect(result.files[0].path).toContain('.claude/skills/my-project-rules.md');
-            expect(result.files[0].content).toContain('My Project Rules');
-            expect(result.files[0].content).toContain('Rules for the project');
-            expect(result.files[0].content).toContain('typescript');
-            expect(result.files[0].content).toContain('express');
-            expect(result.files[0].content).toContain('postgresql');
-            expect(result.files[0].content).toContain('layered');
-            expect(result.files[0].content).toContain('SOLID');
-            expect(result.files[0].content).toContain('API');
-            expect(result.message).toContain('project-rules');
-        });
-        it('uses rulesFile when no skillsDir', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateSkill('cursor', 'project-rules', 'My Rules', 'Description', knowledge);
-            expect(result.files[0].path).toBe('.cursorrules');
-        });
-        it('handles null framework', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge({ framework: null });
-            const result = await generateSkill('claude-code', 'project-rules', 'Rules', 'Desc', knowledge);
-            expect(result.files[0].content).toContain('Framework: none');
-        });
-    });
-    describe('domain-skill skill type', () => {
-        it('generates domain skill with specContent', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateSkill('claude-code', 'domain-skill', 'Auth Domain', 'Authentication domain skill', knowledge, 'This spec covers JWT authentication with refresh tokens.');
-            expect(result.files).toHaveLength(1);
-            expect(result.files[0].path).toContain('.claude/skills/auth-domain.md');
-            expect(result.files[0].content).toContain('Auth Domain');
-            expect(result.files[0].content).toContain('Authentication domain skill');
-            expect(result.files[0].content).toContain('Spec Content');
-            expect(result.files[0].content).toContain('JWT authentication');
-        });
-        it('generates domain skill without specContent', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateSkill('claude-code', 'domain-skill', 'Auth Domain', 'Authentication domain skill', knowledge);
-            expect(result.files[0].content).not.toContain('Spec Content');
-        });
-        it('uses skills/ fallback path when no skillsDir', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateSkill('cursor', 'domain-skill', 'Auth Domain', 'Desc', knowledge);
-            expect(result.files[0].path).toBe('skills/auth-domain.md');
-        });
-        it('handles null framework in context', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge({ framework: null });
-            const result = await generateSkill('claude-code', 'domain-skill', 'Auth', 'Desc', knowledge);
-            expect(result.files[0].content).toContain('typescript/native');
-        });
-    });
-    describe('workflow skill type', () => {
-        it('generates workflow skill', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateSkill('claude-code', 'workflow', 'SDD Workflow', 'Follow the SDD process', knowledge);
-            expect(result.files).toHaveLength(1);
-            expect(result.files[0].content).toContain('Workflow Steps');
-            expect(result.files[0].content).toContain('npm run build');
-            expect(result.files[0].content).toContain('npm test');
-            expect(result.files[0].content).toContain('docs/sdd/specs');
-        });
-        it('omits build/test when null', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge({ buildCommand: null, testCommand: null });
-            const result = await generateSkill('claude-code', 'workflow', 'Workflow', 'Desc', knowledge);
-            expect(result.files[0].content).not.toContain('Build:');
-            expect(result.files[0].content).not.toContain('Test:');
-        });
-        it('uses skills/ fallback path when no skillsDir', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateSkill('cursor', 'workflow', 'My Workflow', 'Desc', knowledge);
-            expect(result.files[0].path).toBe('skills/my-workflow.md');
-        });
-    });
-    describe('convention skill type', () => {
-        it('generates convention skill', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateSkill('claude-code', 'convention', 'Code Conventions', 'Team coding conventions', knowledge);
-            expect(result.files).toHaveLength(1);
-            expect(result.files[0].content).toContain('Code Conventions');
-            expect(result.files[0].content).toContain('naming-files');
-            expect(result.files[0].content).toContain('kebab-case');
-            expect(result.files[0].content).toContain('Strictness: strict');
-            expect(result.files[0].content).toContain('SOLID');
-            expect(result.files[0].content).toContain('solid');
-            expect(result.files[0].content).toContain('clean-code');
-        });
-        it('uses skills/ fallback path when no skillsDir', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateSkill('cursor', 'convention', 'My Conventions', 'Desc', knowledge);
-            expect(result.files[0].path).toBe('skills/my-conventions.md');
-        });
-    });
-    describe('install instructions', () => {
-        it('adds claude-code specific instructions', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateSkill('claude-code', 'project-rules', 'Rules', 'Desc', knowledge);
-            expect(result.installInstructions).toContain('Claude Code');
-            expect(result.installInstructions).toContain('CLAUDE.md');
-        });
-        it('adds cursor specific instructions', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateSkill('cursor', 'project-rules', 'Rules', 'Desc', knowledge);
-            expect(result.installInstructions).toContain('Cursor');
-            expect(result.installInstructions).toContain('.cursorrules');
-        });
-        it('adds windsurf specific instructions', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateSkill('windsurf', 'project-rules', 'Rules', 'Desc', knowledge);
-            expect(result.installInstructions).toContain('Windsurf');
-            expect(result.installInstructions).toContain('.windsurfrules');
-        });
-        it('generates generic instructions for other platforms', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateSkill('cline', 'project-rules', 'Rules', 'Desc', knowledge);
-            expect(result.installInstructions).toContain('Cline');
-            expect(result.installInstructions).not.toContain('automatically detect');
-        });
-    });
-    describe('all platforms', () => {
-        const platforms = ['claude-code', 'cursor', 'windsurf', 'aider', 'copilot', 'cline', 'continue'];
-        for (const platform of platforms) {
-            it(`generates skill for ${platform}`, async () => {
-                setupConfigMock();
-                const knowledge = makeKnowledge();
-                const result = await generateSkill(platform, 'project-rules', 'Rules', 'Description', knowledge);
-                expect(result.platform).toBe(platform);
-                expect(result.files).toHaveLength(1);
-                expect(result.message).toContain('project-rules');
-            });
-        }
-    });
-});
-// === Tests for generateRules ===
-describe('generateRules', () => {
-    describe('unsupported platform', () => {
-        it('returns empty rules for unknown platform', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('nonexistent', knowledge);
-            expect(result.rulesFile.path).toBe('');
-            expect(result.rulesFile.content).toBe('Platform not supported');
-            expect(result.rulesCount).toBe(0);
-            expect(result.categories).toEqual([]);
-        });
-    });
-    describe('markdown format platforms', () => {
-        it('generates full rules for claude-code with all sections', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('claude-code', knowledge);
-            expect(result.platform).toBe('claude-code');
-            expect(result.rulesFile.path).toBe('CLAUDE.md');
-            expect(result.rulesFile.format).toBe('markdown');
-            expect(result.rulesCount).toBeGreaterThan(0);
-            expect(result.categories).toContain('project');
-            expect(result.categories).toContain('architecture');
-            expect(result.categories).toContain('conventions');
-            expect(result.categories).toContain('quality');
-            expect(result.categories).toContain('workflow');
-        });
-        it('includes project overview rules', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('claude-code', knowledge);
-            expect(result.rulesFile.content).toContain('typescript');
-            expect(result.rulesFile.content).toContain('express');
-            expect(result.rulesFile.content).toContain('postgresql');
-            expect(result.rulesFile.content).toContain('npm');
-            expect(result.rulesFile.content).toContain('typescript, express, postgresql');
-        });
-        it('omits database rule when unknown', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge({ database: 'unknown' });
-            const result = await generateRules('claude-code', knowledge);
-            expect(result.rulesFile.content).not.toContain('Database: unknown');
-        });
-        it('omits package manager rule when null', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge({ packageManager: null });
-            const result = await generateRules('claude-code', knowledge);
-            expect(result.rulesFile.content).not.toContain('Package manager:');
-        });
-        it('omits stack rule when empty', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge({ stack: [] });
-            const result = await generateRules('claude-code', knowledge);
-            expect(result.rulesFile.content).not.toContain('Tech stack:');
-        });
-        it('omits framework in project overview when null', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge({ framework: null });
-            const result = await generateRules('claude-code', knowledge);
-            expect(result.rulesFile.content).toContain('typescript project');
-            expect(result.rulesFile.content).not.toContain('using express');
-        });
-        it('includes architecture rules with layers and boundaries', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('claude-code', knowledge);
-            expect(result.rulesFile.content).toContain('Architecture');
-            expect(result.rulesFile.content).toContain('layered');
-            expect(result.rulesFile.content).toContain('API');
-            expect(result.rulesFile.content).toContain('NEVER import from');
-            expect(result.rulesFile.content).toContain('Auth');
-        });
-        it('omits neverDependsOn when empty', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            // Service layer has no neverDependsOn
-            const result = await generateRules('claude-code', knowledge);
-            // Only API has neverDependsOn Database
-            expect(result.rulesFile.content).toContain('NEVER import from Database');
-        });
-        it('includes conventions', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('claude-code', knowledge);
-            expect(result.rulesFile.content).toContain('naming-files');
-            expect(result.rulesFile.content).toContain('kebab-case');
-            expect(result.rulesFile.content).toContain('descriptive');
-            expect(result.rulesFile.content).toContain('pure functions');
-        });
-        it('includes quality rules', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('claude-code', knowledge);
-            expect(result.rulesFile.content).toContain('Quality');
-            expect(result.rulesFile.content).toContain('SOLID');
-            expect(result.rulesFile.content).toContain('security issues');
-            expect(result.rulesFile.content).toContain('Handle all errors');
-        });
-        it('uses strict enforcement for strict quality profile', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('claude-code', knowledge);
-            expect(result.rulesFile.content).toContain('[STRICT]');
-        });
-        it('uses recommended enforcement for non-strict profile', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge({
-                qualityProfile: {
-                    enabledCategories: [],
-                    customRules: [],
-                    principles: ['KISS'],
-                    strictness: 'relaxed',
-                },
-            });
-            const result = await generateRules('claude-code', knowledge);
-            // KISS should be recommended, not strict
-            const kissLine = result.rulesFile.content.split('\n').find((l) => l.includes('KISS'));
-            expect(kissLine).toBeDefined();
-            expect(kissLine).not.toContain('[STRICT]');
-        });
-        it('includes workflow rules with build/test commands', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('claude-code', knowledge);
-            expect(result.rulesFile.content).toContain('Workflow');
-            expect(result.rulesFile.content).toContain('docs/sdd/specs');
-            expect(result.rulesFile.content).toContain('npm run build');
-            expect(result.rulesFile.content).toContain('npm test');
-        });
-        it('omits build/test rules when null', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge({ buildCommand: null, testCommand: null });
-            const result = await generateRules('claude-code', knowledge);
-            expect(result.rulesFile.content).not.toContain('Build command:');
-            expect(result.rulesFile.content).not.toContain('Test command:');
-        });
-        it('includes constitution when provided', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const constitution = makeConstitution();
-            const result = await generateRules('claude-code', knowledge, constitution);
-            expect(result.categories).toContain('constitution');
-            expect(result.rulesFile.content).toContain('Project Constitution');
-            expect(result.rulesFile.content).toContain('Use layered architecture');
-            expect(result.rulesFile.content).toContain('Separation of concerns');
-        });
-        it('includes custom rules when provided', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('claude-code', knowledge, undefined, {
-                customRules: ['Always use TypeScript strict mode', 'No any types'],
-            });
-            expect(result.categories).toContain('custom');
-            expect(result.rulesFile.content).toContain('Custom Rules');
-            expect(result.rulesFile.content).toContain('Always use TypeScript strict mode');
-            expect(result.rulesFile.content).toContain('No any types');
-        });
-        it('respects include flags - exclude architecture', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('claude-code', knowledge, undefined, {
-                includeArchitecture: false,
-            });
-            expect(result.categories).not.toContain('architecture');
-        });
-        it('respects include flags - exclude conventions', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('claude-code', knowledge, undefined, {
-                includeConventions: false,
-            });
-            expect(result.categories).not.toContain('conventions');
-        });
-        it('respects include flags - exclude quality', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('claude-code', knowledge, undefined, {
-                includeQuality: false,
-            });
-            expect(result.categories).not.toContain('quality');
-        });
-        it('respects include flags - exclude workflow', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('claude-code', knowledge, undefined, {
-                includeWorkflow: false,
-            });
-            expect(result.categories).not.toContain('workflow');
-        });
-        it('excludes all optional sections', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('claude-code', knowledge, undefined, {
-                includeArchitecture: false,
-                includeConventions: false,
-                includeQuality: false,
-                includeWorkflow: false,
-            });
-            expect(result.categories).toEqual(['project']);
-        });
-        it('generates additional SDD workflow file for claude-code', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('claude-code', knowledge);
-            expect(result.additionalFiles).toHaveLength(1);
-            expect(result.additionalFiles[0].path).toContain('.claude/skills/sdd-workflow.md');
-            expect(result.additionalFiles[0].content).toContain('SDD Workflow Skill');
-            expect(result.additionalFiles[0].content).toContain('typescript');
-            expect(result.additionalFiles[0].content).toContain('layered');
-            expect(result.additionalFiles[0].content).toContain('docs/sdd/specs');
-        });
-        it('handles null framework in additional file', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge({ framework: null });
-            const result = await generateRules('claude-code', knowledge);
-            expect(result.additionalFiles[0].content).toContain('Framework: none');
-        });
-        it('does not generate additional files for non-claude-code platforms', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('cursor', knowledge);
-            expect(result.additionalFiles).toHaveLength(0);
-        });
-        it('includes platform title in markdown header', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('claude-code', knowledge);
-            expect(result.rulesFile.content).toContain('# Claude Code Rules');
-        });
-        it('uses correct platform title for cursor', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('cursor', knowledge);
-            expect(result.rulesFile.content).toContain('# Cursor Rules');
-        });
-        it('uses correct platform title for windsurf', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('windsurf', knowledge);
-            expect(result.rulesFile.content).toContain('# Windsurf Rules');
-        });
-        it('uses correct platform title for copilot', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('copilot', knowledge);
-            expect(result.rulesFile.content).toContain('# GitHub Copilot Rules');
-        });
-        it('uses correct platform title for cline', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('cline', knowledge);
-            expect(result.rulesFile.content).toContain('# Cline Rules');
-        });
-        it('uses correct platform title for continue', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            // Continue uses JSON format, so the title won't be in markdown
-            // but the JSON output should be valid
-            const result = await generateRules('continue', knowledge);
-            // JSON format doesn't have platform title in same way
-            expect(result.rulesFile.format).toBe('json');
-        });
-        it('uses correct platform title for aider', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('aider', knowledge);
-            // aider uses yaml format, check that it is YAML and has auto-generated header
-            expect(result.rulesFile.content).toContain('# Auto-generated by SpecForge');
-        });
-    });
-    describe('json format platforms', () => {
-        it('generates rules in JSON format for continue', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('continue', knowledge);
-            expect(result.rulesFile.format).toBe('json');
-            const parsed = JSON.parse(result.rulesFile.content);
-            expect(parsed).toBeDefined();
-            expect(parsed.project_overview).toBeDefined();
-            expect(parsed.architecture).toBeDefined();
-            expect(parsed.conventions).toBeDefined();
-            expect(parsed.quality).toBeDefined();
-            expect(parsed.workflow).toBeDefined();
-        });
-        it('JSON format includes enforcement level', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('continue', knowledge);
-            const parsed = JSON.parse(result.rulesFile.content);
-            expect(parsed.project_overview[0]).toHaveProperty('rule');
-            expect(parsed.project_overview[0]).toHaveProperty('enforcement');
-        });
-    });
-    describe('yaml format platforms', () => {
-        it('generates rules in YAML format for aider', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge();
-            const result = await generateRules('aider', knowledge);
-            expect(result.rulesFile.format).toBe('yaml');
-            expect(result.rulesFile.content).toContain('# Auto-generated by SpecForge');
-            expect(result.rulesFile.content).toContain('project_overview:');
-            expect(result.rulesFile.content).toContain('enforcement: strict');
-        });
-        it('escapes double quotes in YAML', async () => {
-            setupConfigMock();
-            const knowledge = makeKnowledge({
-                conventions: { 'quote-test': 'Use "double" quotes carefully' },
-            });
-            const result = await generateRules('aider', knowledge);
-            expect(result.rulesFile.content).toContain('\\"double\\"');
-        });
-    });
-    describe('all platforms generate rules', () => {
-        const platforms = ['claude-code', 'cursor', 'windsurf', 'aider', 'copilot', 'cline', 'continue'];
-        for (const platform of platforms) {
-            it(`generates rules for ${platform}`, async () => {
-                setupConfigMock();
-                const knowledge = makeKnowledge();
-                const result = await generateRules(platform, knowledge);
-                expect(result.platform).toBe(platform);
-                expect(result.rulesCount).toBeGreaterThan(0);
-                expect(result.categories).toContain('project');
-            });
-        }
-    });
-});
-// === Tests for getAgentConfig ===
-describe('getAgentConfig', () => {
-    it('returns config for known platform', async () => {
-        setupConfigMock();
-        const config = await getAgentConfig('claude-code');
-        expect(config.platform).toBe('claude-code');
-        expect(config.rulesFile).toBe('CLAUDE.md');
-        expect(config.skillsDir).toBe('.claude/skills/');
-        expect(config.format).toBe('markdown');
-        expect(config.capabilities).toContain('mcp');
-        expect(config.mcpSupport).toBe(true);
-    });
-    it('returns empty config for unknown platform', async () => {
-        setupConfigMock();
-        const config = await getAgentConfig('nonexistent');
-        expect(config.platform).toBe('nonexistent');
-        expect(config.rulesFile).toBe('');
-        expect(config.format).toBe('markdown');
-        expect(config.capabilities).toEqual([]);
-        expect(config.mcpSupport).toBe(false);
-    });
-    it('returns undefined skillsDir when platform has null', async () => {
-        setupConfigMock();
-        const config = await getAgentConfig('cursor');
-        expect(config.skillsDir).toBeUndefined();
-    });
-});
-// === Tests for detectAgentPlatform ===
-describe('detectAgentPlatform', () => {
-    it('detects claude-code from CLAUDE.md', async () => {
-        setupConfigMock();
-        const result = await detectAgentPlatform({ 'ai-rules': 'CLAUDE.md' });
-        expect(result.platform).toBe('claude-code');
-        expect(result.confidence).toBeGreaterThan(0);
-        expect(result.detectedFrom.length).toBeGreaterThan(0);
-    });
-    it('detects cursor from cursor-rules', async () => {
-        setupConfigMock();
-        const result = await detectAgentPlatform({ 'cursor-rules': '.cursorrules' });
-        expect(result.platform).toBe('cursor');
-        expect(result.confidence).toBeGreaterThan(0);
-        expect(result.detectedFrom).toContain('.cursorrules detected');
-    });
-    it('detects from rules file convention', async () => {
-        setupConfigMock();
-        const result = await detectAgentPlatform({ 'ai-rules': '.clinerules' });
-        expect(result.platform).toBe('cline');
-        expect(result.detectedFrom).toContain('Rules file: .clinerules');
-    });
-    it('defaults to claude-code with 0 confidence when no match', async () => {
-        setupConfigMock();
-        const result = await detectAgentPlatform({});
-        expect(result.platform).toBe('claude-code');
-        expect(result.confidence).toBe(0);
-        expect(result.detectedFrom).toEqual([]);
-    });
-    it('prefers higher score platform', async () => {
-        setupConfigMock();
-        // CLAUDE.md gives score 8 (3+5), so it should win
-        const result = await detectAgentPlatform({
-            'ai-rules': 'CLAUDE.md',
-            'cursor-rules': '.cursorrules',
-        });
-        expect(result.platform).toBe('claude-code');
-    });
-    it('caps confidence at 1', async () => {
-        setupConfigMock();
-        const result = await detectAgentPlatform({ 'ai-rules': 'CLAUDE.md' });
-        expect(result.confidence).toBeLessThanOrEqual(1);
-    });
-});
-// === Tests for loadPlatforms cache and error handling ===
-describe('loadPlatforms', () => {
-    it('uses cache on subsequent calls', async () => {
-        setupConfigMock();
-        await generateSkill('claude-code', 'project-rules', 'R', 'D', makeKnowledge());
-        await generateSkill('cursor', 'project-rules', 'R', 'D', makeKnowledge());
-        // readFile should have been called at most once due to caching
-        expect(mockedReadFile.mock.calls.length).toBeLessThanOrEqual(1);
-    });
-});
-//# sourceMappingURL=skill-generator.test.js.map