@aicgen/aicgen 1.0.0-beta.1 → 1.0.0

package/src/__tests__/services/assistant-file-writer.test.ts

@@ -1,400 +0,0 @@
-import { describe, test, expect, beforeAll } from 'bun:test';
-import { AssistantFileWriter } from '../../services/assistant-file-writer.js';
-import { GuidelineLoader } from '../../services/guideline-loader.js';
-import type { ProfileSelection } from '../../models/profile.js';
-
-describe('AssistantFileWriter', () => {
-  let writer: AssistantFileWriter;
-  let loader: GuidelineLoader;
-  const testSelection: ProfileSelection = {
-    assistant: 'claude-code',
-    language: 'typescript',
-    level: 'standard',
-    architecture: 'microservices',
-    projectType: 'api',
-    projectName: 'test-project',
-    datasource: 'sql'
-  };
-
-  beforeAll(async () => {
-    writer = await AssistantFileWriter.create();
-    loader = await GuidelineLoader.create();
-  });
-
-  describe('Claude Code Files', () => {
-    test('should generate files for Claude Code', async () => {
-      const guidelineIds = loader.getGuidelinesForProfile(
-        testSelection.language,
-        testSelection.level,
-        testSelection.architecture,
-        testSelection.datasource
-      );
-
-      const files = await writer.generateFiles(
-        'claude-code',
-        guidelineIds,
-        testSelection,
-        '/test/path'
-      );
-
-      expect(files.length).toBeGreaterThan(0);
-      expect(files.some(f => f.path.endsWith('CLAUDE.md'))).toBe(true);
-      expect(files.some(f => f.path.includes('.claude') && f.path.includes('guidelines'))).toBe(true);
-      expect(files.some(f => f.path.endsWith('settings.json'))).toBe(true);
-    });
-
-    test('should create separate guideline files by category', async () => {
-      const guidelineIds = loader.getGuidelinesForProfile(
-        testSelection.language,
-        testSelection.level,
-        testSelection.architecture,
-        testSelection.datasource
-      );
-
-      const files = await writer.generateFiles(
-        'claude-code',
-        guidelineIds,
-        testSelection,
-        '/test/path'
-      );
-
-      const guidelineFiles = files.filter(f => f.type === 'guideline');
-      expect(guidelineFiles.length).toBeGreaterThan(0);
-
-      // Should have files like language.md, architecture.md, etc.
-      expect(guidelineFiles.some(f => f.path.includes('language.md'))).toBe(true);
-    });
-
-    test('should create CLAUDE.md with references not content', async () => {
-      const guidelineIds = loader.getGuidelinesForProfile(
-        testSelection.language,
-        testSelection.level,
-        testSelection.architecture,
-        testSelection.datasource
-      );
-
-      const files = await writer.generateFiles(
-        'claude-code',
-        guidelineIds,
-        testSelection,
-        '/test/path'
-      );
-
-      const claudeFile = files.find(f => f.path.includes('CLAUDE.md'));
-      expect(claudeFile).toBeDefined();
-      expect(claudeFile!.content).toContain('@.claude/guidelines/');
-      expect(claudeFile!.content).toContain('## Guidelines');
-    });
-
-    test('should concatenate guidelines within each category file', async () => {
-      const guidelineIds = loader.getGuidelinesForProfile(
-        testSelection.language,
-        'full', // Use full to get more guidelines
-        testSelection.architecture,
-        testSelection.datasource
-      );
-
-      const files = await writer.generateFiles(
-        'claude-code',
-        guidelineIds,
-        { ...testSelection, level: 'full' },
-        '/test/path'
-      );
-
-      const languageFile = files.find(f => f.path.includes('language.md'));
-      expect(languageFile).toBeDefined();
-      expect(languageFile!.content).toContain('---'); // Separator between guidelines
-    });
-  });
-
-  describe('Copilot Files', () => {
-    test('should generate files for GitHub Copilot', async () => {
-      const guidelineIds = loader.getGuidelinesForProfile(
-        testSelection.language,
-        testSelection.level,
-        testSelection.architecture,
-        testSelection.datasource
-      );
-
-      const files = await writer.generateFiles(
-        'copilot',
-        guidelineIds,
-        { ...testSelection, assistant: 'copilot' },
-        '/test/path'
-      );
-
-      expect(files.length).toBeGreaterThan(0);
-      expect(files.some(f => f.path.includes('copilot-instructions.md'))).toBe(true);
-      expect(files.some(f => f.path.includes('.github') && f.path.includes('instructions'))).toBe(true);
-    });
-
-    test('should create instruction files with frontmatter', async () => {
-      const guidelineIds = loader.getGuidelinesForProfile(
-        testSelection.language,
-        testSelection.level,
-        testSelection.architecture,
-        testSelection.datasource
-      );
-
-      const files = await writer.generateFiles(
-        'copilot',
-        guidelineIds,
-        { ...testSelection, assistant: 'copilot' },
-        '/test/path'
-      );
-
-      const instructionFile = files.find(f =>
-        f.path.includes('.github') && f.path.includes('instructions') && f.path.endsWith('.instructions.md')
-      );
-      expect(instructionFile).toBeDefined();
-      expect(instructionFile!.content).toContain('---\napplyTo:');
-      expect(instructionFile!.content).toContain('description:');
-    });
-  });
-
-  describe('Gemini Files', () => {
-    test('should generate single instructions file for Gemini', async () => {
-      const guidelineIds = loader.getGuidelinesForProfile(
-        testSelection.language,
-        testSelection.level,
-        testSelection.architecture,
-        testSelection.datasource
-      );
-
-      const files = await writer.generateFiles(
-        'gemini',
-        guidelineIds,
-        { ...testSelection, assistant: 'gemini' },
-        '/test/path'
-      );
-
-      expect(files.length).toBe(2); // instructions.md + AGENTS.md
-      expect(files.some(f => f.path.includes('.gemini') && f.path.includes('instructions.md'))).toBe(true);
-    });
-
-    test('should inline all guidelines in Gemini file', async () => {
-      const guidelineIds = loader.getGuidelinesForProfile(
-        testSelection.language,
-        testSelection.level,
-        testSelection.architecture,
-        testSelection.datasource
-      );
-
-      const files = await writer.generateFiles(
-        'gemini',
-        guidelineIds,
-        { ...testSelection, assistant: 'gemini' },
-        '/test/path'
-      );
-
-      const geminiFile = files.find(f => f.path.includes('.gemini') && f.path.includes('instructions.md'));
-      expect(geminiFile).toBeDefined();
-      expect(geminiFile!.content).toContain('## Language');
-      expect(geminiFile!.content).toContain('---'); // Category separators
-    });
-  });
-
-  describe('Antigravity Files', () => {
-    test('should generate files for Antigravity', async () => {
-      const guidelineIds = loader.getGuidelinesForProfile(
-        testSelection.language,
-        testSelection.level,
-        testSelection.architecture,
-        testSelection.datasource
-      );
-
-      const files = await writer.generateFiles(
-        'antigravity',
-        guidelineIds,
-        { ...testSelection, assistant: 'antigravity' },
-        '/test/path'
-      );
-
-      expect(files.length).toBeGreaterThan(0);
-      expect(files.some(f => f.path.includes('.agent') && f.path.includes('rules') && f.path.includes('instructions.md'))).toBe(true);
-      expect(files.some(f => f.path.includes('.agent') && f.path.includes('rules') && !f.path.includes('instructions.md'))).toBe(true);
-      expect(files.some(f => f.path.includes('.agent') && f.path.includes('workflows'))).toBe(true);
-    });
-
-    test('should create workflow files based on level', async () => {
-      const guidelineIds = loader.getGuidelinesForProfile(
-        testSelection.language,
-        'expert',
-        testSelection.architecture,
-        testSelection.datasource
-      );
-
-      const files = await writer.generateFiles(
-        'antigravity',
-        guidelineIds,
-        { ...testSelection, assistant: 'antigravity', level: 'expert' },
-        '/test/path'
-      );
-
-      const workflowFiles = files.filter(f => f.path.includes('.agent') && f.path.includes('workflows'));
-      expect(workflowFiles.length).toBeGreaterThan(2); // Expert should have more workflows
-    });
-
-    test('should create rule index with references', async () => {
-      const guidelineIds = loader.getGuidelinesForProfile(
-        testSelection.language,
-        testSelection.level,
-        testSelection.architecture,
-        testSelection.datasource
-      );
-
-      const files = await writer.generateFiles(
-        'antigravity',
-        guidelineIds,
-        { ...testSelection, assistant: 'antigravity' },
-        '/test/path'
-      );
-
-      const instructionsFile = files.find(f => f.path.includes('.agent') && f.path.includes('rules') && f.path.includes('instructions.md'));
-      expect(instructionsFile).toBeDefined();
-      expect(instructionsFile!.content).toContain('## Rule Index');
-      expect(instructionsFile!.content).toContain('@.agent/rules/');
-    });
-  });
-
-  describe('Codex Files', () => {
-    test('should generate single instructions file for Codex', async () => {
-      const guidelineIds = loader.getGuidelinesForProfile(
-        testSelection.language,
-        testSelection.level,
-        testSelection.architecture,
-        testSelection.datasource
-      );
-
-      const files = await writer.generateFiles(
-        'codex',
-        guidelineIds,
-        { ...testSelection, assistant: 'codex' },
-        '/test/path'
-      );
-
-      expect(files.length).toBe(2); // instructions.md + AGENTS.md
-      expect(files.some(f => f.path.includes('.codex') && f.path.includes('instructions.md'))).toBe(true);
-    });
-  });
-
-  describe('Universal AGENTS.md', () => {
-    test('should generate AGENTS.md for all assistants', async () => {
-      const guidelineIds = loader.getGuidelinesForProfile(
-        testSelection.language,
-        testSelection.level,
-        testSelection.architecture,
-        testSelection.datasource
-      );
-
-      const assistants: Array<'claude-code' | 'copilot' | 'gemini' | 'antigravity' | 'codex'> = [
-        'claude-code',
-        'copilot',
-        'gemini',
-        'antigravity',
-        'codex'
-      ];
-
-      for (const assistant of assistants) {
-        const files = await writer.generateFiles(
-          assistant,
-          guidelineIds,
-          { ...testSelection, assistant },
-          '/test/path'
-        );
-
-        const agentsFile = files.find(f => f.path.includes('AGENTS.md'));
-        expect(agentsFile).toBeDefined();
-        expect(agentsFile!.type).toBe('universal');
-        expect(agentsFile!.content).toContain('## Project Overview');
-      }
-    });
-  });
-
-  describe('File Paths', () => {
-    test('should prepend project path to all file paths', async () => {
-      const guidelineIds = loader.getGuidelinesForProfile(
-        testSelection.language,
-        testSelection.level,
-        testSelection.architecture,
-        testSelection.datasource
-      );
-
-      const files = await writer.generateFiles(
-        'claude-code',
-        guidelineIds,
-        testSelection,
-        '/custom/project/path'
-      );
-
-      files.forEach(file => {
-        // On Windows, paths will be normalized to use backslashes
-        expect(file.path.includes('custom') && file.path.includes('project')).toBe(true);
-      });
-    });
-  });
-
-  describe('Content Validation', () => {
-    test('all generated files should have non-empty content', async () => {
-      const guidelineIds = loader.getGuidelinesForProfile(
-        testSelection.language,
-        testSelection.level,
-        testSelection.architecture,
-        testSelection.datasource
-      );
-
-      const files = await writer.generateFiles(
-        'claude-code',
-        guidelineIds,
-        testSelection,
-        '/test/path'
-      );
-
-      files.forEach(file => {
-        expect(file.content.length).toBeGreaterThan(0);
-        expect(file.path.length).toBeGreaterThan(0);
-      });
-    });
-
-    test('should include project name in main files', async () => {
-      const guidelineIds = loader.getGuidelinesForProfile(
-        testSelection.language,
-        testSelection.level,
-        testSelection.architecture,
-        testSelection.datasource
-      );
-
-      const files = await writer.generateFiles(
-        'claude-code',
-        guidelineIds,
-        testSelection,
-        '/test/path'
-      );
-
-      const claudeFile = files.find(f => f.type === 'main');
-      expect(claudeFile).toBeDefined();
-      expect(claudeFile!.content).toContain(testSelection.projectName);
-    });
-
-    test('should include language and architecture in main files', async () => {
-      const guidelineIds = loader.getGuidelinesForProfile(
-        testSelection.language,
-        testSelection.level,
-        testSelection.architecture,
-        testSelection.datasource
-      );
-
-      const files = await writer.generateFiles(
-        'claude-code',
-        guidelineIds,
-        testSelection,
-        '/test/path'
-      );
-
-      const claudeFile = files.find(f => f.type === 'main');
-      expect(claudeFile).toBeDefined();
-      expect(claudeFile!.content).toContain(testSelection.language);
-      expect(claudeFile!.content).toContain(testSelection.architecture);
-    });
-  });
-});

package/src/__tests__/services/guideline-loader.test.ts

@@ -1,281 +0,0 @@
-import { describe, test, expect, beforeAll } from 'bun:test';
-import { GuidelineLoader } from '../../services/guideline-loader.js';
-import type { Language, InstructionLevel, ArchitectureType, DatasourceType } from '../../models/profile.js';
-
-describe('GuidelineLoader', () => {
-  let loader: GuidelineLoader;
-
-  beforeAll(async () => {
-    loader = await GuidelineLoader.create();
-  });
-
-  describe('Initialization', () => {
-    test('should load embedded guidelines', async () => {
-      expect(loader).toBeDefined();
-      const stats = loader.getStats();
-      expect(stats.totalGuidelines).toBeGreaterThan(0);
-    });
-
-    test('should have correct guideline count', async () => {
-      const stats = loader.getStats();
-      expect(stats.totalGuidelines).toBe(82);
-    });
-
-    test('should have expected categories', async () => {
-      const stats = loader.getStats();
-      expect(stats.byCategory).toBeDefined();
-      expect(stats.byCategory['Language']).toBeGreaterThan(0);
-      expect(stats.byCategory['Architecture']).toBeGreaterThan(0);
-      expect(stats.byCategory['Testing']).toBeGreaterThan(0);
-      expect(stats.byCategory['Security']).toBeGreaterThan(0);
-    });
-  });
-
-  describe('Full Level Filtering', () => {
-    test('should include ALL guidelines for full level regardless of architecture', async () => {
-      const typescript = loader.getGuidelinesForProfile('typescript', 'full', 'microservices', 'sql');
-      const typescriptMonolith = loader.getGuidelinesForProfile('typescript', 'full', 'modular-monolith', 'sql');
-
-      // Full level should return same count regardless of architecture
-      expect(typescript.length).toBe(typescriptMonolith.length);
-      expect(typescript.length).toBeGreaterThanOrEqual(65); // Should include all applicable guidelines
-    });
-
-    test('should include all architecture patterns in full level', async () => {
-      const guidelines = loader.getGuidelinesForProfile('typescript', 'full', 'microservices', 'sql');
-      const allGuidelines = loader.getAllGuidelines();
-
-      // Check if architecture-specific guidelines from OTHER architectures are included
-      const architectureGuidelines = allGuidelines.filter(g =>
-        g.mapping.architectures && g.mapping.architectures.length > 0
-      );
-
-      // At least some architecture guidelines should be in the result
-      const includedArchGuidelines = guidelines.filter(id => {
-        const mapping = loader.getMapping(id);
-        return mapping?.architectures && mapping.architectures.length > 0;
-      });
-
-      expect(includedArchGuidelines.length).toBeGreaterThan(0);
-    });
-
-    test('full level should include microservices guidelines even when selecting modular-monolith', async () => {
-      const guidelines = loader.getGuidelinesForProfile('typescript', 'full', 'modular-monolith', 'sql');
-
-      // Find a microservices-specific guideline
-      const allGuidelines = loader.getAllGuidelines();
-      const microservicesGuideline = allGuidelines.find(g =>
-        g.mapping.architectures?.includes('microservices') &&
-        !g.mapping.architectures?.includes('modular-monolith')
-      );
-
-      if (microservicesGuideline) {
-        expect(guidelines).toContain(microservicesGuideline.id);
-      }
-    });
-  });
-
-  describe('Level-Based Filtering', () => {
-    test('basic level should return fewer guidelines than standard', async () => {
-      const basic = loader.getGuidelinesForProfile('typescript', 'basic', 'microservices', 'sql');
-      const standard = loader.getGuidelinesForProfile('typescript', 'standard', 'microservices', 'sql');
-
-      expect(basic.length).toBeLessThan(standard.length);
-    });
-
-    test('standard level should return fewer guidelines than expert', async () => {
-      const standard = loader.getGuidelinesForProfile('typescript', 'standard', 'microservices', 'sql');
-      const expert = loader.getGuidelinesForProfile('typescript', 'expert', 'microservices', 'sql');
-
-      expect(standard.length).toBeLessThan(expert.length);
-    });
-
-    test('expert level should return fewer or equal guidelines than full', async () => {
-      const expert = loader.getGuidelinesForProfile('typescript', 'expert', 'microservices', 'sql');
-      const full = loader.getGuidelinesForProfile('typescript', 'full', 'microservices', 'sql');
-
-      expect(expert.length).toBeLessThanOrEqual(full.length);
-    });
-  });
-
-  describe('Architecture-Based Filtering', () => {
-    test('should filter by architecture for non-full levels', async () => {
-      const microservices = loader.getGuidelinesForProfile('typescript', 'expert', 'microservices', 'sql');
-      const monolith = loader.getGuidelinesForProfile('typescript', 'expert', 'modular-monolith', 'sql');
-
-      // At non-full levels, different architectures should give different results
-      // (though some guidelines may be shared)
-      expect(microservices).toBeDefined();
-      expect(monolith).toBeDefined();
-    });
-
-    test('should NOT filter by architecture for full level', async () => {
-      const microservices = loader.getGuidelinesForProfile('typescript', 'full', 'microservices', 'sql');
-      const monolith = loader.getGuidelinesForProfile('typescript', 'full', 'modular-monolith', 'sql');
-
-      // Full level should return same guidelines regardless of selected architecture
-      expect(microservices.length).toBe(monolith.length);
-    });
-  });
-
-  describe('Language-Based Filtering', () => {
-    test('should filter by language', async () => {
-      const typescript = loader.getGuidelinesForProfile('typescript', 'standard', 'microservices', 'sql');
-      const python = loader.getGuidelinesForProfile('python', 'standard', 'microservices', 'sql');
-
-      // Different languages should have some different guidelines
-      expect(typescript).toBeDefined();
-      expect(python).toBeDefined();
-      expect(typescript.length).toBeGreaterThan(0);
-      expect(python.length).toBeGreaterThan(0);
-    });
-
-    test('should include language-agnostic guidelines for all languages', async () => {
-      const typescript = loader.getGuidelinesForProfile('typescript', 'standard', 'microservices', 'sql');
-      const python = loader.getGuidelinesForProfile('python', 'standard', 'microservices', 'sql');
-
-      // Find language-agnostic guidelines
-      const allGuidelines = loader.getAllGuidelines();
-      const agnosticGuideline = allGuidelines.find(g => !g.mapping.languages);
-
-      if (agnosticGuideline) {
-        // Language-agnostic guidelines should be in both
-        expect(typescript).toContain(agnosticGuideline.id);
-        expect(python).toContain(agnosticGuideline.id);
-      }
-    });
-  });
-
-  describe('Datasource Filtering', () => {
-    test('should exclude database guidelines when datasource is none', async () => {
-      const withDb = loader.getGuidelinesForProfile('typescript', 'standard', 'microservices', 'sql');
-      const withoutDb = loader.getGuidelinesForProfile('typescript', 'standard', 'microservices', 'none');
-
-      expect(withoutDb.length).toBeLessThan(withDb.length);
-    });
-
-    test('should include SQL guidelines when datasource is sql', async () => {
-      const guidelines = loader.getGuidelinesForProfile('typescript', 'standard', 'microservices', 'sql');
-      const categoryTree = loader.getGuidelinesByCategory('typescript', 'standard', 'microservices', 'sql');
-
-      // Should have database category when SQL is selected
-      expect(categoryTree['Database']).toBeDefined();
-    });
-
-    test('should exclude database category when datasource is none', async () => {
-      const categoryTree = loader.getGuidelinesByCategory('typescript', 'standard', 'microservices', 'none');
-
-      // Should NOT have database category when datasource is none
-      expect(categoryTree['Database']).toBeUndefined();
-    });
-  });
-
-  describe('Guideline Loading', () => {
-    test('should load guideline content by ID', async () => {
-      const guidelines = loader.getGuidelinesForProfile('typescript', 'basic', 'microservices', 'sql');
-      expect(guidelines.length).toBeGreaterThan(0);
-
-      const content = loader.loadGuideline(guidelines[0]);
-      expect(content).toBeDefined();
-      expect(typeof content).toBe('string');
-      expect(content.length).toBeGreaterThan(0);
-    });
-
-    test('should throw error for invalid guideline ID', async () => {
-      expect(() => loader.loadGuideline('invalid-guideline-id-12345')).toThrow();
-    });
-  });
-
-  describe('Guideline Mapping', () => {
-    test('should get mapping for guideline ID', async () => {
-      const guidelines = loader.getGuidelinesForProfile('typescript', 'basic', 'microservices', 'sql');
-      const mapping = loader.getMapping(guidelines[0]);
-
-      expect(mapping).toBeDefined();
-      expect(mapping?.path).toBeDefined();
-      expect(mapping?.category).toBeDefined();
-    });
-
-    test('should return undefined for invalid guideline ID', async () => {
-      const mapping = loader.getMapping('invalid-guideline-id-12345');
-      expect(mapping).toBeUndefined();
-    });
-  });
-
-  describe('Profile Assembly', () => {
-    test('should assemble complete profile', async () => {
-      const profile = loader.assembleProfile('typescript', 'basic', 'microservices', 'sql');
-
-      expect(profile).toBeDefined();
-      expect(typeof profile).toBe('string');
-      expect(profile.length).toBeGreaterThan(0);
-      expect(profile).toContain('---'); // Should have separator between guidelines
-    });
-
-    test('should throw error when no guidelines found', async () => {
-      // This would only throw if we had a scenario with truly no matching guidelines
-      // Since basic level includes language-agnostic guidelines, most profiles will have some
-      // The method throws when guidelineIds.length === 0
-      const profile = loader.assembleProfile('typescript', 'basic', 'microservices', 'sql');
-      expect(profile).toBeDefined();
-    });
-  });
-
-  describe('Category Tree', () => {
-    test('should generate category tree', async () => {
-      const tree = loader.getCategoryTree('typescript', 'standard', 'microservices', 'sql');
-
-      expect(tree).toBeDefined();
-      expect(Array.isArray(tree)).toBe(true);
-      expect(tree.length).toBeGreaterThan(0);
-
-      const firstCategory = tree[0];
-      expect(firstCategory.name).toBeDefined();
-      expect(firstCategory.count).toBeGreaterThan(0);
-      expect(Array.isArray(firstCategory.guidelines)).toBe(true);
-    });
-
-    test('should include guideline details in tree', async () => {
-      const tree = loader.getCategoryTree('typescript', 'standard', 'microservices', 'sql');
-      const firstGuideline = tree[0].guidelines[0];
-
-      expect(firstGuideline.id).toBeDefined();
-      expect(firstGuideline.name).toBeDefined();
-      expect(firstGuideline.path).toBeDefined();
-    });
-  });
-
-  describe('Metrics', () => {
-    test('should calculate metrics for guidelines', async () => {
-      const guidelines = loader.getGuidelinesForProfile('typescript', 'standard', 'microservices', 'sql');
-      const metrics = loader.getMetrics(guidelines);
-
-      expect(metrics.guidelineCount).toBe(guidelines.length);
-      expect(metrics.hooksCount).toBeGreaterThanOrEqual(0);
-      expect(metrics.subAgentsCount).toBeGreaterThanOrEqual(1);
-      expect(metrics.estimatedSize).toBeDefined();
-      expect(Array.isArray(metrics.categories)).toBe(true);
-    });
-  });
-
-  describe('Statistics', () => {
-    test('should provide comprehensive stats', async () => {
-      const stats = loader.getStats();
-
-      expect(stats.totalGuidelines).toBe(82);
-      expect(Object.keys(stats.byLanguage).length).toBeGreaterThan(0);
-      expect(Object.keys(stats.byLevel).length).toBeGreaterThan(0);
-      expect(Object.keys(stats.byArchitecture).length).toBeGreaterThan(0);
-      expect(Object.keys(stats.byCategory).length).toBe(12);
-    });
-
-    test('should have expected level counts', async () => {
-      const stats = loader.getStats();
-
-      expect(stats.byLevel['basic']).toBe(17);
-      expect(stats.byLevel['standard']).toBe(68);
-      expect(stats.byLevel['expert']).toBe(82);
-      expect(stats.byLevel['full']).toBe(82);
-    });
-  });
-});