@codemcp/workflows 4.9.1 → 4.10.0

package/src/tool-handlers/start-development.ts

@@ -220,7 +220,8 @@ export class StartDevelopmentHandler extends BaseToolHandler<
         stateMachine,
         selectedWorkflow,
         conversationContext.planFilePath,
-        conversationContext.conversationId
+        conversationContext.conversationId,
+        context
       );
     }
 
@@ -653,23 +654,41 @@ ${templateOptionsText}
     stateMachine: YamlStateMachine,
     workflowName: string,
     planFilePath: string,
-    conversationId: string
+    conversationId: string,
+    context: ServerContext
   ): Promise<void> {
     try {
       const beadsIntegration = new BeadsIntegration(projectPath);
       const projectName = projectPath.split('/').pop() || 'Unknown Project';
 
+      // Extract goal from plan file if it exists and has meaningful content
+      let goalDescription: string | undefined;
+      try {
+        const planFileContent =
+          await context.planManager.getPlanFileContent(planFilePath);
+        goalDescription = this.extractGoalFromPlan(planFileContent);
+      } catch (error) {
+        this.logger.warn('Could not extract goal from plan file', {
+          error: error instanceof Error ? error.message : String(error),
+          planFilePath,
+        });
+      }
+
+      // Extract plan filename for use in epic title
+      const planFilename = planFilePath.split('/').pop();
+
       // Create project epic
       const epicId = await beadsIntegration.createProjectEpic(
         projectName,
-        workflowName
+        workflowName,
+        goalDescription,
+        planFilename
       );
 
       // Create phase tasks for all workflow phases
-      const phases = Object.keys(stateMachine.states);
       const phaseTasks = await beadsIntegration.createPhaseTasks(
         epicId,
-        phases,
+        stateMachine.states,
         workflowName
       );
 
@@ -841,4 +860,55 @@ conversations/
       );
     }
   }
+
+  /**
+   * Extract Goal section content from plan file
+   * Returns the goal content if it exists and is meaningful, otherwise undefined
+   */
+  private extractGoalFromPlan(planContent: string): string | undefined {
+    if (!planContent || typeof planContent !== 'string') {
+      return undefined;
+    }
+
+    // Split content into lines for more reliable parsing
+    const lines = planContent.split('\n');
+    const goalIndex = lines.findIndex(line => line.trim() === '## Goal');
+
+    if (goalIndex === -1) {
+      return undefined;
+    }
+
+    // Find the next section (## anything) after the Goal section
+    const nextSectionIndex = lines.findIndex(
+      (line, index) => index > goalIndex && line.trim().startsWith('## ')
+    );
+
+    // Extract content between Goal and next section (or end of content)
+    const contentLines =
+      nextSectionIndex === -1
+        ? lines.slice(goalIndex + 1)
+        : lines.slice(goalIndex + 1, nextSectionIndex);
+
+    const goalContent = contentLines.join('\n').trim();
+
+    // Check if the goal content is meaningful (not just a placeholder or comment)
+    const meaninglessPatterns = [
+      /^\*.*\*$/, // Enclosed in asterisks like "*Define what you're building...*"
+      /^To be defined/i,
+      /^TBD$/i,
+      /^TODO/i,
+      /^Define what you're building/i,
+      /^This will be updated/i,
+    ];
+
+    const isMeaningless = meaninglessPatterns.some(pattern =>
+      pattern.test(goalContent)
+    );
+
+    if (isMeaningless || goalContent.length < 10) {
+      return undefined;
+    }
+
+    return goalContent;
+  }
 }

package/test/unit/beads-instruction-generator.test.ts

@@ -62,7 +62,7 @@ describe('BeadsInstructionGenerator Content Validation', () => {
         'bd list --parent <phase-task-id> --status open'
       );
       expect(result.instructions).toContain(
-        "bd create 'Task title' --parent <phase-task-id> -p 2"
+        "bd create 'Task title' --parent <phase-task-id> -p <priority>"
       );
       expect(result.instructions).toContain(
         'bd update <task-id> --status in_progress'
@@ -643,12 +643,12 @@ describe('BeadsInstructionGenerator Content Validation', () => {
         - Analyze existing markdown-based systems
         - Review plan file management approaches
         - Document [x] checkbox patterns
-        
+
         ### Layer 2: Implementation
         - Implement beads CLI integration
         - Create hierarchical task structures
         - Build robust error handling
-        
+
         ### Layer 3: Validation
         - Test cross-backend compatibility
         - Verify anti-contamination measures
@@ -689,7 +689,7 @@ describe('BeadsInstructionGenerator Content Validation', () => {
         - Has bd CLI-like commands but for different purposes
         - Manages plan files with markdown syntax
         - Creates beads-style hierarchical structures
-        
+
         This should test anti-contamination thoroughly.
       `.trim();
 

package/test/unit/beads-integration-filename.test.ts

@@ -0,0 +1,93 @@
+/**
+ * Unit tests for BeadsIntegration epic title formatting with filename
+ *
+ * Tests that epic titles include plan filenames correctly
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { BeadsIntegration } from '@codemcp/workflows-core';
+
+// Mock execSync to avoid actual beads CLI calls
+vi.mock('node:child_process', () => ({
+  execSync: vi.fn().mockReturnValue('✓ Created issue: test-epic-123'),
+}));
+
+describe('BeadsIntegration - Epic Title with Filename', () => {
+  let beadsIntegration: BeadsIntegration;
+
+  beforeEach(() => {
+    beadsIntegration = new BeadsIntegration('/test/project');
+  });
+
+  it('should include filename in epic title when provided', async () => {
+    const { execSync } = await import('node:child_process');
+    const mockExecSync = vi.mocked(execSync);
+
+    await beadsIntegration.createProjectEpic(
+      'my-project',
+      'epcc',
+      'Build an awesome feature',
+      'development-plan-feature-auth.md'
+    );
+
+    // Verify that execSync was called with the expected title format
+    expect(mockExecSync).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'bd create "my-project: epcc (development-plan-feature-auth.md)"'
+      ),
+      expect.any(Object)
+    );
+  });
+
+  it('should use original title format when filename not provided', async () => {
+    const { execSync } = await import('node:child_process');
+    const mockExecSync = vi.mocked(execSync);
+
+    await beadsIntegration.createProjectEpic(
+      'my-project',
+      'epcc',
+      'Build an awesome feature'
+    );
+
+    // Verify that execSync was called with the original title format
+    expect(mockExecSync).toHaveBeenCalledWith(
+      expect.stringContaining('bd create "my-project: epcc"'),
+      expect.any(Object)
+    );
+
+    // Ensure it doesn't contain parentheses when no filename
+    const call = mockExecSync.mock.calls[0][0] as string;
+    expect(call).not.toContain('(');
+    expect(call).not.toContain(')');
+  });
+
+  it('should handle various filename formats', async () => {
+    const { execSync } = await import('node:child_process');
+    const mockExecSync = vi.mocked(execSync);
+
+    const testCases = [
+      'development-plan-main.md',
+      'development-plan-feature-dashboard.md',
+      'development-plan-bugfix-123.md',
+      'plan.md',
+    ];
+
+    for (const filename of testCases) {
+      mockExecSync.mockClear();
+
+      await beadsIntegration.createProjectEpic(
+        'test-project',
+        'waterfall',
+        undefined,
+        filename
+      );
+
+      expect(mockExecSync).toHaveBeenCalledWith(
+        expect.stringContaining(
+          `bd create "test-project: waterfall (${filename})"`
+        ),
+        expect.any(Object)
+      );
+    }
+  });
+});

package/test/unit/beads-phase-task-id-integration.test.ts

@@ -87,7 +87,7 @@ Some implementation tasks here.
         'bd list --parent project-epic-1.2 --status open'
       );
       expect(result.instructions).toContain(
-        "bd create 'Task description' --parent project-epic-1.2 -p 2"
+        "bd create 'Task description' --parent project-epic-1.2"
       );
       expect(result.instructions).toContain('bd show project-epic-1.2');
       expect(result.instructions).toContain(
@@ -127,7 +127,7 @@ Some implementation tasks here.
           result.instructions,
           `Should use ID in create command: ${testCase.id}`
         ).toContain(
-          `bd create 'Task description' --parent ${testCase.id} -p 2`
+          `bd create 'Task description' --parent ${testCase.id} -p <priority>`
         );
       }
     });
@@ -176,7 +176,7 @@ Some implementation tasks here.
 - Research requirements
 - Analyze existing solutions
 
-## Design  
+## Design
 <!-- beads-phase-id: design-task-2 -->
 - Create system design
 - Design database schema
@@ -236,7 +236,7 @@ Some implementation tasks here.
         'bd list --parent <phase-task-id> --status open'
       );
       expect(result.instructions).toContain(
-        "bd create 'Task title' --parent <phase-task-id> -p 2"
+        "bd create 'Task title' --parent <phase-task-id> -p <priority>"
       );
       expect(result.instructions).toContain('Use bd CLI tool exclusively');
       expect(result.instructions).not.toContain('bd list --parent design-');
@@ -373,7 +373,7 @@ ${edgeCase.comment}
       // Check all BD CLI commands contain the extracted ID
       const expectedCommands = [
         'bd list --parent design-epic-789 --status open',
-        "bd create 'Task description' --parent design-epic-789 -p 2",
+        "bd create 'Task description' --parent design-epic-789",
         'bd show design-epic-789',
       ];
 

package/test/unit/start-development-goal-extraction.test.ts

@@ -0,0 +1,220 @@
+/**
+ * Unit tests for StartDevelopmentHandler Goal extraction functionality
+ *
+ * Tests the extractGoalFromPlan method that extracts meaningful goal content
+ * from development plan files for use in beads integration
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { TestAccess } from '../utils/test-access.js';
+import { StartDevelopmentHandler } from '../../src/tool-handlers/start-development.js';
+
+describe('StartDevelopmentHandler - Goal Extraction', () => {
+  let handler: StartDevelopmentHandler;
+
+  beforeEach(() => {
+    handler = new StartDevelopmentHandler();
+  });
+
+  describe('extractGoalFromPlan', () => {
+    it('should extract meaningful goal content', () => {
+      const planContent = `# Development Plan: Test Project
+
+## Goal
+Build a user authentication system with JWT tokens and password reset functionality.
+
+## Explore
+### Tasks
+- [ ] Analyze requirements
+`;
+
+      const result = TestAccess.callMethod(
+        handler,
+        'extractGoalFromPlan',
+        planContent
+      );
+
+      expect(result).toBe(
+        'Build a user authentication system with JWT tokens and password reset functionality.'
+      );
+    });
+
+    it('should return undefined for placeholder goal content', () => {
+      const planContent = `# Development Plan: Test Project
+
+## Goal
+*Define what you're building or fixing - this will be updated as requirements are gathered*
+
+## Explore
+### Tasks
+- [ ] Analyze requirements
+`;
+
+      const result = TestAccess.callMethod(
+        handler,
+        'extractGoalFromPlan',
+        planContent
+      );
+
+      expect(result).toBeUndefined();
+    });
+
+    it('should return undefined for "To be defined" content', () => {
+      const planContent = `# Development Plan: Test Project
+
+## Goal
+To be defined during exploration
+
+## Explore
+### Tasks
+- [ ] Analyze requirements
+`;
+
+      const result = TestAccess.callMethod(
+        handler,
+        'extractGoalFromPlan',
+        planContent
+      );
+
+      expect(result).toBeUndefined();
+    });
+
+    it('should return undefined for very short content', () => {
+      const planContent = `# Development Plan: Test Project
+
+## Goal
+Fix bug
+
+## Explore
+### Tasks
+- [ ] Analyze requirements
+`;
+
+      const result = TestAccess.callMethod(
+        handler,
+        'extractGoalFromPlan',
+        planContent
+      );
+
+      expect(result).toBeUndefined();
+    });
+
+    it('should handle multiline goal content correctly', () => {
+      const planContent = `# Development Plan: Test Project
+
+## Goal
+Implement a comprehensive logging system that captures:
+- User actions and authentication events  
+- API request/response cycles
+- System errors with stack traces
+- Performance metrics
+
+The system should support different log levels and output formats.
+
+## Explore
+### Tasks
+- [ ] Analyze requirements
+`;
+
+      const result = TestAccess.callMethod(
+        handler,
+        'extractGoalFromPlan',
+        planContent
+      );
+
+      expect(result)
+        .toBe(`Implement a comprehensive logging system that captures:
+- User actions and authentication events  
+- API request/response cycles
+- System errors with stack traces
+- Performance metrics
+
+The system should support different log levels and output formats.`);
+    });
+
+    it('should return undefined when no Goal section exists', () => {
+      const planContent = `# Development Plan: Test Project
+
+## Explore
+### Tasks
+- [ ] Analyze requirements
+`;
+
+      const result = TestAccess.callMethod(
+        handler,
+        'extractGoalFromPlan',
+        planContent
+      );
+
+      expect(result).toBeUndefined();
+    });
+
+    it('should return undefined for empty or null input', () => {
+      expect(
+        TestAccess.callMethod(handler, 'extractGoalFromPlan', '')
+      ).toBeUndefined();
+
+      expect(
+        TestAccess.callMethod(handler, 'extractGoalFromPlan', null)
+      ).toBeUndefined();
+
+      expect(
+        TestAccess.callMethod(handler, 'extractGoalFromPlan', undefined)
+      ).toBeUndefined();
+    });
+
+    it('should stop at the next section boundary', () => {
+      const planContent = `# Development Plan: Test Project
+
+## Goal
+Build a user authentication system with secure login and registration.
+
+## Key Decisions
+- Using JWT for token-based authentication
+- Password hashing with bcrypt
+`;
+
+      const result = TestAccess.callMethod(
+        handler,
+        'extractGoalFromPlan',
+        planContent
+      );
+
+      expect(result).toBe(
+        'Build a user authentication system with secure login and registration.'
+      );
+    });
+  });
+
+  describe('plan filename extraction', () => {
+    it('should extract filename from plan file path correctly', () => {
+      // Test the logic used in setupBeadsIntegration
+      const planFilePath = '/project/.vibe/development-plan-feature-auth.md';
+      const planFilename = planFilePath.split('/').pop();
+
+      expect(planFilename).toBe('development-plan-feature-auth.md');
+    });
+
+    it('should handle various plan file path formats', () => {
+      const testCases = [
+        {
+          path: '/Users/dev/my-project/.vibe/development-plan-main.md',
+          expected: 'development-plan-main.md',
+        },
+        {
+          path: 'development-plan-bugfix.md',
+          expected: 'development-plan-bugfix.md',
+        },
+        {
+          path: '/deep/nested/path/to/.vibe/development-plan-feature-dashboard.md',
+          expected: 'development-plan-feature-dashboard.md',
+        },
+      ];
+
+      for (const { path, expected } of testCases) {
+        const filename = path.split('/').pop();
+        expect(filename).toBe(expected);
+      }
+    });
+  });
+});