@codemcp/workflows 4.10.12 → 4.11.0

package/test/e2e/commit-plugin-integration.test.ts

@@ -0,0 +1,222 @@
+/**
+ * Integration test for CommitPlugin end-to-end behavior
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { execSync } from 'node:child_process';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { initializeServerComponents } from '../../src/server-config.js';
+
+describe('CommitPlugin Integration', () => {
+  const testDir = resolve(__dirname, 'test-commit-plugin');
+  let originalEnv: Record<string, string | undefined>;
+
+  beforeEach(() => {
+    // Save original environment
+    originalEnv = {
+      COMMIT_BEHAVIOR: process.env.COMMIT_BEHAVIOR,
+      COMMIT_MESSAGE_TEMPLATE: process.env.COMMIT_MESSAGE_TEMPLATE,
+    };
+
+    // Clean up any existing test directory
+    try {
+      rmSync(testDir, { recursive: true, force: true });
+    } catch {
+      // Ignore if directory doesn't exist
+    }
+
+    // Create test git repository
+    mkdirSync(testDir, { recursive: true });
+    execSync('git init', { cwd: testDir });
+    execSync('git config user.name "Test User"', { cwd: testDir });
+    execSync('git config user.email "test@example.com"', { cwd: testDir });
+
+    // Create initial commit
+    writeFileSync(resolve(testDir, 'README.md'), '# Test Project\n');
+    execSync('git add .', { cwd: testDir });
+    execSync('git commit -m "Initial commit"', { cwd: testDir });
+  });
+
+  afterEach(() => {
+    // Restore original environment
+    for (const [key, value] of Object.entries(originalEnv)) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+
+    // Clean up test directory
+    try {
+      rmSync(testDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  it('should register CommitPlugin when COMMIT_BEHAVIOR is set', async () => {
+    // Arrange
+    process.env.COMMIT_BEHAVIOR = 'step';
+
+    // Act
+    const components = await initializeServerComponents({
+      projectPath: testDir,
+    });
+
+    // Assert
+    expect(components.context.pluginRegistry).toBeDefined();
+    const plugins = components.context.pluginRegistry.getEnabledPlugins();
+    const commitPlugin = plugins.find(p => p.getName() === 'CommitPlugin');
+    expect(commitPlugin).toBeDefined();
+    expect(commitPlugin?.getSequence()).toBe(50);
+  });
+
+  it('should not register CommitPlugin when COMMIT_BEHAVIOR is not set', async () => {
+    // Arrange - no COMMIT_BEHAVIOR set
+
+    // Act
+    const components = await initializeServerComponents({
+      projectPath: testDir,
+    });
+
+    // Assert
+    const plugins = components.context.pluginRegistry.getEnabledPlugins();
+    const commitPlugin = plugins.find(p => p.getName() === 'CommitPlugin');
+    expect(commitPlugin).toBeUndefined();
+  });
+
+  it('should add final commit task to plan file when COMMIT_BEHAVIOR=end', async () => {
+    // Arrange
+    process.env.COMMIT_BEHAVIOR = 'end';
+    // Don't set COMMIT_MESSAGE_TEMPLATE to use default message
+
+    // Act
+    const components = await initializeServerComponents({
+      projectPath: testDir,
+    });
+
+    // Create a mock plan file content
+    const mockPlanContent = `# Test Plan
+
+## Explore
+### Tasks
+- [ ] Research the problem
+
+## Code  
+### Tasks
+- [ ] Implement solution
+
+## Commit
+### Tasks
+- [ ] Review implementation
+`;
+
+    // Execute the afterPlanFileCreated hook
+    const plugins = components.context.pluginRegistry.getEnabledPlugins();
+    const commitPlugin = plugins.find(p => p.getName() === 'CommitPlugin');
+    const hooks = commitPlugin?.getHooks();
+
+    if (hooks?.afterPlanFileCreated) {
+      const mockContext = {
+        conversationId: 'test',
+        planFilePath: resolve(testDir, 'plan.md'),
+        currentPhase: 'explore',
+        workflow: 'epcc',
+        projectPath: testDir,
+        gitBranch: 'main',
+      };
+
+      const updatedContent = await hooks.afterPlanFileCreated(
+        mockContext,
+        resolve(testDir, 'plan.md'),
+        mockPlanContent
+      );
+
+      // Assert
+      expect(updatedContent).toContain('Create a conventional commit');
+      expect(updatedContent).toContain(
+        'summarize the intentions and key decisions'
+      );
+    }
+  });
+
+  it('should add squash commit task for step/phase modes', async () => {
+    // Arrange
+    process.env.COMMIT_BEHAVIOR = 'step';
+
+    // Act
+    const components = await initializeServerComponents({
+      projectPath: testDir,
+    });
+
+    const mockPlanContent = `## Commit
+### Tasks
+- [ ] Review implementation
+`;
+
+    const plugins = components.context.pluginRegistry.getEnabledPlugins();
+    const commitPlugin = plugins.find(p => p.getName() === 'CommitPlugin');
+    const hooks = commitPlugin?.getHooks();
+
+    if (hooks?.afterPlanFileCreated) {
+      const mockContext = {
+        conversationId: 'test',
+        planFilePath: resolve(testDir, 'plan.md'),
+        currentPhase: 'explore',
+        workflow: 'epcc',
+        projectPath: testDir,
+        gitBranch: 'main',
+      };
+
+      const updatedContent = await hooks.afterPlanFileCreated(
+        mockContext,
+        resolve(testDir, 'plan.md'),
+        mockPlanContent
+      );
+
+      // Assert
+      expect(updatedContent).toContain('Squash WIP commits:');
+      expect(updatedContent).toContain('git reset --soft');
+    }
+  });
+
+  it('should create WIP commit on phase transition', async () => {
+    // Arrange
+    process.env.COMMIT_BEHAVIOR = 'phase';
+
+    // Create some changes
+    writeFileSync(resolve(testDir, 'test.txt'), 'test content');
+
+    // Act
+    const components = await initializeServerComponents({
+      projectPath: testDir,
+    });
+
+    const plugins = components.context.pluginRegistry.getEnabledPlugins();
+    const commitPlugin = plugins.find(p => p.getName() === 'CommitPlugin');
+    const hooks = commitPlugin?.getHooks();
+
+    if (hooks?.beforePhaseTransition) {
+      const mockContext = {
+        conversationId: 'test',
+        planFilePath: resolve(testDir, 'plan.md'),
+        currentPhase: 'explore',
+        workflow: 'epcc',
+        projectPath: testDir,
+        gitBranch: 'main',
+        targetPhase: 'plan',
+      };
+
+      await hooks.beforePhaseTransition(mockContext, 'explore', 'plan');
+
+      // Assert - check git log for WIP commit
+      const gitLog = execSync('git log --oneline', {
+        cwd: testDir,
+        encoding: 'utf-8',
+      });
+      expect(gitLog).toContain('WIP: transition to plan');
+    }
+  });
+});

package/test/unit/commit-plugin.test.ts

@@ -0,0 +1,196 @@
+/**
+ * Test CommitPlugin activation and lifecycle hooks
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { CommitPlugin } from '../../src/plugin-system/commit-plugin.js';
+import type { PluginHookContext } from '../../src/plugin-system/plugin-interfaces.js';
+
+// Mock GitManager
+vi.mock('@codemcp/workflows-core', async () => {
+  const actual = await vi.importActual('@codemcp/workflows-core');
+  return {
+    ...actual,
+    GitManager: {
+      isGitRepository: vi.fn(),
+      hasUncommittedChanges: vi.fn(),
+      createCommit: vi.fn(),
+    },
+  };
+});
+
+describe('CommitPlugin', () => {
+  let plugin: CommitPlugin;
+  const projectPath = '/test/project';
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Clear environment variables
+    delete process.env.COMMIT_BEHAVIOR;
+    delete process.env.COMMIT_MESSAGE_TEMPLATE;
+  });
+
+  describe('Plugin Interface', () => {
+    it('should have correct name and sequence', () => {
+      plugin = new CommitPlugin({ projectPath });
+
+      expect(plugin.getName()).toBe('CommitPlugin');
+      expect(plugin.getSequence()).toBe(50); // Before BeadsPlugin (100)
+    });
+
+    it('should be enabled when COMMIT_BEHAVIOR is set', () => {
+      process.env.COMMIT_BEHAVIOR = 'step';
+      plugin = new CommitPlugin({ projectPath });
+
+      expect(plugin.isEnabled()).toBe(true);
+    });
+
+    it('should be disabled when COMMIT_BEHAVIOR is not set', () => {
+      plugin = new CommitPlugin({ projectPath });
+
+      expect(plugin.isEnabled()).toBe(false);
+    });
+
+    it('should be disabled when COMMIT_BEHAVIOR is invalid', () => {
+      process.env.COMMIT_BEHAVIOR = 'invalid';
+      plugin = new CommitPlugin({ projectPath });
+
+      expect(plugin.isEnabled()).toBe(false);
+    });
+  });
+
+  describe('Lifecycle Hooks', () => {
+    beforeEach(() => {
+      process.env.COMMIT_BEHAVIOR = 'step';
+      plugin = new CommitPlugin({ projectPath });
+    });
+
+    it('should provide afterStartDevelopment hook', () => {
+      const hooks = plugin.getHooks();
+
+      expect(hooks.afterStartDevelopment).toBeDefined();
+      expect(typeof hooks.afterStartDevelopment).toBe('function');
+    });
+
+    it('should provide beforePhaseTransition hook', () => {
+      const hooks = plugin.getHooks();
+
+      expect(hooks.beforePhaseTransition).toBeDefined();
+      expect(typeof hooks.beforePhaseTransition).toBe('function');
+    });
+
+    it('should provide afterPlanFileCreated hook', () => {
+      const hooks = plugin.getHooks();
+
+      expect(hooks.afterPlanFileCreated).toBeDefined();
+      expect(typeof hooks.afterPlanFileCreated).toBe('function');
+    });
+  });
+
+  describe('Step Commit Behavior', () => {
+    beforeEach(() => {
+      process.env.COMMIT_BEHAVIOR = 'step';
+      plugin = new CommitPlugin({ projectPath });
+    });
+
+    it('should create WIP commit on whats_next calls', async () => {
+      const { GitManager } = await import('@codemcp/workflows-core');
+      vi.mocked(GitManager.isGitRepository).mockReturnValue(true);
+      vi.mocked(GitManager.hasUncommittedChanges).mockReturnValue(true);
+      vi.mocked(GitManager.createCommit).mockReturnValue(true);
+
+      const context: PluginHookContext = {
+        conversationId: 'test-conv',
+        planFilePath: '/test/plan.md',
+        currentPhase: 'explore',
+        workflow: 'epcc',
+        projectPath,
+        gitBranch: 'feature/test',
+      };
+
+      const hooks = plugin.getHooks();
+      await hooks.afterStartDevelopment?.(
+        context,
+        { workflow: 'epcc' },
+        {
+          conversationId: 'test-conv',
+          planFilePath: '/test/plan.md',
+          phase: 'explore',
+          workflow: 'epcc',
+        }
+      );
+
+      // Should store initial commit hash for later squashing
+      expect(GitManager.isGitRepository).toHaveBeenCalledWith(projectPath);
+    });
+  });
+
+  describe('Phase Commit Behavior', () => {
+    beforeEach(() => {
+      process.env.COMMIT_BEHAVIOR = 'phase';
+      plugin = new CommitPlugin({ projectPath });
+    });
+
+    it('should create WIP commit before phase transitions', async () => {
+      const { GitManager } = await import('@codemcp/workflows-core');
+      vi.mocked(GitManager.isGitRepository).mockReturnValue(true);
+      vi.mocked(GitManager.hasUncommittedChanges).mockReturnValue(true);
+      vi.mocked(GitManager.createCommit).mockReturnValue(true);
+
+      const context: PluginHookContext = {
+        conversationId: 'test-conv',
+        planFilePath: '/test/plan.md',
+        currentPhase: 'explore',
+        workflow: 'epcc',
+        projectPath,
+        gitBranch: 'feature/test',
+        targetPhase: 'plan',
+      };
+
+      const hooks = plugin.getHooks();
+      await hooks.beforePhaseTransition?.(context, 'explore', 'plan');
+
+      expect(GitManager.hasUncommittedChanges).toHaveBeenCalledWith(
+        projectPath
+      );
+      expect(GitManager.createCommit).toHaveBeenCalledWith(
+        'WIP: transition to plan',
+        projectPath
+      );
+    });
+  });
+
+  describe('End Commit Behavior', () => {
+    beforeEach(() => {
+      process.env.COMMIT_BEHAVIOR = 'end';
+      plugin = new CommitPlugin({ projectPath });
+    });
+
+    it('should add final commit task to plan file', async () => {
+      const context: PluginHookContext = {
+        conversationId: 'test-conv',
+        planFilePath: '/test/plan.md',
+        currentPhase: 'explore',
+        workflow: 'epcc',
+        projectPath,
+        gitBranch: 'feature/test',
+      };
+
+      const planContent = `## Commit
+### Tasks
+- [ ] Review implementation
+### Completed
+*None yet*`;
+
+      const hooks = plugin.getHooks();
+      const result = await hooks.afterPlanFileCreated?.(
+        context,
+        '/test/plan.md',
+        planContent
+      );
+
+      expect(result).toContain('Create a conventional commit');
+      expect(result).toContain('summarize the intentions and key decisions');
+    });
+  });
+});