@codemcp/workflows 4.10.12 → 4.12.0

package/src/tool-handlers/whats-next.ts

@@ -170,22 +170,13 @@ export class WhatsNextHandler extends ConversationRequiredToolHandler<
         }
       );
 
-    // Add commit instructions if configured
-    let finalInstructions = instructions.instructions;
-    if (
-      conversationContext.gitCommitConfig?.enabled &&
-      conversationContext.gitCommitConfig.commitOnStep
-    ) {
-      const commitMessage = requestContext || 'Step completion';
-      finalInstructions += `\n\n**Git Commit Required**: Create a commit for this step using:\n\`\`\`bash\ngit add . && git commit -m "${commitMessage}"\n\`\`\``;
-    }
-
+    // Note: Commit behavior now handled by CommitPlugin
     // Note: Beads-specific instructions are now handled by BeadsInstructionGenerator via strategy pattern
 
     // Prepare response
     const response: WhatsNextResult = {
       phase: transitionResult.newPhase,
-      instructions: finalInstructions,
+      instructions: instructions.instructions,
       plan_file_path: conversationContext.planFilePath,
     };
 

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

@@ -418,9 +418,9 @@ describe('Beads Plugin Comprehensive Integration', () => {
       );
 
       await cleanupWith();
-      delete process.env.TASK_BACKEND;
 
-      // WITHOUT BEADS
+      // WITHOUT BEADS - explicitly set markdown to disable auto-detection
+      process.env.TASK_BACKEND = 'markdown';
       const scenarioWithout = await createSuiteIsolatedE2EScenario({
         suiteName: 'beads-comparison-without',
         tempProjectFactory: createTempProjectWithDefaultStateMachine,
@@ -441,6 +441,7 @@ describe('Beads Plugin Comprehensive Integration', () => {
       );
 
       await cleanupWithout();
+      delete process.env.TASK_BACKEND;
 
       // VALIDATE: WITH beads has beads markers
       expect(planContentWith).toContain('<!-- beads-phase-id:');
@@ -477,9 +478,9 @@ describe('Beads Plugin Comprehensive Integration', () => {
       const instructionsWithBeads = responseWith.instructions;
 
       await scenarioWith.cleanup();
-      delete process.env.TASK_BACKEND;
 
-      // WITHOUT BEADS
+      // WITHOUT BEADS - explicitly set markdown to disable auto-detection
+      process.env.TASK_BACKEND = 'markdown';
       const scenarioWithout = await createSuiteIsolatedE2EScenario({
         suiteName: 'beads-instructions-comparison-without',
         tempProjectFactory: createTempProjectWithDefaultStateMachine,
@@ -503,6 +504,7 @@ describe('Beads Plugin Comprehensive Integration', () => {
       const instructionsWithout = responseWithout.instructions;
 
       await scenarioWithout.cleanup();
+      delete process.env.TASK_BACKEND;
 
       // VALIDATE: WITH beads mentions bd CLI
       expect(instructionsWithBeads.toLowerCase()).toContain('bd');
@@ -863,12 +865,13 @@ describe('Beads Plugin Comprehensive Integration', () => {
       expect(planContent).toContain('<!-- beads-phase-id:');
     });
 
-    it('should NOT apply beads when TASK_BACKEND is not set', async () => {
-      // Ensure env var is NOT set
+    it('should auto-detect and apply beads when TASK_BACKEND is not set and bd is available', async () => {
+      // Ensure env var is NOT set - auto-detection will check for bd command
       delete process.env.TASK_BACKEND;
+      setupBeadsCliMock();
 
       const scenario = await createSuiteIsolatedE2EScenario({
-        suiteName: 'beads-activation-without',
+        suiteName: 'beads-activation-auto',
         tempProjectFactory: createTempProjectWithDefaultStateMachine,
       });
 
@@ -882,15 +885,41 @@ describe('Beads Plugin Comprehensive Integration', () => {
 
       await scenario.cleanup();
 
-      // VALIDATE: Beads features NOT enabled
-      expect(planContent).not.toContain('<!-- beads-phase-id:');
+      // VALIDATE: Beads features auto-detected and enabled
+      expect(planContent).toContain('<!-- beads-phase-id:');
     });
 
-    it('should NOT apply beads when TASK_BACKEND has different value', async () => {
+    it('should auto-detect beads when TASK_BACKEND has invalid value and bd is available', async () => {
+      // Invalid values are treated as "not set" - triggers auto-detection
       process.env.TASK_BACKEND = 'other-backend';
+      setupBeadsCliMock();
+
+      const scenario = await createSuiteIsolatedE2EScenario({
+        suiteName: 'beads-activation-invalid',
+        tempProjectFactory: createTempProjectWithDefaultStateMachine,
+      });
+
+      const result = await scenario.client.callTool('start_development', {
+        workflow: 'epcc',
+        commit_behaviour: 'none',
+      });
+
+      const response = assertToolSuccess(result) as StartDevelopmentResult;
+      const planContent = await fs.readFile(response.plan_file_path, 'utf-8');
+
+      await scenario.cleanup();
+      delete process.env.TASK_BACKEND;
+
+      // VALIDATE: Beads features auto-detected and enabled
+      expect(planContent).toContain('<!-- beads-phase-id:');
+    });
+
+    it('should NOT apply beads when TASK_BACKEND=markdown explicitly', async () => {
+      // Explicitly setting markdown should disable beads even if bd is available
+      process.env.TASK_BACKEND = 'markdown';
 
       const scenario = await createSuiteIsolatedE2EScenario({
-        suiteName: 'beads-activation-other',
+        suiteName: 'beads-activation-disabled',
         tempProjectFactory: createTempProjectWithDefaultStateMachine,
       });
 
@@ -905,7 +934,7 @@ describe('Beads Plugin Comprehensive Integration', () => {
       await scenario.cleanup();
       delete process.env.TASK_BACKEND;
 
-      // VALIDATE: Beads features NOT enabled
+      // VALIDATE: Beads features NOT enabled when markdown explicitly set
       expect(planContent).not.toContain('<!-- beads-phase-id:');
     });
   });

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');
+    });
+  });
+});

package/test/unit/server-config-plugin-registry.test.ts

@@ -7,17 +7,23 @@ import { initializeServerComponents } from '../../src/server-config.js';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+
+// Mock child_process to control bd command availability
+vi.mock('node:child_process', () => ({
+  execSync: vi.fn(),
+}));
 
 describe('Server Config Plugin Registration', () => {
   let tempDir: string;
 
   beforeEach(async () => {
-    vi.clearAllMocks();
+    vi.resetAllMocks(); // Reset mock implementations, not just call history
     tempDir = await mkdtemp(join(tmpdir(), 'server-config-test-'));
   });
 
   afterEach(async () => {
-    vi.clearAllMocks();
+    vi.resetAllMocks();
     try {
       await rm(tempDir, { recursive: true, force: true });
     } catch {
@@ -25,9 +31,12 @@ describe('Server Config Plugin Registration', () => {
     }
   });
 
-  it('should register BeadsPlugin when TASK_BACKEND is beads', async () => {
+  it('should register BeadsPlugin when TASK_BACKEND is beads and bd is available', async () => {
     vi.stubEnv('TASK_BACKEND', 'beads');
 
+    // Mock bd --version to return success
+    vi.mocked(execSync).mockReturnValue('beads v1.0.0\n');
+
     const components = await initializeServerComponents({
       projectPath: tempDir,
     });
@@ -45,8 +54,9 @@ describe('Server Config Plugin Registration', () => {
     expect(enabledPlugins[0].getName()).toBe('BeadsPlugin');
   });
 
-  it('should not register BeadsPlugin when TASK_BACKEND is not beads', async () => {
-    vi.stubEnv('TASK_BACKEND', 'none');
+  it('should not register BeadsPlugin when TASK_BACKEND is markdown', async () => {
+    // Explicitly set markdown to disable beads
+    vi.stubEnv('TASK_BACKEND', 'markdown');
 
     const components = await initializeServerComponents({
       projectPath: tempDir,
@@ -64,9 +74,14 @@ describe('Server Config Plugin Registration', () => {
     expect(enabledPlugins).toHaveLength(0);
   });
 
-  it('should initialize empty plugin registry by default', async () => {
-    // Don't set TASK_BACKEND environment variable
-    vi.unstubAllEnvs();
+  it('should not register BeadsPlugin when bd is not available', async () => {
+    // Explicitly clear TASK_BACKEND - triggers auto-detection
+    delete process.env.TASK_BACKEND;
+
+    // Mock bd --version to throw (command not found)
+    vi.mocked(execSync).mockImplementation(() => {
+      throw new Error('command not found: bd');
+    });
 
     const components = await initializeServerComponents({
       projectPath: tempDir,
@@ -78,4 +93,7 @@ describe('Server Config Plugin Registration', () => {
       0
     );
   });
+
+  // Note: Auto-detection tests are covered in E2E tests (beads-plugin-integration.test.ts)
+  // because mocking child_process across package boundaries requires E2E-style server setup
 });