@planu/cli 0.89.0 → 0.90.1

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

@@ -0,0 +1,742 @@
+// 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