@codemcp/workflows 5.2.4 → 6.0.1

package/packages/core/dist/instruction-generator.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Instruction Generator
+ *
+ * Creates phase-specific guidance for the LLM based on current conversation state.
+ * Customizes instructions based on project context and development phase.
+ * Supports custom state machine definitions for dynamic instruction generation.
+ * Handles variable substitution for project artifact references.
+ */
+import { PlanManager } from './plan-manager.js';
+import type { YamlStateMachine } from './state-machine-types.js';
+import type { IInstructionGenerator, InstructionContext, GeneratedInstructions } from './interfaces/instruction-generator.interface.js';
+export declare class InstructionGenerator implements IInstructionGenerator {
+    private projectDocsManager;
+    constructor(_planManager: PlanManager);
+    /**
+     * Set the state machine definition for dynamic instruction generation
+     */
+    setStateMachine(_stateMachine: YamlStateMachine): void;
+    /**
+     * Generate comprehensive instructions for the LLM
+     */
+    generateInstructions(baseInstructions: string, context: InstructionContext): Promise<GeneratedInstructions>;
+    /**
+     * Apply variable substitution to instructions
+     * Replaces project artifact variables with actual file paths
+     */
+    private applyVariableSubstitution;
+    /**
+     * Escape special regex characters in variable names
+     */
+    private escapeRegExp;
+    /**
+     * Enhance base instructions with context-specific information
+     */
+    private enhanceInstructions;
+    /**
+     * Capitalize phase name for display
+     */
+    private capitalizePhase;
+}

package/packages/core/dist/instruction-generator.js

@@ -0,0 +1,89 @@
+/**
+ * Instruction Generator
+ *
+ * Creates phase-specific guidance for the LLM based on current conversation state.
+ * Customizes instructions based on project context and development phase.
+ * Supports custom state machine definitions for dynamic instruction generation.
+ * Handles variable substitution for project artifact references.
+ */
+import { ProjectDocsManager } from './project-docs-manager.js';
+export class InstructionGenerator {
+    projectDocsManager;
+    constructor(_planManager) {
+        // planManager parameter kept for API compatibility but not stored since unused
+        this.projectDocsManager = new ProjectDocsManager();
+    }
+    /**
+     * Set the state machine definition for dynamic instruction generation
+     */
+    setStateMachine(_stateMachine) {
+        // stateMachine parameter kept for API compatibility but not stored since unused
+        return;
+    }
+    /**
+     * Generate comprehensive instructions for the LLM
+     */
+    async generateInstructions(baseInstructions, context) {
+        // Apply variable substitution to base instructions
+        const substitutedInstructions = this.applyVariableSubstitution(baseInstructions, context.conversationContext.projectPath, context.conversationContext.gitBranch);
+        // Enhance base instructions with context-specific guidance
+        const enhancedInstructions = await this.enhanceInstructions(substitutedInstructions, context);
+        return {
+            instructions: enhancedInstructions,
+            planFileGuidance: 'Task management guidance is now included in main instructions',
+            metadata: {
+                phase: context.phase,
+                planFilePath: context.conversationContext.planFilePath,
+                transitionReason: context.transitionReason,
+                isModeled: context.isModeled,
+            },
+        };
+    }
+    /**
+     * Apply variable substitution to instructions
+     * Replaces project artifact variables with actual file paths
+     */
+    applyVariableSubstitution(instructions, projectPath, gitBranch) {
+        const substitutions = this.projectDocsManager.getVariableSubstitutions(projectPath, gitBranch);
+        let result = instructions;
+        for (const [variable, value] of Object.entries(substitutions)) {
+            // Use global replace to handle multiple occurrences
+            result = result.replace(new RegExp(this.escapeRegExp(variable), 'g'), value);
+        }
+        return result;
+    }
+    /**
+     * Escape special regex characters in variable names
+     */
+    escapeRegExp(string) {
+        return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    /**
+     * Enhance base instructions with context-specific information
+     */
+    async enhanceInstructions(baseInstructions, context) {
+        const { phase, conversationContext, planFileExists } = context;
+        const phaseName = this.capitalizePhase(phase);
+        let workflowSection = `---
+**Workflow Continuity:**
+Maintain \`${conversationContext.planFilePath}\`:
+- Work through tasks in the "${phaseName}" section; Focus on those tasks!
+- Add newly discovered tasks; log decisions in "Key Decisions"
+- DO NOT maintain tasks in other tools or documents than explicitly stated in this plan file!`;
+        if (!planFileExists) {
+            workflowSection += '\n- Note: plan file will be created on first update';
+        }
+        workflowSection += '\n\nCall `whats_next()` after each user message.';
+        return `## ${phaseName} Phase\n\n${baseInstructions}\n\n${workflowSection}`;
+    }
+    /**
+     * Capitalize phase name for display
+     */
+    capitalizePhase(phase) {
+        return phase
+            .split('_')
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+            .join(' ');
+    }
+}
+//# sourceMappingURL=instruction-generator.js.map

package/packages/core/dist/instruction-generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instruction-generator.js","sourceRoot":"","sources":["../src/instruction-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAS/D,MAAM,OAAO,oBAAoB;IACvB,kBAAkB,CAAqB;IAE/C,YAAY,YAAyB;QACnC,+EAA+E;QAC/E,IAAI,CAAC,kBAAkB,GAAG,IAAI,kBAAkB,EAAE,CAAC;IACrD,CAAC;IAED;;OAEG;IACH,eAAe,CAAC,aAA+B;QAC7C,gFAAgF;QAChF,OAAO;IACT,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,oBAAoB,CACxB,gBAAwB,EACxB,OAA2B;QAE3B,mDAAmD;QACnD,MAAM,uBAAuB,GAAG,IAAI,CAAC,yBAAyB,CAC5D,gBAAgB,EAChB,OAAO,CAAC,mBAAmB,CAAC,WAAW,EACvC,OAAO,CAAC,mBAAmB,CAAC,SAAS,CACtC,CAAC;QAEF,2DAA2D;QAC3D,MAAM,oBAAoB,GAAG,MAAM,IAAI,CAAC,mBAAmB,CACzD,uBAAuB,EACvB,OAAO,CACR,CAAC;QAEF,OAAO;YACL,YAAY,EAAE,oBAAoB;YAClC,gBAAgB,EACd,+DAA+D;YACjE,QAAQ,EAAE;gBACR,KAAK,EAAE,OAAO,CAAC,KAAK;gBACpB,YAAY,EAAE,OAAO,CAAC,mBAAmB,CAAC,YAAY;gBACtD,gBAAgB,EAAE,OAAO,CAAC,gBAAgB;gBAC1C,SAAS,EAAE,OAAO,CAAC,SAAS;aAC7B;SACF,CAAC;IACJ,CAAC;IAED;;;OAGG;IACK,yBAAyB,CAC/B,YAAoB,EACpB,WAAmB,EACnB,SAAkB;QAElB,MAAM,aAAa,GAAG,IAAI,CAAC,kBAAkB,CAAC,wBAAwB,CACpE,WAAW,EACX,SAAS,CACV,CAAC;QAEF,IAAI,MAAM,GAAG,YAAY,CAAC;QAC1B,KAAK,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,CAAC;YAC9D,oDAAoD;YACpD,MAAM,GAAG,MAAM,CAAC,OAAO,CACrB,IAAI,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,GAAG,CAAC,EAC5C,KAAK,CACN,CAAC;QACJ,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACK,YAAY,CAAC,MAAc;QACjC,OAAO,MAAM,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;IACvD,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,mBAAmB,CAC/B,gBAAwB,EACxB,OAA2B;QAE3B,MAAM,EAAE,KAAK,EAAE,mBAAmB,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC;QAE/D,MAAM,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;QAE9C,IAAI,eAAe,GAAG;;aAEb,mBAAmB,CAAC,YAAY;+BACd,SAAS;;8FAEsD,CAAC;QAE3F,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,eAAe,IAAI,qDAAqD,CAAC;QAC3E,CAAC;QAED,eAAe,IAAI,kDAAkD,CAAC;QAEtE,OAAO,MAAM,SAAS,aAAa,gBAAgB,OAAO,eAAe,EAAE,CAAC;IAC9E,CAAC;IAED;;OAEG;IACK,eAAe,CAAC,KAAa;QACnC,OAAO,KAAK;aACT,KAAK,CAAC,GAAG,CAAC;aACV,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;aACzD,IAAI,CAAC,GAAG,CAAC,CAAC;IACf,CAAC;CACF"}

package/packages/core/dist/interaction-logger.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Interaction Logger module
+ *
+ * Handles logging of tool interactions to the database for auditing and debugging.
+ */
+import type { IPersistence } from './persistence-interface.js';
+import type { InteractionLog } from './types.js';
+/**
+ * Handles logging of tool interactions to the database
+ */
+export declare class InteractionLogger {
+    private database;
+    /**
+     * Create a new InteractionLogger
+     *
+     * @param database - Persistence instance to use for logging
+     */
+    constructor(database: IPersistence);
+    /**
+     * Log an interaction with a tool
+     *
+     * @param conversationId - ID of the conversation
+     * @param toolName - Name of the tool that was called
+     * @param inputParams - Input parameters to the tool (will be stringified)
+     * @param responseData - Response data from the tool (will be stringified)
+     * @param currentPhase - Current development phase
+     * @returns Promise that resolves when the log is saved
+     */
+    logInteraction(conversationId: string, toolName: string, inputParams: unknown, responseData: unknown, currentPhase: string): Promise<void>;
+    /**
+     * Get all interactions for a specific conversation
+     *
+     * @param conversationId - ID of the conversation to get logs for
+     * @returns Promise that resolves to an array of interaction logs
+     */
+    getInteractionsByConversationId(conversationId: string): Promise<InteractionLog[]>;
+}

package/packages/core/dist/interaction-logger.js

@@ -0,0 +1,87 @@
+/**
+ * Interaction Logger module
+ *
+ * Handles logging of tool interactions to the database for auditing and debugging.
+ */
+import { createLogger } from './logger.js';
+const logger = createLogger('InteractionLogger');
+/**
+ * Handles logging of tool interactions to the database
+ */
+export class InteractionLogger {
+    database;
+    /**
+     * Create a new InteractionLogger
+     *
+     * @param database - Persistence instance to use for logging
+     */
+    constructor(database) {
+        this.database = database;
+        logger.debug('InteractionLogger initialized');
+    }
+    /**
+     * Log an interaction with a tool
+     *
+     * @param conversationId - ID of the conversation
+     * @param toolName - Name of the tool that was called
+     * @param inputParams - Input parameters to the tool (will be stringified)
+     * @param responseData - Response data from the tool (will be stringified)
+     * @param currentPhase - Current development phase
+     * @returns Promise that resolves when the log is saved
+     */
+    async logInteraction(conversationId, toolName, inputParams, responseData, currentPhase) {
+        logger.debug('Logging interaction', {
+            conversationId,
+            toolName,
+            currentPhase,
+        });
+        try {
+            const timestamp = new Date().toISOString();
+            const log = {
+                conversationId,
+                toolName,
+                inputParams: JSON.stringify(inputParams),
+                responseData: JSON.stringify(responseData),
+                currentPhase,
+                timestamp,
+            };
+            await this.database.logInteraction(log);
+            logger.info('Interaction logged successfully', {
+                conversationId,
+                toolName,
+                timestamp,
+            });
+        }
+        catch (error) {
+            logger.error('Failed to log interaction', error, {
+                conversationId,
+                toolName,
+            });
+            // Don't throw the error - logging should not break the main flow
+        }
+    }
+    /**
+     * Get all interactions for a specific conversation
+     *
+     * @param conversationId - ID of the conversation to get logs for
+     * @returns Promise that resolves to an array of interaction logs
+     */
+    async getInteractionsByConversationId(conversationId) {
+        logger.debug('Getting interactions by conversation ID', { conversationId });
+        try {
+            const logs = await this.database.getInteractionsByConversationId(conversationId);
+            logger.info('Retrieved interaction logs', {
+                conversationId,
+                count: logs.length,
+            });
+            return logs;
+        }
+        catch (error) {
+            logger.error('Failed to get interaction logs', error, {
+                conversationId,
+            });
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=interaction-logger.js.map

package/packages/core/dist/interaction-logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction-logger.js","sourceRoot":"","sources":["../src/interaction-logger.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAI3C,MAAM,MAAM,GAAG,YAAY,CAAC,mBAAmB,CAAC,CAAC;AAEjD;;GAEG;AACH,MAAM,OAAO,iBAAiB;IACpB,QAAQ,CAAe;IAE/B;;;;OAIG;IACH,YAAY,QAAsB;QAChC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,MAAM,CAAC,KAAK,CAAC,+BAA+B,CAAC,CAAC;IAChD,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,cAAc,CAClB,cAAsB,EACtB,QAAgB,EAChB,WAAoB,EACpB,YAAqB,EACrB,YAAoB;QAEpB,MAAM,CAAC,KAAK,CAAC,qBAAqB,EAAE;YAClC,cAAc;YACd,QAAQ;YACR,YAAY;SACb,CAAC,CAAC;QAEH,IAAI,CAAC;YACH,MAAM,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;YAE3C,MAAM,GAAG,GAAmB;gBAC1B,cAAc;gBACd,QAAQ;gBACR,WAAW,EAAE,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC;gBACxC,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;gBAC1C,YAAY;gBACZ,SAAS;aACV,CAAC;YAEF,MAAM,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;YAExC,MAAM,CAAC,IAAI,CAAC,iCAAiC,EAAE;gBAC7C,cAAc;gBACd,QAAQ;gBACR,SAAS;aACV,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,2BAA2B,EAAE,KAAc,EAAE;gBACxD,cAAc;gBACd,QAAQ;aACT,CAAC,CAAC;YACH,iEAAiE;QACnE,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,+BAA+B,CACnC,cAAsB;QAEtB,MAAM,CAAC,KAAK,CAAC,yCAAyC,EAAE,EAAE,cAAc,EAAE,CAAC,CAAC;QAE5E,IAAI,CAAC;YACH,MAAM,IAAI,GACR,MAAM,IAAI,CAAC,QAAQ,CAAC,+BAA+B,CAAC,cAAc,CAAC,CAAC;YAEtE,MAAM,CAAC,IAAI,CAAC,4BAA4B,EAAE;gBACxC,cAAc;gBACd,KAAK,EAAE,IAAI,CAAC,MAAM;aACnB,CAAC,CAAC;YAEH,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,gCAAgC,EAAE,KAAc,EAAE;gBAC7D,cAAc;aACf,CAAC,CAAC;YACH,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;CACF"}

package/packages/core/dist/interfaces/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Core Component Interfaces
+ *
+ * Defines contract interfaces for core components to enable strategy pattern.
+ * Enables clean substitution of components based on task backend configuration.
+ */
+export * from './plan-manager.interface.js';
+export * from './instruction-generator.interface.js';
+export * from './task-backend-client.interface.js';

package/packages/core/dist/interfaces/index.js

@@ -0,0 +1,10 @@
+/**
+ * Core Component Interfaces
+ *
+ * Defines contract interfaces for core components to enable strategy pattern.
+ * Enables clean substitution of components based on task backend configuration.
+ */
+export * from './plan-manager.interface.js';
+export * from './instruction-generator.interface.js';
+export * from './task-backend-client.interface.js';
+//# sourceMappingURL=index.js.map

package/packages/core/dist/interfaces/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/interfaces/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sCAAsC,CAAC;AACrD,cAAc,oCAAoC,CAAC"}

package/packages/core/dist/interfaces/instruction-generator.interface.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Instruction Generator Interface
+ *
+ * Defines the contract for instruction generation functionality.
+ * Enables strategy pattern implementation for different task backends.
+ */
+import type { ConversationContext } from '../types.js';
+import type { YamlStateMachine } from '../state-machine-types.js';
+export interface InstructionContext {
+    phase: string;
+    conversationContext: ConversationContext;
+    transitionReason: string;
+    isModeled: boolean;
+    planFileExists: boolean;
+    /** Source of the instruction generation request - helps generators adapt output */
+    instructionSource: 'proceed_to_phase' | 'whats_next';
+}
+export interface GeneratedInstructions {
+    instructions: string;
+    planFileGuidance: string;
+    metadata: {
+        phase: string;
+        planFilePath: string;
+        transitionReason: string;
+        isModeled: boolean;
+    };
+}
+/**
+ * Interface for instruction generation operations
+ * All instruction generators must implement this interface
+ */
+export interface IInstructionGenerator {
+    /**
+     * Set the state machine definition for dynamic instruction generation
+     */
+    setStateMachine(stateMachine: YamlStateMachine): void;
+    /**
+     * Generate comprehensive instructions for the LLM
+     */
+    generateInstructions(baseInstructions: string, context: InstructionContext): Promise<GeneratedInstructions>;
+}

package/packages/core/dist/interfaces/instruction-generator.interface.js

@@ -0,0 +1,8 @@
+/**
+ * Instruction Generator Interface
+ *
+ * Defines the contract for instruction generation functionality.
+ * Enables strategy pattern implementation for different task backends.
+ */
+export {};
+//# sourceMappingURL=instruction-generator.interface.js.map

package/packages/core/dist/interfaces/instruction-generator.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instruction-generator.interface.js","sourceRoot":"","sources":["../../src/interfaces/instruction-generator.interface.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/packages/core/dist/interfaces/plan-manager.interface.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Plan Manager Interface
+ *
+ * Defines the contract for plan management functionality.
+ * Enables strategy pattern implementation for different task backends.
+ */
+import type { YamlStateMachine } from '../state-machine-types.js';
+import type { TaskBackendConfig } from '../task-backend.js';
+export interface PlanFileInfo {
+    path: string;
+    exists: boolean;
+    content?: string;
+}
+/**
+ * Interface for plan management operations
+ * All plan managers must implement this interface
+ */
+export interface IPlanManager {
+    /**
+     * Set the state machine definition for dynamic plan generation
+     */
+    setStateMachine(stateMachine: YamlStateMachine): void;
+    /**
+     * Set the task backend configuration
+     */
+    setTaskBackend(taskBackend: TaskBackendConfig): void;
+    /**
+     * Get plan file information
+     */
+    getPlanFileInfo(planFilePath: string): Promise<PlanFileInfo>;
+    /**
+     * Create initial plan file if it doesn't exist
+     */
+    ensurePlanFile(planFilePath: string, projectPath: string, gitBranch: string): Promise<void>;
+    /**
+     * Update plan file with new content
+     */
+    updatePlanFile(planFilePath: string, content: string): Promise<void>;
+    /**
+     * Get plan file content for LLM context
+     */
+    getPlanFileContent(planFilePath: string): Promise<string>;
+    /**
+     * Generate phase-specific plan file guidance based on state machine
+     */
+    generatePlanFileGuidance(phase: string): string;
+    /**
+     * Delete plan file
+     */
+    deletePlanFile(planFilePath: string): Promise<boolean>;
+    /**
+     * Ensure plan file is deleted (verify deletion)
+     */
+    ensurePlanFileDeleted(planFilePath: string): Promise<boolean>;
+}

package/packages/core/dist/interfaces/plan-manager.interface.js

@@ -0,0 +1,8 @@
+/**
+ * Plan Manager Interface
+ *
+ * Defines the contract for plan management functionality.
+ * Enables strategy pattern implementation for different task backends.
+ */
+export {};
+//# sourceMappingURL=plan-manager.interface.js.map

package/packages/core/dist/interfaces/plan-manager.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-manager.interface.js","sourceRoot":"","sources":["../../src/interfaces/plan-manager.interface.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/packages/core/dist/interfaces/task-backend-client.interface.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Task Backend Client Interface
+ *
+ * Defines the contract for task backend operations (CLI commands, etc.).
+ * Enables clean abstraction of different task backends (beads, GitHub Issues, etc.).
+ */
+/**
+ * Represents a task from the backend
+ */
+export interface BackendTask {
+    id: string;
+    title: string;
+    status: 'open' | 'in_progress' | 'completed' | 'cancelled';
+    priority: number;
+    parent?: string;
+    children?: BackendTask[];
+}
+/**
+ * Result of task validation operations
+ */
+export interface TaskValidationResult {
+    valid: boolean;
+    openTasks: BackendTask[];
+    message?: string;
+}
+/**
+ * Interface for task backend client operations
+ * All task backend clients must implement this interface
+ */
+export interface ITaskBackendClient {
+    /**
+     * Check if the task backend is available and properly configured
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Get all open tasks for a given parent task
+     */
+    getOpenTasks(parentTaskId: string): Promise<BackendTask[]>;
+    /**
+     * Validate that all tasks under a parent are completed
+     * Returns validation result with details about any remaining open tasks
+     */
+    validateTasksCompleted(parentTaskId: string): Promise<TaskValidationResult>;
+    /**
+     * Create a new task under a parent
+     */
+    createTask(title: string, parentTaskId: string, priority?: number): Promise<string>;
+    /**
+     * Update task status
+     */
+    updateTaskStatus(taskId: string, status: 'open' | 'in_progress' | 'completed' | 'cancelled'): Promise<void>;
+}

package/packages/core/dist/interfaces/task-backend-client.interface.js

@@ -0,0 +1,8 @@
+/**
+ * Task Backend Client Interface
+ *
+ * Defines the contract for task backend operations (CLI commands, etc.).
+ * Enables clean abstraction of different task backends (beads, GitHub Issues, etc.).
+ */
+export {};
+//# sourceMappingURL=task-backend-client.interface.js.map

package/packages/core/dist/interfaces/task-backend-client.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-backend-client.interface.js","sourceRoot":"","sources":["../../src/interfaces/task-backend-client.interface.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/packages/core/dist/logger.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Logging utility for Vibe Feature MCP Server
+ *
+ * Provides structured logging with proper MCP compliance:
+ * - Uses stderr for all local logging (MCP requirement)
+ * - Supports MCP log message notifications to client
+ * - Provides structured logging with proper levels:
+ *   - debug: Tracing and detailed execution flow
+ *   - info: Success operations and important milestones
+ *   - warn: Expected errors and recoverable issues
+ *   - error: Caught but unexpected errors
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    SILENT = 4
+}
+export interface LogContext {
+    component?: string;
+    conversationId?: string;
+    phase?: string;
+    operation?: string;
+    [key: string]: unknown;
+}
+/**
+ * Set the MCP server instance for log notifications
+ */
+export declare function setMcpServerForLogging(server: McpServer): void;
+/**
+ * Set the logging level from MCP client request
+ */
+export declare function setMcpLoggingLevel(level: string): void;
+declare class Logger {
+    private component;
+    private explicitLogLevel?;
+    constructor(component: string, logLevel?: LogLevel);
+    private getCurrentLogLevel;
+    private getLogLevelFromEnv;
+    private shouldLog;
+    private formatMessage;
+    /**
+     * Send log message to MCP client if server is available and level is appropriate
+     */
+    private sendMcpLogMessage;
+    debug(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    /**
+     * Send enhanced MCP notifications with better formatting for important events
+     */
+    private sendEnhancedMcpNotification;
+    /**
+     * Capitalize phase name for display
+     */
+    private capitalizePhase;
+    warn(message: string, context?: LogContext): void;
+    error(message: string, error?: Error, context?: LogContext): void;
+    child(childComponent: string): Logger;
+}
+export declare function createLogger(component: string, logLevel?: LogLevel): Logger;
+export declare const logger: Logger;
+export {};