@codemcp/workflows-core 3.1.16

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

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

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,224 @@
+/**
+ * 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');
+    });
+  });
+});