@codemcp/workflows-core 3.1.21 → 3.2.0

package/test/unit/instruction-generator.test.ts

@@ -1,247 +0,0 @@
-/**
- * Unit tests for InstructionGenerator
- *
- * Tests instruction generation and variable substitution functionality
- */
-
-import { describe, it, expect, beforeEach, Mocked, vi } from 'vitest';
-import { TestAccess } from '../utils/test-access.js';
-import { InstructionGenerator } from '@codemcp/workflows-core';
-import { PlanManager } from '@codemcp/workflows-core';
-import { ProjectDocsManager } from '@codemcp/workflows-core';
-import type { ConversationContext } from '../../src/types.js';
-import type { InstructionContext } from '../../src/instruction-generator.js';
-import { join } from 'node:path';
-
-// Mock PlanManager
-vi.mock('../../src/plan-manager.js');
-
-// Mock ProjectDocsManager
-vi.mock('../../src/project-docs-manager.js');
-
-describe('InstructionGenerator', () => {
-  let instructionGenerator: InstructionGenerator;
-  let mockPlanManager: Mocked<PlanManager>;
-  let mockProjectDocsManager: Mocked<ProjectDocsManager>;
-  let testProjectPath: string;
-  let mockConversationContext: ConversationContext;
-  let mockInstructionContext: InstructionContext;
-
-  beforeEach(() => {
-    testProjectPath = '/test/project';
-
-    // Mock PlanManager
-    mockPlanManager = {
-      generatePlanFileGuidance: vi
-        .fn()
-        .mockReturnValue('Test plan file guidance'),
-    } as unknown;
-
-    // Mock ProjectDocsManager
-    mockProjectDocsManager = {
-      getVariableSubstitutions: vi.fn().mockReturnValue({
-        $ARCHITECTURE_DOC: join(
-          testProjectPath,
-          '.vibe',
-          'docs',
-          'architecture.md'
-        ),
-        $REQUIREMENTS_DOC: join(
-          testProjectPath,
-          '.vibe',
-          'docs',
-          'requirements.md'
-        ),
-        $DESIGN_DOC: join(testProjectPath, '.vibe', 'docs', 'design.md'),
-      }),
-    } as unknown;
-
-    // Create instruction generator and inject mocks
-    instructionGenerator = new InstructionGenerator(mockPlanManager);
-    TestAccess.injectMock(
-      instructionGenerator,
-      'projectDocsManager',
-      mockProjectDocsManager
-    );
-
-    // Mock conversation context
-    mockConversationContext = {
-      projectPath: testProjectPath,
-      planFilePath: join(testProjectPath, '.vibe', 'plan.md'),
-      gitBranch: 'main',
-      conversationId: 'test-conversation',
-    } as ConversationContext;
-
-    // Mock instruction context
-    mockInstructionContext = {
-      phase: 'design',
-      conversationContext: mockConversationContext,
-      transitionReason: 'Test transition',
-      isModeled: false,
-      planFileExists: true,
-    };
-  });
-
-  describe('generateInstructions', () => {
-    it('should apply variable substitution to base instructions', async () => {
-      const baseInstructions =
-        'Review the architecture in $ARCHITECTURE_DOC and update requirements in $REQUIREMENTS_DOC.';
-
-      const result = await instructionGenerator.generateInstructions(
-        baseInstructions,
-        mockInstructionContext
-      );
-
-      expect(result.instructions).toContain(
-        join(testProjectPath, '.vibe', 'docs', 'architecture.md')
-      );
-      expect(result.instructions).toContain(
-        join(testProjectPath, '.vibe', 'docs', 'requirements.md')
-      );
-      expect(result.instructions).not.toContain('$ARCHITECTURE_DOC');
-      expect(result.instructions).not.toContain('$REQUIREMENTS_DOC');
-    });
-
-    it('should handle multiple occurrences of the same variable', async () => {
-      const baseInstructions =
-        'Check $DESIGN_DOC for details. Update $DESIGN_DOC with new information.';
-
-      const result = await instructionGenerator.generateInstructions(
-        baseInstructions,
-        mockInstructionContext
-      );
-
-      const designDocPath = join(testProjectPath, '.vibe', 'docs', 'design.md');
-      const occurrences = (
-        result.instructions.match(
-          new RegExp(designDocPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g')
-        ) || []
-      ).length;
-      expect(occurrences).toBe(2);
-      expect(result.instructions).not.toContain('$DESIGN_DOC');
-    });
-
-    it('should handle instructions with no variables', async () => {
-      const baseInstructions = 'Continue with the current phase tasks.';
-
-      const result = await instructionGenerator.generateInstructions(
-        baseInstructions,
-        mockInstructionContext
-      );
-
-      expect(result.instructions).toContain(
-        'Continue with the current phase tasks.'
-      );
-      expect(
-        mockProjectDocsManager.getVariableSubstitutions
-      ).toHaveBeenCalledWith(testProjectPath);
-    });
-
-    it('should handle all three document variables', async () => {
-      const baseInstructions =
-        'Review $ARCHITECTURE_DOC, check $REQUIREMENTS_DOC, and update $DESIGN_DOC.';
-
-      const result = await instructionGenerator.generateInstructions(
-        baseInstructions,
-        mockInstructionContext
-      );
-
-      expect(result.instructions).toContain(
-        join(testProjectPath, '.vibe', 'docs', 'architecture.md')
-      );
-      expect(result.instructions).toContain(
-        join(testProjectPath, '.vibe', 'docs', 'requirements.md')
-      );
-      expect(result.instructions).toContain(
-        join(testProjectPath, '.vibe', 'docs', 'design.md')
-      );
-      expect(result.instructions).not.toContain('$ARCHITECTURE_DOC');
-      expect(result.instructions).not.toContain('$REQUIREMENTS_DOC');
-      expect(result.instructions).not.toContain('$DESIGN_DOC');
-    });
-
-    it('should preserve enhanced instruction structure', async () => {
-      const baseInstructions = 'Work on design tasks using $DESIGN_DOC.';
-
-      const result = await instructionGenerator.generateInstructions(
-        baseInstructions,
-        mockInstructionContext
-      );
-
-      // Should contain enhanced instruction elements
-      expect(result.instructions).toContain('Check your plan file');
-      expect(result.instructions).toContain('**Plan File Guidance:**');
-      expect(result.instructions).toContain('**Project Context:**');
-      expect(result.instructions).toContain('Project: /test/project');
-      expect(result.instructions).toContain('Branch: main');
-      expect(result.instructions).toContain('Current Phase: design');
-
-      // Should contain substituted variable
-      expect(result.instructions).toContain(
-        join(testProjectPath, '.vibe', 'docs', 'design.md')
-      );
-    });
-
-    it('should return correct metadata', async () => {
-      const baseInstructions = 'Test instructions with $ARCHITECTURE_DOC.';
-
-      const result = await instructionGenerator.generateInstructions(
-        baseInstructions,
-        mockInstructionContext
-      );
-
-      expect(result.metadata).toEqual({
-        phase: 'design',
-        planFilePath: join(testProjectPath, '.vibe', 'plan.md'),
-        transitionReason: 'Test transition',
-        isModeled: false,
-      });
-    });
-
-    it('should handle special regex characters in variables', async () => {
-      // Mock a variable with special characters (though unlikely in practice)
-      mockProjectDocsManager.getVariableSubstitutions.mockReturnValue({
-        '$TEST[DOC]': '/test/path/doc.md',
-      });
-
-      const baseInstructions = 'Check $TEST[DOC] for information.';
-
-      const result = await instructionGenerator.generateInstructions(
-        baseInstructions,
-        mockInstructionContext
-      );
-
-      expect(result.instructions).toContain('/test/path/doc.md');
-      expect(result.instructions).not.toContain('$TEST[DOC]');
-    });
-  });
-
-  describe('variable substitution edge cases', () => {
-    it('should handle empty substitutions', async () => {
-      mockProjectDocsManager.getVariableSubstitutions.mockReturnValue({});
-
-      const baseInstructions = 'Work on tasks without variables.';
-
-      const result = await instructionGenerator.generateInstructions(
-        baseInstructions,
-        mockInstructionContext
-      );
-
-      expect(result.instructions).toContain('Work on tasks without variables.');
-    });
-
-    it('should handle variables that do not exist in instructions', async () => {
-      const baseInstructions = 'Work on general tasks.';
-
-      const result = await instructionGenerator.generateInstructions(
-        baseInstructions,
-        mockInstructionContext
-      );
-
-      expect(result.instructions).toContain('Work on general tasks.');
-      expect(
-        mockProjectDocsManager.getVariableSubstitutions
-      ).toHaveBeenCalledWith(testProjectPath);
-    });
-  });
-});

package/test/unit/list-workflows-filtering.test.ts

@@ -1,68 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { ListWorkflowsHandler } from '../../packages/mcp-server/src/tool-handlers/list-workflows.js';
-import { WorkflowManager } from '@codemcp/workflows-core';
-
-describe('List Workflows Filtering', () => {
-  let originalEnv: string | undefined;
-
-  beforeEach(() => {
-    originalEnv = process.env.VIBE_WORKFLOW_DOMAINS;
-  });
-
-  afterEach(() => {
-    if (originalEnv !== undefined) {
-      process.env.VIBE_WORKFLOW_DOMAINS = originalEnv;
-    } else {
-      delete process.env.VIBE_WORKFLOW_DOMAINS;
-    }
-  });
-
-  it('should return only loaded workflows by default', async () => {
-    process.env.VIBE_WORKFLOW_DOMAINS = 'code';
-
-    const handler = new ListWorkflowsHandler();
-    const workflowManager = new WorkflowManager();
-
-    const context = {
-      workflowManager,
-      projectPath: process.cwd(),
-    } as { workflowManager: WorkflowManager; projectPath: string };
-
-    const result = await handler.executeHandler({}, context);
-
-    // Should only include code workflows
-    const hasCodeWorkflows = result.workflows.some(
-      w => w.name === 'waterfall' || w.name === 'epcc'
-    );
-    const hasOfficeWorkflows = result.workflows.some(w => w.name === 'posts');
-
-    expect(hasCodeWorkflows).toBe(true);
-    expect(hasOfficeWorkflows).toBe(false);
-  });
-
-  it('should return all workflows when include_unloaded is true', async () => {
-    process.env.VIBE_WORKFLOW_DOMAINS = 'code';
-
-    const handler = new ListWorkflowsHandler();
-    const workflowManager = new WorkflowManager();
-
-    const context = {
-      workflowManager,
-      projectPath: process.cwd(),
-    } as { workflowManager: WorkflowManager; projectPath: string };
-
-    const result = await handler.executeHandler(
-      { include_unloaded: true },
-      context
-    );
-
-    // Should include workflows from all domains
-    const hasCodeWorkflows = result.workflows.some(
-      w => w.name === 'waterfall' || w.name === 'epcc'
-    );
-    const hasOfficeWorkflows = result.workflows.some(w => w.name === 'posts');
-
-    expect(hasCodeWorkflows).toBe(true);
-    expect(hasOfficeWorkflows).toBe(true);
-  });
-});

package/test/unit/none-template-functionality.test.ts

@@ -1,224 +0,0 @@
-/**
- * Tests for "none" template functionality
- *
- * Tests the ability to disable specific document types using "none" templates
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { ProjectDocsManager } from '@codemcp/workflows-core';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { mkdir, rmdir, readFile } from 'node:fs/promises';
-
-describe('None Template Functionality', () => {
-  let testProjectPath: string;
-  let projectDocsManager: ProjectDocsManager;
-
-  beforeEach(async () => {
-    // Create test project directory
-    testProjectPath = join(tmpdir(), `none-template-test-${Date.now()}`);
-    await mkdir(testProjectPath, { recursive: true });
-
-    projectDocsManager = new ProjectDocsManager();
-  });
-
-  afterEach(async () => {
-    // Clean up test directory
-    try {
-      await rmdir(testProjectPath, { recursive: true });
-    } catch {
-      // Ignore cleanup errors
-    }
-  });
-
-  describe('None Template Creation', () => {
-    it('should create none template for architecture', async () => {
-      const result = await projectDocsManager.createOrLinkProjectDocs(
-        testProjectPath,
-        {
-          architecture: 'none',
-          requirements: 'freestyle',
-          design: 'freestyle',
-        },
-        {}
-      );
-
-      expect(result.created).toContain('architecture.md');
-      expect(result.created).toContain('requirements.md');
-      expect(result.created).toContain('design.md');
-
-      // Verify the none template content
-      const archPath = await projectDocsManager.readDocument(
-        testProjectPath,
-        'architecture'
-      );
-      expect(archPath).toContain('architecture.md');
-
-      // Read the actual file to verify placeholder content
-      const archContent = await readFile(archPath, 'utf-8');
-      expect(archContent).toContain('Architecture Placeholder');
-      expect(archContent).toContain('DO NOT EDIT THIS FILE');
-      expect(archContent).toContain('plan file');
-    });
-
-    it('should create none template for requirements', async () => {
-      const result = await projectDocsManager.createOrLinkProjectDocs(
-        testProjectPath,
-        {
-          architecture: 'freestyle',
-          requirements: 'none',
-          design: 'freestyle',
-        },
-        {}
-      );
-
-      expect(result.created).toContain('requirements.md');
-
-      // Verify the none template content
-      const reqPath = await projectDocsManager.readDocument(
-        testProjectPath,
-        'requirements'
-      );
-      expect(reqPath).toContain('requirements.md');
-
-      // Read the actual file to verify placeholder content
-      const reqContent = await readFile(reqPath, 'utf-8');
-      expect(reqContent).toContain('Requirements Placeholder');
-      expect(reqContent).toContain('DO NOT EDIT THIS FILE');
-      expect(reqContent).toContain('plan file');
-    });
-
-    it('should create none template for design', async () => {
-      const result = await projectDocsManager.createOrLinkProjectDocs(
-        testProjectPath,
-        {
-          architecture: 'freestyle',
-          requirements: 'freestyle',
-          design: 'none',
-        },
-        {}
-      );
-
-      expect(result.created).toContain('design.md');
-
-      // Verify the none template content
-      const designPath = await projectDocsManager.readDocument(
-        testProjectPath,
-        'design'
-      );
-      expect(designPath).toContain('design.md');
-
-      // Read the actual file to verify placeholder content
-      const designContent = await readFile(designPath, 'utf-8');
-      expect(designContent).toContain('Design Placeholder');
-      expect(designContent).toContain('DO NOT EDIT THIS FILE');
-      expect(designContent).toContain('plan file');
-    });
-
-    it('should support mixed usage with none templates', async () => {
-      // Create a test README file
-      const readmePath = join(testProjectPath, 'README.md');
-      await mkdir(testProjectPath, { recursive: true });
-      const fs = await import('node:fs/promises');
-      await fs.writeFile(
-        readmePath,
-        '# Test Project\n\nThis is a test project.'
-      );
-
-      const result = await projectDocsManager.createOrLinkProjectDocs(
-        testProjectPath,
-        {
-          architecture: 'freestyle', // Template
-          design: 'none', // None template
-        },
-        {
-          requirements: readmePath, // File link
-        }
-      );
-
-      expect(result.created).toContain('architecture.md');
-      expect(result.created).toContain('design.md');
-      expect(result.linked).toContain('requirements.md');
-
-      // Verify each document type
-      const archPath = await projectDocsManager.readDocument(
-        testProjectPath,
-        'architecture'
-      );
-      const archContent = await readFile(archPath, 'utf-8');
-      expect(archContent).toContain('INSTRUCTIONS FOR ARCHITECTURE');
-
-      const reqPath = await projectDocsManager.readDocument(
-        testProjectPath,
-        'requirements'
-      );
-      const reqContent = await readFile(reqPath, 'utf-8');
-      expect(reqContent).toContain('This is a test project');
-
-      const designPath = await projectDocsManager.readDocument(
-        testProjectPath,
-        'design'
-      );
-      const designContent = await readFile(designPath, 'utf-8');
-      expect(designContent).toContain('Design Placeholder');
-      expect(designContent).toContain('DO NOT EDIT THIS FILE');
-    });
-
-    it('should create all none templates when all are disabled', async () => {
-      const result = await projectDocsManager.createOrLinkProjectDocs(
-        testProjectPath,
-        {
-          architecture: 'none',
-          requirements: 'none',
-          design: 'none',
-        },
-        {}
-      );
-
-      expect(result.created).toEqual([
-        'architecture.md',
-        'requirements.md',
-        'design.md',
-      ]);
-      expect(result.linked).toEqual([]);
-
-      // Verify all contain placeholder content
-      const archPath = await projectDocsManager.readDocument(
-        testProjectPath,
-        'architecture'
-      );
-      const reqPath = await projectDocsManager.readDocument(
-        testProjectPath,
-        'requirements'
-      );
-      const designPath = await projectDocsManager.readDocument(
-        testProjectPath,
-        'design'
-      );
-
-      const archContent = await readFile(archPath, 'utf-8');
-      const reqContent = await readFile(reqPath, 'utf-8');
-      const designContent = await readFile(designPath, 'utf-8');
-
-      expect(archContent).toContain('Architecture Placeholder');
-      expect(reqContent).toContain('Requirements Placeholder');
-      expect(designContent).toContain('Design Placeholder');
-
-      // All should contain the DO NOT EDIT instruction
-      expect(archContent).toContain('DO NOT EDIT THIS FILE');
-      expect(reqContent).toContain('DO NOT EDIT THIS FILE');
-      expect(designContent).toContain('DO NOT EDIT THIS FILE');
-    });
-  });
-
-  describe('Template Discovery', () => {
-    it('should include none in available templates', async () => {
-      const availableTemplates =
-        await projectDocsManager.templateManager.getAvailableTemplates();
-
-      expect(availableTemplates.architecture).toContain('none');
-      expect(availableTemplates.requirements).toContain('none');
-      expect(availableTemplates.design).toContain('none');
-    });
-  });
-});