@codemcp/workflows-core 3.1.21 → 3.2.0

package/test/unit/file-linking-integration.test.ts

@@ -1,256 +0,0 @@
-/**
- * Integration tests for file linking functionality
- *
- * Tests the complete file linking workflow including path validation,
- * file detection, and symlink creation.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { PathValidationUtils } from '@codemcp/workflows-core';
-import { FileDetectionManager } from '@codemcp/workflows-core';
-import { ProjectDocsManager } from '@codemcp/workflows-core';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { mkdir, writeFile, rmdir, lstat } from 'node:fs/promises';
-
-describe('File Linking Integration', () => {
-  let testProjectPath: string;
-  let projectDocsManager: ProjectDocsManager;
-  let fileDetectionManager: FileDetectionManager;
-
-  beforeEach(async () => {
-    // Create test project directory
-    testProjectPath = join(tmpdir(), `file-linking-test-${Date.now()}`);
-    await mkdir(testProjectPath, { recursive: true });
-
-    // Create test files
-    await writeFile(
-      join(testProjectPath, 'README.md'),
-      '# Test Project\n\nThis is a test project with requirements and architecture info.'
-    );
-    await writeFile(
-      join(testProjectPath, 'ARCHITECTURE.md'),
-      '# Architecture\n\nSystem architecture details.'
-    );
-
-    // Create docs directory with files
-    await mkdir(join(testProjectPath, 'docs'), { recursive: true });
-    await writeFile(
-      join(testProjectPath, 'docs', 'design.md'),
-      '# Design\n\nDetailed design specifications.'
-    );
-
-    projectDocsManager = new ProjectDocsManager();
-    fileDetectionManager = new FileDetectionManager(testProjectPath);
-  });
-
-  afterEach(async () => {
-    // Clean up test directory
-    try {
-      await rmdir(testProjectPath, { recursive: true });
-    } catch {
-      // Ignore cleanup errors
-    }
-  });
-
-  describe('PathValidationUtils', () => {
-    it('should validate template names correctly', () => {
-      const availableTemplates = ['arc42', 'freestyle'];
-
-      expect(
-        PathValidationUtils.isTemplateName('arc42', availableTemplates)
-      ).toBe(true);
-      expect(
-        PathValidationUtils.isTemplateName('freestyle', availableTemplates)
-      ).toBe(true);
-      expect(
-        PathValidationUtils.isTemplateName('invalid', availableTemplates)
-      ).toBe(false);
-    });
-
-    it('should validate file paths correctly', async () => {
-      const result = await PathValidationUtils.validateFilePath(
-        'README.md',
-        testProjectPath
-      );
-
-      expect(result.isValid).toBe(true);
-      expect(result.resolvedPath).toBe(join(testProjectPath, 'README.md'));
-    });
-
-    it('should reject non-existent files', async () => {
-      const result = await PathValidationUtils.validateFilePath(
-        'nonexistent.md',
-        testProjectPath
-      );
-
-      expect(result.isValid).toBe(false);
-      expect(result.error).toContain('File not found');
-    });
-
-    it('should validate mixed parameters correctly', async () => {
-      const availableTemplates = ['arc42', 'freestyle'];
-
-      // Template name
-      const templateResult = await PathValidationUtils.validateParameter(
-        'arc42',
-        availableTemplates,
-        testProjectPath
-      );
-      expect(templateResult.isTemplate).toBe(true);
-      expect(templateResult.isFilePath).toBe(false);
-
-      // File path
-      const fileResult = await PathValidationUtils.validateParameter(
-        'README.md',
-        availableTemplates,
-        testProjectPath
-      );
-      expect(fileResult.isTemplate).toBe(false);
-      expect(fileResult.isFilePath).toBe(true);
-      expect(fileResult.resolvedPath).toBe(join(testProjectPath, 'README.md'));
-
-      // Invalid parameter
-      const invalidResult = await PathValidationUtils.validateParameter(
-        'invalid',
-        availableTemplates,
-        testProjectPath
-      );
-      expect(invalidResult.isTemplate).toBe(false);
-      expect(invalidResult.isFilePath).toBe(false);
-      expect(invalidResult.error).toBeDefined();
-    });
-  });
-
-  describe('FileDetectionManager', () => {
-    it('should detect existing documentation files', async () => {
-      const result = await fileDetectionManager.detectDocumentationFiles();
-
-      expect(result.architecture.length).toBeGreaterThan(0);
-      expect(result.requirements.length).toBeGreaterThan(0);
-      expect(result.design.length).toBeGreaterThan(0);
-
-      // Check that README.md is detected for multiple types
-      const readmeInRequirements = result.requirements.some(
-        file => file.relativePath === 'README.md'
-      );
-      expect(readmeInRequirements).toBe(true);
-    });
-
-    it('should format suggestions correctly', async () => {
-      const result = await fileDetectionManager.detectDocumentationFiles();
-      const suggestions = fileDetectionManager.formatSuggestions(result);
-
-      expect(suggestions).toContain('Existing documentation files detected');
-      expect(suggestions).toContain('README.md');
-      expect(suggestions).toContain('setup_project_docs');
-    });
-  });
-
-  describe('ProjectDocsManager Symlink Creation', () => {
-    it('should create symlinks for file paths', async () => {
-      const result = await projectDocsManager.createOrLinkProjectDocs(
-        testProjectPath,
-        {}, // No templates
-        {
-          architecture: join(testProjectPath, 'ARCHITECTURE.md'),
-          requirements: join(testProjectPath, 'README.md'),
-          design: join(testProjectPath, 'docs', 'design.md'),
-        }
-      );
-
-      expect(result.created).toEqual([]);
-      expect(result.linked).toEqual([
-        'architecture.md',
-        'requirements.md',
-        'design.md',
-      ]);
-      expect(result.skipped).toEqual([]);
-
-      // Verify symlinks were created
-      const paths = projectDocsManager.getDocumentPaths(testProjectPath);
-
-      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 template and file path scenarios', async () => {
-      const result = await projectDocsManager.createOrLinkProjectDocs(
-        testProjectPath,
-        {
-          architecture: 'freestyle', // Template
-        },
-        {
-          requirements: join(testProjectPath, 'README.md'), // File path
-          design: join(testProjectPath, 'docs', 'design.md'), // File path
-        }
-      );
-
-      expect(result.created).toEqual(['architecture.md']);
-      expect(result.linked).toEqual(['requirements.md', 'design.md']);
-      expect(result.skipped).toEqual([]);
-    });
-
-    it('should check if documents are symlinks', async () => {
-      // Create a symlink
-      await projectDocsManager.createOrLinkProjectDocs(
-        testProjectPath,
-        {},
-        { requirements: join(testProjectPath, 'README.md') }
-      );
-
-      const isSymlink = await projectDocsManager.isSymlink(
-        testProjectPath,
-        'requirements'
-      );
-      expect(isSymlink).toBe(true);
-
-      const isArchSymlink = await projectDocsManager.isSymlink(
-        testProjectPath,
-        'architecture'
-      );
-      expect(isArchSymlink).toBe(false);
-    });
-  });
-
-  describe('End-to-End File Linking', () => {
-    it('should support complete file linking workflow', async () => {
-      // 1. Detect existing files
-      const detectionResult =
-        await fileDetectionManager.detectDocumentationFiles();
-      expect(detectionResult.requirements.length).toBeGreaterThan(0);
-
-      // 2. Validate file paths
-      const readmePath = join(testProjectPath, 'README.md');
-      const validation = await PathValidationUtils.validateFilePath(
-        'README.md',
-        testProjectPath
-      );
-      expect(validation.isValid).toBe(true);
-
-      // 3. Create symlinks
-      const linkResult = await projectDocsManager.createOrLinkProjectDocs(
-        testProjectPath,
-        { architecture: 'freestyle' }, // Mix of template and file
-        { requirements: readmePath }
-      );
-
-      expect(linkResult.created).toContain('architecture.md');
-      expect(linkResult.linked).toContain('requirements.md');
-
-      // 4. Verify symlinks work
-      const requirementsPath = await projectDocsManager.readDocument(
-        testProjectPath,
-        'requirements'
-      );
-      expect(requirementsPath).toContain('requirements.md');
-      expect(requirementsPath).toContain('.vibe/docs');
-    });
-  });
-});

package/test/unit/git-commit-integration.test.ts

@@ -1,91 +0,0 @@
-/**
- * Git Commit Integration Tests
- *
- * Simple tests to verify that the commit_behaviour parameter is handled correctly
- * and that the dynamic tool descriptions work as expected
- */
-
-import { describe, it, expect } from 'vitest';
-import { GitManager } from '@codemcp/workflows-core';
-
-describe('Git Commit Integration', () => {
-  describe('GitManager Repository Detection', () => {
-    it('should detect git repositories correctly', () => {
-      // This test verifies that GitManager can detect git repositories
-      // The actual detection logic is tested in git-manager.test.ts
-      expect(typeof GitManager.isGitRepository).toBe('function');
-      expect(typeof GitManager.getCurrentBranch).toBe('function');
-      expect(typeof GitManager.getCurrentCommitHash).toBe('function');
-    });
-  });
-
-  describe('Commit Behaviour Parameter', () => {
-    it('should define all expected commit behaviour options', () => {
-      // This test verifies that all expected commit behaviour options are available
-      const expectedOptions = ['step', 'phase', 'end', 'none'];
-
-      // These are the options that should be available in the MCP tool description
-      for (const option of expectedOptions) {
-        expect(typeof option).toBe('string');
-        expect(option.length).toBeGreaterThan(0);
-      }
-    });
-
-    it('should have meaningful option descriptions', () => {
-      // This test verifies that the commit behaviour options have meaningful descriptions
-      const optionDescriptions = {
-        step: 'commit after each development step',
-        phase: 'commit before phase transitions',
-        end: 'final commit only',
-        none: 'no automatic commits',
-      };
-
-      for (const [option, description] of Object.entries(optionDescriptions)) {
-        expect(typeof option).toBe('string');
-        expect(typeof description).toBe('string');
-        expect(description.length).toBeGreaterThan(10);
-      }
-    });
-  });
-
-  describe('Dynamic Tool Description Logic', () => {
-    it('should provide different guidance for git vs non-git projects', () => {
-      // This test verifies the core logic of our dynamic tool descriptions
-
-      // Simulate git repository detection
-      const isGitRepo = true;
-      const gitDescription = isGitRepo
-        ? 'Use "end" unless the user specifically requests different behavior.'
-        : 'Use "none" as this is not a git repository. Other options are not applicable for non-git projects.';
-
-      expect(gitDescription).toContain('Use "end"');
-      expect(gitDescription).toContain('unless the user specifically requests');
-
-      // Simulate non-git directory detection
-      const isNonGitRepo = false;
-      const nonGitDescription = isNonGitRepo
-        ? 'Use "end" unless the user specifically requests different behavior.'
-        : 'Use "none" as this is not a git repository. Other options are not applicable for non-git projects.';
-
-      expect(nonGitDescription).toContain('Use "none"');
-      expect(nonGitDescription).toContain('not a git repository');
-      expect(nonGitDescription).toContain('not applicable');
-
-      // Verify the descriptions are different
-      expect(gitDescription).not.toBe(nonGitDescription);
-    });
-
-    it('should maintain all commit behavior options regardless of project type', () => {
-      // This test verifies that all options remain available regardless of git detection
-      const allOptions = ['step', 'phase', 'end', 'none'];
-
-      // Both git and non-git projects should have access to all options
-      // (the difference is in the guidance, not the available options)
-      for (const option of allOptions) {
-        expect(allOptions).toContain(option);
-      }
-
-      expect(allOptions).toHaveLength(4);
-    });
-  });
-});

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

@@ -1,86 +0,0 @@
-/**
- * GitManager Tests
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { GitManager } from '@codemcp/workflows-core';
-import { execSync } from 'node:child_process';
-import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-
-describe('GitManager', () => {
-  const testDir = resolve(__dirname, 'test-git-repo');
-
-  beforeEach(() => {
-    // Clean up any existing test directory
-    try {
-      rmSync(testDir, { recursive: true, force: true });
-    } catch {
-      // Ignore if directory doesn't exist
-    }
-
-    // Create test directory
-    mkdirSync(testDir, { recursive: true });
-
-    // Initialize git repository
-    execSync('git init', { cwd: testDir, stdio: 'ignore' });
-    execSync('git config user.name "Test User"', {
-      cwd: testDir,
-      stdio: 'ignore',
-    });
-    execSync('git config user.email "test@example.com"', {
-      cwd: testDir,
-      stdio: 'ignore',
-    });
-
-    // Create initial commit
-    writeFileSync(resolve(testDir, 'README.md'), '# Test Repository');
-    execSync('git add .', { cwd: testDir, stdio: 'ignore' });
-    execSync('git commit -m "Initial commit"', {
-      cwd: testDir,
-      stdio: 'ignore',
-    });
-  });
-
-  afterEach(() => {
-    // Clean up test directory
-    try {
-      rmSync(testDir, { recursive: true, force: true });
-    } catch {
-      // Ignore cleanup errors
-    }
-  });
-
-  describe('isGitRepository', () => {
-    it('should detect git repository', () => {
-      expect(GitManager.isGitRepository(testDir)).toBe(true);
-    });
-
-    it('should detect non-git directory', () => {
-      const nonGitDir = resolve(__dirname, 'non-git-dir');
-      mkdirSync(nonGitDir, { recursive: true });
-
-      try {
-        expect(GitManager.isGitRepository(nonGitDir)).toBe(false);
-      } finally {
-        rmSync(nonGitDir, { recursive: true, force: true });
-      }
-    });
-  });
-
-  describe('getCurrentBranch', () => {
-    it('should get current branch name', () => {
-      const branch = GitManager.getCurrentBranch(testDir);
-      // CI environments may use different default branch names
-      expect(['main', 'master']).toContain(branch);
-    });
-  });
-
-  describe('getCurrentCommitHash', () => {
-    it('should get current commit hash', () => {
-      const hash = GitManager.getCurrentCommitHash(testDir);
-      expect(hash).toBeTruthy();
-      expect(hash).toMatch(/^[a-f0-9]{40}$/); // SHA-1 hash format
-    });
-  });
-});

package/test/unit/install-workflow.test.ts

@@ -1,138 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { InstallWorkflowHandler } from '../../packages/mcp-server/src/tool-handlers/install-workflow.js';
-import { WorkflowManager } from '@codemcp/workflows-core';
-import fs from 'node:fs';
-import path from 'node:path';
-import { tmpdir } from 'node:os';
-
-describe('Install Workflow', () => {
-  let testProjectPath: string;
-  let originalEnv: string | undefined;
-
-  beforeEach(() => {
-    originalEnv = process.env.VIBE_WORKFLOW_DOMAINS;
-    testProjectPath = fs.mkdtempSync(
-      path.join(tmpdir(), 'install-workflow-test-')
-    );
-  });
-
-  afterEach(() => {
-    if (originalEnv !== undefined) {
-      process.env.VIBE_WORKFLOW_DOMAINS = originalEnv;
-    } else {
-      delete process.env.VIBE_WORKFLOW_DOMAINS;
-    }
-
-    // Clean up test directory
-    fs.rmSync(testProjectPath, { recursive: true, force: true });
-  });
-
-  it('should install workflow and make it immediately available', async () => {
-    process.env.VIBE_WORKFLOW_DOMAINS = 'code';
-
-    const handler = new InstallWorkflowHandler();
-    const workflowManager = new WorkflowManager();
-    const context = { workflowManager, projectPath: testProjectPath } as {
-      workflowManager: WorkflowManager;
-      projectPath: string;
-    };
-
-    // Before installation - posts should not be available (office domain)
-    let workflows =
-      workflowManager.getAvailableWorkflowsForProject(testProjectPath);
-    expect(workflows.some(w => w.name === 'posts')).toBe(false);
-
-    // Install posts workflow
-    const result = await handler.executeHandler({ source: 'posts' }, context);
-    expect(result.success).toBe(true);
-
-    // After installation - posts should be available (project workflows ignore domain filtering)
-    workflows =
-      workflowManager.getAvailableWorkflowsForProject(testProjectPath);
-    expect(workflows.some(w => w.name === 'posts')).toBe(true);
-  });
-
-  it('should prevent overwriting existing workflows', async () => {
-    const handler = new InstallWorkflowHandler();
-    const workflowManager = new WorkflowManager();
-    const context = { workflowManager, projectPath: testProjectPath } as {
-      workflowManager: WorkflowManager;
-      projectPath: string;
-    };
-
-    // Install workflow first time
-    const result1 = await handler.executeHandler({ source: 'posts' }, context);
-    expect(result1.success).toBe(true);
-
-    // Try to install same workflow again
-    const result2 = await handler.executeHandler({ source: 'posts' }, context);
-    expect(result2.success).toBe(false);
-    expect(result2.message).toContain('already exists');
-  });
-
-  it('should install with custom name', async () => {
-    const handler = new InstallWorkflowHandler();
-    const workflowManager = new WorkflowManager();
-    const context = { workflowManager, projectPath: testProjectPath } as {
-      workflowManager: WorkflowManager;
-      projectPath: string;
-    };
-
-    // Install with custom name
-    const result = await handler.executeHandler(
-      {
-        source: 'posts',
-        name: 'my-posts',
-      },
-      context
-    );
-
-    expect(result.success).toBe(true);
-    expect(result.installedPath).toContain('my-posts.yaml');
-
-    // Check file exists with custom name
-    const customFile = path.join(
-      testProjectPath,
-      '.vibe',
-      'workflows',
-      'my-posts.yaml'
-    );
-    expect(fs.existsSync(customFile)).toBe(true);
-  });
-
-  it('should handle non-existent workflow', async () => {
-    const handler = new InstallWorkflowHandler();
-    const workflowManager = new WorkflowManager();
-    const context = { workflowManager, projectPath: testProjectPath } as {
-      workflowManager: WorkflowManager;
-      projectPath: string;
-    };
-
-    const result = await handler.executeHandler(
-      { source: 'nonexistent' },
-      context
-    );
-    expect(result.success).toBe(false);
-    expect(result.message).toContain('not found');
-  });
-
-  it('should create .vibe/workflows directory if it does not exist', async () => {
-    const handler = new InstallWorkflowHandler();
-    const workflowManager = new WorkflowManager();
-    const context = { workflowManager, projectPath: testProjectPath } as {
-      workflowManager: WorkflowManager;
-      projectPath: string;
-    };
-
-    // Ensure directory doesn't exist
-    const workflowsDir = path.join(testProjectPath, '.vibe', 'workflows');
-    expect(fs.existsSync(workflowsDir)).toBe(false);
-
-    // Install workflow
-    const result = await handler.executeHandler({ source: 'posts' }, context);
-    expect(result.success).toBe(true);
-
-    // Directory should now exist
-    expect(fs.existsSync(workflowsDir)).toBe(true);
-  });
-});