@codemcp/workflows-core 3.1.22 → 3.2.0

package/test/unit/workflow-override-by-name.test.ts

@@ -1,116 +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 Override by Name', () => {
-  let testProjectPath: string;
-  let originalEnv: string | undefined;
-
-  beforeEach(() => {
-    originalEnv = process.env.VIBE_WORKFLOW_DOMAINS;
-    testProjectPath = fs.mkdtempSync(
-      path.join(tmpdir(), 'workflow-override-test-')
-    );
-  });
-
-  afterEach(() => {
-    if (originalEnv !== undefined) {
-      process.env.VIBE_WORKFLOW_DOMAINS = originalEnv;
-    } else {
-      delete process.env.VIBE_WORKFLOW_DOMAINS;
-    }
-
-    fs.rmSync(testProjectPath, { recursive: true, force: true });
-  });
-
-  it('should override predefined workflow by YAML name, not filename', () => {
-    process.env.VIBE_WORKFLOW_DOMAINS = 'code';
-
-    const workflowsDir = path.join(testProjectPath, '.vibe', 'workflows');
-    fs.mkdirSync(workflowsDir, { recursive: true });
-
-    // Copy existing waterfall workflow but change description
-    const waterfallPath = path.join(
-      __dirname,
-      '..',
-      '..',
-      'resources',
-      'workflows',
-      'waterfall.yaml'
-    );
-    const originalContent = fs.readFileSync(waterfallPath, 'utf8');
-    const customContent = originalContent.replace(
-      /description: .*/,
-      "description: 'Custom company waterfall'"
-    );
-
-    fs.writeFileSync(
-      path.join(workflowsDir, 'company-waterfall.yaml'),
-      customContent
-    );
-
-    const manager = new WorkflowManager();
-
-    // Load project workflows to trigger override
-    const workflows = manager.getAvailableWorkflowsForProject(testProjectPath);
-
-    // Should override predefined waterfall workflow
-    const workflow = manager.getWorkflow('waterfall');
-    expect(workflow?.name).toBe('waterfall');
-    expect(workflow?.description).toBe('Custom company waterfall');
-
-    // Should be available in workflow list
-    const waterfallWorkflow = workflows.find(w => w.name === 'waterfall');
-    expect(waterfallWorkflow?.description).toBe('Custom company waterfall');
-  });
-
-  it('should use YAML name as workflow key, not filename', () => {
-    process.env.VIBE_WORKFLOW_DOMAINS = 'code';
-
-    const workflowsDir = path.join(testProjectPath, '.vibe', 'workflows');
-    fs.mkdirSync(workflowsDir, { recursive: true });
-
-    // Copy existing waterfall workflow with different filename
-    const waterfallPath = path.join(
-      __dirname,
-      '..',
-      '..',
-      'resources',
-      'workflows',
-      'waterfall.yaml'
-    );
-    const originalContent = fs.readFileSync(waterfallPath, 'utf8');
-    const customContent = originalContent.replace(
-      /description: .*/,
-      "description: 'Different filename, same name'"
-    );
-
-    // Use completely different filename but keep YAML name as 'waterfall'
-    fs.writeFileSync(
-      path.join(workflowsDir, 'totally-different-filename.yaml'),
-      customContent
-    );
-
-    const manager = new WorkflowManager();
-
-    // Load project workflows
-    const workflows = manager.getAvailableWorkflowsForProject(testProjectPath);
-
-    // Should still be accessible as 'waterfall' (YAML name), not 'totally-different-filename'
-    const workflow = manager.getWorkflow('waterfall');
-    expect(workflow?.name).toBe('waterfall');
-    expect(workflow?.description).toBe('Different filename, same name');
-
-    // Should not be accessible by filename
-    const byFilename = manager.getWorkflow('totally-different-filename');
-    expect(byFilename).toBeUndefined();
-
-    // Should be in workflow list with correct name
-    const waterfallWorkflow = workflows.find(w => w.name === 'waterfall');
-    expect(waterfallWorkflow?.description).toBe(
-      'Different filename, same name'
-    );
-  });
-});

package/test/unit/workflow-prioritization.test.ts

@@ -1,38 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { WorkflowManager } from '@codemcp/workflows-core';
-
-describe('Workflow Prioritization', () => {
-  it('should prioritize project workflows over predefined ones in getWorkflow method', () => {
-    const manager = new WorkflowManager();
-
-    // Get original waterfall workflow
-    const originalWaterfall = manager.getWorkflow('waterfall');
-    expect(originalWaterfall?.name).toBe('waterfall');
-
-    // Simulate adding a project workflow with same name
-    // Access private property for testing (this simulates successful loading)
-    const projectWorkflows = (manager as unknown).projectWorkflows;
-    const workflowInfos = (manager as unknown).workflowInfos;
-
-    const customWorkflow = {
-      name: 'custom-waterfall',
-      description: 'Custom override',
-      initial_state: 'custom-start',
-      states: { 'custom-start': { description: 'test' } },
-    };
-
-    projectWorkflows.set('waterfall', customWorkflow);
-    workflowInfos.set('waterfall', {
-      name: 'waterfall',
-      displayName: 'custom-waterfall',
-      description: 'Custom override',
-      initialState: 'custom-start',
-      phases: ['custom-start'],
-    });
-
-    // Now getWorkflow should return the project workflow
-    const prioritizedWorkflow = manager.getWorkflow('waterfall');
-    expect(prioritizedWorkflow?.name).toBe('custom-waterfall');
-    expect(prioritizedWorkflow?.description).toBe('Custom override');
-  });
-});

package/test/unit/workflow-validation.test.ts

@@ -1,303 +0,0 @@
-/**
- * Workflow Validation Tests
- *
- * Comprehensive tests to ensure all workflow files are valid and meet formal criteria:
- * - All workflows can be loaded without errors
- * - Every state is reachable through transition chains
- * - Workflow structure integrity (initial state exists, phases defined, etc.)
- * - No orphaned states or unreachable phases
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import { WorkflowInfo, WorkflowManager } from '@codemcp/workflows-core';
-import { readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { YamlStateMachine, YamlState } from '@codemcp/workflows-core';
-
-describe('Workflow Validation', () => {
-  const workflowsDir = join(__dirname, '..', '..', 'resources', 'workflows');
-  const workflowFiles = readdirSync(workflowsDir).filter(
-    file => file.endsWith('.yaml') || file.endsWith('.yml')
-  );
-
-  describe('Workflow Loading', () => {
-    it('should load all workflow files without errors', () => {
-      const workflowManager = new WorkflowManager();
-
-      // Get all available workflows
-      const workflows = workflowManager.getAvailableWorkflows();
-
-      // Should have loaded workflows (at least the core ones)
-      expect(workflows.length).toBeGreaterThan(0);
-
-      // Check that we have the expected core workflows
-      const expectedCoreWorkflows = ['bugfix', 'waterfall', 'epcc', 'minor'];
-      const workflowNames = workflows.map(w => w.name);
-      for (const workflow of expectedCoreWorkflows) {
-        expect(workflowNames).toContain(workflow);
-      }
-    });
-
-    it('should load ALL workflow files from resources directory', () => {
-      // Temporarily disable domain filtering for this test
-      const originalEnv = process.env.VIBE_WORKFLOW_DOMAINS;
-      process.env.VIBE_WORKFLOW_DOMAINS = 'code,architecture,office';
-
-      try {
-        // Create manager after setting env var to include all domains
-        const workflowManager = new WorkflowManager();
-        const loadedWorkflows = workflowManager.getAvailableWorkflows();
-        const loadedWorkflowNames = loadedWorkflows.map(w => w.name);
-
-        // Count expected workflow files
-        const expectedWorkflowCount = workflowFiles.length;
-
-        // Should load exactly the same number of workflows as files
-        expect(loadedWorkflows.length).toBe(expectedWorkflowCount);
-
-        // Each workflow file should correspond to a loaded workflow
-        for (const file of workflowFiles) {
-          const workflowName = file.replace(/\.(yaml|yml)$/, '');
-          expect(loadedWorkflowNames).toContain(workflowName);
-        }
-      } finally {
-        if (originalEnv !== undefined) {
-          process.env.VIBE_WORKFLOW_DOMAINS = originalEnv;
-        } else {
-          delete process.env.VIBE_WORKFLOW_DOMAINS;
-        }
-      }
-    });
-
-    it('should have valid workflow files in resources directory', () => {
-      expect(workflowFiles.length).toBeGreaterThan(0);
-
-      // Check that all files have valid extensions
-      for (const file of workflowFiles) {
-        expect(file.endsWith('.yaml') || file.endsWith('.yml')).toBe(true);
-      }
-    });
-  });
-
-  describe('Workflow Structure Validation', () => {
-    let workflowManager: WorkflowManager;
-    let workflows: WorkflowInfo[];
-
-    beforeEach(() => {
-      workflowManager = new WorkflowManager();
-      workflows = workflowManager.getAvailableWorkflows();
-    });
-
-    it('should have required fields for each workflow', () => {
-      for (const workflow of workflows) {
-        expect(workflow).toBeDefined();
-        expect(workflow.name).toBeDefined();
-        expect(typeof workflow.name).toBe('string');
-        expect(workflow.displayName).toBeDefined();
-        expect(typeof workflow.displayName).toBe('string');
-        expect(workflow.phases).toBeDefined();
-        expect(Array.isArray(workflow.phases)).toBe(true);
-        expect(workflow.phases.length).toBeGreaterThan(0);
-      }
-    });
-
-    it('should have valid state machines for each workflow', () => {
-      for (const workflow of workflows) {
-        // Get the state machine for this workflow
-        const stateMachine = workflowManager.getWorkflow(workflow.name);
-
-        expect(stateMachine).toBeDefined();
-        expect(stateMachine!.name).toBe(workflow.name);
-        expect(stateMachine!.description).toBeDefined();
-        expect(stateMachine!.initial_state).toBeDefined();
-        expect(stateMachine!.states).toBeDefined();
-        expect(typeof stateMachine!.states).toBe('object');
-      }
-    });
-
-    it('should have initial state defined in states', () => {
-      for (const workflow of workflows) {
-        const stateMachine = workflowManager.getWorkflow(workflow.name);
-
-        expect(stateMachine!.states[stateMachine!.initial_state]).toBeDefined();
-      }
-    });
-
-    it('should have all phases represented as states', () => {
-      for (const workflow of workflows) {
-        const stateMachine = workflowManager.getWorkflow(workflow.name);
-
-        // Every phase should exist as a state
-        for (const phase of workflow.phases) {
-          expect(stateMachine!.states[phase]).toBeDefined();
-        }
-      }
-    });
-  });
-
-  describe('State Reachability Analysis', () => {
-    let workflowManager: WorkflowManager;
-    let workflows: WorkflowInfo[];
-
-    beforeEach(() => {
-      workflowManager = new WorkflowManager();
-      workflows = workflowManager.getAvailableWorkflows();
-    });
-
-    /**
-     * Build a graph of state transitions and check reachability
-     */
-    function analyzeStateReachability(stateMachine: YamlStateMachine) {
-      const states = Object.keys(stateMachine.states);
-      const reachableStates = new Set<string>();
-      const visited = new Set<string>();
-
-      // Start from initial state
-      const queue = [stateMachine.initial_state];
-      reachableStates.add(stateMachine.initial_state);
-
-      while (queue.length > 0) {
-        const currentState = queue.shift()!;
-
-        if (visited.has(currentState)) continue;
-        visited.add(currentState);
-
-        const stateConfig = stateMachine.states[currentState];
-        if (stateConfig.transitions) {
-          for (const transition of stateConfig.transitions) {
-            if (transition.to && !reachableStates.has(transition.to)) {
-              reachableStates.add(transition.to);
-              queue.push(transition.to);
-            }
-          }
-        }
-      }
-
-      return {
-        allStates: states,
-        reachableStates: Array.from(reachableStates),
-        unreachableStates: states.filter(state => !reachableStates.has(state)),
-      };
-    }
-
-    it('should have all states reachable from initial state', () => {
-      for (const workflow of workflows) {
-        const stateMachine = workflowManager.getWorkflow(workflow.name);
-        const analysis = analyzeStateReachability(stateMachine!);
-
-        expect(analysis.unreachableStates).toEqual([]);
-
-        // All states should be reachable
-        expect(analysis.reachableStates.length).toBe(analysis.allStates.length);
-      }
-    });
-
-    it('should have valid transition targets', () => {
-      for (const workflow of workflows) {
-        const stateMachine = workflowManager.getWorkflow(workflow.name);
-
-        for (const [_stateName, stateConfig] of Object.entries(
-          stateMachine!.states
-        ) as [string, YamlState][]) {
-          if (stateConfig.transitions) {
-            for (const transition of stateConfig.transitions) {
-              if (transition.to) {
-                // Target state must exist
-                expect(stateMachine!.states[transition.to]).toBeDefined();
-              }
-            }
-          }
-        }
-      }
-    });
-
-    it('should have meaningful transition triggers', () => {
-      for (const workflow of workflows) {
-        const stateMachine = workflowManager.getWorkflow(workflow.name);
-
-        for (const [_stateName, stateConfig] of Object.entries(
-          stateMachine!.states
-        ) as [string, YamlState][]) {
-          if (stateConfig.transitions) {
-            for (const transition of stateConfig.transitions) {
-              // Each transition should have a trigger
-              expect(transition.trigger).toBeDefined();
-              expect(typeof transition.trigger).toBe('string');
-              expect(transition.trigger.length).toBeGreaterThan(0);
-
-              // Trigger should be meaningful (not just whitespace)
-              expect(transition.trigger.trim()).toBe(transition.trigger);
-              expect(transition.trigger.trim().length).toBeGreaterThan(0);
-            }
-          }
-        }
-      }
-    });
-  });
-
-  describe('Workflow Content Quality', () => {
-    let workflowManager: WorkflowManager;
-    let workflows: WorkflowInfo[];
-
-    beforeEach(() => {
-      workflowManager = new WorkflowManager();
-      workflows = workflowManager.getAvailableWorkflows();
-    });
-
-    it('should have meaningful descriptions for all states', () => {
-      for (const workflow of workflows) {
-        const stateMachine = workflowManager.getWorkflow(workflow.name);
-
-        for (const [_stateName, stateConfig] of Object.entries(
-          stateMachine!.states
-        ) as [string, YamlState][]) {
-          expect(stateConfig.description).toBeDefined();
-          expect(typeof stateConfig.description).toBe('string');
-          expect(stateConfig.description.length).toBeGreaterThan(10); // Meaningful description
-        }
-      }
-    });
-
-    it('should have default instructions for all states', () => {
-      for (const workflow of workflows) {
-        const stateMachine = workflowManager.getWorkflow(workflow.name);
-
-        for (const [_stateName, stateConfig] of Object.entries(
-          stateMachine!.states
-        ) as [string, YamlState][]) {
-          expect(stateConfig.default_instructions).toBeDefined();
-          expect(typeof stateConfig.default_instructions).toBe('string');
-          expect(stateConfig.default_instructions.length).toBeGreaterThan(20); // Substantial instructions
-        }
-      }
-    });
-
-    it('should have workflow metadata', () => {
-      for (const workflow of workflows) {
-        const stateMachine = workflowManager.getWorkflow(workflow.name);
-
-        // Should have basic metadata
-        expect(stateMachine!.name).toBeDefined();
-        expect(stateMachine!.description).toBeDefined();
-        expect(typeof stateMachine!.description).toBe('string');
-        expect(stateMachine!.description.length).toBeGreaterThan(10);
-      }
-    });
-  });
-
-  describe('Workflow Integration', () => {
-    it('should be able to create workflow instances', () => {
-      const workflowManager = new WorkflowManager();
-      const workflows = workflowManager.getAvailableWorkflows();
-
-      // Should be able to get workflow info for each workflow
-      for (const workflow of workflows) {
-        const workflowInfo = workflowManager.getWorkflowInfo(workflow.name);
-        expect(workflowInfo).toBeDefined();
-        expect(workflowInfo!.name).toBe(workflow.name);
-        expect(workflowInfo!.phases).toBeDefined();
-        expect(Array.isArray(workflowInfo!.phases)).toBe(true);
-      }
-    });
-  });
-});