@codemcp/workflows 5.3.0 → 6.0.1

package/packages/core/dist/state-machine.js

@@ -0,0 +1,256 @@
+/**
+ * State Machine Definition for Vibe Feature MCP Server
+ *
+ * This module defines the development workflow state machine, including:
+ * - Development phases (states)
+ * - Transition triggers and conditions
+ * - Phase-specific instructions for LLM guidance
+ * - Transition-specific prompts for contextual guidance
+ */
+/**
+ * Complete state transition table
+ *
+ * This table defines all possible transitions between development phases.
+ * - Modeled transitions: Shown in the state diagram, get contextual guidance
+ * - Direct transitions: Not shown in diagram, get general phase instructions
+ */
+export const STATE_TRANSITIONS = [
+    // FROM IDLE
+    {
+        from: 'idle',
+        to: 'requirements',
+        trigger: 'new_feature_request',
+        isModeled: true,
+        instructions: 'New feature request detected! 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.',
+        transitionReason: 'New feature request detected, starting requirements analysis',
+    },
+    // FROM REQUIREMENTS
+    {
+        from: 'requirements',
+        to: 'requirements',
+        trigger: 'refine_requirements',
+        isModeled: true,
+        instructions: 'Continue refining requirements. Ask more detailed questions to clarify scope, constraints, and user needs. Add any new requirements to the plan file and mark completed tasks. Ensure you have a complete understanding of WHAT needs to be built before moving to design.',
+        transitionReason: 'Requirements need further refinement and clarification',
+    },
+    {
+        from: 'requirements',
+        to: 'design',
+        trigger: 'requirements_complete',
+        isModeled: true,
+        instructions: 'Requirements are complete! ✅ Now transition to design phase. Help the user design the technical solution by asking about architecture, technologies, quality goals, and implementation approach. Focus on HOW to build what was defined in requirements. Document design decisions in the plan file and mark completed requirements tasks.',
+        transitionReason: 'All requirements tasks completed, moving to technical design',
+    },
+    {
+        from: 'requirements',
+        to: 'idle',
+        trigger: 'abandon_feature',
+        isModeled: true,
+        instructions: 'Feature development abandoned. Clean up any temporary work and return to idle state. The plan file will remain for future reference if the user wants to resume this feature later.',
+        transitionReason: 'User decided to abandon this feature development',
+    },
+    // FROM DESIGN
+    {
+        from: 'design',
+        to: 'design',
+        trigger: 'refine_design',
+        isModeled: true,
+        instructions: 'Continue refining the technical design. Ask about architecture details, technology choices, data models, API design, and quality considerations. Update the plan file with design decisions and mark completed design tasks. Ensure the design is solid before implementation.',
+        transitionReason: 'Design needs further refinement and detail',
+    },
+    {
+        from: 'design',
+        to: 'requirements',
+        trigger: 'requirements_unclear',
+        isModeled: true,
+        instructions: 'Design phase revealed unclear requirements. Return to requirements analysis to clarify the WHAT before continuing with HOW. Ask specific questions about the unclear aspects and update the plan file with refined requirements.',
+        transitionReason: 'Design work revealed gaps or ambiguities in requirements',
+    },
+    {
+        from: 'design',
+        to: 'implementation',
+        trigger: 'design_complete',
+        isModeled: true,
+        instructions: 'Design is complete! ✅ Now transition to implementation. Guide the user through building the solution following the design. Focus on coding best practices, proper structure, error handling, and basic testing. Update the plan file with implementation progress and mark completed design tasks.',
+        transitionReason: 'Technical design is complete, ready to start building',
+    },
+    {
+        from: 'design',
+        to: 'idle',
+        trigger: 'abandon_feature',
+        isModeled: true,
+        instructions: 'Feature development abandoned during design phase. Clean up any design artifacts and return to idle state. The plan file will remain for future reference.',
+        transitionReason: 'User decided to abandon feature during design phase',
+    },
+    // FROM IMPLEMENTATION
+    {
+        from: 'implementation',
+        to: 'implementation',
+        trigger: 'refine_implementation',
+        isModeled: true,
+        instructions: 'Continue implementation work. Help with coding, debugging, structure improvements, and adding functionality. Follow best practices and ensure code quality. Update the plan file with progress and mark completed implementation tasks.',
+        transitionReason: 'Implementation work continues, adding features or improving code',
+    },
+    {
+        from: 'implementation',
+        to: 'design',
+        trigger: 'design_issues',
+        isModeled: true,
+        instructions: "Implementation revealed issues with the design. Return to design phase to address architectural problems or design gaps. Analyze what's not working and revise the technical approach. Update the plan file with design changes.",
+        transitionReason: 'Implementation work revealed problems with the current design',
+    },
+    {
+        from: 'implementation',
+        to: 'qa',
+        trigger: 'implementation_complete',
+        isModeled: true,
+        instructions: "Implementation is complete! ✅ Now transition to quality assurance. Take these specific actions:\n\n1. **Syntax Check**: Run syntax checking tools or validate syntax manually\n2. **Build Project**: Build the project to verify it compiles without errors\n3. **Run Linter**: Execute linting tools to ensure code style consistency\n4. **Execute Tests**: Run existing tests to verify functionality\n\nThen conduct a multi-perspective code review:\n- **Security Perspective**: Check for vulnerabilities, input validation, authentication issues\n- **Performance Perspective**: Identify bottlenecks, inefficient algorithms, resource usage\n- **UX Perspective**: Evaluate from the end-user's viewpoint\n- **Maintainability Perspective**: Assess code readability, documentation, future maintenance\n- **Requirement Compliance**: Verify all requirements are properly implemented\n\nUpdate the plan file and mark completed implementation tasks.",
+        transitionReason: 'Core implementation is complete, ready for quality review',
+    },
+    {
+        from: 'implementation',
+        to: 'idle',
+        trigger: 'abandon_feature',
+        isModeled: true,
+        instructions: 'Feature development abandoned during implementation. Clean up any incomplete code and return to idle state. The plan file and any completed work will remain for future reference.',
+        transitionReason: 'User decided to abandon feature during implementation',
+    },
+    // FROM QA (Quality Assurance)
+    {
+        from: 'qa',
+        to: 'qa',
+        trigger: 'refine_qa',
+        isModeled: true,
+        instructions: "Continue quality assurance work. Take these specific actions if not already completed:\n\n1. **Syntax Check**: Run syntax checking tools or validate syntax manually\n2. **Build Project**: Build the project to verify it compiles without errors\n3. **Run Linter**: Execute linting tools to ensure code style consistency\n4. **Execute Tests**: Run existing tests to verify functionality\n\nContinue multi-perspective code review:\n- **Security Perspective**: Check for vulnerabilities, input validation, authentication issues\n- **Performance Perspective**: Identify bottlenecks, inefficient algorithms, resource usage\n- **UX Perspective**: Evaluate from the end-user's viewpoint\n- **Maintainability Perspective**: Assess code readability, documentation, future maintenance\n- **Requirement Compliance**: Verify all requirements are properly implemented\n\nUpdate the plan file with QA progress and mark completed tasks.",
+        transitionReason: 'Quality assurance work continues, improving code quality',
+    },
+    {
+        from: 'qa',
+        to: 'implementation',
+        trigger: 'implementation_issues',
+        isModeled: true,
+        instructions: 'Quality assurance revealed implementation issues. Return to implementation phase to fix bugs, improve code quality, or add missing functionality. Focus on addressing the specific issues identified during QA review.',
+        transitionReason: 'QA review found issues that require implementation changes',
+    },
+    {
+        from: 'qa',
+        to: 'testing',
+        trigger: 'qa_complete',
+        isModeled: true,
+        instructions: 'Quality assurance is complete! ✅ Now transition to testing phase. Create comprehensive test plans, write and execute tests, validate feature completeness, and ensure everything works as expected. Update the plan file and mark completed QA tasks.',
+        transitionReason: 'Quality assurance is complete, ready for comprehensive testing',
+    },
+    {
+        from: 'qa',
+        to: 'idle',
+        trigger: 'abandon_feature',
+        isModeled: true,
+        instructions: 'Feature development abandoned during QA phase. Clean up any QA artifacts and return to idle state. The plan file and completed work will remain for future reference.',
+        transitionReason: 'User decided to abandon feature during quality assurance',
+    },
+    // FROM TESTING
+    {
+        from: 'testing',
+        to: 'testing',
+        trigger: 'refine_testing',
+        isModeled: true,
+        instructions: 'Continue testing work. Create more test cases, improve test coverage, run integration tests, and validate edge cases. Update the plan file with testing progress and mark completed testing tasks.',
+        transitionReason: 'Testing work continues, improving coverage and validation',
+    },
+    {
+        from: 'testing',
+        to: 'qa',
+        trigger: 'qa_issues',
+        isModeled: true,
+        instructions: 'Testing revealed quality issues. Return to QA phase to address code quality problems, documentation gaps, or requirement compliance issues identified during testing. Focus on the specific QA issues found.',
+        transitionReason: 'Testing found issues that require quality assurance attention',
+    },
+    {
+        from: 'testing',
+        to: 'complete',
+        trigger: 'testing_complete',
+        isModeled: true,
+        instructions: 'Testing is complete! ✅ The feature is fully implemented, tested, and ready for delivery. Transition to complete state. Summarize what was accomplished and prepare final documentation. Mark all testing tasks as complete.',
+        transitionReason: 'All testing is complete, feature is ready for delivery',
+    },
+    {
+        from: 'testing',
+        to: 'idle',
+        trigger: 'abandon_feature',
+        isModeled: true,
+        instructions: 'Feature development abandoned during testing phase. Clean up any testing artifacts and return to idle state. The plan file and completed work will remain for future reference.',
+        transitionReason: 'User decided to abandon feature during testing phase',
+    },
+    // FROM COMPLETE
+    {
+        from: 'complete',
+        to: 'idle',
+        trigger: 'feature_delivered',
+        isModeled: true,
+        instructions: 'Feature has been delivered successfully! Return to idle state, ready for the next development task. The completed plan file serves as documentation of what was accomplished.',
+        transitionReason: 'Feature delivery complete, returning to idle state',
+    },
+    {
+        from: 'complete',
+        to: 'requirements',
+        trigger: 'new_feature_request',
+        isModeled: true,
+        instructions: 'New feature request while previous feature is complete. Start fresh requirements analysis for the new feature. Ask clarifying questions about what they need and create a new development plan.',
+        transitionReason: 'New feature request received, starting new development cycle',
+    },
+];
+/**
+ * Direct transition instructions for non-modeled transitions
+ * These are used when users jump directly to any phase using proceed_to_phase
+ */
+export const DIRECT_PHASE_INSTRUCTIONS = {
+    idle: 'Returned to idle state. Ready to help with new feature development or other tasks.',
+    requirements: 'Starting requirements analysis. Ask the user clarifying questions about WHAT they need. Focus on understanding their goals, scope, constraints, and success criteria. Break down their needs into specific, actionable tasks and document them in the plan file. Mark completed requirements tasks as you progress.',
+    design: "Starting design phase. Help the user design the technical solution by asking about architecture, technologies, data models, API design, and quality goals. Focus on HOW to implement what's needed. Document design decisions in the plan file and ensure the approach is solid before implementation.",
+    implementation: 'Starting implementation phase. Guide the user through building the solution following best practices. Focus on code structure, error handling, security, and maintainability. Write clean, well-documented code and include basic testing. Update the plan file with implementation progress.',
+    qa: "Starting quality assurance phase. Take the following specific actions:\n\n1. **Syntax Check**: Run syntax checking tools or validate syntax manually\n2. **Build Project**: Build the project to verify it compiles without errors\n3. **Run Linter**: Execute linting tools to ensure code style consistency\n4. **Execute Tests**: Run existing tests to verify functionality\n\nThen conduct a multi-perspective code review:\n- **Security Perspective**: Check for vulnerabilities, input validation, authentication issues\n- **Performance Perspective**: Identify bottlenecks, inefficient algorithms, resource usage\n- **UX Perspective**: Evaluate from the end-user's viewpoint\n- **Maintainability Perspective**: Assess code readability, documentation, future maintenance\n- **Requirement Compliance**: Verify all requirements are properly implemented\n\nUpdate the plan file with QA progress and mark completed tasks.",
+    testing: 'Starting testing phase. Create comprehensive test plans, write and execute tests, validate feature completeness, and ensure everything works as expected. Focus on test coverage, edge cases, integration testing, and user acceptance validation.',
+    complete: 'Feature development is complete! All phases have been finished successfully. The feature is implemented, tested, and ready for delivery. Summarize what was accomplished and ensure all documentation is finalized.',
+};
+/**
+ * Get transition instructions for a specific state change
+ */
+export function getTransitionInstructions(fromState, toState, trigger) {
+    // Look for a modeled transition first
+    const modeledTransition = STATE_TRANSITIONS.find(t => t.from === fromState &&
+        t.to === toState &&
+        (trigger ? t.trigger === trigger : true));
+    if (modeledTransition) {
+        return {
+            instructions: modeledTransition.instructions,
+            transitionReason: modeledTransition.transitionReason,
+            isModeled: true,
+        };
+    }
+    // Fall back to direct phase instructions
+    return {
+        instructions: DIRECT_PHASE_INSTRUCTIONS[toState],
+        transitionReason: `Direct transition to ${toState} phase`,
+        isModeled: false,
+    };
+}
+/**
+ * Get all possible transitions from a given state
+ */
+export function getPossibleTransitions(fromState) {
+    return STATE_TRANSITIONS.filter(t => t.from === fromState);
+}
+/**
+ * Check if a transition is modeled (shown in state diagram)
+ */
+export function isModeledTransition(fromState, toState) {
+    return STATE_TRANSITIONS.some(t => t.from === fromState && t.to === toState && t.isModeled);
+}
+/**
+ * Get phase-specific instructions for continuing work in current phase
+ */
+export function getContinuePhaseInstructions(phase) {
+    const continueTransition = STATE_TRANSITIONS.find(t => t.from === phase && t.to === phase);
+    return continueTransition?.instructions || DIRECT_PHASE_INSTRUCTIONS[phase];
+}
+//# sourceMappingURL=state-machine.js.map

package/packages/core/dist/state-machine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-machine.js","sourceRoot":"","sources":["../src/state-machine.ts"],"names":[],"mappings":"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"}

package/packages/core/dist/system-prompt-generator.d.ts

@@ -0,0 +1,14 @@
+/**
+ * System Prompt Generator for Vibe Feature MCP
+ *
+ * Dynamically generates a comprehensive system prompt for LLMs to properly
+ * integrate with the workflows server. The prompt is generated from
+ * the actual state machine definition to ensure accuracy and consistency.
+ */
+import type { YamlStateMachine } from './state-machine-types.js';
+/**
+ * Generate a system prompt for LLM integration
+ * @param stateMachine The state machine definition to use for generating the prompt
+ * @returns The generated system prompt
+ */
+export declare function generateSystemPrompt(stateMachine: YamlStateMachine): string;

package/packages/core/dist/system-prompt-generator.js

@@ -0,0 +1,42 @@
+/**
+ * System Prompt Generator for Vibe Feature MCP
+ *
+ * Dynamically generates a comprehensive system prompt for LLMs to properly
+ * integrate with the workflows server. The prompt is generated from
+ * the actual state machine definition to ensure accuracy and consistency.
+ */
+import { createLogger } from './logger.js';
+const logger = createLogger('SystemPromptGenerator');
+/**
+ * Generate a system prompt for LLM integration
+ * @param stateMachine The state machine definition to use for generating the prompt
+ * @returns The generated system prompt
+ */
+export function generateSystemPrompt(stateMachine) {
+    logger.debug('Generating system prompt from state machine definition', {
+        stateMachineName: stateMachine.name,
+        phaseCount: Object.keys(stateMachine.states).length,
+    });
+    return generateSimpleSystemPrompt(stateMachine);
+}
+/**
+ * Generate a simple system prompt for LLM integration
+ */
+function generateSimpleSystemPrompt(_stateMachine) {
+    logger.debug('Generating system prompt');
+    const systemPrompt = `
+You are an AI assistant that helps users develop software features using the workflows server.
+
+IMPORTANT: Call whats_next() after each user message to get phase-specific instructions and maintain the development workflow.
+
+Each tool call returns a JSON response with an "instructions" field. Follow these instructions immediately after you receive them.
+
+Use the development plan which you will retrieve via whats_next() to record important insights and decisions as per the structure of the plan.
+
+Do not use your own task management tools.`;
+    logger.info('System prompt generated successfully', {
+        promptLength: systemPrompt.length,
+    });
+    return systemPrompt;
+}
+//# sourceMappingURL=system-prompt-generator.js.map

package/packages/core/dist/system-prompt-generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-prompt-generator.js","sourceRoot":"","sources":["../src/system-prompt-generator.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,MAAM,GAAG,YAAY,CAAC,uBAAuB,CAAC,CAAC;AAErD;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,YAA8B;IACjE,MAAM,CAAC,KAAK,CAAC,wDAAwD,EAAE;QACrE,gBAAgB,EAAE,YAAY,CAAC,IAAI;QACnC,UAAU,EAAE,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,MAAM;KACpD,CAAC,CAAC;IAEH,OAAO,0BAA0B,CAAC,YAAY,CAAC,CAAC;AAClD,CAAC;AAED;;GAEG;AACH,SAAS,0BAA0B,CAAC,aAA+B;IACjE,MAAM,CAAC,KAAK,CAAC,0BAA0B,CAAC,CAAC;IAEzC,MAAM,YAAY,GAAG;;;;;;;;;2CASoB,CAAC;IAE1C,MAAM,CAAC,IAAI,CAAC,sCAAsC,EAAE;QAClD,YAAY,EAAE,YAAY,CAAC,MAAM;KAClC,CAAC,CAAC;IAEH,OAAO,YAAY,CAAC;AACtB,CAAC"}

package/packages/core/dist/task-backend.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Task Backend Management
+ *
+ * Provides abstraction layer for different task management backends:
+ * - markdown: Traditional plan file with checkbox tasks
+ * - beads: Beads distributed issue tracker integration
+ */
+export type TaskBackend = 'markdown' | 'beads';
+export interface TaskBackendConfig {
+    backend: TaskBackend;
+    isAvailable: boolean;
+    errorMessage?: string;
+}
+/**
+ * Task backend detection and management utility
+ */
+export declare class TaskBackendManager {
+    /**
+     * Detect and validate the requested task backend
+     *
+     * When TASK_BACKEND is not set:
+     * - Auto-detects if beads (bd) command is available
+     * - Uses beads if bd command exists, markdown otherwise
+     *
+     * When TASK_BACKEND is explicitly set:
+     * - Uses the specified backend (markdown or beads)
+     * - For beads, validates availability and provides setup instructions if not available
+     */
+    static detectTaskBackend(): TaskBackendConfig;
+    /**
+     * Check if beads command is available and functional
+     */
+    static checkBeadsAvailability(): {
+        isAvailable: boolean;
+        errorMessage?: string;
+    };
+    /**
+     * Get setup instructions for beads backend
+     */
+    static getBeadsSetupInstructions(): string;
+    /**
+     * Validate task backend configuration and throw error if invalid
+     */
+    static validateTaskBackend(): TaskBackendConfig;
+}

package/packages/core/dist/task-backend.js

@@ -0,0 +1,176 @@
+/**
+ * Task Backend Management
+ *
+ * Provides abstraction layer for different task management backends:
+ * - markdown: Traditional plan file with checkbox tasks
+ * - beads: Beads distributed issue tracker integration
+ */
+import { execSync } from 'node:child_process';
+import { createLogger } from './logger.js';
+const logger = createLogger('TaskBackend');
+/**
+ * Task backend detection and management utility
+ */
+export class TaskBackendManager {
+    /**
+     * Detect and validate the requested task backend
+     *
+     * When TASK_BACKEND is not set:
+     * - Auto-detects if beads (bd) command is available
+     * - Uses beads if bd command exists, markdown otherwise
+     *
+     * When TASK_BACKEND is explicitly set:
+     * - Uses the specified backend (markdown or beads)
+     * - For beads, validates availability and provides setup instructions if not available
+     */
+    static detectTaskBackend() {
+        const envBackend = process.env['TASK_BACKEND']?.toLowerCase().trim();
+        // Handle invalid values by treating as not set
+        if (envBackend && !['markdown', 'beads'].includes(envBackend)) {
+            logger.debug('Invalid TASK_BACKEND value, treating as not set', {
+                envBackend,
+            });
+        }
+        // Auto-detect backend when not explicitly configured
+        if (!envBackend || !['markdown', 'beads'].includes(envBackend)) {
+            const beadsAvailable = TaskBackendManager.checkBeadsAvailability();
+            if (beadsAvailable.isAvailable) {
+                logger.info('Auto-detected beads backend (bd command available)', {
+                    reason: 'TASK_BACKEND not set, bd command found',
+                });
+                return {
+                    backend: 'beads',
+                    isAvailable: true,
+                };
+            }
+            logger.debug('Using markdown backend (bd command not available)', {
+                reason: 'TASK_BACKEND not set, bd command not found',
+            });
+            return {
+                backend: 'markdown',
+                isAvailable: true,
+            };
+        }
+        const backend = envBackend;
+        if (backend === 'markdown') {
+            logger.debug('Using explicitly configured markdown backend');
+            return {
+                backend: 'markdown',
+                isAvailable: true,
+            };
+        }
+        // backend === 'beads' is the only remaining case (explicitly configured)
+        const beadsAvailable = TaskBackendManager.checkBeadsAvailability();
+        if (beadsAvailable.isAvailable) {
+            logger.debug('Using explicitly configured beads backend');
+            return {
+                backend: 'beads',
+                isAvailable: true,
+            };
+        }
+        return {
+            backend: 'beads',
+            isAvailable: false,
+            errorMessage: beadsAvailable.errorMessage || 'Beads backend not available',
+        };
+    }
+    /**
+     * Check if beads command is available and functional
+     */
+    static checkBeadsAvailability() {
+        try {
+            // Check if bd command exists and is functional
+            const output = execSync('bd --version', {
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'pipe'],
+                timeout: 5000,
+            });
+            logger.debug('Beads command available', { version: output.trim() });
+            return { isAvailable: true };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Provide helpful error message based on error type
+            if (errorMessage.includes('command not found') ||
+                errorMessage.includes('not recognized')) {
+                return {
+                    isAvailable: false,
+                    errorMessage: 'Beads command (bd) not found. Please install beads from: https://github.com/beads-data/beads',
+                };
+            }
+            if (errorMessage.includes('timeout')) {
+                return {
+                    isAvailable: false,
+                    errorMessage: 'Beads command (bd) timed out. Check if beads is properly installed and configured.',
+                };
+            }
+            logger.warn('Beads availability check failed', { errorMessage });
+            return {
+                isAvailable: false,
+                errorMessage: `Beads command (bd) check failed: ${errorMessage}`,
+            };
+        }
+    }
+    /**
+     * Get setup instructions for beads backend
+     */
+    static getBeadsSetupInstructions() {
+        return `## Beads Setup Required
+
+To use beads as your task backend, you need to install beads:
+
+### Installation
+1. Clone the beads repository:
+   \`\`\`bash
+   git clone https://github.com/beads-data/beads.git ~/beads
+   cd ~/beads
+   \`\`\`
+
+2. Build and install beads:
+   \`\`\`bash
+   make install
+   \`\`\`
+
+3. Verify installation:
+   \`\`\`bash
+   bd --version
+   \`\`\`
+
+### Auto-Detection
+The system automatically detects the task backend:
+- If the \`bd\` command is available, beads backend is used automatically
+- If the \`bd\` command is not found, markdown backend is used
+
+### Explicit Configuration (Optional)
+You can explicitly set the backend via environment variable:
+\`\`\`bash
+export TASK_BACKEND=beads     # Force beads backend
+export TASK_BACKEND=markdown  # Force markdown backend
+\`\`\`
+
+### Alternative: Use Markdown Backend
+If you prefer to continue with traditional plan file task management,
+simply ensure the \`bd\` command is not installed, or set:
+\`\`\`bash
+export TASK_BACKEND=markdown
+\`\`\``;
+    }
+    /**
+     * Validate task backend configuration and throw error if invalid
+     */
+    static validateTaskBackend() {
+        const config = this.detectTaskBackend();
+        if (!config.isAvailable) {
+            const setupInstructions = config.backend === 'beads'
+                ? this.getBeadsSetupInstructions()
+                : 'Task backend validation failed';
+            throw new Error(`Task backend '${config.backend}' is not available.\n\n${config.errorMessage || ''}\n\n${setupInstructions}`);
+        }
+        logger.info('Task backend validated successfully', {
+            backend: config.backend,
+            available: config.isAvailable,
+        });
+        return config;
+    }
+}
+//# sourceMappingURL=task-backend.js.map

package/packages/core/dist/task-backend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-backend.js","sourceRoot":"","sources":["../src/task-backend.ts"],"names":[],"mappings":"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"}

package/packages/core/dist/template-manager.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Template Manager
+ *
+ * Handles loading and rendering of project document templates.
+ * Supports different template formats for architecture, requirements, and design documents.
+ */
+export type ArchitectureTemplate = string;
+export type RequirementsTemplate = string;
+export type DesignTemplate = string;
+export interface TemplateOptions {
+    architecture?: ArchitectureTemplate;
+    requirements?: RequirementsTemplate;
+    design?: DesignTemplate;
+}
+export interface TemplateResult {
+    content: string;
+    additionalFiles?: Array<{
+        relativePath: string;
+        content: Buffer;
+    }>;
+}
+export declare class TemplateManager {
+    private templatesPath;
+    constructor();
+    /**
+     * Resolve templates path using similar strategy as WorkflowManager
+     */
+    private resolveTemplatesPath;
+    /**
+     * Get the default template options based on available templates
+     */
+    getDefaults(): Promise<Required<TemplateOptions>>;
+    /**
+     * Get preferred template from available options, with fallback preferences
+     */
+    private getPreferredTemplate;
+    /**
+     * Load and render a template
+     */
+    loadTemplate(type: 'architecture' | 'requirements' | 'design', template: string): Promise<TemplateResult>;
+    /**
+     * Load a directory-based template (like arc42 with images)
+     */
+    private loadDirectoryTemplate;
+    /**
+     * Recursively load additional files from template directory
+     */
+    private loadAdditionalFiles;
+    /**
+     * Validate template options against available templates
+     */
+    validateOptions(options: TemplateOptions): Promise<void>;
+    /**
+     * Get available templates for each type by scanning the file system
+     */
+    getAvailableTemplates(): Promise<{
+        architecture: string[];
+        requirements: string[];
+        design: string[];
+    }>;
+}