@deimoscloud/coreai 0.1.9 → 0.1.11

package/src/skills/generator.test.ts

@@ -1,602 +0,0 @@
-/**
- * Skill Generator Tests
- */
-
-import { promises as fs } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import type { ResolvedCoreAIConfig } from '../config/types.js';
-import {
-  extractVariables,
-  substituteVariables,
-  checkDependencies,
-  loadCustomTemplates,
-  generateSkills,
-  formatGenerateResult,
-} from './generator.js';
-import type { SkillTemplate, GenerateSkillsResult } from './types.js';
-
-describe('Skill Generator', () => {
-  describe('extractVariables', () => {
-    it('should return empty object for null config', () => {
-      const vars = extractVariables(null);
-      expect(vars).toEqual({});
-    });
-
-    it('should return empty object for undefined config', () => {
-      const vars = extractVariables(undefined);
-      expect(vars).toEqual({});
-    });
-
-    it('should extract project variables', () => {
-      const config = {
-        project: {
-          name: 'TestProject',
-          root: '/path/to/project',
-          type: 'software' as const,
-        },
-      } as ResolvedCoreAIConfig;
-
-      const vars = extractVariables(config);
-      expect(vars.PROJECT_NAME).toBe('TestProject');
-      expect(vars.PROJECT_ROOT).toBe('/path/to/project');
-      expect(vars.PROJECT_TYPE).toBe('software');
-    });
-
-    it('should extract issue tracker variables', () => {
-      const config = {
-        project: { name: 'Test', root: '/test' },
-        integrations: {
-          issue_tracker: {
-            provider: 'jira',
-            config: {
-              project_key: 'TEST',
-              base_url: 'https://jira.example.com',
-            },
-          },
-        },
-      } as ResolvedCoreAIConfig;
-
-      const vars = extractVariables(config);
-      expect(vars.JIRA_PROJECT).toBe('TEST');
-      expect(vars.JIRA_URL).toBe('https://jira.example.com');
-    });
-
-    it('should extract git variables', () => {
-      const config = {
-        project: { name: 'Test', root: '/test' },
-        integrations: {
-          git: {
-            provider: 'github',
-            config: {
-              owner: 'testowner',
-              repo: 'testrepo',
-              default_branch: 'main',
-            },
-          },
-        },
-      } as ResolvedCoreAIConfig;
-
-      const vars = extractVariables(config);
-      expect(vars.GITHUB_OWNER).toBe('testowner');
-      expect(vars.GITHUB_REPO).toBe('testrepo');
-      expect(vars.DEFAULT_BRANCH).toBe('main');
-    });
-
-    it('should extract documentation variables', () => {
-      const config = {
-        project: { name: 'Test', root: '/test' },
-        integrations: {
-          documentation: {
-            provider: 'confluence',
-            config: {
-              space_key: 'DOCS',
-              base_url: 'https://wiki.example.com',
-              base_path: '/docs',
-            },
-          },
-        },
-      } as ResolvedCoreAIConfig;
-
-      const vars = extractVariables(config);
-      expect(vars.CONFLUENCE_SPACE).toBe('DOCS');
-      expect(vars.CONFLUENCE_URL).toBe('https://wiki.example.com');
-      expect(vars.DOCS_PATH).toBe('/docs');
-    });
-
-    it('should extract quality gate variables', () => {
-      const config = {
-        project: { name: 'Test', root: '/test' },
-        quality_gates: {
-          lint: { command: 'npm run lint', required: true },
-          test: { command: 'npm test', required: true },
-          build: { command: 'npm run build', required: true },
-          static_analysis: { command: 'npm run analyze', required: false },
-        },
-      } as ResolvedCoreAIConfig;
-
-      const vars = extractVariables(config);
-      expect(vars.LINT_CMD).toBe('npm run lint');
-      expect(vars.TEST_CMD).toBe('npm test');
-      expect(vars.BUILD_CMD).toBe('npm run build');
-      expect(vars.STATIC_ANALYSIS_CMD).toBe('npm run analyze');
-    });
-
-    it('should extract tech stack variables', () => {
-      const config = {
-        project: { name: 'Test', root: '/test' },
-        tech_stack: {
-          primary_language: 'typescript',
-          frameworks: ['node.js', 'express'],
-        },
-      } as ResolvedCoreAIConfig;
-
-      const vars = extractVariables(config);
-      expect(vars.PRIMARY_LANGUAGE).toBe('typescript');
-    });
-  });
-
-  describe('substituteVariables', () => {
-    it('should replace single variable', () => {
-      const content = 'Hello, {{NAME}}!';
-      const result = substituteVariables(content, { NAME: 'World' });
-      expect(result).toBe('Hello, World!');
-    });
-
-    it('should replace multiple occurrences', () => {
-      const content = '{{NAME}} says {{NAME}}';
-      const result = substituteVariables(content, { NAME: 'Alice' });
-      expect(result).toBe('Alice says Alice');
-    });
-
-    it('should replace multiple variables', () => {
-      const content = '{{PROJECT}} by {{AUTHOR}}';
-      const result = substituteVariables(content, {
-        PROJECT: 'CoreAI',
-        AUTHOR: 'Team',
-      });
-      expect(result).toBe('CoreAI by Team');
-    });
-
-    it('should leave unreplaced variables intact', () => {
-      const content = '{{KNOWN}} and {{UNKNOWN}}';
-      const result = substituteVariables(content, { KNOWN: 'value' });
-      expect(result).toBe('value and {{UNKNOWN}}');
-    });
-
-    it('should handle empty variables', () => {
-      const content = 'No variables here';
-      const result = substituteVariables(content, {});
-      expect(result).toBe('No variables here');
-    });
-
-    it('should skip undefined values', () => {
-      const content = '{{A}} {{B}}';
-      const result = substituteVariables(content, {
-        A: 'defined',
-        B: undefined,
-      });
-      expect(result).toBe('defined {{B}}');
-    });
-  });
-
-  describe('checkDependencies', () => {
-    it('should return satisfied for skill without dependencies', () => {
-      const skill: SkillTemplate = {
-        name: 'test',
-        description: 'Test skill',
-        category: 'core',
-        content: 'content',
-      };
-
-      const result = checkDependencies(skill, null);
-      expect(result.satisfied).toBe(true);
-      expect(result.missing).toEqual([]);
-    });
-
-    it('should return satisfied for empty dependencies array', () => {
-      const skill: SkillTemplate = {
-        name: 'test',
-        description: 'Test skill',
-        category: 'core',
-        dependencies: [],
-        content: 'content',
-      };
-
-      const result = checkDependencies(skill, null);
-      expect(result.satisfied).toBe(true);
-    });
-
-    it('should skip optional dependencies', () => {
-      const skill: SkillTemplate = {
-        name: 'test',
-        description: 'Test skill',
-        category: 'core',
-        dependencies: [{ type: 'issue_tracker', required: false }],
-        content: 'content',
-      };
-
-      const result = checkDependencies(skill, null);
-      expect(result.satisfied).toBe(true);
-    });
-
-    it('should detect missing required integration', () => {
-      const skill: SkillTemplate = {
-        name: 'test',
-        description: 'Test skill',
-        category: 'optional',
-        dependencies: [{ type: 'issue_tracker', required: true }],
-        content: 'content',
-      };
-
-      const config = {
-        project: { name: 'Test', root: '/test' },
-      } as ResolvedCoreAIConfig;
-
-      const result = checkDependencies(skill, config);
-      expect(result.satisfied).toBe(false);
-      expect(result.missing).toHaveLength(1);
-      expect(result.missing[0]?.type).toBe('issue_tracker');
-    });
-
-    it('should satisfy when integration exists', () => {
-      const skill: SkillTemplate = {
-        name: 'test',
-        description: 'Test skill',
-        category: 'optional',
-        dependencies: [{ type: 'git', required: true }],
-        content: 'content',
-      };
-
-      const config = {
-        project: { name: 'Test', root: '/test' },
-        integrations: {
-          git: { provider: 'github', config: {} },
-        },
-      } as ResolvedCoreAIConfig;
-
-      const result = checkDependencies(skill, config);
-      expect(result.satisfied).toBe(true);
-    });
-
-    it('should check documentation dependency', () => {
-      const skill: SkillTemplate = {
-        name: 'test',
-        description: 'Test skill',
-        category: 'optional',
-        dependencies: [{ type: 'documentation', required: true }],
-        content: 'content',
-      };
-
-      const config = {
-        project: { name: 'Test', root: '/test' },
-        integrations: {
-          documentation: { provider: 'confluence', config: {} },
-        },
-      } as ResolvedCoreAIConfig;
-
-      const result = checkDependencies(skill, config);
-      expect(result.satisfied).toBe(true);
-    });
-
-    it('should check state dependency', () => {
-      const skill: SkillTemplate = {
-        name: 'test',
-        description: 'Test skill',
-        category: 'optional',
-        dependencies: [{ type: 'state', required: true }],
-        content: 'content',
-      };
-
-      const config = {
-        project: { name: 'Test', root: '/test' },
-        integrations: {
-          state: { provider: 'filesystem', config: {} },
-        },
-      } as ResolvedCoreAIConfig;
-
-      const result = checkDependencies(skill, config);
-      expect(result.satisfied).toBe(true);
-    });
-  });
-
-  describe('loadCustomTemplates', () => {
-    let testDir: string;
-
-    beforeEach(async () => {
-      testDir = join(
-        tmpdir(),
-        `skill-templates-test-${Date.now()}-${Math.random().toString(36).slice(2)}`
-      );
-      await fs.mkdir(testDir, { recursive: true });
-    });
-
-    afterEach(async () => {
-      try {
-        await fs.rm(testDir, { recursive: true, force: true });
-      } catch {
-        // Ignore cleanup errors
-      }
-    });
-
-    it('should return empty array for non-existent directory', () => {
-      const templates = loadCustomTemplates('/non/existent/path');
-      expect(templates).toEqual([]);
-    });
-
-    it('should load skill template from markdown file', async () => {
-      const content = `---
-description: Custom skill
-argument-hint: <argument>
----
-
-# Custom Skill
-
-This is a custom skill.
-`;
-      await fs.writeFile(join(testDir, 'custom-skill.md'), content);
-
-      const templates = loadCustomTemplates(testDir);
-      expect(templates).toHaveLength(1);
-      expect(templates[0]?.name).toBe('custom-skill');
-      expect(templates[0]?.description).toBe('Custom skill');
-      expect(templates[0]?.argumentHint).toBe('<argument>');
-      expect(templates[0]?.category).toBe('custom');
-    });
-
-    it('should parse required dependencies', async () => {
-      const content = `---
-description: Skill with deps
-requires: [jira, github]
----
-
-Content
-`;
-      await fs.writeFile(join(testDir, 'with-deps.md'), content);
-
-      const templates = loadCustomTemplates(testDir);
-      expect(templates).toHaveLength(1);
-      expect(templates[0]?.dependencies).toBeDefined();
-      expect(templates[0]?.dependencies).toHaveLength(2);
-      expect(templates[0]?.dependencies?.[0]?.type).toBe('issue_tracker');
-      expect(templates[0]?.dependencies?.[0]?.required).toBe(true);
-      expect(templates[0]?.dependencies?.[1]?.type).toBe('git');
-    });
-
-    it('should parse optional dependencies', async () => {
-      const content = `---
-description: Skill with optional deps
-optional: [docs]
----
-
-Content
-`;
-      await fs.writeFile(join(testDir, 'optional-deps.md'), content);
-
-      const templates = loadCustomTemplates(testDir);
-      expect(templates).toHaveLength(1);
-      expect(templates[0]?.dependencies).toHaveLength(1);
-      expect(templates[0]?.dependencies?.[0]?.type).toBe('documentation');
-      expect(templates[0]?.dependencies?.[0]?.required).toBe(false);
-    });
-
-    it('should skip non-markdown files', async () => {
-      await fs.writeFile(join(testDir, 'readme.txt'), 'Not a template');
-      await fs.writeFile(join(testDir, 'skill.md'), '---\ndescription: Test\n---\nContent');
-
-      const templates = loadCustomTemplates(testDir);
-      expect(templates).toHaveLength(1);
-      expect(templates[0]?.name).toBe('skill');
-    });
-  });
-
-  describe('generateSkills', () => {
-    let testDir: string;
-
-    beforeEach(async () => {
-      testDir = join(
-        tmpdir(),
-        `skill-gen-test-${Date.now()}-${Math.random().toString(36).slice(2)}`
-      );
-      await fs.mkdir(testDir, { recursive: true });
-    });
-
-    afterEach(async () => {
-      try {
-        await fs.rm(testDir, { recursive: true, force: true });
-      } catch {
-        // Ignore cleanup errors
-      }
-    });
-
-    it('should generate skills to output directory', () => {
-      const result = generateSkills(undefined, {
-        projectRoot: testDir,
-        includeCoreSkills: true,
-        includeOptionalSkills: false,
-      });
-
-      expect(result.generated.length).toBeGreaterThan(0);
-      expect(result.errors).toEqual([]);
-
-      // Check a file was created
-      const created = result.generated.filter((g) => g.action === 'created');
-      expect(created.length).toBeGreaterThan(0);
-    });
-
-    it('should skip existing files without overwrite', async () => {
-      const outputDir = join(testDir, '.claude', 'commands');
-      await fs.mkdir(outputDir, { recursive: true });
-      await fs.writeFile(join(outputDir, 'check-inbox.md'), 'existing content');
-
-      const result = generateSkills(undefined, {
-        projectRoot: testDir,
-        includeCoreSkills: true,
-        includeOptionalSkills: false,
-        skills: ['check-inbox'],
-      });
-
-      const skipped = result.generated.filter((g) => g.action === 'skipped');
-      expect(skipped).toHaveLength(1);
-      expect(skipped[0]?.name).toBe('check-inbox');
-      expect(skipped[0]?.skipReason).toContain('already exists');
-    });
-
-    it('should overwrite existing files with overwrite option', async () => {
-      const outputDir = join(testDir, '.claude', 'commands');
-      await fs.mkdir(outputDir, { recursive: true });
-      await fs.writeFile(join(outputDir, 'check-inbox.md'), 'old content');
-
-      const result = generateSkills(undefined, {
-        projectRoot: testDir,
-        includeCoreSkills: true,
-        includeOptionalSkills: false,
-        skills: ['check-inbox'],
-        overwrite: true,
-      });
-
-      const updated = result.generated.filter((g) => g.action === 'updated');
-      expect(updated).toHaveLength(1);
-      expect(updated[0]?.name).toBe('check-inbox');
-    });
-
-    it('should filter to specific skills', () => {
-      const result = generateSkills(undefined, {
-        projectRoot: testDir,
-        skills: ['check-inbox', 'delegate'],
-      });
-
-      expect(result.generated).toHaveLength(2);
-      const names = result.generated.map((g) => g.name);
-      expect(names).toContain('check-inbox');
-      expect(names).toContain('delegate');
-    });
-
-    it('should skip skills with missing dependencies', () => {
-      const config = {
-        project: { name: 'Test', root: testDir },
-      } as ResolvedCoreAIConfig;
-
-      const result = generateSkills(config, {
-        projectRoot: testDir,
-        includeCoreSkills: false,
-        includeOptionalSkills: true,
-        skills: ['jira-create'], // Requires issue_tracker
-      });
-
-      const skipped = result.generated.filter((g) => g.action === 'skipped');
-      expect(skipped.length).toBeGreaterThan(0);
-      const jiraSkill = skipped.find((s) => s.name === 'jira-create');
-      expect(jiraSkill?.skipReason).toContain('Missing required integrations');
-    });
-
-    it('should substitute variables in templates', () => {
-      const config = {
-        project: { name: 'TestProject', root: testDir },
-        quality_gates: {
-          lint: { command: 'npm run lint', required: true },
-          test: { command: 'npm test', required: true },
-          build: { command: 'npm run build', required: true },
-        },
-      } as ResolvedCoreAIConfig;
-
-      const result = generateSkills(config, {
-        projectRoot: testDir,
-        includeCoreSkills: true,
-        includeOptionalSkills: false,
-        skills: ['git-commit'],
-      });
-
-      expect(result.generated).toHaveLength(1);
-      expect(result.variables.LINT_CMD).toBe('npm run lint');
-    });
-
-    it('should merge custom variables', () => {
-      const result = generateSkills(undefined, {
-        projectRoot: testDir,
-        includeCoreSkills: true,
-        includeOptionalSkills: false,
-        variables: {
-          CUSTOM_VAR: 'custom value',
-        },
-      });
-
-      expect(result.variables.CUSTOM_VAR).toBe('custom value');
-    });
-  });
-
-  describe('formatGenerateResult', () => {
-    it('should format result with created skills', () => {
-      const result: GenerateSkillsResult = {
-        generated: [
-          { name: 'skill1', category: 'core', outputPath: '/out/skill1.md', action: 'created' },
-          { name: 'skill2', category: 'core', outputPath: '/out/skill2.md', action: 'created' },
-        ],
-        errors: [],
-        variables: {},
-      };
-
-      const output = formatGenerateResult(result);
-      expect(output).toContain('Created 2 skill(s)');
-      expect(output).toContain('skill1');
-      expect(output).toContain('skill2');
-    });
-
-    it('should format result with updated skills', () => {
-      const result: GenerateSkillsResult = {
-        generated: [
-          { name: 'skill1', category: 'core', outputPath: '/out/skill1.md', action: 'updated' },
-        ],
-        errors: [],
-        variables: {},
-      };
-
-      const output = formatGenerateResult(result);
-      expect(output).toContain('Updated 1 skill(s)');
-    });
-
-    it('should format result with skipped skills', () => {
-      const result: GenerateSkillsResult = {
-        generated: [
-          {
-            name: 'skill1',
-            category: 'core',
-            outputPath: '/out/skill1.md',
-            action: 'skipped',
-            skipReason: 'File exists',
-          },
-        ],
-        errors: [],
-        variables: {},
-      };
-
-      const output = formatGenerateResult(result);
-      expect(output).toContain('Skipped 1 skill(s)');
-      expect(output).toContain('File exists');
-    });
-
-    it('should format result with errors', () => {
-      const result: GenerateSkillsResult = {
-        generated: [],
-        errors: [{ name: 'bad-skill', error: 'Parse error' }],
-        variables: {},
-      };
-
-      const output = formatGenerateResult(result);
-      expect(output).toContain('Failed to generate 1 skill(s)');
-      expect(output).toContain('bad-skill');
-      expect(output).toContain('Parse error');
-    });
-
-    it('should show message when nothing to generate', () => {
-      const result: GenerateSkillsResult = {
-        generated: [],
-        errors: [],
-        variables: {},
-      };
-
-      const output = formatGenerateResult(result);
-      expect(output).toContain('No skills to generate');
-    });
-  });
-});