@codemcp/workflows 5.0.1 → 5.1.1

package/test/unit/commit-plugin.test.ts

@@ -1,196 +0,0 @@
-/**
- * Test CommitPlugin activation and lifecycle hooks
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { CommitPlugin } from '../../src/plugin-system/commit-plugin.js';
-import type { PluginHookContext } from '../../src/plugin-system/plugin-interfaces.js';
-
-// Mock GitManager
-vi.mock('@codemcp/workflows-core', async () => {
-  const actual = await vi.importActual('@codemcp/workflows-core');
-  return {
-    ...actual,
-    GitManager: {
-      isGitRepository: vi.fn(),
-      hasUncommittedChanges: vi.fn(),
-      createCommit: vi.fn(),
-    },
-  };
-});
-
-describe('CommitPlugin', () => {
-  let plugin: CommitPlugin;
-  const projectPath = '/test/project';
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    // Clear environment variables
-    delete process.env.COMMIT_BEHAVIOR;
-    delete process.env.COMMIT_MESSAGE_TEMPLATE;
-  });
-
-  describe('Plugin Interface', () => {
-    it('should have correct name and sequence', () => {
-      plugin = new CommitPlugin({ projectPath });
-
-      expect(plugin.getName()).toBe('CommitPlugin');
-      expect(plugin.getSequence()).toBe(50); // Before BeadsPlugin (100)
-    });
-
-    it('should be enabled when COMMIT_BEHAVIOR is set', () => {
-      process.env.COMMIT_BEHAVIOR = 'step';
-      plugin = new CommitPlugin({ projectPath });
-
-      expect(plugin.isEnabled()).toBe(true);
-    });
-
-    it('should be disabled when COMMIT_BEHAVIOR is not set', () => {
-      plugin = new CommitPlugin({ projectPath });
-
-      expect(plugin.isEnabled()).toBe(false);
-    });
-
-    it('should be disabled when COMMIT_BEHAVIOR is invalid', () => {
-      process.env.COMMIT_BEHAVIOR = 'invalid';
-      plugin = new CommitPlugin({ projectPath });
-
-      expect(plugin.isEnabled()).toBe(false);
-    });
-  });
-
-  describe('Lifecycle Hooks', () => {
-    beforeEach(() => {
-      process.env.COMMIT_BEHAVIOR = 'step';
-      plugin = new CommitPlugin({ projectPath });
-    });
-
-    it('should provide afterStartDevelopment hook', () => {
-      const hooks = plugin.getHooks();
-
-      expect(hooks.afterStartDevelopment).toBeDefined();
-      expect(typeof hooks.afterStartDevelopment).toBe('function');
-    });
-
-    it('should provide beforePhaseTransition hook', () => {
-      const hooks = plugin.getHooks();
-
-      expect(hooks.beforePhaseTransition).toBeDefined();
-      expect(typeof hooks.beforePhaseTransition).toBe('function');
-    });
-
-    it('should provide afterPlanFileCreated hook', () => {
-      const hooks = plugin.getHooks();
-
-      expect(hooks.afterPlanFileCreated).toBeDefined();
-      expect(typeof hooks.afterPlanFileCreated).toBe('function');
-    });
-  });
-
-  describe('Step Commit Behavior', () => {
-    beforeEach(() => {
-      process.env.COMMIT_BEHAVIOR = 'step';
-      plugin = new CommitPlugin({ projectPath });
-    });
-
-    it('should create WIP commit on whats_next calls', async () => {
-      const { GitManager } = await import('@codemcp/workflows-core');
-      vi.mocked(GitManager.isGitRepository).mockReturnValue(true);
-      vi.mocked(GitManager.hasUncommittedChanges).mockReturnValue(true);
-      vi.mocked(GitManager.createCommit).mockReturnValue(true);
-
-      const context: PluginHookContext = {
-        conversationId: 'test-conv',
-        planFilePath: '/test/plan.md',
-        currentPhase: 'explore',
-        workflow: 'epcc',
-        projectPath,
-        gitBranch: 'feature/test',
-      };
-
-      const hooks = plugin.getHooks();
-      await hooks.afterStartDevelopment?.(
-        context,
-        { workflow: 'epcc' },
-        {
-          conversationId: 'test-conv',
-          planFilePath: '/test/plan.md',
-          phase: 'explore',
-          workflow: 'epcc',
-        }
-      );
-
-      // Should store initial commit hash for later squashing
-      expect(GitManager.isGitRepository).toHaveBeenCalledWith(projectPath);
-    });
-  });
-
-  describe('Phase Commit Behavior', () => {
-    beforeEach(() => {
-      process.env.COMMIT_BEHAVIOR = 'phase';
-      plugin = new CommitPlugin({ projectPath });
-    });
-
-    it('should create WIP commit before phase transitions', async () => {
-      const { GitManager } = await import('@codemcp/workflows-core');
-      vi.mocked(GitManager.isGitRepository).mockReturnValue(true);
-      vi.mocked(GitManager.hasUncommittedChanges).mockReturnValue(true);
-      vi.mocked(GitManager.createCommit).mockReturnValue(true);
-
-      const context: PluginHookContext = {
-        conversationId: 'test-conv',
-        planFilePath: '/test/plan.md',
-        currentPhase: 'explore',
-        workflow: 'epcc',
-        projectPath,
-        gitBranch: 'feature/test',
-        targetPhase: 'plan',
-      };
-
-      const hooks = plugin.getHooks();
-      await hooks.beforePhaseTransition?.(context, 'explore', 'plan');
-
-      expect(GitManager.hasUncommittedChanges).toHaveBeenCalledWith(
-        projectPath
-      );
-      expect(GitManager.createCommit).toHaveBeenCalledWith(
-        'WIP: transition to plan',
-        projectPath
-      );
-    });
-  });
-
-  describe('End Commit Behavior', () => {
-    beforeEach(() => {
-      process.env.COMMIT_BEHAVIOR = 'end';
-      plugin = new CommitPlugin({ projectPath });
-    });
-
-    it('should add final commit task to plan file', async () => {
-      const context: PluginHookContext = {
-        conversationId: 'test-conv',
-        planFilePath: '/test/plan.md',
-        currentPhase: 'explore',
-        workflow: 'epcc',
-        projectPath,
-        gitBranch: 'feature/test',
-      };
-
-      const planContent = `## Commit
-### Tasks
-- [ ] Review implementation
-### Completed
-*None yet*`;
-
-      const hooks = plugin.getHooks();
-      const result = await hooks.afterPlanFileCreated?.(
-        context,
-        '/test/plan.md',
-        planContent
-      );
-
-      expect(result).toContain('Create a conventional commit');
-      expect(result).toContain('summarize the intentions and key decisions');
-    });
-  });
-});

package/test/unit/conduct-review.test.ts

@@ -1,151 +0,0 @@
-/**
- * Unit tests for ConductReviewHandler
- * Tests the expected behavior of conducting reviews before phase transitions
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { ConductReviewHandler } from '../../src/tool-handlers/conduct-review.js';
-import type { ServerContext } from '../../src/types';
-import type { ConversationContext } from '../../src/types.js';
-
-// Mock logger
-vi.mock('../../src/logger', () => ({
-  createLogger: () => ({
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-  }),
-}));
-
-describe('ConductReviewHandler', () => {
-  let handler: ConductReviewHandler;
-  let mockContext: ServerContext;
-
-  beforeEach(() => {
-    handler = new ConductReviewHandler();
-
-    mockContext = {
-      workflowManager: {
-        loadWorkflowForProject: vi.fn(),
-      },
-      transitionEngine: {
-        getStateMachine: vi.fn(),
-      },
-      planManager: {
-        setStateMachine: vi.fn(),
-      },
-      instructionGenerator: {
-        setStateMachine: vi.fn(),
-      },
-      projectPath: '/test/project',
-    } as unknown as ServerContext;
-  });
-
-  it('should conduct review for ideation to architecture transition in greenfield workflow', async () => {
-    // Set up greenfield workflow
-    const mockWorkflow = {
-      states: {
-        ideation: {
-          transitions: [
-            {
-              trigger: 'ideation_complete',
-              to: 'architecture',
-              review_perspectives: [
-                {
-                  perspective: 'business_analyst',
-                  prompt:
-                    'Review the Product Requirements Document for completeness, clarity, and business value.',
-                },
-                {
-                  perspective: 'ux_expert',
-                  prompt:
-                    'Evaluate user experience requirements and usability considerations.',
-                },
-              ],
-            },
-          ],
-        },
-      },
-    };
-
-    mockContext.workflowManager.loadWorkflowForProject.mockReturnValue(
-      mockWorkflow
-    );
-
-    const conversationContext: ConversationContext = {
-      conversationId: 'test-conversation',
-      projectPath: '/test/project',
-      gitBranch: 'main',
-      currentPhase: 'ideation',
-      planFilePath: '/test/project/.vibe/plan.md',
-      workflowName: 'greenfield',
-      requireReviewsBeforePhaseTransition: true,
-    };
-
-    const result = await handler.executeWithConversation(
-      { target_phase: 'architecture' },
-      mockContext,
-      conversationContext
-    );
-
-    expect(result.instructions).toContain('ideation');
-    expect(result.instructions).toContain('architecture');
-    expect(result.perspectives).toHaveLength(2);
-    expect(result.perspectives[0].name).toBe('business_analyst');
-    expect(result.perspectives[1].name).toBe('ux_expert');
-  });
-
-  it('should handle the reported bug scenario: ideation_complete transition with reviews', async () => {
-    const mockWorkflow = {
-      states: {
-        ideation: {
-          transitions: [
-            {
-              trigger: 'ideation_complete',
-              to: 'architecture',
-              review_perspectives: [
-                {
-                  perspective: 'business_analyst',
-                  prompt:
-                    'Review the Product Requirements Document for completeness, clarity, and business value.',
-                },
-                {
-                  perspective: 'ux_expert',
-                  prompt:
-                    'Evaluate user experience requirements and usability considerations.',
-                },
-              ],
-            },
-          ],
-        },
-      },
-    };
-
-    mockContext.workflowManager.loadWorkflowForProject.mockReturnValue(
-      mockWorkflow
-    );
-
-    const conversationContext: ConversationContext = {
-      conversationId: 'test-conversation',
-      projectPath: '/test/project',
-      gitBranch: 'main',
-      currentPhase: 'ideation',
-      planFilePath: '/test/project/.vibe/plan.md',
-      workflowName: 'greenfield',
-      requireReviewsBeforePhaseTransition: true,
-    };
-
-    const result = await handler.executeWithConversation(
-      { target_phase: 'architecture' },
-      mockContext,
-      conversationContext
-    );
-
-    expect(result.instructions).toContain('ideation');
-    expect(result.instructions).toContain('architecture');
-    expect(result.perspectives).toHaveLength(2);
-    expect(result.perspectives[0].name).toBe('business_analyst');
-    expect(result.perspectives[1].name).toBe('ux_expert');
-  });
-});

package/test/unit/conversation-not-found-error.test.ts

@@ -1,120 +0,0 @@
-/**
- * Unit tests for CONVERSATION_NOT_FOUND error handling
- *
- * Tests that tools requiring a conversation provide helpful error messages
- * when no conversation exists, guiding users to call start_development.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { ResponsibleVibeMCPServer } from '../../src/server-implementation.js';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { ServerTestHelper } from '../utils/test-helpers.js';
-
-describe('CONVERSATION_NOT_FOUND error handling', () => {
-  let server: ResponsibleVibeMCPServer;
-  let tempDir: string;
-
-  beforeEach(async () => {
-    // Create temporary directory for testing
-    tempDir = await mkdtemp(join(tmpdir(), 'conversation-error-test-'));
-    server = await ServerTestHelper.createServer(tempDir);
-    // Note: We deliberately do NOT call start_development to test the error case
-  });
-
-  afterEach(async () => {
-    await ServerTestHelper.cleanupServer(server);
-    await rm(tempDir, { recursive: true, force: true });
-  });
-
-  describe('whats_next tool', () => {
-    it('should provide helpful error message when no conversation exists', async () => {
-      try {
-        await server.handleWhatsNext({});
-        expect.fail('Should have thrown an error');
-      } catch (error: unknown) {
-        // Verify the error message is helpful
-        const err = error as Error;
-        expect(err.message).toContain(
-          'No development conversation has been started'
-        );
-        expect(err.message).toContain('start_development');
-      }
-    });
-  });
-
-  describe('proceed_to_phase tool', () => {
-    it('should provide helpful error message when no conversation exists', async () => {
-      try {
-        await server.handleProceedToPhase({
-          target_phase: 'implementation',
-          review_state: 'not-required',
-        });
-        expect.fail('Should have thrown an error');
-      } catch (error: unknown) {
-        // Verify the error message is helpful
-        const err = error as Error;
-        expect(err.message).toContain(
-          'No development conversation has been started'
-        );
-        expect(err.message).toContain('start_development');
-      }
-    });
-  });
-
-  describe('resume_workflow tool', () => {
-    it('should provide helpful error message when no conversation exists', async () => {
-      try {
-        await server.handleResumeWorkflow({});
-        expect.fail('Should have thrown an error');
-      } catch (error: unknown) {
-        // Verify the error message is helpful
-        const err = error as Error;
-        expect(err.message).toContain(
-          'No development conversation has been started'
-        );
-        expect(err.message).toContain('start_development');
-      }
-    });
-  });
-
-  describe('error message content', () => {
-    it('should not suggest specific workflows', async () => {
-      try {
-        await server.handleWhatsNext({});
-        expect.fail('Should have thrown an error');
-      } catch (error: unknown) {
-        // Verify that error does NOT contain specific workflow names in the suggestion
-        // (the suggestion should be generic like "Use the start_development tool")
-        const err = error as Error;
-        const message = err.message.toLowerCase();
-
-        // Should contain generic guidance
-        expect(message).toContain('start_development');
-
-        // Should NOT contain workflow-specific suggestions like:
-        // "start_development({ workflow: 'waterfall' })"
-        const hasSpecificWorkflowSuggestion =
-          message.includes('workflow:') ||
-          message.includes('waterfall') ||
-          message.includes('epcc') ||
-          message.includes('bugfix');
-
-        expect(hasSpecificWorkflowSuggestion).toBe(false);
-      }
-    });
-  });
-
-  describe('error with no available workflows', () => {
-    it('should provide guidance about workflow configuration when no workflows available', async () => {
-      // This test would require mocking the workflow manager to return no workflows
-      // For now, we'll just verify the helper function behavior
-      // The actual scenario is covered by the server-helpers.ts implementation
-
-      // Test is implicit: if no workflows are available, the error should mention
-      // VIBE_WORKFLOW_DOMAINS environment variable (see server-helpers.ts line 113)
-      expect(true).toBe(true);
-    });
-  });
-});

package/test/unit/plugin-error-handling.test.ts

@@ -1,240 +0,0 @@
-/**
- * Tests for Plugin Error Handling and Graceful Degradation
- *
- * Verifies that the plugin system handles errors gracefully:
- * - Plugin failures don't crash the core application
- * - Non-critical plugin errors allow graceful degradation
- * - Validation errors (beforePhaseTransition) are always re-thrown
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import { PluginRegistry } from '../../src/plugin-system/plugin-registry.js';
-import type { IPlugin } from '../../src/plugin-system/plugin-interfaces.js';
-
-const createMockContext = () => ({
-  conversationId: 'test',
-  planFilePath: '/test/plan.md',
-  projectPath: '/test',
-  currentPhase: 'explore',
-  workflow: 'epcc',
-  gitBranch: 'main',
-});
-
-describe('Plugin Error Handling and Graceful Degradation', () => {
-  describe('Non-critical hook error handling', () => {
-    it('should continue execution when afterStartDevelopment hook fails', async () => {
-      const registry = new PluginRegistry();
-
-      // Register first plugin that throws
-      const failingPlugin: IPlugin = {
-        getName: () => 'FailingPlugin',
-        getSequence: () => 1,
-        isEnabled: () => true,
-        getHooks: () => ({
-          afterStartDevelopment: vi
-            .fn()
-            .mockRejectedValue(new Error('Beads backend unavailable')),
-        }),
-      };
-
-      // Register second plugin that succeeds
-      const successHookSpy = vi.fn().mockResolvedValue(undefined);
-      const successPlugin: IPlugin = {
-        getName: () => 'SuccessPlugin',
-        getSequence: () => 2,
-        isEnabled: () => true,
-        getHooks: () => ({
-          afterStartDevelopment: successHookSpy,
-        }),
-      };
-
-      registry.registerPlugin(failingPlugin);
-      registry.registerPlugin(successPlugin);
-
-      // Execute hook - should NOT throw despite first plugin failure
-      const result = await registry.executeHook(
-        'afterStartDevelopment',
-        createMockContext(),
-        { workflow: 'epcc', commit_behaviour: 'end' },
-        {
-          conversationId: 'test',
-          planFilePath: '/test/plan.md',
-          phase: 'explore',
-          workflow: 'epcc',
-        }
-      );
-
-      // Should reach here without throwing
-      expect(result).toBeUndefined();
-      expect(successHookSpy).toHaveBeenCalled();
-    });
-
-    it('should continue execution when afterPlanFileCreated hook fails', async () => {
-      const registry = new PluginRegistry();
-
-      const failingPlugin: IPlugin = {
-        getName: () => 'FailingPlugin',
-        getSequence: () => 1,
-        isEnabled: () => true,
-        getHooks: () => ({
-          afterPlanFileCreated: vi
-            .fn()
-            .mockRejectedValue(new Error('Plan file update failed')),
-        }),
-      };
-
-      registry.registerPlugin(failingPlugin);
-
-      // Should not throw despite plugin error
-      const result = await registry.executeHook(
-        'afterPlanFileCreated',
-        createMockContext(),
-        '/test/plan.md',
-        'initial content'
-      );
-
-      expect(result).toBeUndefined();
-    });
-  });
-
-  describe('Validation hook error handling', () => {
-    it('should re-throw validation errors from beforePhaseTransition', async () => {
-      const registry = new PluginRegistry();
-
-      const validationPlugin: IPlugin = {
-        getName: () => 'ValidationPlugin',
-        getSequence: () => 1,
-        isEnabled: () => true,
-        getHooks: () => ({
-          beforePhaseTransition: vi
-            .fn()
-            .mockRejectedValue(
-              new Error('Cannot proceed to code - incomplete tasks')
-            ),
-        }),
-      };
-
-      registry.registerPlugin(validationPlugin);
-
-      // Should re-throw validation errors
-      await expect(
-        registry.executeHook(
-          'beforePhaseTransition',
-          createMockContext(),
-          'plan',
-          'code'
-        )
-      ).rejects.toThrow('Cannot proceed to code - incomplete tasks');
-    });
-
-    it('should re-throw any beforePhaseTransition hook errors', async () => {
-      const registry = new PluginRegistry();
-
-      const validationPlugin: IPlugin = {
-        getName: () => 'ValidationPlugin',
-        getSequence: () => 1,
-        isEnabled: () => true,
-        getHooks: () => ({
-          beforePhaseTransition: vi
-            .fn()
-            .mockRejectedValue(new Error('Validation failed for any reason')),
-        }),
-      };
-
-      registry.registerPlugin(validationPlugin);
-
-      // Should re-throw validation errors (not just specific messages)
-      await expect(
-        registry.executeHook(
-          'beforePhaseTransition',
-          createMockContext(),
-          'plan',
-          'code'
-        )
-      ).rejects.toThrow('Validation failed for any reason');
-    });
-  });
-
-  describe('Multiple plugin execution', () => {
-    it('should execute all plugins even if some fail on non-critical hooks', async () => {
-      const registry = new PluginRegistry();
-
-      const plugin1Spy = vi
-        .fn()
-        .mockRejectedValue(new Error('Plugin 1 failed'));
-      const plugin2Spy = vi.fn().mockResolvedValue(undefined);
-      const plugin3Spy = vi.fn().mockResolvedValue(undefined);
-
-      registry.registerPlugin({
-        getName: () => 'Plugin1',
-        getSequence: () => 1,
-        isEnabled: () => true,
-        getHooks: () => ({ afterStartDevelopment: plugin1Spy }),
-      });
-
-      registry.registerPlugin({
-        getName: () => 'Plugin2',
-        getSequence: () => 2,
-        isEnabled: () => true,
-        getHooks: () => ({ afterStartDevelopment: plugin2Spy }),
-      });
-
-      registry.registerPlugin({
-        getName: () => 'Plugin3',
-        getSequence: () => 3,
-        isEnabled: () => true,
-        getHooks: () => ({ afterStartDevelopment: plugin3Spy }),
-      });
-
-      // Execute should not throw
-      const _result = await registry.executeHook(
-        'afterStartDevelopment',
-        createMockContext(),
-        { workflow: 'epcc', commit_behaviour: 'end' },
-        {
-          conversationId: 'test',
-          planFilePath: '/test/plan.md',
-          phase: 'explore',
-          workflow: 'epcc',
-        }
-      );
-
-      // All plugins should be called
-      expect(plugin1Spy).toHaveBeenCalled();
-      expect(plugin2Spy).toHaveBeenCalled();
-      expect(plugin3Spy).toHaveBeenCalled();
-    });
-  });
-
-  describe('Disabled plugin handling', () => {
-    it('should not execute hooks from disabled plugins', async () => {
-      const registry = new PluginRegistry();
-
-      const hookSpy = vi.fn();
-
-      const disabledPlugin: IPlugin = {
-        getName: () => 'DisabledPlugin',
-        getSequence: () => 1,
-        isEnabled: () => false, // Disabled
-        getHooks: () => ({ afterStartDevelopment: hookSpy }),
-      };
-
-      registry.registerPlugin(disabledPlugin);
-
-      await registry.executeHook(
-        'afterStartDevelopment',
-        createMockContext(),
-        { workflow: 'epcc', commit_behaviour: 'end' },
-        {
-          conversationId: 'test',
-          planFilePath: '/test/plan.md',
-          phase: 'explore',
-          workflow: 'epcc',
-        }
-      );
-
-      // Disabled plugin's hook should not be called
-      expect(hookSpy).not.toHaveBeenCalled();
-    });
-  });
-});