@codemcp/workflows-core 3.1.21 → 3.2.0

package/test/unit/conversation-manager.test.ts

@@ -1,179 +0,0 @@
-/**
- * Unit tests for ConversationManager
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { ConversationManager } from '../../src/conversation-manager.js';
-import type { Database } from '../../src/database.js';
-
-// Mock WorkflowManager state machine
-const mockStateMachine = {
-  name: 'Test Workflow',
-  description: 'Test workflow for unit tests',
-  initial_state: 'idle',
-  states: {
-    idle: {
-      description: 'Idle state',
-      transitions: [],
-    },
-  },
-};
-
-describe('ConversationManager', () => {
-  let conversationManager: ConversationManager;
-
-  // Mock database functions
-  const mockGetConversationState = vi.fn();
-  const mockSaveConversationState = vi.fn();
-  const mockDeleteConversationState = vi.fn();
-  const mockSoftDeleteInteractionLogs = vi.fn();
-  const mockInitialize = vi.fn();
-  const mockClose = vi.fn();
-
-  beforeEach(() => {
-    vi.resetAllMocks();
-
-    // Create mock WorkflowManager
-    const mockWorkflowManager = {
-      loadWorkflowForProject: vi.fn().mockReturnValue(mockStateMachine),
-      validateWorkflowName: vi.fn().mockReturnValue(true),
-      getWorkflowNames: vi
-        .fn()
-        .mockReturnValue([
-          'mock-workflow-1',
-          'mock-workflow-2',
-          'mock-workflow-3',
-        ]),
-    };
-
-    // Create a mock database with the mocked functions
-    const mockDb = {
-      getConversationState: mockGetConversationState,
-      saveConversationState: mockSaveConversationState,
-      deleteConversationState: mockDeleteConversationState,
-      softDeleteInteractionLogs: mockSoftDeleteInteractionLogs,
-      initialize: mockInitialize,
-      close: mockClose,
-    };
-
-    // Create conversation manager with dependency injection
-    conversationManager = new ConversationManager(
-      mockDb as Database,
-      mockWorkflowManager,
-      '/test/project/path'
-    );
-  });
-
-  afterEach(() => {
-    vi.resetAllMocks();
-  });
-
-  describe('getConversationContext', () => {
-    it('should throw an error when no conversation exists', async () => {
-      // Mock database to return null (no conversation)
-      mockGetConversationState.mockResolvedValue(null);
-
-      // Expect the method to throw an error
-      await expect(
-        conversationManager.getConversationContext()
-      ).rejects.toThrow(
-        'No development conversation exists for this project. Use the start_development tool first to initialize development with a workflow.'
-      );
-
-      // Verify database was called with expected ID
-      expect(mockGetConversationState).toHaveBeenCalledWith(expect.any(String));
-    });
-
-    it('should return conversation context when conversation exists', async () => {
-      // Mock existing conversation state
-      const mockState = {
-        conversationId: 'test-conversation-id',
-        projectPath: '/test/project/path',
-        gitBranch: 'main',
-        currentPhase: 'idle',
-        planFilePath: '/test/project/path/.vibe/development-plan.md',
-        workflowName: 'custom',
-        createdAt: '2025-06-25T00:00:00.000Z',
-        updatedAt: '2025-06-25T00:00:00.000Z',
-      };
-
-      mockGetConversationState.mockResolvedValue(mockState);
-
-      // Call the method
-      const result = await conversationManager.getConversationContext();
-
-      // Verify result
-      expect(result).toEqual({
-        conversationId: 'test-conversation-id',
-        projectPath: '/test/project/path',
-        gitBranch: 'main',
-        currentPhase: 'idle',
-        planFilePath: '/test/project/path/.vibe/development-plan.md',
-        workflowName: 'custom',
-      });
-
-      // Verify database was called with expected ID
-      expect(mockGetConversationState).toHaveBeenCalledWith(expect.any(String));
-    });
-  });
-
-  describe('createConversationContext', () => {
-    it('should create a new conversation when none exists', async () => {
-      // Mock database to return null (no conversation) then accept the new state
-      mockGetConversationState.mockResolvedValue(null);
-      mockSaveConversationState.mockResolvedValue(undefined);
-
-      // Call the method
-      const result =
-        await conversationManager.createConversationContext('mock-workflow');
-
-      // Verify result has expected structure
-      expect(result).toHaveProperty('conversationId');
-      expect(result).toHaveProperty('projectPath', '/test/project/path');
-      expect(result).toHaveProperty('gitBranch', 'default');
-      expect(result).toHaveProperty('currentPhase', 'idle'); // Should be idle from mock state machine
-      expect(result).toHaveProperty('planFilePath');
-      expect(result).toHaveProperty('workflowName', 'mock-workflow');
-
-      // Verify database was called to save the new state
-      expect(mockSaveConversationState).toHaveBeenCalled();
-      const savedState = mockSaveConversationState.mock.calls[0][0];
-      expect(savedState.workflowName).toBe('mock-workflow'); // Should match what we passed in
-      expect(savedState.currentPhase).toBe('idle');
-    });
-
-    it('should return existing conversation when one already exists', async () => {
-      // Mock existing conversation state
-      const mockState = {
-        conversationId: 'test-conversation-id',
-        projectPath: '/test/project/path',
-        gitBranch: 'main',
-        currentPhase: 'idle',
-        planFilePath: '/test/project/path/.vibe/development-plan.md',
-        workflowName: 'existing-workflow',
-        createdAt: '2025-06-25T00:00:00.000Z',
-        updatedAt: '2025-06-25T00:00:00.000Z',
-      };
-
-      mockGetConversationState.mockResolvedValue(mockState);
-
-      // Call the method with a different workflow
-      const result = await conversationManager.createConversationContext(
-        'mock-different-workflow'
-      );
-
-      // Verify result is the existing conversation
-      expect(result).toEqual({
-        conversationId: 'test-conversation-id',
-        projectPath: '/test/project/path',
-        gitBranch: 'main',
-        currentPhase: 'idle',
-        planFilePath: '/test/project/path/.vibe/development-plan.md',
-        workflowName: 'existing-workflow',
-      });
-
-      // Verify database was NOT called to save a new state
-      expect(mockSaveConversationState).not.toHaveBeenCalled();
-    });
-  });
-});

package/test/unit/custom-workflow-loading.test.ts

@@ -1,174 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { WorkflowManager } from '@codemcp/workflows-core';
-import fs from 'node:fs';
-import path from 'node:path';
-import { tmpdir } from 'node:os';
-
-describe('Custom Workflow Loading', () => {
-  let testProjectPath: string;
-  let originalEnv: string | undefined;
-
-  beforeEach(() => {
-    originalEnv = process.env.VIBE_WORKFLOW_DOMAINS;
-    testProjectPath = fs.mkdtempSync(
-      path.join(tmpdir(), 'custom-workflow-test-')
-    );
-  });
-
-  afterEach(() => {
-    if (originalEnv !== undefined) {
-      process.env.VIBE_WORKFLOW_DOMAINS = originalEnv;
-    } else {
-      delete process.env.VIBE_WORKFLOW_DOMAINS;
-    }
-
-    fs.rmSync(testProjectPath, { recursive: true, force: true });
-  });
-
-  it('should load custom workflow from .vibe/workflows directory', () => {
-    process.env.VIBE_WORKFLOW_DOMAINS = 'code';
-
-    const workflowsDir = path.join(testProjectPath, '.vibe', 'workflows');
-    fs.mkdirSync(workflowsDir, { recursive: true });
-
-    // Copy existing minor workflow and customize it
-    const minorPath = path.join(
-      __dirname,
-      '..',
-      '..',
-      'resources',
-      'workflows',
-      'minor.yaml'
-    );
-    const originalContent = fs.readFileSync(minorPath, 'utf8');
-    const customContent = originalContent
-      .replace("name: 'minor'", "name: 'my-custom-workflow'")
-      .replace(
-        /description: .*/,
-        "description: 'My completely custom workflow'"
-      );
-
-    fs.writeFileSync(path.join(workflowsDir, 'custom.yaml'), customContent);
-
-    const manager = new WorkflowManager();
-
-    // Load project workflows
-    const workflows = manager.getAvailableWorkflowsForProject(testProjectPath);
-
-    // Should load custom workflow
-    const customWf = manager.getWorkflow('my-custom-workflow');
-    expect(customWf?.name).toBe('my-custom-workflow');
-    expect(customWf?.description).toBe('My completely custom workflow');
-    expect(customWf?.initial_state).toBe('explore');
-    expect(Object.keys(customWf?.states || {})).toEqual([
-      'explore',
-      'implement',
-      'finalize',
-    ]);
-
-    // Should be in workflow list
-    const customInList = workflows.find(w => w.name === 'my-custom-workflow');
-    expect(customInList?.description).toBe('My completely custom workflow');
-    expect(customInList?.phases).toEqual(['explore', 'implement', 'finalize']);
-  });
-
-  it('should load multiple custom workflows', () => {
-    process.env.VIBE_WORKFLOW_DOMAINS = 'code';
-
-    const workflowsDir = path.join(testProjectPath, '.vibe', 'workflows');
-    fs.mkdirSync(workflowsDir, { recursive: true });
-
-    // Copy and customize first workflow
-    const minorPath = path.join(
-      __dirname,
-      '..',
-      '..',
-      'resources',
-      'workflows',
-      'minor.yaml'
-    );
-    const minorContent = fs.readFileSync(minorPath, 'utf8');
-    const workflow1 = minorContent
-      .replace("name: 'minor'", "name: 'workflow-one'")
-      .replace(/description: .*/, "description: 'First custom workflow'");
-
-    // Copy and customize second workflow
-    const bugfixPath = path.join(
-      __dirname,
-      '..',
-      '..',
-      'resources',
-      'workflows',
-      'bugfix.yaml'
-    );
-    const bugfixContent = fs.readFileSync(bugfixPath, 'utf8');
-    const workflow2 = bugfixContent
-      .replace("name: 'bugfix'", "name: 'workflow-two'")
-      .replace(/description: .*/, "description: 'Second custom workflow'");
-
-    fs.writeFileSync(path.join(workflowsDir, 'first.yaml'), workflow1);
-    fs.writeFileSync(path.join(workflowsDir, 'second.yaml'), workflow2);
-
-    const manager = new WorkflowManager();
-
-    // Load project workflows
-    const workflows = manager.getAvailableWorkflowsForProject(testProjectPath);
-
-    // Should load both custom workflows
-    const wf1 = manager.getWorkflow('workflow-one');
-    const wf2 = manager.getWorkflow('workflow-two');
-
-    expect(wf1?.name).toBe('workflow-one');
-    expect(wf1?.description).toBe('First custom workflow');
-
-    expect(wf2?.name).toBe('workflow-two');
-    expect(wf2?.description).toBe('Second custom workflow');
-
-    // Both should be in workflow list
-    expect(workflows.some(w => w.name === 'workflow-one')).toBe(true);
-    expect(workflows.some(w => w.name === 'workflow-two')).toBe(true);
-
-    // Should still have predefined workflows too
-    expect(workflows.some(w => w.name === 'waterfall')).toBe(true);
-  });
-
-  it('should ignore domain filtering for custom workflows', () => {
-    process.env.VIBE_WORKFLOW_DOMAINS = 'code'; // Only code domain
-
-    const workflowsDir = path.join(testProjectPath, '.vibe', 'workflows');
-    fs.mkdirSync(workflowsDir, { recursive: true });
-
-    // Copy posts workflow (office domain) and customize it
-    const postsPath = path.join(
-      __dirname,
-      '..',
-      '..',
-      'resources',
-      'workflows',
-      'posts.yaml'
-    );
-    const postsContent = fs.readFileSync(postsPath, 'utf8');
-    const officeWorkflow = postsContent
-      .replace('name: posts', 'name: custom-office-workflow')
-      .replace(/description: .*/, "description: 'Custom office workflow'");
-
-    fs.writeFileSync(path.join(workflowsDir, 'office.yaml'), officeWorkflow);
-
-    const manager = new WorkflowManager();
-
-    // Load project workflows
-    const workflows = manager.getAvailableWorkflowsForProject(testProjectPath);
-
-    // Custom office workflow should be available despite domain filtering
-    const customOffice = manager.getWorkflow('custom-office-workflow');
-    expect(customOffice?.name).toBe('custom-office-workflow');
-    expect(customOffice?.metadata?.domain).toBe('office');
-
-    // Should be in workflow list
-    expect(workflows.some(w => w.name === 'custom-office-workflow')).toBe(true);
-
-    // Predefined office workflows should still be filtered out
-    expect(workflows.some(w => w.name === 'posts')).toBe(false);
-    expect(workflows.some(w => w.name === 'slides')).toBe(false);
-  });
-});

package/test/unit/directory-linking-and-extensions.test.ts

@@ -1,338 +0,0 @@
-/**
- * Tests for directory linking and extension preservation functionality
- *
- * Tests the fixes for:
- * - Issue 1: Directory linking support
- * - Issue 2: Extension preservation in symlinks
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { PathValidationUtils } from '@codemcp/workflows-core';
-import { ProjectDocsManager } from '@codemcp/workflows-core';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { mkdir, writeFile, rm, readlink, lstat } from 'node:fs/promises';
-
-describe('Directory Linking and Extension Preservation', () => {
-  let testProjectPath: string;
-  let projectDocsManager: ProjectDocsManager;
-
-  beforeEach(async () => {
-    // Create test project directory
-    testProjectPath = join(tmpdir(), `dir-ext-test-${Date.now()}`);
-    await mkdir(testProjectPath, { recursive: true });
-
-    projectDocsManager = new ProjectDocsManager();
-  });
-
-  afterEach(async () => {
-    // Clean up test directory
-    try {
-      await rm(testProjectPath, { recursive: true });
-    } catch {
-      // Ignore cleanup errors
-    }
-  });
-
-  describe('Directory Linking Support (Issue 1 Fix)', () => {
-    it('should validate directories with validateFileOrDirectoryPath', async () => {
-      // Create test directory
-      const docsDir = join(testProjectPath, 'docs');
-      await mkdir(docsDir, { recursive: true });
-      await writeFile(join(docsDir, 'index.md'), '# Documentation');
-
-      const result = await PathValidationUtils.validateFileOrDirectoryPath(
-        docsDir,
-        testProjectPath
-      );
-
-      expect(result.isValid).toBe(true);
-      expect(result.resolvedPath).toBe(docsDir);
-    });
-
-    it('should reject directories with old validateFilePath method', async () => {
-      // Create test directory
-      const docsDir = join(testProjectPath, 'docs');
-      await mkdir(docsDir, { recursive: true });
-      await writeFile(join(docsDir, 'index.md'), '# Documentation');
-
-      const result = await PathValidationUtils.validateFilePath(
-        docsDir,
-        testProjectPath
-      );
-
-      expect(result.isValid).toBe(false);
-      expect(result.error).toContain('directory, not a file');
-    });
-
-    it('should recognize directories as valid file paths in validateParameter', async () => {
-      // Create test directory
-      const docsDir = join(testProjectPath, 'docs');
-      await mkdir(docsDir, { recursive: true });
-      await writeFile(join(docsDir, 'index.md'), '# Documentation');
-
-      const result = await PathValidationUtils.validateParameter(
-        docsDir,
-        ['arc42'],
-        testProjectPath
-      );
-
-      expect(result.isTemplate).toBe(false);
-      expect(result.isFilePath).toBe(true);
-      expect(result.resolvedPath).toBe(docsDir);
-    });
-
-    it('should create symlinks to directories', async () => {
-      // Create test directory
-      const docsDir = join(testProjectPath, 'docs');
-      await mkdir(docsDir, { recursive: true });
-      await writeFile(join(docsDir, 'architecture.md'), '# Architecture');
-
-      const result = await projectDocsManager.createOrLinkProjectDocs(
-        testProjectPath,
-        {}, // No templates
-        { architecture: docsDir }
-      );
-
-      expect(result.linked).toContain('architecture');
-      expect(result.created.length).toBe(2); // requirements and design from templates
-      expect(result.skipped.length).toBe(0);
-
-      // Verify symlink was created
-      const paths = await projectDocsManager.getDocumentPathsWithExtensions(
-        testProjectPath,
-        { architecture: docsDir }
-      );
-      const stats = await lstat(paths.architecture);
-      expect(stats.isSymbolicLink()).toBe(true);
-
-      const linkTarget = await readlink(paths.architecture);
-      expect(linkTarget).toContain('docs');
-    });
-  });
-
-  describe('Extension Preservation (Issue 2 Fix)', () => {
-    it('should preserve file extensions in getDocumentPathsWithExtensions', async () => {
-      // Create test files with different extensions
-      await writeFile(join(testProjectPath, 'arch.adoc'), '= Architecture');
-      await writeFile(join(testProjectPath, 'reqs.docx'), 'Requirements');
-      await writeFile(join(testProjectPath, 'design.txt'), 'Design');
-
-      const sourcePaths = {
-        architecture: join(testProjectPath, 'arch.adoc'),
-        requirements: join(testProjectPath, 'reqs.docx'),
-        design: join(testProjectPath, 'design.txt'),
-      };
-
-      const paths = await projectDocsManager.getDocumentPathsWithExtensions(
-        testProjectPath,
-        sourcePaths
-      );
-
-      expect(paths.architecture.endsWith('.adoc')).toBe(true);
-      expect(paths.requirements.endsWith('.docx')).toBe(true);
-      expect(paths.design.endsWith('.txt')).toBe(true);
-    });
-
-    it('should use .md extension for templates (backward compatibility)', async () => {
-      const paths =
-        await projectDocsManager.getDocumentPathsWithExtensions(
-          testProjectPath
-        );
-
-      expect(paths.architecture.endsWith('.md')).toBe(true);
-      expect(paths.requirements.endsWith('.md')).toBe(true);
-      expect(paths.design.endsWith('.md')).toBe(true);
-    });
-
-    it('should create symlinks with preserved extensions', async () => {
-      // Create test files
-      await writeFile(
-        join(testProjectPath, 'architecture.adoc'),
-        '= Architecture\n\nAsciiDoc format'
-      );
-      await writeFile(
-        join(testProjectPath, 'requirements.docx'),
-        'Word document'
-      );
-      await writeFile(join(testProjectPath, 'design.txt'), 'Plain text');
-
-      const sourcePaths = {
-        architecture: join(testProjectPath, 'architecture.adoc'),
-        requirements: join(testProjectPath, 'requirements.docx'),
-        design: join(testProjectPath, 'design.txt'),
-      };
-
-      const result = await projectDocsManager.createOrLinkProjectDocs(
-        testProjectPath,
-        {}, // No templates
-        sourcePaths
-      );
-
-      expect(result.linked).toEqual([
-        'architecture.adoc',
-        'requirements.docx',
-        'design.txt',
-      ]);
-      expect(result.created).toEqual([]);
-      expect(result.skipped).toEqual([]);
-
-      // Verify symlinks exist with correct extensions
-      const paths = await projectDocsManager.getDocumentPathsWithExtensions(
-        testProjectPath,
-        sourcePaths
-      );
-
-      const archStats = await lstat(paths.architecture);
-      expect(archStats.isSymbolicLink()).toBe(true);
-
-      const reqStats = await lstat(paths.requirements);
-      expect(reqStats.isSymbolicLink()).toBe(true);
-
-      const designStats = await lstat(paths.design);
-      expect(designStats.isSymbolicLink()).toBe(true);
-    });
-
-    it('should handle mixed templates and file paths with correct extensions', async () => {
-      // Create one test file
-      await writeFile(
-        join(testProjectPath, 'existing-design.adoc'),
-        '= Design\n\nExisting design doc'
-      );
-
-      const result = await projectDocsManager.createOrLinkProjectDocs(
-        testProjectPath,
-        {
-          architecture: 'freestyle', // Template
-          requirements: 'freestyle', // Template
-        },
-        {
-          design: join(testProjectPath, 'existing-design.adoc'), // File path
-        }
-      );
-
-      expect(result.created).toEqual(['architecture.md', 'requirements.md']);
-      expect(result.linked).toEqual(['design.adoc']);
-      expect(result.skipped).toEqual([]);
-    });
-
-    it('should handle files without extensions', async () => {
-      // Create file without extension
-      await writeFile(
-        join(testProjectPath, 'README'),
-        '# Project\n\nNo extension file'
-      );
-
-      const sourcePaths = {
-        architecture: join(testProjectPath, 'README'),
-      };
-
-      const paths = await projectDocsManager.getDocumentPathsWithExtensions(
-        testProjectPath,
-        sourcePaths
-      );
-
-      // Should default to .md for files without extensions
-      expect(paths.architecture.endsWith('.md')).toBe(true);
-    });
-
-    it('should handle directories with no extension', async () => {
-      // Create test directory
-      const docsDir = join(testProjectPath, 'documentation');
-      await mkdir(docsDir, { recursive: true });
-      await writeFile(join(docsDir, 'index.md'), '# Documentation Index');
-
-      const sourcePaths = {
-        architecture: docsDir,
-      };
-
-      const paths = await projectDocsManager.getDocumentPathsWithExtensions(
-        testProjectPath,
-        sourcePaths
-      );
-
-      // Should use standardized document type name
-      expect(paths.architecture.endsWith('architecture')).toBe(true);
-      expect(paths.architecture).not.toContain('.md');
-    });
-  });
-
-  describe('Backward Compatibility', () => {
-    it('should maintain old getDocumentPaths behavior', () => {
-      const paths = projectDocsManager.getDocumentPaths(testProjectPath);
-
-      expect(paths.architecture.endsWith('architecture.md')).toBe(true);
-      expect(paths.requirements.endsWith('requirements.md')).toBe(true);
-      expect(paths.design.endsWith('design.md')).toBe(true);
-    });
-
-    it('should maintain old getVariableSubstitutions behavior', () => {
-      const substitutions =
-        projectDocsManager.getVariableSubstitutions(testProjectPath);
-
-      expect(
-        substitutions['$ARCHITECTURE_DOC'].endsWith('architecture.md')
-      ).toBe(true);
-      expect(
-        substitutions['$REQUIREMENTS_DOC'].endsWith('requirements.md')
-      ).toBe(true);
-      expect(substitutions['$DESIGN_DOC'].endsWith('design.md')).toBe(true);
-    });
-
-    it('should provide new getVariableSubstitutionsWithExtensions method', async () => {
-      // Create test files
-      await writeFile(join(testProjectPath, 'arch.adoc'), '= Architecture');
-
-      const sourcePaths = {
-        architecture: join(testProjectPath, 'arch.adoc'),
-      };
-
-      const substitutions =
-        await projectDocsManager.getVariableSubstitutionsWithExtensions(
-          testProjectPath,
-          sourcePaths
-        );
-
-      expect(
-        substitutions['$ARCHITECTURE_DOC'].endsWith('architecture.adoc')
-      ).toBe(true);
-      expect(
-        substitutions['$REQUIREMENTS_DOC'].endsWith('requirements.md')
-      ).toBe(true); // Default for no source
-      expect(substitutions['$DESIGN_DOC'].endsWith('design.md')).toBe(true); // Default for no source
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should handle non-existent source paths gracefully', async () => {
-      const sourcePaths = {
-        architecture: join(testProjectPath, 'nonexistent.adoc'),
-      };
-
-      const paths = await projectDocsManager.getDocumentPathsWithExtensions(
-        testProjectPath,
-        sourcePaths
-      );
-
-      // Should default to .md when source doesn't exist
-      expect(paths.architecture.endsWith('.md')).toBe(true);
-    });
-
-    it('should validate security boundaries for directories', async () => {
-      // Test with an absolute path that's clearly outside any reasonable project boundary
-      // This tests the security logic without relying on filesystem creation
-      const maliciousPath = '/etc/passwd';
-
-      const result = await PathValidationUtils.validateFileOrDirectoryPath(
-        maliciousPath,
-        testProjectPath
-      );
-
-      // This should fail because /etc/passwd doesn't exist as a directory we can create,
-      // but more importantly, it tests that we're not allowing arbitrary system paths
-      expect(result.isValid).toBe(false);
-      // The error could be either "outside project boundaries" or "not found" - both are acceptable
-      expect(result.error).toBeDefined();
-    });
-  });
-});