@codemcp/workflows 5.0.1 → 5.1.0

package/test/utils/temp-files.ts

@@ -1,320 +0,0 @@
-/**
- * Temporary File Management for Integration Tests
- *
- * Provides utilities for creating and managing real temporary files
- * for integration tests that spawn server processes.
- */
-
-import { mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
-import { rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-/**
- * Temporary test project configuration
- */
-export interface TempProjectOptions {
-  /** Custom state machine YAML content */
-  customStateMachine?: string;
-  /** Project name (used for directory name) */
-  projectName?: string;
-  /** Git branch name */
-  gitBranch?: string;
-  /** Additional files to create */
-  additionalFiles?: Record<string, string>;
-  /** Base directory for the project (defaults to OS temp dir) */
-  baseDirectory?: string;
-}
-
-/**
- * Default state machine YAML for testing
- */
-export const DEFAULT_STATE_MACHINE_YAML = `
-name: "Development Workflow"
-description: "State machine for guiding feature development workflow"
-initial_state: "idle"
-states:
-  idle:
-    description: "Waiting for feature requests"
-    transitions:
-      - trigger: "new_feature_request"
-        to: "requirements"
-        instructions: "Start requirements analysis by asking the user clarifying questions about WHAT they need. Focus on understanding their goals, scope, and constraints. Break down their needs into specific, actionable tasks and document them in the plan file. Mark completed requirements tasks as you progress."
-        transition_reason: "New feature request detected, starting requirements analysis"
-  requirements:
-    description: "Gathering requirements"
-    transitions:
-      - trigger: "requirements_complete"
-        to: "design"
-        instructions: "Help the user design the technical solution. Ask about quality goals, technology preferences, and architectural decisions. Document the design decisions and update the plan file. Mark completed requirements tasks as done."
-        transition_reason: "Requirements gathering complete, starting design phase"
-  design:
-    description: "Designing solution"
-    transitions:
-      - trigger: "design_complete"
-        to: "implementation"
-        instructions: "Guide the user through implementing the solution. Follow coding best practices, provide structure guidance, and track implementation progress. Update the plan file and mark completed design tasks."
-        transition_reason: "Design phase complete, starting implementation"
-  implementation:
-    description: "Implementing solution"
-    transitions:
-      - trigger: "implementation_complete"
-        to: "qa"
-        instructions: "Guide code review and quality validation. Ensure requirements are properly met, help with testing and documentation. Update the plan file and mark completed implementation tasks."
-        transition_reason: "Implementation phase complete, starting QA"
-  qa:
-    description: "Quality assurance"
-    transitions:
-      - trigger: "qa_complete"
-        to: "testing"
-        instructions: "Guide comprehensive testing strategies. Help create and execute test plans, validate feature completeness. Update the plan file and mark completed QA tasks."
-        transition_reason: "QA phase complete, starting testing"
-  testing:
-    description: "Testing solution"
-    transitions:
-      - trigger: "testing_complete"
-        to: "complete"
-        instructions: "Feature development is complete! All phases have been finished successfully. The feature is ready for delivery."
-        transition_reason: "Testing phase complete, feature development finished"
-  complete:
-    description: "Feature complete"
-    transitions: []
-
-direct_transitions:
-  - state: "idle"
-    instructions: "Returned to idle state"
-    transition_reason: "Direct transition to idle state"
-  - state: "requirements"
-    instructions: "Starting requirements analysis"
-    transition_reason: "Direct transition to requirements phase"
-  - state: "design"
-    instructions: "Starting design phase"
-    transition_reason: "Direct transition to design phase"
-  - state: "implementation"
-    instructions: "Starting implementation phase"
-    transition_reason: "Direct transition to implementation phase"
-  - state: "qa"
-    instructions: "Starting QA phase"
-    transition_reason: "Direct transition to QA phase"
-  - state: "testing"
-    instructions: "Starting testing phase"
-    transition_reason: "Direct transition to testing phase"
-  - state: "complete"
-    instructions: "Feature development complete"
-    transition_reason: "Direct transition to complete phase"
-`;
-
-/**
- * Custom state machine YAML for testing
- */
-export const CUSTOM_STATE_MACHINE_YAML = `
-name: "Custom Test State Machine"
-description: "Simple two-phase state machine for testing"
-initial_state: "phase1"
-states:
-  phase1:
-    description: "First test phase"
-    transitions:
-      - trigger: "move_to_phase2"
-        to: "phase2"
-        instructions: "Moving to phase 2"
-        transition_reason: "Transition to phase 2 triggered"
-  phase2:
-    description: "Second test phase"
-    transitions: []
-direct_transitions:
-  - state: "phase1"
-    instructions: "Direct to phase 1"
-    transition_reason: "Direct transition to phase 1"
-  - state: "phase2"
-    instructions: "Direct to phase 2"
-    transition_reason: "Direct transition to phase 2"
-`;
-
-/**
- * Temporary project manager
- */
-export class TempProject {
-  public readonly projectPath: string;
-  private readonly cleanupPaths: string[] = [];
-
-  constructor(options: TempProjectOptions = {}) {
-    const {
-      projectName = `test-project-${Date.now()}`,
-      gitBranch = 'main',
-      customStateMachine,
-      additionalFiles = {},
-      baseDirectory = tmpdir(),
-    } = options;
-
-    // Create temporary project directory
-    this.projectPath = join(
-      baseDirectory,
-      'responsible-vibe-tests',
-      projectName
-    );
-    this.cleanupPaths.push(this.projectPath);
-
-    // Create directory structure
-    mkdirSync(this.projectPath, { recursive: true });
-    mkdirSync(join(this.projectPath, '.vibe'), { recursive: true });
-    mkdirSync(join(this.projectPath, '.git'), { recursive: true });
-
-    // Create basic project files
-    writeFileSync(
-      join(this.projectPath, 'package.json'),
-      JSON.stringify(
-        {
-          name: projectName,
-          version: '1.0.0',
-        },
-        null,
-        2
-      )
-    );
-
-    // Create git branch file
-    writeFileSync(
-      join(this.projectPath, '.git', 'HEAD'),
-      `ref: refs/heads/${gitBranch}`
-    );
-
-    // Create custom state machine if provided
-    if (customStateMachine) {
-      writeFileSync(
-        join(this.projectPath, '.vibe', 'workflow.yaml'),
-        customStateMachine
-      );
-    }
-
-    // Create additional files
-    for (const [filePath, content] of Object.entries(additionalFiles)) {
-      const fullPath = join(this.projectPath, filePath);
-      const dir = fullPath.substring(0, fullPath.lastIndexOf('/'));
-      mkdirSync(dir, { recursive: true });
-      writeFileSync(fullPath, content);
-    }
-  }
-
-  /**
-   * Add a file to the project
-   */
-  addFile(relativePath: string, content: string): void {
-    const fullPath = join(this.projectPath, relativePath);
-    const dir = fullPath.substring(0, fullPath.lastIndexOf('/'));
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(fullPath, content);
-  }
-
-  /**
-   * Check if a file exists in the project
-   */
-  hasFile(relativePath: string): boolean {
-    return existsSync(join(this.projectPath, relativePath));
-  }
-
-  /**
-   * Add mock project documents to satisfy artifact checking
-   */
-  addMockProjectDocs(): void {
-    this.addFile(
-      '.vibe/docs/architecture.md',
-      '# Architecture\n\nMock architecture document for testing.'
-    );
-    this.addFile(
-      '.vibe/docs/requirements.md',
-      '# Requirements\n\nMock requirements document for testing.'
-    );
-    this.addFile(
-      '.vibe/docs/design.md',
-      '# Design\n\nMock design document for testing.'
-    );
-  }
-
-  /**
-   * Clean up the temporary project
-   */
-  cleanup(): void {
-    for (const path of this.cleanupPaths) {
-      if (existsSync(path)) {
-        rmSync(path, { recursive: true, force: true });
-      }
-    }
-  }
-}
-
-/**
- * Create a temporary project with custom state machine
- */
-export function createTempProjectWithCustomStateMachine(
-  customStateMachine: string = CUSTOM_STATE_MACHINE_YAML,
-  baseDirectory?: string
-): TempProject {
-  const project = new TempProject({
-    customStateMachine,
-    projectName: `custom-sm-${Date.now()}`,
-    baseDirectory,
-  });
-
-  // Add mock project documents to satisfy artifact checking
-  project.addMockProjectDocs();
-
-  return project;
-}
-
-/**
- * Create a temporary project with default state machine (no custom one)
- */
-export function createTempProjectWithDefaultStateMachine(
-  baseDirectory?: string
-): TempProject {
-  const project = new TempProject({
-    projectName: `default-sm-${Date.now()}`,
-    baseDirectory,
-  });
-
-  // Add mock project documents to satisfy artifact checking
-  project.addMockProjectDocs();
-
-  return project;
-}
-
-/**
- * Helper to safely parse JSON responses from server, handling error cases
- */
-export function safeParseServerResponse(
-  content: Array<{ text?: string }>
-): unknown {
-  if (!content || content.length === 0) {
-    throw new Error('No content in server response');
-  }
-
-  const text = content[0].text;
-  if (!text) {
-    throw new Error('No text content in server response');
-  }
-
-  // If the response starts with "Error:", it's an error message, not JSON
-  if (typeof text === 'string' && text.startsWith('Error:')) {
-    throw new Error(`Server error: ${text}`);
-  }
-
-  try {
-    return JSON.parse(text);
-  } catch {
-    throw new Error(
-      `Failed to parse server response as JSON: ${text.substring(0, 100)}...`
-    );
-  }
-}
-
-/**
- * Async helper to clean up a directory
- * Uses fs.rm which is the Node.js 14.14+ recommended approach
- * @param dirPath - Path to directory to remove
- */
-export async function cleanupDirectory(dirPath: string): Promise<void> {
-  if (existsSync(dirPath)) {
-    await rm(dirPath, { recursive: true, force: true });
-  }
-}

package/test/utils/test-access.ts

@@ -1,79 +0,0 @@
-/**
- * Test Access Utilities
- *
- * Clean utilities for accessing private methods and properties in tests
- * without using @ts-ignore or unsafe type assertions.
- *
- * Note: Uses 'any' types intentionally for test utilities to access private members
- */
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-/**
- * Safely access a private property for testing purposes
- * @param instance - The class instance
- * @param propertyName - The name of the private property
- * @returns The property value
- */
-export function getPrivateProperty<T, K extends keyof T>(
-  instance: T,
-  propertyName: K
-): T[K] {
-  return (instance as any)[propertyName];
-}
-
-/**
- * Safely set a private property for testing purposes (e.g., injecting mocks)
- * @param instance - The class instance
- * @param propertyName - The name of the private property
- * @param value - The value to set
- */
-export function setPrivateProperty<T, K extends keyof T>(
-  instance: T,
-  propertyName: K,
-  value: T[K]
-): void {
-  (instance as any)[propertyName] = value;
-}
-
-/**
- * Safely call a private method for testing purposes
- * @param instance - The class instance
- * @param methodName - The name of the private method
- * @param args - Arguments to pass to the method
- * @returns The method return value
- */
-export function callPrivateMethod<T>(
-  instance: T,
-  methodName: string,
-  ...args: unknown[]
-): unknown {
-  return (instance as any)[methodName](...args);
-}
-
-/**
- * Type-safe helper specifically for common test scenarios
- */
-export class TestAccess {
-  /**
-   * Inject a mock dependency into a private property
-   */
-  static injectMock<T>(
-    instance: T,
-    propertyName: string,
-    mockValue: unknown
-  ): void {
-    setPrivateProperty(instance, propertyName as keyof T, mockValue);
-  }
-
-  /**
-   * Call a private method with proper typing
-   */
-  static callMethod<T>(
-    instance: T,
-    methodName: string,
-    ...args: unknown[]
-  ): unknown {
-    return callPrivateMethod(instance, methodName, ...args);
-  }
-}

package/test/utils/test-helpers.ts

@@ -1,288 +0,0 @@
-/**
- * Shared Test Utilities
- *
- * Common utilities to eliminate repetition across test files
- */
-
-import { mkdirSync, writeFileSync, existsSync } from 'node:fs';
-import { execSync } from 'node:child_process';
-import { join } from 'node:path';
-import { vi, expect } from 'vitest';
-import {
-  ResponsibleVibeMCPServer,
-  createResponsibleVibeMCPServer,
-} from '../../src/server.js';
-import type { ServerContext } from '../../src/types';
-import type { StartDevelopmentResult } from '../../src/tool-handlers/start-development.js';
-import { TempProject } from './temp-files.js';
-import { PluginRegistry } from '../../src/plugin-system/plugin-registry.js';
-
-/**
- * Mock project documents content
- */
-export const MOCK_DOCS = {
-  architecture: '# Architecture\n\nMock architecture document for testing.',
-  requirements: '# Requirements\n\nMock requirements document for testing.',
-  design: '# Design\n\nMock design document for testing.',
-} as const;
-
-/**
- * Git repository setup utilities
- */
-export class GitTestHelper {
-  static initializeRepo(projectPath: string): void {
-    execSync('git init', { cwd: projectPath });
-    execSync('git config user.email "test@example.com"', { cwd: projectPath });
-    execSync('git config user.name "Test User"', { cwd: projectPath });
-  }
-
-  static createInitialCommit(projectPath: string): void {
-    writeFileSync(join(projectPath, 'README.md'), '# Test Project');
-    execSync('git add .', { cwd: projectPath });
-    execSync('git commit -m "Initial commit"', { cwd: projectPath });
-  }
-
-  static createFeatureBranch(
-    projectPath: string,
-    branchName: string = 'feature/test'
-  ): void {
-    execSync(`git checkout -b ${branchName}`, { cwd: projectPath });
-  }
-
-  static setupFullRepo(projectPath: string, branchName?: string): void {
-    this.initializeRepo(projectPath);
-    this.createInitialCommit(projectPath);
-    if (branchName) {
-      this.createFeatureBranch(projectPath, branchName);
-    }
-  }
-}
-
-/**
- * Server test utilities
- */
-export class ServerTestHelper {
-  static async createServer(
-    projectPath: string,
-    options: { enableLogging?: boolean } = {}
-  ): Promise<ResponsibleVibeMCPServer> {
-    const server = await createResponsibleVibeMCPServer({
-      projectPath,
-      enableLogging: options.enableLogging ?? false,
-    });
-    await server.initialize();
-    return server;
-  }
-
-  static async cleanupServer(server: ResponsibleVibeMCPServer): Promise<void> {
-    if (server) {
-      await server.cleanup();
-    }
-  }
-}
-
-/**
- * Mock project documents utilities
- */
-export class MockDocsHelper {
-  static addToProject(projectPath: string): void {
-    const docsDir = join(projectPath, '.vibe', 'docs');
-    mkdirSync(docsDir, { recursive: true });
-
-    for (const [docType, content] of Object.entries(MOCK_DOCS)) {
-      writeFileSync(join(docsDir, `${docType}.md`), content);
-    }
-  }
-
-  static addToTempProject(tempProject: TempProject): void {
-    tempProject.addMockProjectDocs();
-  }
-
-  static ensureExists(projectPath: string): void {
-    if (!existsSync(join(projectPath, '.vibe', 'docs'))) {
-      this.addToProject(projectPath);
-    }
-  }
-}
-
-/**
- * Mock context factory for unit tests
- */
-export class MockContextFactory {
-  static createBasicContext(
-    projectPath: string,
-    overrides: Partial<ServerContext> = {}
-  ) {
-    return {
-      projectPath,
-      pluginRegistry: new PluginRegistry(),
-      workflowManager: {
-        validateWorkflowName: vi.fn().mockReturnValue(true),
-        getWorkflowNames: vi
-          .fn()
-          .mockReturnValue(['waterfall', 'epcc', 'greenfield']),
-        loadProjectWorkflows: vi.fn(),
-        loadWorkflowForProject: vi.fn().mockReturnValue({
-          initial_state: 'requirements',
-          states: {
-            requirements: {
-              description: 'Define requirements',
-              instructions: 'Create detailed requirements for the project.',
-            },
-          },
-        }),
-      },
-      conversationManager: {
-        createConversationContext: vi.fn().mockResolvedValue({
-          conversationId: 'test-conversation',
-          currentPhase: 'requirements',
-          projectPath,
-          planFilePath: join(projectPath, '.vibe', 'plan.md'),
-          gitBranch: 'feature-branch',
-        }),
-        updateConversationState: vi.fn(),
-      },
-      transitionEngine: {
-        handleExplicitTransition: vi.fn().mockResolvedValue({
-          newPhase: 'requirements',
-        }),
-      },
-      planManager: {
-        setStateMachine: vi.fn(),
-        ensurePlanFile: vi.fn(),
-      },
-      ...overrides,
-    };
-  }
-
-  static createProjectDocsManagerMock(projectPath: string) {
-    return {
-      getProjectDocsInfo: vi.fn(),
-      getVariableSubstitutions: vi.fn().mockReturnValue({
-        $ARCHITECTURE_DOC: join(
-          projectPath,
-          '.vibe',
-          'docs',
-          'architecture.md'
-        ),
-        $REQUIREMENTS_DOC: join(
-          projectPath,
-          '.vibe',
-          'docs',
-          'requirements.md'
-        ),
-        $DESIGN_DOC: join(projectPath, '.vibe', 'docs', 'design.md'),
-      }),
-      templateManager: {
-        getAvailableTemplates: vi.fn().mockResolvedValue({
-          architecture: ['arc42', 'freestyle'],
-          requirements: ['ears', 'freestyle'],
-          design: ['comprehensive', 'freestyle'],
-        }),
-        getDefaults: vi.fn().mockResolvedValue({
-          architecture: 'freestyle',
-          requirements: 'freestyle',
-          design: 'freestyle',
-        }),
-      },
-    };
-  }
-}
-
-/**
- * Test workflow patterns
- */
-export const TEST_WORKFLOWS = {
-  simple: {
-    initial_state: 'requirements',
-    states: {
-      requirements: {
-        description: 'Define requirements',
-        instructions: 'Create detailed requirements for the project.',
-      },
-    },
-  },
-
-  withArchDoc: {
-    initial_state: 'design',
-    states: {
-      design: {
-        description: 'Create design',
-        instructions:
-          'Review the architecture in $ARCHITECTURE_DOC and create detailed design.',
-      },
-    },
-  },
-
-  withMultipleDocs: {
-    initial_state: 'implementation',
-    states: {
-      implementation: {
-        description: 'Implement solution',
-        instructions:
-          'Follow the architecture in $ARCHITECTURE_DOC and implement according to $DESIGN_DOC requirements.',
-      },
-      testing: {
-        description: 'Test solution',
-        instructions: 'Verify all requirements from $REQUIREMENTS_DOC are met.',
-      },
-    },
-  },
-
-  // Test workflows with requiresDocumentation: true
-  requiredArchDoc: {
-    initial_state: 'design',
-    metadata: {
-      requiresDocumentation: true,
-    },
-    states: {
-      design: {
-        description: 'Create design',
-        instructions:
-          'Review the architecture in $ARCHITECTURE_DOC and create detailed design.',
-      },
-    },
-  },
-
-  requiredMultipleDocs: {
-    initial_state: 'implementation',
-    metadata: {
-      requiresDocumentation: true,
-    },
-    states: {
-      implementation: {
-        description: 'Implement solution',
-        instructions:
-          'Follow the architecture in $ARCHITECTURE_DOC and implement according to $DESIGN_DOC requirements.',
-      },
-      testing: {
-        description: 'Test solution',
-        instructions: 'Verify all requirements from $REQUIREMENTS_DOC are met.',
-      },
-    },
-  },
-} as const;
-
-/**
- * Common test assertions
- */
-export class TestAssertions {
-  static expectValidResult(result: StartDevelopmentResult): void {
-    expect(result).toBeTypeOf('object');
-    expect(result.phase).toBeDefined();
-    expect(result.instructions).toBeDefined();
-  }
-
-  static expectArtifactSetupPhase(result: StartDevelopmentResult): void {
-    expect(result.phase).toBe('artifact-setup');
-    expect(result.instructions).toContain('Referenced Variables');
-  }
-
-  static expectNormalPhase(
-    result: StartDevelopmentResult,
-    expectedPhase: string
-  ): void {
-    expect(result.phase).toBe(expectedPhase);
-    expect(result.instructions).toBeDefined();
-  }
-}