@codemcp/workflows 3.1.21

package/dist/types.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Core types and interfaces for the refactored server architecture
+ */
+import { ConversationManager } from '@codemcp/workflows-core';
+import { TransitionEngine } from '@codemcp/workflows-core';
+import { PlanManager } from '@codemcp/workflows-core';
+import { InstructionGenerator } from '@codemcp/workflows-core';
+import { WorkflowManager } from '@codemcp/workflows-core';
+import { InteractionLogger } from '@codemcp/workflows-core';
+/**
+ * Server context shared across all handlers
+ * Contains all the core dependencies needed by tool and resource handlers
+ */
+export interface ServerContext {
+    conversationManager: ConversationManager;
+    transitionEngine: TransitionEngine;
+    planManager: PlanManager;
+    instructionGenerator: InstructionGenerator;
+    workflowManager: WorkflowManager;
+    interactionLogger?: InteractionLogger;
+    projectPath: string;
+}
+/**
+ * Standard result format for all handler operations
+ * Separates business logic results from MCP protocol concerns
+ */
+export interface HandlerResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Resource content structure
+ */
+export interface ResourceContent {
+    uri: string;
+    text: string;
+    mimeType: string;
+}
+/**
+ * MCP Tool Response format (compatible with MCP SDK)
+ */
+export interface McpToolResponse {
+    [x: string]: unknown;
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}
+/**
+ * MCP Resource Response format (compatible with MCP SDK)
+ */
+export interface McpResourceResponse {
+    [x: string]: unknown;
+    contents: Array<{
+        uri: string;
+        text: string;
+        mimeType: string;
+    }>;
+}
+/**
+ * Tool handler interface
+ * All tool handlers must implement this interface
+ */
+export interface ToolHandler<TArgs = unknown, TResult = unknown> {
+    handle(args: TArgs, context: ServerContext): Promise<HandlerResult<TResult>>;
+}
+/**
+ * Resource handler interface
+ * All resource handlers must implement this interface
+ */
+export interface ResourceHandler {
+    handle(uri: URL, context: ServerContext): Promise<HandlerResult<ResourceContent>>;
+}
+/**
+ * Response renderer interface
+ * Handles translation between domain results and MCP protocol responses
+ */
+export interface ResponseRenderer {
+    renderToolResponse<T>(result: HandlerResult<T>): McpToolResponse;
+    renderResourceResponse(result: HandlerResult<ResourceContent>): McpResourceResponse;
+    renderError(error: Error | string): McpToolResponse;
+}
+/**
+ * Tool registry interface
+ * Manages registration and lookup of tool handlers
+ */
+export interface ToolRegistry {
+    register<T extends ToolHandler>(name: string, handler: T): void;
+    get(name: string): ToolHandler | undefined;
+    list(): string[];
+}
+/**
+ * Resource registry interface
+ * Manages registration and lookup of resource handlers
+ */
+export interface ResourceRegistry {
+    register(pattern: string, handler: ResourceHandler): void;
+    resolve(uri: string): ResourceHandler | undefined;
+}
+/**
+ * Server configuration options
+ */
+export interface ServerConfig {
+    /** Project path to operate on (defaults to process.cwd()) */
+    projectPath?: string;
+    /** Database path override */
+    databasePath?: string;
+    /** Enable interaction logging */
+    enableLogging?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

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

package/dist/types.js

@@ -0,0 +1,5 @@
+/**
+ * Core types and interfaces for the refactored server architecture
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@codemcp/workflows",
+  "version": "3.1.21",
+  "description": "MCP server implementation for responsible-vibe",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "responsible-vibe-mcp": "dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.17.5",
+    "@codemcp/workflows-core": "3.1.21"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "3.2.4"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "clean:build": "rimraf ./dist",
+    "dev": "tsc --watch",
+    "test": "vitest --run",
+    "lint": "oxlint .",
+    "lint:fix": "oxlint --fix .",
+    "format:check": "prettier --check .",
+    "format": "prettier --write ."
+  }
+}

package/src/index.ts

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+
+/**
+ * Vibe Feature MCP Server Entry Point
+ *
+ * Starts the MCP server with stdio transport for process-based usage.
+ * The core server logic is in server.ts for better testability.
+ */
+
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createResponsibleVibeMCPServer } from './server.js';
+
+// Re-export for external use
+export {
+  ResponsibleVibeMCPServer,
+  createResponsibleVibeMCPServer,
+} from './server.js';
+import { createLogger } from '@codemcp/workflows-core';
+
+const logger = createLogger('Main');
+
+/**
+ * Parse command line arguments and handle special flags
+ */
+function parseCliArgs(): { shouldStartServer: boolean } {
+  // Since routing is handled at root level, always start server when this module is loaded
+  return { shouldStartServer: true };
+}
+
+/**
+ * Main entry point for the MCP server process
+ */
+async function main() {
+  // Parse CLI arguments first
+  const { shouldStartServer } = parseCliArgs();
+
+  // If special flags were handled, exit gracefully
+  if (!shouldStartServer) {
+    return;
+  }
+
+  // Normal MCP server startup
+  try {
+    const projectPath = process.env.PROJECT_PATH;
+
+    // Create server instance with project path configuration
+    const server = await createResponsibleVibeMCPServer({
+      projectPath: projectPath,
+    });
+
+    // Initialize server
+    await server.initialize();
+
+    // Create stdio transport
+    const transport = new StdioServerTransport();
+
+    // Connect server to transport
+    await server.getMcpServer().connect(transport);
+
+    // Note: No logging here to ensure compatibility with Amazon Q CLI
+    // Amazon Q CLI expects no logging notifications before MCP initialization completes
+
+    // Handle graceful shutdown
+    process.on('SIGINT', async () => {
+      logger.info('Shutting down Vibe Feature MCP Server...');
+      await server.cleanup();
+      process.exit(0);
+    });
+
+    process.on('SIGTERM', async () => {
+      logger.info('Shutting down Vibe Feature MCP Server...');
+      await server.cleanup();
+      process.exit(0);
+    });
+  } catch (error) {
+    logger.error('Failed to start server', error as Error);
+    process.exit(1);
+  }
+}
+
+// Start the server if this file is run directly
+// More robust check that works with npx and direct execution
+const isMainModule =
+  import.meta.url === `file://${process.argv[1]}` ||
+  process.argv[1]?.endsWith('responsible-vibe-mcp') ||
+  process.argv[1]?.endsWith('index.js');
+
+if (isMainModule) {
+  main().catch(error => {
+    logger.error('Unhandled error in main', error);
+    process.exit(1);
+  });
+}

package/src/notification-service.ts

@@ -0,0 +1,23 @@
+/**
+ * Notification Service
+ *
+ * Simple event system for notifying MCP client of changes
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+class NotificationService {
+  private mcpServer?: McpServer;
+
+  setMcpServer(server: McpServer): void {
+    this.mcpServer = server;
+  }
+
+  async notifyToolListChanged(): Promise<void> {
+    if (this.mcpServer) {
+      this.mcpServer.sendToolListChanged();
+    }
+  }
+}
+
+export const notificationService = new NotificationService();

package/src/resource-handlers/conversation-state.ts

@@ -0,0 +1,55 @@
+/**
+ * Conversation State Resource Handler
+ *
+ * Handles the conversation-state resource which provides access to current
+ * conversation state and phase information including conversation ID, project context,
+ * current development phase, and plan file location.
+ */
+
+import { createLogger } from '@codemcp/workflows-core';
+import {
+  ResourceHandler,
+  ServerContext,
+  HandlerResult,
+  ResourceContent,
+} from '../types.js';
+import { safeExecute } from '../server-helpers.js';
+
+const logger = createLogger('ConversationStateResourceHandler');
+
+/**
+ * Conversation State resource handler implementation
+ */
+export class ConversationStateResourceHandler implements ResourceHandler {
+  async handle(
+    uri: URL,
+    context: ServerContext
+  ): Promise<HandlerResult<ResourceContent>> {
+    logger.debug('Processing conversation state resource request', {
+      uri: uri.href,
+    });
+
+    return safeExecute(async () => {
+      // Get conversation context
+      const conversationContext =
+        await context.conversationManager.getConversationContext();
+
+      // Build state information
+      const stateInfo = {
+        conversationId: conversationContext.conversationId,
+        projectPath: conversationContext.projectPath,
+        gitBranch: conversationContext.gitBranch,
+        currentPhase: conversationContext.currentPhase,
+        planFilePath: conversationContext.planFilePath,
+        timestamp: new Date().toISOString(),
+        description: 'Current state of the development workflow conversation',
+      };
+
+      return {
+        uri: uri.href,
+        text: JSON.stringify(stateInfo, null, 2),
+        mimeType: 'application/json',
+      };
+    }, 'Failed to retrieve conversation state resource');
+  }
+}

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

@@ -0,0 +1,48 @@
+/**
+ * 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

@@ -0,0 +1,73 @@
+/**
+ * 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

@@ -0,0 +1,55 @@
+/**
+ * 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

@@ -0,0 +1,126 @@
+/**
+ * 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 - dist is one level down from project root
+        projectRoot = path.resolve(path.dirname(currentFilePath), '../../../');
+      } else {
+        // Running from source (development) - src is one level 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}`);
+  }
+}