@codemcp/workflows 5.0.1 → 5.1.1

package/test/unit/proceed-to-phase-plugin-integration.test.ts

@@ -1,150 +0,0 @@
-/**
- * Test plugin hook integration in proceed-to-phase
- * Focus on testing that plugin hooks are called correctly
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { ProceedToPhaseHandler } from '../../src/tool-handlers/proceed-to-phase.js';
-import { PluginRegistry } from '../../src/plugin-system/plugin-registry.js';
-import type { ServerContext } from '../../src/types.js';
-import type { PluginHookContext } from '../../src/plugin-system/plugin-interfaces.js';
-
-// Mock dependencies
-vi.mock('@codemcp/workflows-core', () => ({
-  createLogger: vi.fn(() => ({
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-  })),
-}));
-
-describe('ProceedToPhase Plugin Integration', () => {
-  let handler: ProceedToPhaseHandler;
-  let mockPluginRegistry: PluginRegistry;
-  let mockContext: ServerContext;
-
-  beforeEach(() => {
-    mockPluginRegistry = new PluginRegistry();
-
-    mockContext = {
-      conversationManager: {
-        getConversationContext: vi.fn().mockResolvedValue({
-          conversationId: 'test-conversation',
-          planFilePath: '/test/plan.md',
-          currentPhase: 'plan',
-          workflowName: 'epcc',
-          projectPath: '/test/project',
-          gitBranch: 'main',
-        }),
-        updateConversationState: vi.fn().mockResolvedValue(undefined),
-      },
-      transitionEngine: {
-        handleExplicitTransition: vi.fn().mockReturnValue({
-          newPhase: 'code',
-          transitionReason: 'Test transition',
-          isModeled: true,
-          instructions: 'Test transition instructions',
-        }),
-      },
-      planManager: {
-        getPlanFileInfo: vi.fn().mockResolvedValue({ exists: true }),
-      },
-      instructionGenerator: {
-        generateInstructions: vi.fn().mockResolvedValue({
-          instructions: 'Test instructions',
-        }),
-      },
-      workflowManager: {
-        loadWorkflowForProject: vi.fn().mockReturnValue({
-          name: 'epcc',
-          states: { plan: {}, code: {} },
-        }),
-      },
-      interactionLogger: {
-        logInteraction: vi.fn().mockResolvedValue(undefined),
-      },
-      projectPath: '/test/project',
-      pluginRegistry: mockPluginRegistry,
-    } as unknown as ServerContext;
-
-    handler = new ProceedToPhaseHandler();
-  });
-
-  it('should call beforePhaseTransition plugin hook during phase transition', async () => {
-    const hookSpy = vi.fn().mockResolvedValue(undefined);
-
-    // Register a mock plugin with beforePhaseTransition hook
-    const mockPlugin = {
-      getName: () => 'TestPlugin',
-      getSequence: () => 100,
-      isEnabled: () => true,
-      getHooks: () => ({
-        beforePhaseTransition: hookSpy,
-      }),
-    };
-
-    mockPluginRegistry.registerPlugin(mockPlugin);
-
-    // Execute the proceed_to_phase handler
-    await handler.handle(
-      {
-        target_phase: 'code',
-        reason: 'Testing plugin integration',
-        review_state: 'not-required',
-      },
-      mockContext
-    );
-
-    // Verify the hook was called with correct parameters
-    expect(hookSpy).toHaveBeenCalledOnce();
-
-    const [pluginContext, currentPhase, targetPhase] = hookSpy.mock.calls[0];
-
-    // Verify plugin context structure
-    expect(pluginContext).toMatchObject<Partial<PluginHookContext>>({
-      conversationId: 'test-conversation',
-      planFilePath: '/test/plan.md',
-      currentPhase: 'plan',
-      workflow: 'epcc',
-      projectPath: '/test/project',
-      gitBranch: 'main',
-      targetPhase: 'code',
-    });
-
-    // Verify phase parameters
-    expect(currentPhase).toBe('plan');
-    expect(targetPhase).toBe('code');
-  });
-
-  it('should handle plugin hook errors by returning error result', async () => {
-    const hookError = new Error('Plugin validation failed');
-    const hookSpy = vi.fn().mockRejectedValue(hookError);
-
-    // Register a mock plugin that throws an error
-    const mockPlugin = {
-      getName: () => 'TestPlugin',
-      getSequence: () => 100,
-      isEnabled: () => true,
-      getHooks: () => ({
-        beforePhaseTransition: hookSpy,
-      }),
-    };
-
-    mockPluginRegistry.registerPlugin(mockPlugin);
-
-    // Execute the handler and expect it to return error result
-    const result = await handler.handle(
-      {
-        target_phase: 'code',
-        reason: 'Testing plugin error handling',
-        review_state: 'not-required',
-      },
-      mockContext
-    );
-
-    expect(result.success).toBe(false);
-    expect(result.error).toContain('Plugin validation failed');
-    expect(hookSpy).toHaveBeenCalledOnce();
-  });
-});

package/test/unit/reset-functionality.test.ts

@@ -1,72 +0,0 @@
-/**
- * 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

@@ -1,193 +0,0 @@
-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.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');
-    // Streamlined prompt is ~400-600 chars (was 2000+ before)
-    expect(result.system_prompt.length).toBeGreaterThan(200);
-    expect(result.system_prompt.length).toBeLessThan(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);
-  });
-});

package/test/unit/server-config-plugin-registry.test.ts

@@ -1,99 +0,0 @@
-/**
- * Test plugin registration in server-config
- */
-
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { initializeServerComponents } from '../../src/server-config.js';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { execSync } from 'node:child_process';
-
-// Mock child_process to control bd command availability
-vi.mock('node:child_process', () => ({
-  execSync: vi.fn(),
-}));
-
-describe('Server Config Plugin Registration', () => {
-  let tempDir: string;
-
-  beforeEach(async () => {
-    vi.resetAllMocks(); // Reset mock implementations, not just call history
-    tempDir = await mkdtemp(join(tmpdir(), 'server-config-test-'));
-  });
-
-  afterEach(async () => {
-    vi.resetAllMocks();
-    try {
-      await rm(tempDir, { recursive: true, force: true });
-    } catch {
-      // Ignore cleanup errors
-    }
-  });
-
-  it('should register BeadsPlugin when TASK_BACKEND is beads and bd is available', async () => {
-    vi.stubEnv('TASK_BACKEND', 'beads');
-
-    // Mock bd --version to return success
-    vi.mocked(execSync).mockReturnValue('beads v1.0.0\n');
-
-    const components = await initializeServerComponents({
-      projectPath: tempDir,
-    });
-
-    expect(components.context.pluginRegistry).toBeDefined();
-
-    // Check that BeadsPlugin was registered
-    const pluginNames = components.context.pluginRegistry.getPluginNames();
-    expect(pluginNames).toContain('BeadsPlugin');
-
-    // Check that it's enabled
-    const enabledPlugins =
-      components.context.pluginRegistry.getEnabledPlugins();
-    expect(enabledPlugins).toHaveLength(1);
-    expect(enabledPlugins[0].getName()).toBe('BeadsPlugin');
-  });
-
-  it('should not register BeadsPlugin when TASK_BACKEND is markdown', async () => {
-    // Explicitly set markdown to disable beads
-    vi.stubEnv('TASK_BACKEND', 'markdown');
-
-    const components = await initializeServerComponents({
-      projectPath: tempDir,
-    });
-
-    expect(components.context.pluginRegistry).toBeDefined();
-
-    // Check that no plugins are registered
-    const pluginNames = components.context.pluginRegistry.getPluginNames();
-    expect(pluginNames).toHaveLength(0);
-
-    // Check that no plugins are enabled
-    const enabledPlugins =
-      components.context.pluginRegistry.getEnabledPlugins();
-    expect(enabledPlugins).toHaveLength(0);
-  });
-
-  it('should not register BeadsPlugin when bd is not available', async () => {
-    // Explicitly clear TASK_BACKEND - triggers auto-detection
-    delete process.env.TASK_BACKEND;
-
-    // Mock bd --version to throw (command not found)
-    vi.mocked(execSync).mockImplementation(() => {
-      throw new Error('command not found: bd');
-    });
-
-    const components = await initializeServerComponents({
-      projectPath: tempDir,
-    });
-
-    expect(components.context.pluginRegistry).toBeDefined();
-    expect(components.context.pluginRegistry.getPluginNames()).toHaveLength(0);
-    expect(components.context.pluginRegistry.getEnabledPlugins()).toHaveLength(
-      0
-    );
-  });
-
-  // Note: Auto-detection tests are covered in E2E tests (beads-plugin-integration.test.ts)
-  // because mocking child_process across package boundaries requires E2E-style server setup
-});