@codemcp/workflows 5.0.1 → 5.1.1

package/src/resource-handlers/development-plan.ts

@@ -1,48 +0,0 @@
-/**
- * Development Plan Resource Handler
- *
- * Handles the development-plan resource which provides access to the current
- * development plan document (markdown) that tracks project progress, tasks, and decisions.
- */
-
-import { createLogger } from '@codemcp/workflows-core';
-import {
-  ResourceHandler,
-  ServerContext,
-  HandlerResult,
-  ResourceContent,
-} from '../types.js';
-import { safeExecute } from '../server-helpers.js';
-
-const logger = createLogger('DevelopmentPlanResourceHandler');
-
-/**
- * Development Plan resource handler implementation
- */
-export class DevelopmentPlanResourceHandler implements ResourceHandler {
-  async handle(
-    uri: URL,
-    context: ServerContext
-  ): Promise<HandlerResult<ResourceContent>> {
-    logger.debug('Processing development plan resource request', {
-      uri: uri.href,
-    });
-
-    return safeExecute(async () => {
-      // Get conversation context
-      const conversationContext =
-        await context.conversationManager.getConversationContext();
-
-      // Get plan file content
-      const planContent = await context.planManager.getPlanFileContent(
-        conversationContext.planFilePath
-      );
-
-      return {
-        uri: uri.href,
-        text: planContent,
-        mimeType: 'text/markdown',
-      };
-    }, 'Failed to retrieve development plan resource');
-  }
-}

package/src/resource-handlers/index.ts

@@ -1,73 +0,0 @@
-/**
- * Resource Handler Registry
- *
- * Central registry for all resource handlers. Provides registration and lookup
- * functionality for resource handlers used by the MCP server.
- */
-
-import { createLogger } from '@codemcp/workflows-core';
-import { DevelopmentPlanResourceHandler } from './development-plan.js';
-import { ConversationStateResourceHandler } from './conversation-state.js';
-import { WorkflowResourceHandler } from './workflow-resource.js';
-import { SystemPromptResourceHandler } from './system-prompt.js';
-import { ResourceHandler, ResourceRegistry } from '../types.js';
-
-const logger = createLogger('ResourceRegistry');
-
-/**
- * Default implementation of ResourceRegistry
- */
-export class DefaultResourceRegistry implements ResourceRegistry {
-  private handlers = new Map<string, ResourceHandler>();
-
-  register(pattern: string, handler: ResourceHandler): void {
-    logger.debug('Registering resource handler', {
-      pattern,
-      handlerType: handler.constructor.name,
-    });
-    this.handlers.set(pattern, handler);
-  }
-
-  resolve(uri: string): ResourceHandler | undefined {
-    // Simple pattern matching - could be enhanced with regex patterns
-    for (const [pattern, handler] of this.handlers.entries()) {
-      if (uri.includes(pattern)) {
-        logger.debug('Resolved resource handler', { uri, pattern });
-        return handler;
-      }
-    }
-
-    logger.debug('No resource handler found for URI', { uri });
-    return undefined;
-  }
-}
-
-/**
- * Create and configure the default resource registry with all standard handlers
- */
-export function createResourceRegistry(): ResourceRegistry {
-  const registry = new DefaultResourceRegistry();
-
-  // Register all standard resource handlers
-  registry.register('plan://current', new DevelopmentPlanResourceHandler());
-  registry.register('state://current', new ConversationStateResourceHandler());
-  registry.register('workflow://', new WorkflowResourceHandler());
-  registry.register('system-prompt://', new SystemPromptResourceHandler());
-
-  logger.info('Resource registry created with handlers', {
-    patterns: [
-      'plan://current',
-      'state://current',
-      'workflow://',
-      'system-prompt://',
-    ],
-  });
-
-  return registry;
-}
-
-// Export all handler types for external use
-export { DevelopmentPlanResourceHandler } from './development-plan.js';
-export { ConversationStateResourceHandler } from './conversation-state.js';
-export { WorkflowResourceHandler } from './workflow-resource.js';
-export { SystemPromptResourceHandler } from './system-prompt.js';

package/src/resource-handlers/system-prompt.ts

@@ -1,55 +0,0 @@
-/**
- * System Prompt Resource Handler
- *
- * Handles the system-prompt resource which provides access to the complete
- * system prompt for LLM integration. This allows programmatic access to the
- * system prompt through the MCP protocol. The system prompt is workflow-independent.
- */
-
-import { createLogger } from '@codemcp/workflows-core';
-import {
-  ResourceHandler,
-  ServerContext,
-  HandlerResult,
-  ResourceContent,
-} from '../types.js';
-import { safeExecute } from '../server-helpers.js';
-import { generateSystemPrompt } from '@codemcp/workflows-core';
-import { StateMachineLoader } from '@codemcp/workflows-core';
-
-const logger = createLogger('SystemPromptResourceHandler');
-
-/**
- * System Prompt resource handler implementation
- */
-export class SystemPromptResourceHandler implements ResourceHandler {
-  async handle(
-    uri: URL,
-    _context: ServerContext
-  ): Promise<HandlerResult<ResourceContent>> {
-    logger.debug('Processing system prompt resource request', {
-      uri: uri.href,
-    });
-
-    return safeExecute(async () => {
-      // Use the default waterfall workflow for system prompt generation
-      // The system prompt is workflow-independent and uses a standard workflow
-      const loader = new StateMachineLoader();
-      const stateMachine = loader.loadStateMachine(process.cwd()); // Uses default waterfall workflow
-
-      // Generate the system prompt
-      const systemPrompt = generateSystemPrompt(stateMachine);
-
-      logger.debug('Generated system prompt for resource', {
-        promptLength: systemPrompt.length,
-        workflowName: stateMachine.name,
-      });
-
-      return {
-        uri: uri.href,
-        text: systemPrompt,
-        mimeType: 'text/plain',
-      };
-    }, 'Failed to retrieve system prompt resource');
-  }
-}

package/src/resource-handlers/workflow-resource.ts

@@ -1,132 +0,0 @@
-/**
- * Workflow Resource Handler
- *
- * Handles MCP resources for individual workflows, returning the raw YAML content
- * from workflow definition files.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createLogger } from '@codemcp/workflows-core';
-import {
-  ResourceHandler,
-  ServerContext,
-  HandlerResult,
-  ResourceContent,
-} from '../types.js';
-import { safeExecute } from '../server-helpers.js';
-
-const logger = createLogger('WorkflowResourceHandler');
-
-/**
- * Resource handler for workflow:// URIs
- * Returns raw YAML content from workflow definition files
- */
-export class WorkflowResourceHandler implements ResourceHandler {
-  async handle(
-    uri: URL,
-    context: ServerContext
-  ): Promise<HandlerResult<ResourceContent>> {
-    logger.debug('Processing workflow resource request', { uri: uri.href });
-
-    return safeExecute(async () => {
-      // Extract workflow name from URI (workflow://workflow-name)
-      const workflowName = uri.hostname;
-
-      if (!workflowName) {
-        throw new Error(
-          'Invalid workflow URI: missing workflow name. Expected: workflow://workflow-name'
-        );
-      }
-
-      logger.info('Loading workflow resource', { workflowName, uri: uri.href });
-
-      let yamlContent: string;
-      let filePath: string;
-
-      // Try to get workflow from workflow manager
-      const workflow = context.workflowManager.getWorkflow(workflowName);
-      if (!workflow) {
-        throw new Error(`Workflow '${workflowName}' not found`);
-      }
-
-      // Handle predefined workflows
-      // Get the workflows directory path - more reliable approach
-      const currentFileUrl = import.meta.url;
-      const currentFilePath = fileURLToPath(currentFileUrl);
-
-      // Navigate from the compiled location to the project root
-      // From dist/server/resource-handlers/workflow-resource.js -> project root
-      let projectRoot: string;
-      if (currentFilePath.includes('/dist/')) {
-        // Running from compiled code - from packages/mcp-server/dist/resource-handlers/ to project root is 4 levels up
-        projectRoot = path.resolve(
-          path.dirname(currentFilePath),
-          '../../../../'
-        );
-      } else {
-        // Running from source (development) - src is 4 levels down from project root
-        projectRoot = path.resolve(
-          path.dirname(currentFilePath),
-          '../../../../'
-        );
-      }
-
-      const workflowFile = path.join(
-        projectRoot,
-        'resources',
-        'workflows',
-        `${workflowName}.yaml`
-      );
-
-      if (!fs.existsSync(workflowFile)) {
-        // Try .yml extension
-        const workflowFileYml = path.join(
-          projectRoot,
-          'resources',
-          'workflows',
-          `${workflowName}.yml`
-        );
-        if (!fs.existsSync(workflowFileYml)) {
-          // Log debug info to help troubleshoot
-          logger.error(
-            'Workflow file not found',
-            new Error(`Workflow '${workflowName}' not found`),
-            {
-              workflowName,
-              currentFilePath,
-              projectRoot,
-              workflowFile,
-              workflowFileYml,
-              workflowsDir: path.join(projectRoot, 'resources', 'workflows'),
-              workflowsDirExists: fs.existsSync(
-                path.join(projectRoot, 'resources', 'workflows')
-              ),
-            }
-          );
-          throw new Error(
-            `Workflow '${workflowName}' not found in resources/workflows/`
-          );
-        }
-        filePath = workflowFileYml;
-      } else {
-        filePath = workflowFile;
-      }
-
-      yamlContent = fs.readFileSync(filePath, 'utf-8');
-
-      logger.info('Successfully loaded workflow resource', {
-        workflowName,
-        filePath,
-        contentLength: yamlContent.length,
-      });
-
-      return {
-        uri: uri.href,
-        text: yamlContent,
-        mimeType: 'application/x-yaml',
-      };
-    }, `Failed to load workflow resource: ${uri.href}`);
-  }
-}

package/src/response-renderer.ts

@@ -1,116 +0,0 @@
-/**
- * Response Renderer
- *
- * Handles translation between domain handler results and MCP protocol responses.
- * This provides clean separation between business logic and protocol concerns.
- */
-
-import { createLogger } from '@codemcp/workflows-core';
-import {
-  ResponseRenderer,
-  HandlerResult,
-  ResourceContent,
-  McpToolResponse,
-  McpResourceResponse,
-} from './types.js';
-
-const logger = createLogger('ResponseRenderer');
-
-/**
- * Default implementation of ResponseRenderer
- * Converts domain results to MCP protocol format
- */
-export class DefaultResponseRenderer implements ResponseRenderer {
-  /**
-   * Render a tool handler result as an MCP tool response
-   */
-  renderToolResponse<T>(result: HandlerResult<T>): McpToolResponse {
-    logger.debug('Rendering tool response', {
-      success: result.success,
-      hasData: !!result.data,
-      hasError: !!result.error,
-    });
-
-    if (!result.success && result.error) {
-      return this.renderError(result.error);
-    }
-
-    // Convert data to JSON string for MCP protocol
-    const responseText = result.data
-      ? JSON.stringify(result.data, null, 2)
-      : '';
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: responseText,
-        },
-      ],
-    };
-  }
-
-  /**
-   * Render a resource handler result as an MCP resource response
-   */
-  renderResourceResponse(
-    result: HandlerResult<ResourceContent>
-  ): McpResourceResponse {
-    logger.debug('Rendering resource response', {
-      success: result.success,
-      hasData: !!result.data,
-    });
-
-    if (!result.success || !result.data) {
-      // For resources, we still need to return a valid response structure
-      // but with error content
-      const errorText = result.error || 'Resource not available';
-
-      return {
-        contents: [
-          {
-            uri: result.data?.uri || 'error://unknown',
-            text: `Error: ${errorText}`,
-            mimeType: 'text/plain',
-          },
-        ],
-      };
-    }
-
-    return {
-      contents: [
-        {
-          uri: result.data.uri,
-          text: result.data.text,
-          mimeType: result.data.mimeType,
-        },
-      ],
-    };
-  }
-
-  /**
-   * Render an error as an MCP tool response
-   */
-  renderError(error: Error | string): McpToolResponse {
-    const errorMessage = error instanceof Error ? error.message : error;
-
-    logger.debug('Rendering error response', { errorMessage });
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error: ${errorMessage}`,
-        },
-      ],
-      isError: true,
-    };
-  }
-}
-
-/**
- * Create a default response renderer instance
- */
-export function createResponseRenderer(): ResponseRenderer {
-  return new DefaultResponseRenderer();
-}