@codemcp/workflows-core 3.1.22 → 3.2.1

package/test/unit/template-manager.test.ts

@@ -1,217 +0,0 @@
-/**
- * Unit tests for TemplateManager
- *
- * Tests template loading, validation, and rendering functionality
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { TestAccess } from '../utils/test-access.js';
-import { TemplateManager } from '@codemcp/workflows-core';
-import { mkdir, writeFile, rmdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-describe('TemplateManager', () => {
-  let templateManager: TemplateManager;
-  let testTemplatesPath: string;
-
-  beforeEach(async () => {
-    // Create a temporary directory for test templates
-    testTemplatesPath = join(tmpdir(), `template-test-${Date.now()}`);
-    await mkdir(testTemplatesPath, { recursive: true });
-
-    // Create test template directories
-    await mkdir(join(testTemplatesPath, 'architecture'), { recursive: true });
-    await mkdir(join(testTemplatesPath, 'requirements'), { recursive: true });
-    await mkdir(join(testTemplatesPath, 'design'), { recursive: true });
-
-    // Create test template files
-    await writeFile(
-      join(testTemplatesPath, 'architecture', 'freestyle.md'),
-      '# Test Architecture Template\n\nThis is a test template.'
-    );
-
-    await writeFile(
-      join(testTemplatesPath, 'requirements', 'ears.md'),
-      '# Test Requirements Template\n\n## REQ-1: Test Requirement'
-    );
-
-    await writeFile(
-      join(testTemplatesPath, 'requirements', 'freestyle.md'),
-      '# Freestyle Requirements Template\n\nFlexible requirements format.'
-    );
-
-    await writeFile(
-      join(testTemplatesPath, 'design', 'comprehensive.md'),
-      '# Test Design Template\n\n## Components\n\nTest components here.'
-    );
-
-    await writeFile(
-      join(testTemplatesPath, 'design', 'freestyle.md'),
-      '# Freestyle Design Template\n\nFlexible design format.'
-    );
-
-    // Create arc42 directory template with images
-    const arc42Path = join(testTemplatesPath, 'architecture', 'arc42');
-    await mkdir(arc42Path, { recursive: true });
-    await mkdir(join(arc42Path, 'images'), { recursive: true });
-
-    await writeFile(
-      join(arc42Path, 'arc42-template-EN.md'),
-      '# Arc42 Template\n\n## Introduction and Goals\n\nTest arc42 content.'
-    );
-
-    await writeFile(
-      join(arc42Path, 'images', 'test-image.png'),
-      Buffer.from('fake-image-data')
-    );
-
-    // Mock the templatesPath in TemplateManager
-    templateManager = new TemplateManager();
-    TestAccess.injectMock(templateManager, 'templatesPath', testTemplatesPath);
-  });
-
-  afterEach(async () => {
-    // Clean up test directory
-    try {
-      await rmdir(testTemplatesPath, { recursive: true });
-    } catch {
-      // Ignore cleanup errors
-    }
-  });
-
-  describe('getDefaults', () => {
-    it('should return correct default template options', async () => {
-      const defaults = await templateManager.getDefaults();
-
-      expect(defaults).toEqual({
-        architecture: 'arc42',
-        requirements: 'ears',
-        design: 'comprehensive',
-      });
-    });
-  });
-
-  describe('validateOptions', () => {
-    it('should validate correct template options', async () => {
-      await expect(
-        templateManager.validateOptions({
-          architecture: 'arc42',
-          requirements: 'ears',
-          design: 'comprehensive',
-        })
-      ).resolves.not.toThrow();
-    });
-
-    it('should validate freestyle options', async () => {
-      await expect(
-        templateManager.validateOptions({
-          architecture: 'freestyle',
-          requirements: 'freestyle',
-          design: 'freestyle',
-        })
-      ).resolves.not.toThrow();
-    });
-
-    it('should throw error for invalid architecture template', async () => {
-      await expect(
-        templateManager.validateOptions({
-          // @ts-ignore - testing invalid input
-          architecture: 'invalid',
-        })
-      ).rejects.toThrow('Invalid architecture template: invalid');
-    });
-
-    it('should throw error for invalid requirements template', async () => {
-      await expect(
-        templateManager.validateOptions({
-          // @ts-ignore - testing invalid input
-          requirements: 'invalid',
-        })
-      ).rejects.toThrow('Invalid requirements template: invalid');
-    });
-
-    it('should throw error for invalid design template', async () => {
-      await expect(
-        templateManager.validateOptions({
-          // @ts-ignore - testing invalid input
-          design: 'invalid',
-        })
-      ).rejects.toThrow('Invalid design template: invalid');
-    });
-  });
-
-  describe('loadTemplate', () => {
-    it('should load freestyle architecture template', async () => {
-      const result = await templateManager.loadTemplate(
-        'architecture',
-        'freestyle'
-      );
-
-      expect(result.content).toContain('# Test Architecture Template');
-      expect(result.content).toContain('This is a test template.');
-      expect(result.additionalFiles).toBeUndefined();
-    });
-
-    it('should load ears requirements template', async () => {
-      const result = await templateManager.loadTemplate('requirements', 'ears');
-
-      expect(result.content).toContain('# Test Requirements Template');
-      expect(result.content).toContain('## REQ-1: Test Requirement');
-      expect(result.additionalFiles).toBeUndefined();
-    });
-
-    it('should load comprehensive design template', async () => {
-      const result = await templateManager.loadTemplate(
-        'design',
-        'comprehensive'
-      );
-
-      expect(result.content).toContain('# Test Design Template');
-      expect(result.content).toContain('## Components');
-      expect(result.additionalFiles).toBeUndefined();
-    });
-
-    it('should load arc42 directory template with images', async () => {
-      const result = await templateManager.loadTemplate(
-        'architecture',
-        'arc42'
-      );
-
-      expect(result.content).toContain('# Arc42 Template');
-      expect(result.content).toContain('## Introduction and Goals');
-      expect(result.additionalFiles).toBeDefined();
-      expect(result.additionalFiles).toHaveLength(1);
-
-      // Safe to access [0] after length check
-      const firstFile = result.additionalFiles?.[0];
-      expect(firstFile?.relativePath).toBe('images/test-image.png');
-      expect(firstFile?.content).toEqual(Buffer.from('fake-image-data'));
-    });
-
-    it('should throw error for non-existent template', async () => {
-      await expect(
-        templateManager.loadTemplate('architecture', 'nonexistent')
-      ).rejects.toThrow('Template not found: architecture/nonexistent');
-    });
-
-    it('should throw error for non-existent template type', async () => {
-      await expect(
-        // @ts-ignore - testing invalid input
-        templateManager.loadTemplate('invalid', 'freestyle')
-      ).rejects.toThrow('Template not found: invalid/freestyle');
-    });
-  });
-
-  describe('getAvailableTemplates', () => {
-    it('should return all available template options', async () => {
-      const templates = await templateManager.getAvailableTemplates();
-
-      expect(templates).toEqual({
-        architecture: ['arc42', 'freestyle'],
-        requirements: ['ears', 'freestyle'],
-        design: ['comprehensive', 'freestyle'],
-      });
-    });
-  });
-});

package/test/unit/validate-workflow-name.test.ts

@@ -1,150 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { WorkflowManager } from '@codemcp/workflows-core';
-import fs from 'node:fs';
-import path from 'node:path';
-import { tmpdir } from 'node:os';
-
-describe('validateWorkflowName', () => {
-  let testProjectPath: string;
-  let manager: WorkflowManager;
-
-  beforeEach(() => {
-    testProjectPath = fs.mkdtempSync(
-      path.join(tmpdir(), 'validate-workflow-test-')
-    );
-    manager = new WorkflowManager();
-  });
-
-  afterEach(() => {
-    fs.rmSync(testProjectPath, { recursive: true, force: true });
-  });
-
-  it('should validate predefined workflows', () => {
-    expect(manager.validateWorkflowName('waterfall', testProjectPath)).toBe(
-      true
-    );
-    expect(manager.validateWorkflowName('epcc', testProjectPath)).toBe(true);
-    expect(manager.validateWorkflowName('bugfix', testProjectPath)).toBe(true);
-  });
-
-  it('should validate project workflows', () => {
-    // Create a project workflow using valid format from existing workflow
-    const workflowsDir = path.join(testProjectPath, '.vibe', 'workflows');
-    fs.mkdirSync(workflowsDir, { recursive: true });
-
-    // Copy minor workflow and customize it
-    const minorPath = path.join(
-      __dirname,
-      '..',
-      '..',
-      'resources',
-      'workflows',
-      'minor.yaml'
-    );
-    const originalContent = fs.readFileSync(minorPath, 'utf8');
-    const customContent = originalContent
-      .replace("name: 'minor'", "name: 'my-project-workflow'")
-      .replace(/description: .*/, "description: 'Project specific workflow'");
-
-    fs.writeFileSync(path.join(workflowsDir, 'project.yaml'), customContent);
-
-    // Should validate the project workflow
-    expect(
-      manager.validateWorkflowName('my-project-workflow', testProjectPath)
-    ).toBe(true);
-  });
-
-  it('should reject invalid workflow names', () => {
-    expect(manager.validateWorkflowName('nonexistent', testProjectPath)).toBe(
-      false
-    );
-    expect(
-      manager.validateWorkflowName('invalid-workflow', testProjectPath)
-    ).toBe(false);
-  });
-
-  it('should validate "custom" workflow if it exists as project workflow', () => {
-    // Create a project workflow named "custom"
-    const workflowsDir = path.join(testProjectPath, '.vibe', 'workflows');
-    fs.mkdirSync(workflowsDir, { recursive: true });
-
-    // Copy minor workflow and name it "custom"
-    const minorPath = path.join(
-      __dirname,
-      '..',
-      '..',
-      'resources',
-      'workflows',
-      'minor.yaml'
-    );
-    const originalContent = fs.readFileSync(minorPath, 'utf8');
-    const customContent = originalContent
-      .replace("name: 'minor'", "name: 'custom'")
-      .replace(/description: .*/, "description: 'Custom workflow'");
-
-    fs.writeFileSync(path.join(workflowsDir, 'custom.yaml'), customContent);
-
-    // Should validate the "custom" workflow as a normal project workflow
-    expect(manager.validateWorkflowName('custom', testProjectPath)).toBe(true);
-  });
-
-  it('should validate "custom" workflow if it exists as project workflow', () => {
-    // Create a project workflow named "custom"
-    const workflowsDir = path.join(testProjectPath, '.vibe', 'workflows');
-    fs.mkdirSync(workflowsDir, { recursive: true });
-
-    // Copy minor workflow and name it "custom"
-    const minorPath = path.join(
-      __dirname,
-      '..',
-      '..',
-      'resources',
-      'workflows',
-      'minor.yaml'
-    );
-    const originalContent = fs.readFileSync(minorPath, 'utf8');
-    const customContent = originalContent
-      .replace("name: 'minor'", "name: 'custom'")
-      .replace(/description: .*/, "description: 'Custom workflow'");
-
-    fs.writeFileSync(path.join(workflowsDir, 'custom.yaml'), customContent);
-
-    // Should validate the "custom" workflow as a normal project workflow
-    expect(manager.validateWorkflowName('custom', testProjectPath)).toBe(true);
-  });
-
-  it('should validate project workflows after migration', () => {
-    // Create legacy workflow file using valid format
-    const vibeDir = path.join(testProjectPath, '.vibe');
-    fs.mkdirSync(vibeDir, { recursive: true });
-
-    // Copy minor workflow and customize it
-    const minorPath = path.join(
-      __dirname,
-      '..',
-      '..',
-      'resources',
-      'workflows',
-      'minor.yaml'
-    );
-    const originalContent = fs.readFileSync(minorPath, 'utf8');
-    const legacyContent = originalContent
-      .replace("name: 'minor'", "name: 'migrated-workflow'")
-      .replace(/description: .*/, "description: 'Migrated workflow'");
-
-    fs.writeFileSync(path.join(vibeDir, 'workflow.yaml'), legacyContent);
-
-    // Should validate the migrated workflow (migration happens during validation)
-    expect(
-      manager.validateWorkflowName('migrated-workflow', testProjectPath)
-    ).toBe(true);
-
-    // Legacy file should be gone
-    expect(fs.existsSync(path.join(vibeDir, 'workflow.yaml'))).toBe(false);
-
-    // New file should exist
-    expect(fs.existsSync(path.join(vibeDir, 'workflows', 'custom.yaml'))).toBe(
-      true
-    );
-  });
-});

package/test/unit/workflow-domain-filtering.test.ts

@@ -1,75 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { WorkflowManager } from '@codemcp/workflows-core';
-
-describe('Workflow Domain Filtering', () => {
-  let originalEnv: string | undefined;
-
-  beforeEach(() => {
-    originalEnv = process.env.VIBE_WORKFLOW_DOMAINS;
-  });
-
-  afterEach(() => {
-    if (originalEnv !== undefined) {
-      process.env.VIBE_WORKFLOW_DOMAINS = originalEnv;
-    } else {
-      delete process.env.VIBE_WORKFLOW_DOMAINS;
-    }
-  });
-
-  it('should load only code workflows when no domain filter is set', () => {
-    delete process.env.VIBE_WORKFLOW_DOMAINS;
-
-    const manager = new WorkflowManager();
-    const workflows = manager.getAvailableWorkflows();
-
-    // Should only include code domain workflows and workflows without domain
-    const codeWorkflows = workflows.filter(
-      w => !w.metadata?.domain || w.metadata.domain === 'code'
-    );
-    const nonCodeWorkflows = workflows.filter(
-      w => w.metadata?.domain && w.metadata.domain !== 'code'
-    );
-
-    expect(codeWorkflows.length).toBeGreaterThan(0);
-    expect(nonCodeWorkflows.length).toBe(0);
-  });
-
-  it('should filter workflows by domain when VIBE_WORKFLOW_DOMAINS is set', () => {
-    process.env.VIBE_WORKFLOW_DOMAINS = 'code';
-
-    const manager = new WorkflowManager();
-    const workflows = manager.getAvailableWorkflows();
-
-    // Should only include code domain workflows
-    const codeWorkflows = workflows.filter(w => w.metadata?.domain === 'code');
-    const nonCodeWorkflows = workflows.filter(
-      w => w.metadata?.domain && w.metadata.domain !== 'code'
-    );
-
-    expect(codeWorkflows.length).toBeGreaterThan(0);
-    expect(nonCodeWorkflows.length).toBe(0);
-  });
-
-  it('should support multiple domains', () => {
-    process.env.VIBE_WORKFLOW_DOMAINS = 'code,office';
-
-    const manager = new WorkflowManager();
-    const workflows = manager.getAvailableWorkflows();
-
-    const allowedWorkflows = workflows.filter(
-      w => !w.metadata?.domain || ['code', 'office'].includes(w.metadata.domain)
-    );
-
-    expect(allowedWorkflows.length).toBe(workflows.length);
-  });
-
-  it('should handle invalid domains gracefully', () => {
-    process.env.VIBE_WORKFLOW_DOMAINS = 'code,invalid,office';
-
-    const manager = new WorkflowManager();
-    const workflows = manager.getAvailableWorkflows();
-
-    // Should still work with valid domains
-    expect(workflows.length).toBeGreaterThan(0);
-  });
-});

package/test/unit/workflow-enum-generation.test.ts

@@ -1,92 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { WorkflowManager } from '@codemcp/workflows-core';
-import fs from 'node:fs';
-import path from 'node:path';
-import { tmpdir } from 'node:os';
-
-describe('Workflow Enum Generation', () => {
-  let testProjectPath: string;
-  let manager: WorkflowManager;
-
-  beforeEach(() => {
-    testProjectPath = fs.mkdtempSync(
-      path.join(tmpdir(), 'workflow-enum-test-')
-    );
-    manager = new WorkflowManager();
-  });
-
-  afterEach(() => {
-    fs.rmSync(testProjectPath, { recursive: true, force: true });
-  });
-
-  it('should include predefined workflows in enum', () => {
-    const workflowNames = manager.getWorkflowNames();
-
-    // Should include common predefined workflows
-    expect(workflowNames).toContain('waterfall');
-    expect(workflowNames).toContain('epcc');
-    expect(workflowNames).toContain('bugfix');
-  });
-
-  it('should include project workflows in enum after loading', () => {
-    // Create a project workflow
-    const workflowsDir = path.join(testProjectPath, '.vibe', 'workflows');
-    fs.mkdirSync(workflowsDir, { recursive: true });
-
-    // Copy minor workflow and customize it
-    const minorPath = path.join(
-      __dirname,
-      '..',
-      '..',
-      'resources',
-      'workflows',
-      'minor.yaml'
-    );
-    const originalContent = fs.readFileSync(minorPath, 'utf8');
-    const customContent = originalContent
-      .replace("name: 'minor'", "name: 'my-custom-workflow'")
-      .replace(/description: .*/, "description: 'Custom workflow for testing'");
-
-    fs.writeFileSync(path.join(workflowsDir, 'custom.yaml'), customContent);
-
-    // Load project workflows
-    manager.loadProjectWorkflows(testProjectPath);
-
-    const workflowNames = manager.getWorkflowNames();
-
-    // Should include both predefined and project workflows
-    expect(workflowNames).toContain('waterfall'); // predefined
-    expect(workflowNames).toContain('my-custom-workflow'); // project
-  });
-
-  it('should not duplicate workflow names when project overrides predefined', () => {
-    // Create a project workflow with same name as predefined
-    const workflowsDir = path.join(testProjectPath, '.vibe', 'workflows');
-    fs.mkdirSync(workflowsDir, { recursive: true });
-
-    // Copy minor workflow but keep the same name
-    const minorPath = path.join(
-      __dirname,
-      '..',
-      '..',
-      'resources',
-      'workflows',
-      'minor.yaml'
-    );
-    const originalContent = fs.readFileSync(minorPath, 'utf8');
-
-    fs.writeFileSync(
-      path.join(workflowsDir, 'minor-override.yaml'),
-      originalContent
-    );
-
-    // Load project workflows
-    manager.loadProjectWorkflows(testProjectPath);
-
-    const workflowNames = manager.getWorkflowNames();
-
-    // Should not have duplicates
-    const minorCount = workflowNames.filter(name => name === 'minor').length;
-    expect(minorCount).toBe(1);
-  });
-});