@codemcp/workflows 6.0.4 → 6.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemcp/workflows",
-  "version": "6.0.4",
+  "version": "6.1.0",
   "description": "A Model Context Protocol server that acts as an intelligent conversation state manager and development guide for LLMs, featuring comprehensive long-term memory with persistent project artifacts",
   "type": "module",
   "main": "packages/cli/dist/index.js",
@@ -51,7 +51,7 @@
     "typescript": "^5.9.3",
     "vitepress": "^1.6.4",
     "vitest": "4.0.18",
-    "@codemcp/workflows-core": "6.0.4"
+    "@codemcp/workflows-core": "6.1.0"
   },
   "lint-staged": {
     "*.{ts,js,mts,cts,tsx,jsx}": [

package/packages/cli/dist/{chunk-RTDQR2KY.js → chunk-D2Q6Y3QQ.js}

@@ -3924,13 +3924,14 @@ ${continueTransition.additional_instructions}`;
       workflowName,
       reason
     });
-    if (!stateMachine.states[targetPhase]) {
+    const normalizedTargetPhase = targetPhase.toLowerCase();
+    if (!stateMachine.states[normalizedTargetPhase]) {
       const validPhases = Object.keys(stateMachine.states);
       const errorMsg = `Invalid target phase: "${targetPhase}". Valid phases are: ${validPhases.join(", ")}`;
       logger5.error("Invalid target phase", new Error(errorMsg));
       throw new Error(errorMsg);
     }
-    const targetState = stateMachine.states[targetPhase];
+    const targetState = stateMachine.states[normalizedTargetPhase];
     const instructions = targetState.default_instructions;
     const transitionInfo = {
       instructions,
@@ -3940,12 +3941,12 @@ ${continueTransition.additional_instructions}`;
     };
     logger5.info("Explicit phase transition processed", {
       fromPhase: currentPhase,
-      toPhase: targetPhase,
+      toPhase: normalizedTargetPhase,
       reason: transitionInfo.transitionReason,
       isModeled: transitionInfo.isModeled
     });
     return {
-      newPhase: targetPhase,
+      newPhase: normalizedTargetPhase,
       instructions: transitionInfo.instructions,
       transitionReason: reason || transitionInfo.transitionReason,
       isModeled: transitionInfo.isModeled

package/packages/cli/dist/{cli-NHYEKRXH.js → cli-UWGNSSFS.js}

@@ -2,7 +2,7 @@ import {
   StateMachineLoader,
   WorkflowManager,
   generateSystemPrompt
-} from "./chunk-RTDQR2KY.js";
+} from "./chunk-D2Q6Y3QQ.js";
 import "./chunk-R5U7XKVJ.js";
 
 // src/cli.ts
@@ -977,11 +977,11 @@ var isLocal = existsSync3(join5(__dirname3, "../../core/dist/index.js"));
 var generateSystemPrompt2;
 var StateMachineLoader2;
 if (isLocal) {
-  const coreModule = await import("./dist-KZOA4GL5.js");
+  const coreModule = await import("./dist-W7PPKVFG.js");
   generateSystemPrompt2 = coreModule.generateSystemPrompt;
   StateMachineLoader2 = coreModule.StateMachineLoader;
 } else {
-  const coreModule = await import("./dist-KZOA4GL5.js");
+  const coreModule = await import("./dist-W7PPKVFG.js");
   generateSystemPrompt2 = coreModule.generateSystemPrompt;
   StateMachineLoader2 = coreModule.StateMachineLoader;
 }

package/packages/cli/dist/{dist-KZOA4GL5.js → dist-W7PPKVFG.js}

@@ -29,7 +29,7 @@ import {
   logger,
   setMcpLoggingLevel,
   setMcpServerForLogging
-} from "./chunk-RTDQR2KY.js";
+} from "./chunk-D2Q6Y3QQ.js";
 import "./chunk-R5U7XKVJ.js";
 export {
   BeadsIntegration,

package/packages/cli/dist/{dist-6TO57O6M.js → dist-W7VMGB3G.js}

@@ -7781,13 +7781,14 @@ ${continueTransition.additional_instructions}`;
       workflowName,
       reason
     });
-    if (!stateMachine.states[targetPhase]) {
+    const normalizedTargetPhase = targetPhase.toLowerCase();
+    if (!stateMachine.states[normalizedTargetPhase]) {
       const validPhases = Object.keys(stateMachine.states);
       const errorMsg = `Invalid target phase: "${targetPhase}". Valid phases are: ${validPhases.join(", ")}`;
       logger5.error("Invalid target phase", new Error(errorMsg));
       throw new Error(errorMsg);
     }
-    const targetState = stateMachine.states[targetPhase];
+    const targetState = stateMachine.states[normalizedTargetPhase];
     const instructions = targetState.default_instructions;
     const transitionInfo = {
       instructions,
@@ -7797,12 +7798,12 @@ ${continueTransition.additional_instructions}`;
     };
     logger5.info("Explicit phase transition processed", {
       fromPhase: currentPhase,
-      toPhase: targetPhase,
+      toPhase: normalizedTargetPhase,
       reason: transitionInfo.transitionReason,
       isModeled: transitionInfo.isModeled
     });
     return {
-      newPhase: targetPhase,
+      newPhase: normalizedTargetPhase,
       instructions: transitionInfo.instructions,
       transitionReason: reason || transitionInfo.transitionReason,
       isModeled: transitionInfo.isModeled
@@ -12447,7 +12448,8 @@ var WhatsNextHandler = class extends ConversationRequiredToolHandler {
 var ProceedToPhaseHandler = class extends ConversationRequiredToolHandler {
   async executeWithConversation(args, context, conversationContext) {
     validateRequiredArgs(args, ["target_phase", "review_state"]);
-    const { target_phase, reason = "", review_state } = args;
+    const { reason = "", review_state } = args;
+    const target_phase = args.target_phase.toLowerCase();
     const conversationId = conversationContext.conversationId;
     const currentPhase = conversationContext.currentPhase;
     this.logger.debug("Processing proceed_to_phase request", {

package/packages/cli/dist/index.js

@@ -10,7 +10,7 @@ var args = process.argv.slice(2);
 if (args.length === 0) {
   const isLocal = existsSync(join(__dirname, "../../mcp-server/dist/index.js"));
   if (isLocal) {
-    const { startMcpServer } = await import("./dist-6TO57O6M.js");
+    const { startMcpServer } = await import("./dist-W7VMGB3G.js");
     await startMcpServer();
   } else {
     const mcpServerModule = "@codemcp/workflows-server";
@@ -18,6 +18,6 @@ if (args.length === 0) {
     await startMcpServer();
   }
 } else {
-  const { runCli } = await import("./cli-NHYEKRXH.js");
+  const { runCli } = await import("./cli-UWGNSSFS.js");
   await runCli();
 }

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemcp/workflows-cli",
-  "version": "6.0.4",
+  "version": "6.1.0",
   "description": "CLI tools for responsible-vibe development workflows",
   "type": "module",
   "scripts": {

package/packages/cli/resources/workflows/skilled-bugfix.yaml

@@ -0,0 +1,182 @@
+---
+name: 'skilled-bugfix'
+description: 'A focused workflow for bug fixing: Reproduce, Analyze, Fix, Verify - optimized for debugging and fixing existing issues'
+initial_state: 'reproduce'
+
+# Enhanced metadata for better discoverability
+metadata:
+  domain: 'skilled'
+  complexity: 'medium'
+  bestFor:
+    - 'Bug fixes'
+    - 'Issue resolution'
+    - 'Error debugging'
+    - 'Performance problems'
+  useCases:
+    - 'Fixing a crash or error'
+    - 'Resolving incorrect behavior'
+    - 'Performance optimization'
+  examples:
+    - 'Fix login authentication error'
+    - 'Resolve memory leak issue'
+    - 'Fix incorrect calculation in reports'
+
+# States with default instructions and transitions
+states:
+  reproduce:
+    description: 'Reproduce and understand the bug'
+    default_instructions: |
+      Gather specific information to reliably reproduce the reported bug:
+      - What are the exact OS, browser/runtime versions, and hardware specs?
+      - What is the precise sequence of actions that trigger the bug?
+      - What error messages, logs, or stack traces are available?
+      - Does this happen every time or intermittently?
+      - How many users are affected and what is the business impact?
+
+      Create test cases that demonstrate the problem. Document your findings and create tasks as needed.
+    transitions:
+      - trigger: 'bug_reproduced'
+        to: 'analyze'
+        transition_reason: 'Bug reproduced successfully, ready to analyze root cause'
+
+      - trigger: 'bug_not_reproducible'
+        to: 'reproduce'
+        instructions: >
+          Unable to reproduce the bug with current information. Gather more details about the environment,
+          conditions, or steps that might be missing. Contact the reporter for additional information if needed.
+          Continue attempting reproduction with new information.
+        transition_reason: 'Bug could not be reproduced, need more information'
+
+  analyze:
+    description: 'Analyze the bug and identify root cause'
+    default_instructions: |
+      Examine the code paths involved in the bug, identify the root cause, and understand why the issue occurs. Use debugging tools, add logging, and trace through the problematic code.
+
+      - Use the **architecture** skill to understand the architectural conventions of this project
+      - Use the **application-design** skill to understand authentication, routing, error handling, or form patterns that may be involved
+
+      Document your analysis and create tasks as needed.
+    transitions:
+      - trigger: 'need_more_reproduction'
+        to: 'reproduce'
+        additional_instructions: 'Analysis revealed need for additional reproduction scenarios. Focus on reproducing the specific conditions identified during analysis.'
+        transition_reason: 'Analysis revealed need for additional reproduction work'
+
+      - trigger: 'root_cause_identified'
+        to: 'fix'
+        additional_instructions: 'Document the root cause approach and update task progress.'
+        transition_reason: 'Root cause identified, ready to implement fix'
+        review_perspectives:
+          - perspective: 'architect'
+            prompt: "Review root cause analysis and ensure the proposed fix doesn't introduce architectural issues or technical debt. Consider the broader system impact of the proposed solution."
+          - perspective: 'security_expert'
+            prompt: "Evaluate if the bug has security implications and ensure the fix doesn't introduce new vulnerabilities. Review the security aspects of the proposed solution."
+
+      - trigger: 'abandon_bug'
+        to: 'reproduce'
+        additional_instructions: 'Bug analysis abandoned. Clean up any analysis work and prepare for new bug reports.'
+        transition_reason: 'Bug analysis abandoned'
+
+  fix:
+    description: 'Implement the bug fix'
+    default_instructions: |
+      Implement the solution based on your analysis:
+
+      - Check whether there is a design document in the project and follow it
+      - Use the **coding** skill to implement the fix. Apply this skill to all coding tasks of this phase!
+      - Use the **testing** skill to write targeted tests that cover the bug scenario. Apply this skill to all test tasks of this phase!
+
+      Before implementing, assess the approach:
+      - How critical is this system? What is the blast radius if the fix causes issues?
+      - Should this be a minimal fix or a more comprehensive solution?
+
+      Make targeted changes that address the root cause without introducing new issues. Be careful to maintain existing functionality while fixing the bug.
+    transitions:
+      - trigger: 'need_more_analysis'
+        to: 'analyze'
+        additional_instructions: 'Fix implementation revealed additional complexity or issues. Focus on analyzing the newly discovered aspects of the problem.'
+        transition_reason: 'Fix work revealed need for additional analysis'
+
+      - trigger: 'fix_implemented'
+        to: 'verify'
+        additional_instructions: 'Document the fix approach and update task progress.'
+        transition_reason: 'Fix implemented, ready for verification'
+        review_perspectives:
+          - perspective: 'senior_software_developer'
+            prompt: 'Review fix implementation, code quality, and ensure the solution properly addresses the root cause. Check for potential side effects and code maintainability.'
+          - perspective: 'performance_engineer'
+            prompt: "Verify that the fix doesn't introduce performance regressions or new bottlenecks. Assess the performance impact of the implemented solution."
+
+      - trigger: 'abandon_bug'
+        to: 'reproduce'
+        additional_instructions: 'Bug fix abandoned. Clean up any fix work and prepare for new bug reports.'
+        transition_reason: 'Bug fix abandoned'
+
+  verify:
+    description: 'Verify the fix and ensure no regressions'
+    default_instructions: |
+      Test the fix thoroughly to ensure the original bug is resolved and no new issues were introduced.
+
+      - Use the **testing** skill to run existing tests and write new ones covering the bug scenario
+      - Verify the solution is robust and handles edge cases
+    transitions:
+      - trigger: 'fix_needs_adjustment'
+        to: 'fix'
+        additional_instructions: 'Verification revealed issues with the current fix. Focus on addressing the specific problems identified during verification.'
+        transition_reason: 'Verification found issues requiring fix adjustments'
+
+      - trigger: 'need_more_analysis'
+        to: 'analyze'
+        additional_instructions: "Verification revealed the fix doesn't fully address the root cause. Focus on deeper analysis of the remaining issues."
+        transition_reason: 'Verification revealed need for additional analysis'
+
+      - trigger: 'bug_fixed'
+        to: 'finalize'
+        transition_reason: 'Bug fix complete and verified, ready for next issue'
+
+      - trigger: 'abandon_bug'
+        to: 'reproduce'
+        additional_instructions: 'Bug verification abandoned. Clean up any verification work and prepare for new bug reports.'
+        transition_reason: 'Bug verification abandoned'
+
+  finalize:
+    description: 'Code cleanup and documentation finalization'
+    default_instructions: |
+      Ensure code quality and documentation accuracy through systematic cleanup and review.
+
+      **STEP 1: Code Cleanup**
+      Systematically clean up development artifacts:
+      - Remove all temporary debug output statements used during bug investigation (console logging, print statements, debug output functions)
+      - Address each TODO/FIXME comment by either implementing the solution or documenting why it's deferred
+      - Remove completed TODOs and convert remaining ones to proper issue tracking if needed
+      - Remove temporary debugging code, test code blocks, and commented-out code
+      - Ensure proper error handling replaces temporary debug logging
+
+      **STEP 2: Documentation Review**
+      Review and update documentation to reflect the bug fix:
+      - Check whether there is a design document in the project and update it if the fix changed any design details
+      - Compare documentation against the actual bug fix implementation
+      - Update only the documentation sections that have functional changes
+      - Remove references to investigation iterations, progress notes, and temporary decisions
+      - Ensure documentation describes the final fixed state, not the debugging process
+      - Ask the user to review document updates
+
+      **STEP 3: Final Validation**
+      - Use the **testing** skill to run and verify all tests
+      - Verify documentation accuracy with a final review
+      - Ensure bug fix is ready for production
+      - Update task progress and mark completed work as you finalize the bug fix
+    transitions:
+      - trigger: 'need_fix_changes'
+        to: 'fix'
+        additional_instructions: 'Finalization revealed issues with the bug fix. Focus on addressing the specific problems identified during final review.'
+        transition_reason: 'Finalization revealed issues requiring fix changes'
+
+      - trigger: 'finalization_complete'
+        to: 'reproduce'
+        transition_reason: 'Bug fix complete and finalized, ready for next issue'
+
+      - trigger: 'abandon_bug'
+        to: 'reproduce'
+        additional_instructions: 'Bug finalization abandoned. Clean up any finalization work and prepare for new bug reports.'
+        transition_reason: 'Bug finalization abandoned'

package/packages/cli/resources/workflows/skilled-epcc.yaml

@@ -0,0 +1,171 @@
+---
+name: 'skilled-epcc'
+description: "A comprehensive development workflow based on Anthropic's best practices: Explore, Plan, Code, Commit - ideal for smaller features and iterative development"
+initial_state: 'explore'
+
+# Enhanced metadata for better discoverability
+metadata:
+  domain: 'skilled'
+  complexity: 'medium'
+  bestFor:
+    - 'Medium-sized features'
+    - 'Iterative development'
+    - 'Research-heavy tasks'
+    - 'Exploratory coding'
+  useCases:
+    - 'Adding a new API endpoint'
+    - 'Implementing a new algorithm'
+    - 'Integrating a third-party service'
+  examples:
+    - 'Add user profile management'
+    - 'Implement search functionality'
+    - 'Create data export feature'
+
+# States with default instructions and transitions
+states:
+  explore:
+    description: 'Research and exploration phase - understanding the problem space'
+    default_instructions: |
+      Research the codebase to understand existing patterns and gather context about the problem space.
+
+      - If uncertain about conventions or rules, ask the user about them
+      - Read relevant files and documentation
+      - Check whether there is a requirements document in the project and if so, read it carefully
+      - If the project is still empty, use the **starting-project** skill to understand how to set it up correctly
+      - Use the **architecture** skill to understand the architectural conventions of this project
+
+      Focus on understanding without writing code yet. Document your findings and create tasks as needed.
+    transitions:
+      - trigger: 'exploration_complete'
+        to: 'plan'
+        additional_instructions: 'Present the plan to the user, describing the impact of the changes.'
+        transition_reason: 'Sufficient understanding gained, ready to create implementation plan'
+
+  plan:
+    description: 'Planning phase - creating a detailed implementation strategy'
+    default_instructions: |
+      Create a detailed implementation strategy based on your exploration:
+
+      - Check whether there is a requirements document in the project and base your strategy on it
+      - Check whether there is a design document in the project and adhere to it; if not, elaborate design options and present them to the user
+      - Use the **architecture** skill to ensure architectural decisions align with SAB conventions
+      - Use the **application-design** skill when planning authentication, routing, error handling, or forms
+
+      Break down the work into specific, actionable tasks. Consider edge cases, dependencies, and potential challenges. Document the planning work thoroughly and create implementation tasks as part of the code phase as needed.
+    transitions:
+      - trigger: 'need_more_exploration'
+        to: 'explore'
+        additional_instructions: 'Focus on the specific areas that need clarification and ask the user about needs and preferences.'
+        transition_reason: 'Planning work revealed need for more exploration'
+
+      - trigger: 'plan_complete'
+        to: 'code'
+        transition_reason: 'Implementation plan is complete and ready for coding'
+        review_perspectives:
+          - perspective: 'architect'
+            prompt: 'Review implementation strategy, design decisions, and integration approach for soundness and maintainability. Ensure the plan aligns with existing system architecture and follows best practices.'
+          - perspective: 'security_expert'
+            prompt: 'Assess security considerations and potential risks in the planned implementation approach. Review data handling, authentication, and potential vulnerabilities.'
+
+      - trigger: 'abandon_feature'
+        to: 'explore'
+        instructions: >
+          Feature development abandoned during planning. Return to exploration state for new tasks.
+          Task history will remain for future reference.
+        additional_instructions: 'Feature development abandoned during planning. Clean up any planning work and prepare for new tasks.'
+        transition_reason: 'User decided to abandon feature during planning phase'
+
+  code:
+    description: 'Implementation phase - writing and building the solution'
+    default_instructions: |
+      Follow your plan to build the solution:
+
+      - Check whether there is a design document in the project and follow it; if not, elaborate design options and present them to the user
+      - Check whether there is a requirements document in the project and ensure all requirements are met
+      - Use the **coding** skill to implement components, styling, and coding patterns. Apply this skill to all coding tasks of this phase!
+      - Use the **testing** skill to write and run tests. Apply this skill to all test tasks of this phase!
+
+      Write clean, well-structured code with proper error handling. Prevent regression by building, linting, and executing existing tests. Stay flexible and adapt the plan as you learn more during implementation. Update task progress and create new tasks as needed.
+    transitions:
+      - trigger: 'need_replanning'
+        to: 'plan'
+        additional_instructions: "Consider what you've learned during coding and adjust the plan accordingly. Document the changes and reasons."
+        transition_reason: 'Implementation work revealed need to revise the plan'
+
+      - trigger: 'need_more_exploration'
+        to: 'explore'
+        additional_instructions: 'Focus on the specific areas that are blocking implementation progress.'
+        transition_reason: 'Implementation work revealed need for more exploration'
+
+      - trigger: 'code_complete'
+        to: 'commit'
+        transition_reason: 'Core implementation is complete, ready for finalization'
+        review_perspectives:
+          - perspective: 'senior_software_developer'
+            prompt: 'Review code quality, best practices, testing coverage, and readiness for production deployment. Ensure the implementation follows coding standards and is maintainable.'
+          - perspective: 'performance_engineer'
+            prompt: 'Evaluate performance impact, resource efficiency, and scalability of the implemented solution. Check for potential bottlenecks or optimization opportunities.'
+
+      - trigger: 'abandon_feature'
+        to: 'explore'
+        instructions: >
+          Feature development abandoned during implementation. Clean up any incomplete code and return to exploration.
+          Task history and any completed work will remain for future reference.
+        additional_instructions: 'Clean up any incomplete code and prepare for new tasks.'
+        transition_reason: 'User decided to abandon feature during implementation'
+
+  commit:
+    description: 'Code cleanup and documentation finalization'
+    default_instructions: >
+      Ensure code quality and documentation accuracy through systematic cleanup and review.
+
+      **STEP 1: Code Cleanup**
+
+      Systematically clean up development artifacts:
+
+      1. **Remove Debug Output**: Search for and remove all temporary debug output statements used during development.
+         Look for language-specific debug output methods (console logging, print statements, debug output functions).
+         Remove any debugging statements that were added for development purposes.
+
+      2. **Review TODO/FIXME Comments**:
+         - Address each TODO/FIXME comment by either implementing the solution or documenting why it's deferred
+         - Remove completed TODOs
+         - Convert remaining TODOs to proper issue tracking if needed
+
+      3. **Remove Debugging Code Blocks**:
+         - Remove temporary debugging code, test code blocks, and commented-out code
+         - Clean up any experimental code that's no longer needed
+         - Ensure proper error handling replaces temporary debug logging
+
+      **STEP 2: Documentation Review**
+
+      Review and update documentation to reflect final implementation:
+
+      1. Check whether there is a requirements, architecture, or design document in the project and update any that are affected by the implementation
+      2. **Compare Against Implementation**: Review documentation against actual implemented functionality
+      3. **Update Changed Sections**: Only modify documentation sections that have functional changes
+      4. **Remove Development Progress**: Remove references to development iterations, progress notes, and temporary decisions
+      5. **Focus on Final State**: Ensure documentation describes the final implemented state, not the development process
+      6. **Ask User to Review Document Updates**
+
+      **STEP 3: Final Validation**
+
+      - Use the **testing** skill to run and verify all tests
+      - Verify documentation accuracy with a final review
+      - Ensure code is ready for production/delivery
+
+      Update task progress and mark completed work as you finalize the feature.
+    transitions:
+      - trigger: 'need_code_changes'
+        to: 'code'
+        additional_instructions: 'Focus on the problems identified during final review.'
+        transition_reason: 'Final review found issues requiring code changes'
+
+      - trigger: 'commit_complete'
+        to: 'explore'
+        transition_reason: 'Feature delivery complete, ready for next task'
+
+      - trigger: 'abandon_feature'
+        to: 'explore'
+        additional_instructions: 'Clean up any finalization artifacts and prepare for new tasks.'
+        transition_reason: 'User decided to abandon feature during finalization'