@codemcp/workflows 4.10.1 → 4.10.2

package/test/e2e/component-substitution.test.ts

@@ -1,208 +0,0 @@
-/**
- * Component Substitution E2E Tests
- *
- * Tests that the strategy pattern component substitution works correctly
- * in different task backend configurations.
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { createTempProjectWithDefaultStateMachine } from '../utils/temp-files';
-import {
-  DirectServerInterface,
-  createSuiteIsolatedE2EScenario,
-  assertToolSuccess,
-  initializeDevelopment,
-} from '../utils/e2e-test-setup';
-
-vi.unmock('fs');
-vi.unmock('fs/promises');
-
-describe('Component Substitution', () => {
-  let client: DirectServerInterface;
-  let cleanup: () => Promise<void>;
-
-  describe('Markdown Backend Strategy', () => {
-    beforeEach(async () => {
-      // Ensure markdown backend is detected
-      process.env.TASK_BACKEND = 'markdown';
-
-      const scenario = await createSuiteIsolatedE2EScenario({
-        suiteName: 'component-substitution-markdown',
-        tempProjectFactory: createTempProjectWithDefaultStateMachine,
-      });
-      client = scenario.client;
-      cleanup = scenario.cleanup;
-
-      await initializeDevelopment(client);
-    });
-
-    afterEach(async () => {
-      delete process.env.TASK_BACKEND;
-      if (cleanup) {
-        await cleanup();
-      }
-    });
-
-    it('should use markdown-based components for plan management', async () => {
-      const result = await client.callTool('whats_next', {
-        user_input: 'test markdown component substitution',
-      });
-      const response = assertToolSuccess(result);
-
-      expect(response.phase).toBeTruthy();
-      expect(response.instructions).toBeTruthy();
-      expect(response.plan_file_path).toBeTruthy();
-
-      // Verify plan file operations work with markdown backend
-      expect(response.plan_file_path).toContain('.vibe');
-      expect(response.plan_file_path).toMatch(/\.md$/);
-    });
-
-    it('should generate markdown-compatible instructions', async () => {
-      const result = await client.callTool('whats_next', {
-        user_input: 'create feature with markdown backend',
-      });
-      const response = assertToolSuccess(result);
-
-      // Instructions should be generated using markdown-based strategy
-      expect(response.instructions).toContain('Plan File Guidance');
-      expect(response.instructions).toContain('Project Context');
-      expect(typeof response.instructions).toBe('string');
-    });
-
-    it('should handle phase transitions with markdown backend', async () => {
-      // Initialize conversation
-      await client.callTool('whats_next', { user_input: 'start project' });
-
-      const result = await client.callTool('proceed_to_phase', {
-        target_phase: 'design',
-        reason: 'requirements complete',
-        review_state: 'not-required',
-      });
-      const response = assertToolSuccess(result);
-
-      expect(response.phase).toBe('design');
-      expect(response.instructions).toBeTruthy();
-    });
-  });
-
-  describe('Backend Strategy Configuration', () => {
-    // Note: Actual beads fallback testing requires specific environment setup
-    // These tests document the expected behavior when backend fallback occurs
-
-    it.todo('should fallback to default components when beads unavailable');
-    it.todo('should generate compatible instructions with fallback strategy');
-
-    // For now, focus on testing the factory pattern mechanism itself
-    // rather than specific backend availability scenarios
-  });
-
-  describe('Component Factory Integration', () => {
-    beforeEach(async () => {
-      const scenario = await createSuiteIsolatedE2EScenario({
-        suiteName: 'component-substitution-factory',
-        tempProjectFactory: createTempProjectWithDefaultStateMachine,
-      });
-      client = scenario.client;
-      cleanup = scenario.cleanup;
-
-      await initializeDevelopment(client);
-    });
-
-    afterEach(async () => {
-      if (cleanup) {
-        await cleanup();
-      }
-    });
-
-    it('should maintain consistent behavior across component substitutions', async () => {
-      // Test multiple operations to ensure consistent component behavior
-      const first = await client.callTool('whats_next', {
-        user_input: 'first operation',
-      });
-      const firstResponse = assertToolSuccess(first);
-
-      const second = await client.callTool('proceed_to_phase', {
-        target_phase: 'design',
-        reason: 'ready to design',
-        review_state: 'not-required',
-      });
-      const secondResponse = assertToolSuccess(second);
-
-      const third = await client.callTool('whats_next', {
-        user_input: 'continue after transition',
-      });
-      const thirdResponse = assertToolSuccess(third);
-
-      // All responses should be consistent and functional
-      expect(firstResponse.conversation_id).toBe(
-        secondResponse.conversation_id
-      );
-      expect(secondResponse.conversation_id).toBe(
-        thirdResponse.conversation_id
-      );
-      expect(thirdResponse.phase).toBe('design');
-    });
-
-    it('should properly inject dependencies through factory pattern', async () => {
-      const result = await client.callTool('whats_next', {
-        user_input: 'test dependency injection',
-      });
-      const response = assertToolSuccess(result);
-
-      // Verify that components work together properly (dependency injection successful)
-      expect(response.instructions).toBeTruthy();
-      expect(response.plan_file_path).toBeTruthy();
-
-      // Components should be working together to produce complete responses
-      expect(response.phase).toBeTruthy();
-      expect(response.conversation_id).toBeTruthy();
-    });
-
-    it('should handle component errors gracefully', async () => {
-      // Test that factory-created components handle edge cases
-      const result = await client.callTool('whats_next', {
-        user_input: '', // Empty input to test robustness
-      });
-      const response = assertToolSuccess(result);
-
-      // Should still work with empty input
-      expect(response.phase).toBeTruthy();
-      expect(response.instructions).toBeTruthy();
-    });
-  });
-
-  describe('Backend Detection Integration', () => {
-    beforeEach(async () => {
-      const scenario = await createSuiteIsolatedE2EScenario({
-        suiteName: 'component-substitution-detection',
-        tempProjectFactory: createTempProjectWithDefaultStateMachine,
-      });
-      client = scenario.client;
-      cleanup = scenario.cleanup;
-
-      await initializeDevelopment(client);
-    });
-
-    afterEach(async () => {
-      if (cleanup) {
-        await cleanup();
-      }
-    });
-
-    it('should detect task backend and create appropriate components', async () => {
-      const result = await client.callTool('whats_next', {
-        user_input: 'test backend detection',
-      });
-      const response = assertToolSuccess(result);
-
-      // Verify the factory correctly detected and created appropriate components
-      expect(response.phase).toBeTruthy();
-      expect(response.instructions).toBeTruthy();
-
-      // The response should indicate which components are being used
-      // (in practice, this would be markdown components since beads isn't available in tests)
-      expect(response.plan_file_path).toMatch(/\.md$/);
-    });
-  });
-});

package/test/unit/beads-integration-filename.test.ts

@@ -1,93 +0,0 @@
-/**
- * Unit tests for BeadsIntegration epic title formatting with filename
- *
- * Tests that epic titles include plan filenames correctly
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { BeadsIntegration } from '@codemcp/workflows-core';
-
-// Mock execSync to avoid actual beads CLI calls
-vi.mock('node:child_process', () => ({
-  execSync: vi.fn().mockReturnValue('✓ Created issue: test-epic-123'),
-}));
-
-describe('BeadsIntegration - Epic Title with Filename', () => {
-  let beadsIntegration: BeadsIntegration;
-
-  beforeEach(() => {
-    beadsIntegration = new BeadsIntegration('/test/project');
-  });
-
-  it('should include filename in epic title when provided', async () => {
-    const { execSync } = await import('node:child_process');
-    const mockExecSync = vi.mocked(execSync);
-
-    await beadsIntegration.createProjectEpic(
-      'my-project',
-      'epcc',
-      'Build an awesome feature',
-      'development-plan-feature-auth.md'
-    );
-
-    // Verify that execSync was called with the expected title format
-    expect(mockExecSync).toHaveBeenCalledWith(
-      expect.stringContaining(
-        'bd create "my-project: epcc (development-plan-feature-auth.md)"'
-      ),
-      expect.any(Object)
-    );
-  });
-
-  it('should use original title format when filename not provided', async () => {
-    const { execSync } = await import('node:child_process');
-    const mockExecSync = vi.mocked(execSync);
-
-    await beadsIntegration.createProjectEpic(
-      'my-project',
-      'epcc',
-      'Build an awesome feature'
-    );
-
-    // Verify that execSync was called with the original title format
-    expect(mockExecSync).toHaveBeenCalledWith(
-      expect.stringContaining('bd create "my-project: epcc"'),
-      expect.any(Object)
-    );
-
-    // Ensure it doesn't contain parentheses when no filename
-    const call = mockExecSync.mock.calls[0][0] as string;
-    expect(call).not.toContain('(');
-    expect(call).not.toContain(')');
-  });
-
-  it('should handle various filename formats', async () => {
-    const { execSync } = await import('node:child_process');
-    const mockExecSync = vi.mocked(execSync);
-
-    const testCases = [
-      'development-plan-main.md',
-      'development-plan-feature-dashboard.md',
-      'development-plan-bugfix-123.md',
-      'plan.md',
-    ];
-
-    for (const filename of testCases) {
-      mockExecSync.mockClear();
-
-      await beadsIntegration.createProjectEpic(
-        'test-project',
-        'waterfall',
-        undefined,
-        filename
-      );
-
-      expect(mockExecSync).toHaveBeenCalledWith(
-        expect.stringContaining(
-          `bd create "test-project: waterfall (${filename})"`
-        ),
-        expect.any(Object)
-      );
-    }
-  });
-});

package/test/unit/server-components-factory.test.ts

@@ -1,279 +0,0 @@
-/**
- * ServerComponentsFactory Tests
- *
- * Tests the factory pattern implementation for component creation
- * based on task backend configuration.
- */
-
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { ServerComponentsFactory } from '../../src/components/server-components-factory.js';
-import {
-  TaskBackendManager,
-  type TaskBackendConfig,
-} from '@codemcp/workflows-core';
-
-// Mock TaskBackendManager
-vi.mock('@codemcp/workflows-core', async () => {
-  const actual = await vi.importActual('@codemcp/workflows-core');
-  return {
-    ...actual,
-    TaskBackendManager: {
-      detectTaskBackend: vi.fn(),
-    },
-  };
-});
-
-describe('ServerComponentsFactory', () => {
-  let factory: ServerComponentsFactory;
-  let mockDetectTaskBackend: ReturnType<typeof vi.fn>;
-
-  beforeEach(() => {
-    mockDetectTaskBackend = vi.mocked(TaskBackendManager.detectTaskBackend);
-    // Default to markdown backend
-    mockDetectTaskBackend.mockReturnValue({
-      backend: 'markdown',
-      isAvailable: true,
-    });
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('Constructor', () => {
-    it('should use TaskBackendManager.detectTaskBackend() when no options provided', () => {
-      factory = new ServerComponentsFactory();
-
-      expect(mockDetectTaskBackend).toHaveBeenCalled();
-    });
-
-    it('should use provided task backend configuration', () => {
-      const customBackend: TaskBackendConfig = {
-        backend: 'beads',
-        isAvailable: true,
-      };
-
-      factory = new ServerComponentsFactory({ taskBackend: customBackend });
-
-      // Should not call detectTaskBackend when explicit config provided
-      expect(mockDetectTaskBackend).not.toHaveBeenCalled();
-    });
-
-    it('should handle undefined options gracefully', () => {
-      factory = new ServerComponentsFactory(undefined);
-
-      expect(mockDetectTaskBackend).toHaveBeenCalled();
-    });
-  });
-
-  describe('createPlanManager', () => {
-    it('should create default PlanManager for markdown backend', () => {
-      mockDetectTaskBackend.mockReturnValue({
-        backend: 'markdown',
-        isAvailable: true,
-      });
-
-      factory = new ServerComponentsFactory();
-      const planManager = factory.createPlanManager();
-
-      expect(planManager).toBeDefined();
-      expect(planManager.constructor.name).toBe('PlanManager');
-    });
-
-    it('should create default PlanManager when beads backend unavailable', () => {
-      mockDetectTaskBackend.mockReturnValue({
-        backend: 'beads',
-        isAvailable: false,
-      });
-
-      factory = new ServerComponentsFactory();
-      const planManager = factory.createPlanManager();
-
-      expect(planManager).toBeDefined();
-      expect(planManager.constructor.name).toBe('PlanManager');
-    });
-
-    it('should create BeadsPlanManager for beads backend when available', () => {
-      // Now that BeadsPlanManager is implemented, test that it's created correctly
-      const beadsBackend: TaskBackendConfig = {
-        backend: 'beads',
-        isAvailable: true,
-      };
-
-      factory = new ServerComponentsFactory({ taskBackend: beadsBackend });
-      const planManager = factory.createPlanManager();
-
-      expect(planManager).toBeDefined();
-      expect(planManager.constructor.name).toBe('BeadsPlanManager');
-    });
-
-    it('should create consistent instances across multiple calls', () => {
-      factory = new ServerComponentsFactory();
-
-      const planManager1 = factory.createPlanManager();
-      const planManager2 = factory.createPlanManager();
-
-      // Should create new instances (not singletons)
-      expect(planManager1).not.toBe(planManager2);
-      expect(planManager1.constructor.name).toBe(planManager2.constructor.name);
-    });
-  });
-
-  describe('createInstructionGenerator', () => {
-    it('should create default InstructionGenerator for markdown backend', () => {
-      mockDetectTaskBackend.mockReturnValue({
-        backend: 'markdown',
-        isAvailable: true,
-      });
-
-      factory = new ServerComponentsFactory();
-      const instructionGenerator = factory.createInstructionGenerator();
-
-      expect(instructionGenerator).toBeDefined();
-      expect(instructionGenerator.constructor.name).toBe(
-        'InstructionGenerator'
-      );
-    });
-
-    it('should create default InstructionGenerator when beads backend unavailable', () => {
-      mockDetectTaskBackend.mockReturnValue({
-        backend: 'beads',
-        isAvailable: false,
-      });
-
-      factory = new ServerComponentsFactory();
-      const instructionGenerator = factory.createInstructionGenerator();
-
-      expect(instructionGenerator).toBeDefined();
-      expect(instructionGenerator.constructor.name).toBe(
-        'InstructionGenerator'
-      );
-    });
-
-    it('should create BeadsInstructionGenerator for beads backend when available', () => {
-      // Now that BeadsInstructionGenerator is implemented, test that it's created correctly
-      const beadsBackend: TaskBackendConfig = {
-        backend: 'beads',
-        isAvailable: true,
-      };
-
-      factory = new ServerComponentsFactory({ taskBackend: beadsBackend });
-      const instructionGenerator = factory.createInstructionGenerator();
-
-      expect(instructionGenerator).toBeDefined();
-      expect(instructionGenerator.constructor.name).toBe(
-        'BeadsInstructionGenerator'
-      );
-    });
-
-    it('should create InstructionGenerator with proper dependency injection', () => {
-      factory = new ServerComponentsFactory();
-      const instructionGenerator = factory.createInstructionGenerator();
-
-      expect(instructionGenerator).toBeDefined();
-      expect(instructionGenerator.constructor.name).toBe(
-        'InstructionGenerator'
-      );
-
-      // Verify the instance is functional (dependency was injected correctly)
-      // without checking internal implementation details
-      expect(typeof instructionGenerator.generateInstructions).toBe('function');
-    });
-
-    it('should create consistent instances across multiple calls', () => {
-      factory = new ServerComponentsFactory();
-
-      const instructionGenerator1 = factory.createInstructionGenerator();
-      const instructionGenerator2 = factory.createInstructionGenerator();
-
-      // Should create new instances (not singletons)
-      expect(instructionGenerator1).not.toBe(instructionGenerator2);
-      expect(instructionGenerator1.constructor.name).toBe(
-        instructionGenerator2.constructor.name
-      );
-    });
-  });
-
-  describe('getTaskBackend', () => {
-    it('should return the current task backend configuration', () => {
-      const customBackend: TaskBackendConfig = {
-        backend: 'beads',
-        isAvailable: true,
-      };
-
-      factory = new ServerComponentsFactory({ taskBackend: customBackend });
-      const taskBackend = factory.getTaskBackend();
-
-      expect(taskBackend).toEqual(customBackend);
-    });
-
-    it('should return detected task backend when no explicit config provided', () => {
-      const detectedBackend: TaskBackendConfig = {
-        backend: 'markdown',
-        isAvailable: true,
-      };
-      mockDetectTaskBackend.mockReturnValue(detectedBackend);
-
-      factory = new ServerComponentsFactory();
-      const taskBackend = factory.getTaskBackend();
-
-      expect(taskBackend).toEqual(detectedBackend);
-    });
-  });
-
-  describe('Backend Integration', () => {
-    it('should handle unknown backend types gracefully', () => {
-      const unknownBackend: TaskBackendConfig = {
-        backend: 'beads' as TaskBackendConfig['backend'],
-        isAvailable: true,
-      };
-      // Simulate an unknown backend type for testing
-      (unknownBackend as unknown as { backend: string }).backend =
-        'unknown-backend';
-
-      factory = new ServerComponentsFactory({ taskBackend: unknownBackend });
-
-      // Should fall back to default implementations
-      const planManager = factory.createPlanManager();
-      const instructionGenerator = factory.createInstructionGenerator();
-
-      expect(planManager.constructor.name).toBe('PlanManager');
-      expect(instructionGenerator.constructor.name).toBe(
-        'InstructionGenerator'
-      );
-    });
-
-    it('should handle backend availability flag correctly', () => {
-      const unavailableBackend: TaskBackendConfig = {
-        backend: 'beads',
-        isAvailable: false,
-      };
-
-      factory = new ServerComponentsFactory({
-        taskBackend: unavailableBackend,
-      });
-
-      // Should fall back to default implementations when backend unavailable
-      const planManager = factory.createPlanManager();
-      const instructionGenerator = factory.createInstructionGenerator();
-
-      expect(planManager.constructor.name).toBe('PlanManager');
-      expect(instructionGenerator.constructor.name).toBe(
-        'InstructionGenerator'
-      );
-    });
-  });
-
-  describe('Future Extensibility', () => {
-    // These tests document the expected behavior once beads implementations are created
-    it.todo(
-      'should create BeadsPlanManager when beads backend is available and implemented'
-    );
-    it.todo(
-      'should create BeadsInstructionGenerator when beads backend is available and implemented'
-    );
-    it.todo(
-      'should support additional backends (github, linear) through same factory pattern'
-    );
-  });
-});