@codemcp/workflows 3.1.21

package/test/unit/commit-behaviour-interface.test.ts

@@ -0,0 +1,244 @@
+/**
+ * Test the new commit_behaviour interface
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { StartDevelopmentHandler } from '../../packages/mcp-server/src/tool-handlers/start-development.js';
+import * as GitManagerModule from '@codemcp/workflows-core';
+import type { ServerContext } from '../../packages/mcp-server/src/types.js';
+
+// Spy on GitManager methods
+const isGitRepositorySpy = vi.spyOn(
+  GitManagerModule.GitManager,
+  'isGitRepository'
+);
+const getCurrentCommitHashSpy = vi.spyOn(
+  GitManagerModule.GitManager,
+  'getCurrentCommitHash'
+);
+
+describe('Commit Behaviour Interface', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    isGitRepositorySpy.mockReturnValue(true);
+    getCurrentCommitHashSpy.mockReturnValue('abc123');
+  });
+
+  it('should translate commit_behaviour "step" to correct git config', async () => {
+    const handler = new StartDevelopmentHandler();
+    const mockContext = {
+      projectPath: '/test/path',
+      conversationManager: {
+        createConversationContext: vi
+          .fn()
+          .mockResolvedValue({ conversationId: 'test' }),
+        updateConversationState: vi.fn().mockResolvedValue(undefined),
+      },
+      workflowManager: {
+        validateWorkflowName: vi.fn().mockReturnValue(true),
+        loadProjectWorkflows: vi.fn(),
+        loadWorkflowForProject: vi
+          .fn()
+          .mockReturnValue({ name: 'minor', phases: ['explore', 'implement'] }),
+      },
+      transitionEngine: {
+        handleExplicitTransition: vi
+          .fn()
+          .mockResolvedValue({ newPhase: 'explore' }),
+      },
+      planManager: {
+        setStateMachine: vi.fn(),
+        ensurePlanFile: vi.fn().mockResolvedValue('/test/plan.md'),
+      },
+      instructionGenerator: {
+        generateInstructions: vi.fn().mockReturnValue('Test instructions'),
+      },
+    };
+
+    const result = await handler.handle(
+      {
+        workflow: 'minor',
+        commit_behaviour: 'step',
+      },
+      mockContext as ServerContext
+    );
+
+    // Verify the handler processed the commit_behaviour parameter
+    expect(result).toBeTruthy();
+    expect(
+      mockContext.conversationManager.updateConversationState
+    ).toHaveBeenCalledWith(
+      'test',
+      expect.objectContaining({
+        gitCommitConfig: expect.objectContaining({
+          enabled: true,
+          commitOnStep: true,
+          commitOnPhase: false,
+          commitOnComplete: true, // Should be true when step commits are enabled
+        }),
+      })
+    );
+  });
+
+  it('should translate commit_behaviour "phase" to correct git config', async () => {
+    const handler = new StartDevelopmentHandler();
+    const mockContext = {
+      projectPath: '/test/path',
+      conversationManager: {
+        createConversationContext: vi
+          .fn()
+          .mockResolvedValue({ conversationId: 'test' }),
+        updateConversationState: vi.fn().mockResolvedValue(undefined),
+      },
+      workflowManager: {
+        validateWorkflowName: vi.fn().mockReturnValue(true),
+        loadProjectWorkflows: vi.fn(),
+        loadWorkflowForProject: vi
+          .fn()
+          .mockReturnValue({ name: 'minor', phases: ['explore', 'implement'] }),
+      },
+      transitionEngine: {
+        handleExplicitTransition: vi
+          .fn()
+          .mockResolvedValue({ newPhase: 'explore' }),
+      },
+      planManager: {
+        setStateMachine: vi.fn(),
+        ensurePlanFile: vi.fn().mockResolvedValue('/test/plan.md'),
+      },
+      instructionGenerator: {
+        generateInstructions: vi.fn().mockReturnValue('Test instructions'),
+      },
+    };
+
+    await handler.handle(
+      {
+        workflow: 'minor',
+        commit_behaviour: 'phase',
+      },
+      mockContext as unknown as ServerContext
+    );
+
+    expect(
+      mockContext.conversationManager.updateConversationState
+    ).toHaveBeenCalledWith(
+      'test',
+      expect.objectContaining({
+        gitCommitConfig: expect.objectContaining({
+          enabled: true,
+          commitOnStep: false,
+          commitOnPhase: true,
+          commitOnComplete: true, // Should be true when phase commits are enabled
+        }),
+      })
+    );
+  });
+
+  it('should translate commit_behaviour "end" to correct git config', async () => {
+    const handler = new StartDevelopmentHandler();
+    const mockContext = {
+      projectPath: '/test/path',
+      conversationManager: {
+        createConversationContext: vi
+          .fn()
+          .mockResolvedValue({ conversationId: 'test' }),
+        updateConversationState: vi.fn().mockResolvedValue(undefined),
+      },
+      workflowManager: {
+        validateWorkflowName: vi.fn().mockReturnValue(true),
+        loadProjectWorkflows: vi.fn(),
+        loadWorkflowForProject: vi
+          .fn()
+          .mockReturnValue({ name: 'minor', phases: ['explore', 'implement'] }),
+      },
+      transitionEngine: {
+        handleExplicitTransition: vi
+          .fn()
+          .mockResolvedValue({ newPhase: 'explore' }),
+      },
+      planManager: {
+        setStateMachine: vi.fn(),
+        ensurePlanFile: vi.fn().mockResolvedValue('/test/plan.md'),
+      },
+      instructionGenerator: {
+        generateInstructions: vi.fn().mockReturnValue('Test instructions'),
+      },
+    };
+
+    await handler.handle(
+      {
+        workflow: 'minor',
+        commit_behaviour: 'end',
+      },
+      mockContext as ServerContext
+    );
+
+    expect(
+      mockContext.conversationManager.updateConversationState
+    ).toHaveBeenCalledWith(
+      'test',
+      expect.objectContaining({
+        gitCommitConfig: expect.objectContaining({
+          enabled: true,
+          commitOnStep: false,
+          commitOnPhase: false,
+          commitOnComplete: true,
+        }),
+      })
+    );
+  });
+
+  it('should translate commit_behaviour "none" to disabled git config', async () => {
+    const handler = new StartDevelopmentHandler();
+    const mockContext = {
+      projectPath: '/test/path',
+      conversationManager: {
+        createConversationContext: vi
+          .fn()
+          .mockResolvedValue({ conversationId: 'test' }),
+        updateConversationState: vi.fn().mockResolvedValue(undefined),
+      },
+      workflowManager: {
+        validateWorkflowName: vi.fn().mockReturnValue(true),
+        loadProjectWorkflows: vi.fn(),
+        loadWorkflowForProject: vi
+          .fn()
+          .mockReturnValue({ name: 'minor', phases: ['explore', 'implement'] }),
+      },
+      transitionEngine: {
+        handleExplicitTransition: vi
+          .fn()
+          .mockResolvedValue({ newPhase: 'explore' }),
+      },
+      planManager: {
+        setStateMachine: vi.fn(),
+        ensurePlanFile: vi.fn().mockResolvedValue('/test/plan.md'),
+      },
+      instructionGenerator: {
+        generateInstructions: vi.fn().mockReturnValue('Test instructions'),
+      },
+    };
+
+    await handler.handle(
+      {
+        workflow: 'minor',
+        commit_behaviour: 'none',
+      },
+      mockContext as ServerContext
+    );
+
+    expect(
+      mockContext.conversationManager.updateConversationState
+    ).toHaveBeenCalledWith(
+      'test',
+      expect.objectContaining({
+        gitCommitConfig: expect.objectContaining({
+          enabled: false,
+          commitOnStep: false,
+          commitOnPhase: false,
+          commitOnComplete: false,
+        }),
+      })
+    );
+  });
+});

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

@@ -0,0 +1,151 @@
+/**
+ * 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 '../../packages/mcp-server/src/tool-handlers/conduct-review.js';
+import type { ServerContext } from '../../packages/mcp-server/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/reset-functionality.test.ts

@@ -0,0 +1,72 @@
+/**
+ * Test for reset functionality
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { ResponsibleVibeMCPServer } from '../../src/server.js';
+import { TempProject } from '../utils/temp-files.js';
+import { ServerTestHelper, MockDocsHelper } from '../utils/test-helpers.js';
+
+describe('Reset Functionality', () => {
+  let server: ResponsibleVibeMCPServer;
+  let tempProject: TempProject;
+
+  beforeEach(async () => {
+    tempProject = new TempProject({ projectName: 'reset-test' });
+    MockDocsHelper.addToTempProject(tempProject);
+
+    server = await ServerTestHelper.createServer(tempProject.projectPath);
+  });
+
+  afterEach(async () => {
+    await ServerTestHelper.cleanupServer(server);
+    tempProject.cleanup();
+  });
+
+  it('should require confirmation to reset', async () => {
+    // Try to reset without confirmation
+    try {
+      await server.handleResetDevelopment({ confirm: false });
+      expect.fail('Should have thrown an error');
+    } catch (error) {
+      expect(error.message).toContain(
+        'Reset operation requires explicit confirmation'
+      );
+    }
+  });
+
+  it('should successfully reset with confirmation', async () => {
+    // First, initialize development with a workflow
+    await server.handleStartDevelopment({
+      workflow: 'waterfall',
+    });
+
+    // Then create some state by calling whats_next
+    await server.handleWhatsNext({
+      context: 'test context',
+      user_input: 'test input',
+    });
+
+    // Now reset with confirmation
+    const result = await server.handleResetDevelopment({
+      confirm: true,
+      reason: 'test reset',
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.resetItems).toContain('interaction_logs');
+    expect(result.resetItems).toContain('conversation_state');
+    expect(result.resetItems).toContain('plan_file');
+    expect(result.message).toContain('Successfully reset conversation');
+    expect(result.message).toContain('test reset');
+  });
+
+  it('should validate confirm parameter type', async () => {
+    try {
+      await server.handleResetDevelopment({ confirm: 'true' }); // string instead of boolean
+      expect.fail('Should have thrown an error');
+    } catch (error) {
+      expect(error.message).toContain('confirm parameter must be a boolean');
+    }
+  });
+});

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

@@ -0,0 +1,192 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { ResponsibleVibeMCPServer } from '../packages/mcp-server/src/server.js';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdtemp, rm, writeFile, mkdir } from 'node:fs/promises';
+import { ServerTestHelper, MockDocsHelper } from '../utils/test-helpers.js';
+
+describe('resume_workflow tool', () => {
+  let server: ResponsibleVibeMCPServer;
+  let tempDir: string;
+
+  beforeEach(async () => {
+    // Create temporary directory for testing
+    tempDir = await mkdtemp(join(tmpdir(), 'responsible-vibe-test-'));
+    MockDocsHelper.addToProject(tempDir);
+
+    server = await ServerTestHelper.createServer(tempDir);
+
+    // Initialize development with waterfall workflow before testing
+    await server.handleStartDevelopment({ workflow: 'waterfall' });
+  });
+
+  afterEach(async () => {
+    await ServerTestHelper.cleanupServer(server);
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('should return comprehensive workflow resumption information', async () => {
+    const result = await server.handleResumeWorkflow({});
+
+    expect(result).toBeTypeOf('object');
+    expect(result.workflow_status).toBeDefined();
+    expect(result.plan_status).toBeDefined();
+    expect(result.system_prompt).toBeDefined(); // Default: include system prompt
+    expect(result.recommendations).toBeDefined();
+    expect(result.generated_at).toBeDefined();
+    expect(result.tool_version).toBeDefined();
+  });
+
+  it('should include workflow status information', async () => {
+    const result = await server.handleResumeWorkflow({});
+
+    const workflowStatus = result.workflow_status;
+    expect(workflowStatus.conversation_id).toBeTypeOf('string');
+    expect(workflowStatus.current_phase).toBeTypeOf('string');
+    expect(workflowStatus.project_path).toBe(tempDir);
+    expect(workflowStatus.git_branch).toBeTypeOf('string');
+    expect(workflowStatus.state_machine).toBeDefined();
+  });
+
+  it('should include plan status information', async () => {
+    const result = await server.handleResumeWorkflow({});
+
+    const planStatus = result.plan_status;
+    expect(planStatus.exists).toBeTypeOf('boolean');
+    expect(planStatus.path).toBeTypeOf('string');
+    expect(planStatus.path).toContain('.vibe/development-plan');
+  });
+
+  it('should include system prompt by default', async () => {
+    const result = await server.handleResumeWorkflow({});
+
+    expect(result.system_prompt).toBeTypeOf('string');
+    expect(result.system_prompt.length).toBeGreaterThan(1000);
+    expect(result.system_prompt).toContain('responsible-vibe-mcp');
+  });
+
+  it('should exclude system prompt when requested', async () => {
+    const result = await server.handleResumeWorkflow({
+      include_system_prompt: false,
+    });
+
+    expect(result.system_prompt).toBeNull();
+  });
+
+  it('should provide phase-specific recommendations', async () => {
+    const result = await server.handleResumeWorkflow({});
+
+    const recommendations = result.recommendations;
+    expect(recommendations.immediate_actions).toBeInstanceOf(Array);
+    expect(recommendations.immediate_actions.length).toBeGreaterThan(0);
+    expect(recommendations.phase_guidance).toBeTypeOf('string');
+    expect(recommendations.potential_issues).toBeInstanceOf(Array);
+
+    // Should always recommend calling whats_next
+    const hasWhatsNext = recommendations.immediate_actions.some(
+      (action: string) => action.includes('whats_next')
+    );
+    expect(hasWhatsNext).toBe(true);
+  });
+
+  it('should analyze plan file content when available', async () => {
+    // Create a mock plan file
+    const planContent = `# Development Plan
+
+## Implementation
+
+### Tasks
+- [x] Completed task 1
+- [x] Completed task 2
+- [ ] Active task 1
+- [ ] Active task 2
+
+## Decision Log
+- Decision 1: Use TypeScript
+- Decision 2: Use Vitest for testing
+`;
+
+    // Create .vibe directory and write plan file to expected location
+    const planDir = join(tempDir, '.vibe');
+    await mkdir(planDir, { recursive: true });
+    await writeFile(join(planDir, 'development-plan-default.md'), planContent);
+
+    const result = await server.handleResumeWorkflow({});
+
+    const planStatus = result.plan_status;
+    expect(planStatus.exists).toBe(true);
+    expect(planStatus.analysis).toBeDefined();
+
+    const analysis = planStatus.analysis;
+    expect(analysis.active_tasks).toContain('Active task 1');
+    expect(analysis.active_tasks).toContain('Active task 2');
+    expect(analysis.completed_tasks).toContain('Completed task 1');
+    expect(analysis.completed_tasks).toContain('Completed task 2');
+
+    // Phase should come from database, not plan file
+    expect(result.workflow_status.current_phase).toBeDefined();
+    expect(result.workflow_status.current_phase).toBeTypeOf('string');
+  });
+
+  it('should handle missing plan file gracefully', async () => {
+    // Create a custom test that mocks the plan manager to report no plan file
+    const originalPlanManager = (server as unknown).components?.context
+      ?.planManager;
+
+    try {
+      // Replace plan manager with a mock that reports no plan file
+      if ((server as unknown).components?.context) {
+        (server as unknown).components.context.planManager = {
+          getPlanFileInfo: async () => ({
+            exists: false,
+            path: '/fake/path.md',
+          }),
+          ensurePlanFile: async () => {},
+          setStateMachine: () => {},
+        };
+      }
+
+      const result = await server.handleResumeWorkflow({});
+
+      const planStatus = result.plan_status;
+      expect(planStatus.exists).toBe(false);
+      expect(planStatus.analysis).toBeNull();
+    } finally {
+      // Restore original plan manager
+      if ((server as unknown).components?.context && originalPlanManager) {
+        (server as unknown).components.context.planManager =
+          originalPlanManager;
+      }
+    }
+  });
+
+  it('should provide different recommendations based on phase', async () => {
+    // This test would ideally set up different phases and verify recommendations
+    // For now, just verify the structure is correct
+    const result = await server.handleResumeWorkflow({});
+
+    const recommendations = result.recommendations;
+    expect(recommendations.immediate_actions).toBeInstanceOf(Array);
+    expect(recommendations.phase_guidance).toBeTypeOf('string');
+    expect(recommendations.potential_issues).toBeInstanceOf(Array);
+  });
+
+  it('should handle errors gracefully', async () => {
+    // This test ensures the method doesn't throw for any reasonable input
+    await expect(server.handleResumeWorkflow({})).resolves.toBeDefined();
+    await expect(
+      server.handleResumeWorkflow({ include_system_prompt: true })
+    ).resolves.toBeDefined();
+    await expect(
+      server.handleResumeWorkflow({ include_system_prompt: false })
+    ).resolves.toBeDefined();
+  });
+
+  it('should include metadata in response', async () => {
+    const result = await server.handleResumeWorkflow({});
+
+    expect(result.generated_at).toBeTypeOf('string');
+    expect(result.tool_version).toBeTypeOf('string');
+    expect(new Date(result.generated_at)).toBeInstanceOf(Date);
+  });
+});