@codemcp/workflows 5.0.1 → 5.1.1

package/test/unit/server-tools.test.ts

@@ -1,310 +0,0 @@
-/**
- * Unit tests for Server Tools
- *
- * Tests the behavior of MCP tools when no conversation exists
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-
-// Mock conversation manager
-const mockGetConversationContext = vi.fn();
-const mockCreateConversationContext = vi.fn();
-
-// Mock database
-vi.mock('@codemcp/workflows-core', () => {
-  return {
-    Database: vi.fn().mockImplementation(() => ({
-      initialize: vi.fn().mockResolvedValue(undefined),
-      close: vi.fn().mockResolvedValue(undefined),
-    })),
-  };
-});
-
-// Mock transition engine
-const mockAnalyzePhaseTransition = vi.fn();
-const mockHandleExplicitTransition = vi.fn();
-const mockGetStateMachine = vi.fn();
-vi.mock('../../src/transition-engine', () => {
-  return {
-    TransitionEngine: vi.fn().mockImplementation(() => ({
-      analyzePhaseTransition: mockAnalyzePhaseTransition,
-      handleExplicitTransition: mockHandleExplicitTransition,
-      getStateMachine: mockGetStateMachine,
-      setConversationManager: vi.fn(),
-    })),
-  };
-});
-
-// Mock plan manager
-vi.mock('../../src/plan-manager', () => {
-  return {
-    PlanManager: vi.fn().mockImplementation(() => ({
-      ensurePlanFile: vi.fn().mockResolvedValue(undefined),
-      getPlanFileInfo: vi
-        .fn()
-        .mockResolvedValue({ exists: true, path: '/test/plan.md' }),
-      setStateMachine: vi.fn(),
-    })),
-  };
-});
-
-// Mock instruction generator
-vi.mock('../../src/instruction-generator', () => {
-  return {
-    InstructionGenerator: vi.fn().mockImplementation(() => ({
-      generateInstructions: vi
-        .fn()
-        .mockResolvedValue({ instructions: 'Test instructions' }),
-      setStateMachine: vi.fn(),
-    })),
-  };
-});
-
-// Mock workflow manager
-vi.mock('../../src/workflow-manager', () => {
-  return {
-    WorkflowManager: vi.fn().mockImplementation(() => ({
-      validateWorkflowName: vi.fn().mockReturnValue(true),
-      getWorkflowNames: vi
-        .fn()
-        .mockReturnValue(['waterfall', 'agile', 'custom']),
-      loadWorkflowForProject: vi.fn().mockReturnValue({
-        name: 'Test Workflow',
-        description: 'Test workflow',
-        initial_state: 'idle',
-        states: { idle: { description: 'Idle state', transitions: [] } },
-      }),
-      getAvailableWorkflows: vi.fn().mockReturnValue([
-        {
-          name: 'waterfall',
-          displayName: 'Waterfall',
-          description: 'Classic waterfall workflow',
-        },
-      ]),
-    })),
-  };
-});
-
-// Mock system prompt generator
-vi.mock('../../src/system-prompt-generator.js', () => ({
-  generateSystemPrompt: vi.fn().mockReturnValue('Test system prompt'),
-}));
-
-// Create mock handler functions with fixed return values for tests
-const mockHandleWhatsNext = vi.fn().mockImplementation(async _args => {
-  // For the error case test
-  mockGetConversationContext.mockRejectedValueOnce(
-    new Error('No development conversation exists')
-  );
-
-  return {
-    error: true,
-    message: 'No development conversation has been started for this project.',
-    instructions:
-      'Please use the start_development tool first to initialize development with a workflow.',
-    available_workflows: ['waterfall', 'agile', 'custom'],
-    example: 'start_development({ workflow: "waterfall" })',
-  };
-});
-
-const mockHandleProceedToPhase = vi.fn().mockImplementation(async _args => {
-  // For the error case test
-  mockGetConversationContext.mockRejectedValueOnce(
-    new Error('No development conversation exists')
-  );
-
-  return {
-    error: true,
-    message: 'No development conversation has been started for this project.',
-    instructions:
-      'Please use the start_development tool first to initialize development with a workflow.',
-    available_workflows: ['waterfall', 'agile', 'custom'],
-    example: 'start_development({ workflow: "waterfall" })',
-  };
-});
-
-const mockHandleResumeWorkflow = vi.fn().mockImplementation(async _args => {
-  // For the error case test
-  mockGetConversationContext.mockRejectedValueOnce(
-    new Error('No development conversation exists')
-  );
-
-  return {
-    error: true,
-    message: 'No development conversation has been started for this project.',
-    instructions:
-      'Please use the start_development tool first to initialize development with a workflow.',
-    available_workflows: ['waterfall', 'agile', 'custom'],
-    example: 'start_development({ workflow: "waterfall" })',
-  };
-});
-
-const mockHandleStartDevelopment = vi.fn().mockImplementation(async args => {
-  if (!args.workflow) {
-    throw new Error('workflow parameter is required');
-  }
-
-  // Mock successful creation
-  mockCreateConversationContext.mockResolvedValueOnce({
-    conversationId: 'test-id',
-    projectPath: '/test/path',
-    gitBranch: 'main',
-    currentPhase: 'idle',
-    planFilePath: '/test/path/.vibe/plan.md',
-    workflowName: args.workflow,
-  });
-
-  return {
-    phase: 'idle',
-    instructions: 'test instructions',
-    conversation_id: 'test-id',
-    plan_file_path: '/test/path/.vibe/plan.md',
-  };
-});
-
-// Mock the server class
-vi.mock('../../src/server', () => {
-  return {
-    ResponsibleVibeMCPServer: vi.fn().mockImplementation(() => ({
-      handleWhatsNext: mockHandleWhatsNext,
-      handleProceedToPhase: mockHandleProceedToPhase,
-      handleResumeWorkflow: mockHandleResumeWorkflow,
-      handleStartDevelopment: mockHandleStartDevelopment,
-    })),
-  };
-});
-
-describe('Server Tools', () => {
-  // Create a simple mock server object with direct implementations
-  const server = {
-    handleWhatsNext: async () => ({
-      error: true,
-      message: 'No development conversation has been started for this project.',
-      instructions:
-        'Please use the start_development tool first to initialize development with a workflow.',
-      available_workflows: ['waterfall', 'agile', 'custom'],
-      example: 'start_development({ workflow: "waterfall" })',
-    }),
-
-    handleProceedToPhase: async () => ({
-      error: true,
-      message: 'No development conversation has been started for this project.',
-      instructions:
-        'Please use the start_development tool first to initialize development with a workflow.',
-      available_workflows: ['waterfall', 'agile', 'custom'],
-      example: 'start_development({ workflow: "waterfall" })',
-    }),
-
-    handleResumeWorkflow: async () => ({
-      error: true,
-      message: 'No development conversation has been started for this project.',
-      instructions:
-        'Please use the start_development tool first to initialize development with a workflow.',
-      available_workflows: ['waterfall', 'agile', 'custom'],
-      example: 'start_development({ workflow: "waterfall" })',
-      workflow_status: {},
-      plan_status: { exists: false, analysis: null },
-    }),
-
-    handleStartDevelopment: async (args: { workflow?: string }) => {
-      if (!args.workflow) {
-        throw new Error('workflow parameter is required');
-      }
-
-      return {
-        phase: 'idle',
-        instructions: 'test instructions',
-        conversation_id: 'test-id',
-        plan_file_path: '/test/path/.vibe/plan.md',
-      };
-    },
-  };
-
-  beforeEach(() => {
-    vi.resetAllMocks();
-  });
-
-  afterEach(() => {
-    vi.resetAllMocks();
-  });
-
-  describe('whats_next tool', () => {
-    it('should return helpful error when no conversation exists', async () => {
-      // Call the tool handler
-      const result = await server.handleWhatsNext();
-
-      // Verify result contains helpful error message
-      expect(result).toHaveProperty('error', true);
-      expect(result.message).toContain(
-        'No development conversation has been started'
-      );
-      expect(result.instructions).toContain(
-        'Please use the start_development tool'
-      );
-      expect(result.available_workflows).toContain('waterfall');
-      expect(result.example).toContain('start_development');
-    });
-  });
-
-  describe('proceed_to_phase tool', () => {
-    it('should return helpful error when no conversation exists', async () => {
-      mockGetConversationContext.mockRejectedValueOnce(
-        new Error(
-          'No development conversation exists for this project. Use the start_development tool first to initialize development with a workflow.'
-        )
-      );
-
-      // Call the tool handler
-      const result = await server.handleProceedToPhase({
-        target_phase: 'requirements',
-        review_state: 'not-required',
-      });
-
-      // Verify result contains helpful error message
-      expect(result).toHaveProperty('error', true);
-      expect(result).toHaveProperty(
-        'message',
-        'No development conversation has been started for this project.'
-      );
-      expect(result).toHaveProperty(
-        'instructions',
-        'Please use the start_development tool first to initialize development with a workflow.'
-      );
-      expect(result).toHaveProperty('available_workflows');
-      expect(result).toHaveProperty('example');
-    });
-  });
-
-  describe('resume_workflow tool', () => {
-    it('should return helpful error when no conversation exists', async () => {
-      // Call the tool handler
-      const result = await server.handleResumeWorkflow({});
-
-      // Verify result contains helpful error message
-      expect(result).toHaveProperty('error', true);
-      expect(result.message).toContain(
-        'No development conversation has been started'
-      );
-      expect(result.instructions).toContain(
-        'Please use the start_development tool'
-      );
-      expect(result.available_workflows).toContain('waterfall');
-      expect(result.example).toContain('start_development');
-    });
-  });
-
-  describe('start_development tool', () => {
-    it('should create a new conversation with specified workflow', async () => {
-      // Mock conversation context
-      // Call the tool handler
-      const result = await server.handleStartDevelopment({
-        workflow: 'waterfall',
-      });
-
-      // Verify result
-      expect(result).toHaveProperty('phase', 'idle');
-      expect(result).toHaveProperty('instructions');
-      expect(result).toHaveProperty('plan_file_path');
-    });
-  });
-});

package/test/unit/setup-project-docs-handler.test.ts

@@ -1,268 +0,0 @@
-/**
- * Unit tests for SetupProjectDocsHandler
- *
- * Tests the setup_project_docs tool handler functionality
- */
-
-import {
-  describe,
-  it,
-  expect,
-  beforeEach,
-  afterEach,
-  vi,
-  Mocked,
-} from 'vitest';
-import { TestAccess } from '../utils/test-access.js';
-import { SetupProjectDocsHandler } from '../../src/tool-handlers/setup-project-docs.js';
-import { ProjectDocsManager } from '@codemcp/workflows-core';
-import { TemplateManager } from '@codemcp/workflows-core';
-import { ServerContext } from '../../src/types';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { mkdir } from 'node:fs/promises';
-import { cleanupDirectory } from '../utils/temp-files.js';
-
-// Mock ProjectDocsManager and TemplateManager
-vi.mock('../../src/project-docs-manager.js');
-vi.mock('../../src/template-manager.js');
-
-describe('SetupProjectDocsHandler', () => {
-  let handler: SetupProjectDocsHandler;
-  let mockProjectDocsManager: Mocked<ProjectDocsManager>;
-  let mockTemplateManager: Mocked<TemplateManager>;
-  let testProjectPath: string;
-  let mockContext: ServerContext;
-
-  beforeEach(async () => {
-    // Create test project directory
-    testProjectPath = join(tmpdir(), `setup-docs-test-${Date.now()}`);
-    await mkdir(testProjectPath, { recursive: true });
-
-    // Mock TemplateManager
-    mockTemplateManager = {
-      getAvailableTemplates: vi.fn().mockResolvedValue({
-        architecture: ['arc42', 'freestyle'],
-        requirements: ['ears', 'freestyle'],
-        design: ['comprehensive', 'freestyle'],
-      }),
-    } as Partial<TemplateManager>;
-
-    // Mock ProjectDocsManager
-    mockProjectDocsManager = {
-      createOrLinkProjectDocs: vi.fn(),
-      createProjectDocs: vi.fn(),
-      getDocumentPaths: vi.fn(),
-      templateManager: mockTemplateManager,
-    } as Partial<ProjectDocsManager>;
-
-    // Create handler and inject mock
-    handler = new SetupProjectDocsHandler();
-    TestAccess.injectMock(
-      handler,
-      'projectDocsManager',
-      mockProjectDocsManager
-    );
-
-    // Mock context
-    mockContext = {
-      projectPath: testProjectPath,
-    } as ServerContext;
-  });
-
-  afterEach(async () => {
-    // Clean up test directory
-    try {
-      await cleanupDirectory(testProjectPath);
-    } catch {
-      // Ignore cleanup errors
-    }
-  });
-
-  describe('executeHandler', () => {
-    beforeEach(() => {
-      // Setup default mocks
-      mockProjectDocsManager.getDocumentPaths.mockReturnValue({
-        architecture: join(testProjectPath, '.vibe', 'docs', 'architecture.md'),
-        requirements: join(testProjectPath, '.vibe', 'docs', 'requirements.md'),
-        design: join(testProjectPath, '.vibe', 'docs', 'design.md'),
-      });
-    });
-
-    it('should create documents with specified templates', async () => {
-      const args = {
-        architecture: 'arc42',
-        requirements: 'ears',
-        design: 'comprehensive',
-      };
-
-      mockProjectDocsManager.createOrLinkProjectDocs.mockResolvedValue({
-        created: ['architecture.md', 'requirements.md', 'design.md'],
-        linked: [],
-        skipped: [],
-      });
-
-      const result = await handler.executeHandler(args, mockContext);
-
-      expect(result.success).toBe(true);
-      expect(result.created).toEqual([
-        'architecture.md',
-        'requirements.md',
-        'design.md',
-      ]);
-      expect(result.linked).toEqual([]);
-      expect(result.skipped).toEqual([]);
-      expect(result.message).toContain(
-        'Created: architecture.md, requirements.md, design.md'
-      );
-    });
-
-    it('should create documents with freestyle templates', async () => {
-      const args = {
-        architecture: 'freestyle',
-        requirements: 'freestyle',
-        design: 'freestyle',
-      };
-
-      mockProjectDocsManager.createOrLinkProjectDocs.mockResolvedValue({
-        created: ['architecture.md', 'requirements.md', 'design.md'],
-        linked: [],
-        skipped: [],
-      });
-
-      const result = await handler.executeHandler(args, mockContext);
-
-      expect(result.success).toBe(true);
-      expect(
-        mockProjectDocsManager.createOrLinkProjectDocs
-      ).toHaveBeenCalledWith(
-        testProjectPath,
-        expect.objectContaining({
-          architecture: 'freestyle',
-          requirements: 'freestyle',
-          design: 'freestyle',
-        }),
-        {}
-      );
-    });
-
-    it('should handle partial creation with skipped files', async () => {
-      const args = {
-        architecture: 'arc42',
-        requirements: 'ears',
-        design: 'comprehensive',
-      };
-
-      mockProjectDocsManager.createOrLinkProjectDocs.mockResolvedValue({
-        created: ['requirements.md', 'design.md'],
-        linked: [],
-        skipped: ['architecture.md'],
-      });
-
-      const result = await handler.executeHandler(args, mockContext);
-
-      expect(result.success).toBe(true);
-      expect(result.created).toEqual(['requirements.md', 'design.md']);
-      expect(result.skipped).toEqual(['architecture.md']);
-      expect(result.message).toContain('Created: requirements.md, design.md');
-      expect(result.message).toContain('Skipped existing: architecture.md');
-    });
-
-    it('should handle all files being skipped', async () => {
-      const args = {
-        architecture: 'arc42',
-        requirements: 'ears',
-        design: 'comprehensive',
-      };
-
-      mockProjectDocsManager.createOrLinkProjectDocs.mockResolvedValue({
-        created: [],
-        linked: [],
-        skipped: ['architecture.md', 'requirements.md', 'design.md'],
-      });
-
-      const result = await handler.executeHandler(args, mockContext);
-
-      expect(result.success).toBe(true);
-      expect(result.created).toEqual([]);
-      expect(result.skipped).toEqual([
-        'architecture.md',
-        'requirements.md',
-        'design.md',
-      ]);
-      expect(result.message).toContain(
-        'Skipped existing: architecture.md, requirements.md, design.md'
-      );
-    });
-
-    it('should handle errors gracefully', async () => {
-      const args = {
-        architecture: 'arc42',
-        requirements: 'ears',
-        design: 'comprehensive',
-      };
-
-      mockProjectDocsManager.createOrLinkProjectDocs.mockRejectedValue(
-        new Error('Template not found: architecture/arc42')
-      );
-
-      const result = await handler.executeHandler(args, mockContext);
-
-      expect(result.success).toBe(false);
-      expect(result.created).toEqual([]);
-      expect(result.skipped).toEqual([]);
-      expect(result.message).toContain(
-        'Failed to setup project docs: Template not found: architecture/arc42'
-      );
-    });
-
-    it('should use current working directory when no project path in context', async () => {
-      const contextWithoutPath = {} as ServerContext;
-      const args = {
-        architecture: 'freestyle',
-        requirements: 'freestyle',
-        design: 'freestyle',
-      };
-
-      mockProjectDocsManager.createOrLinkProjectDocs.mockResolvedValue({
-        created: ['architecture.md', 'requirements.md', 'design.md'],
-        linked: [],
-        skipped: [],
-      });
-
-      await handler.executeHandler(args, contextWithoutPath);
-
-      expect(
-        mockProjectDocsManager.createOrLinkProjectDocs
-      ).toHaveBeenCalledWith(
-        process.cwd(),
-        expect.any(Object),
-        expect.any(Object)
-      );
-    });
-
-    it('should return correct document paths', async () => {
-      const args = {
-        architecture: 'freestyle',
-        requirements: 'freestyle',
-        design: 'freestyle',
-      };
-
-      const expectedPaths = {
-        architecture: join(testProjectPath, '.vibe', 'docs', 'architecture.md'),
-        requirements: join(testProjectPath, '.vibe', 'docs', 'requirements.md'),
-        design: join(testProjectPath, '.vibe', 'docs', 'design.md'),
-      };
-
-      mockProjectDocsManager.createOrLinkProjectDocs.mockResolvedValue({
-        created: ['architecture.md', 'requirements.md', 'design.md'],
-        linked: [],
-        skipped: [],
-      });
-
-      const result = await handler.executeHandler(args, mockContext);
-
-      expect(result.paths).toEqual(expectedPaths);
-    });
-  });
-});