@codemcp/workflows 5.0.1 → 5.1.0

package/src/tool-handlers/whats-next.ts

@@ -1,246 +0,0 @@
-/**
- * WhatsNext Tool Handler
- *
- * Handles the whats_next tool which analyzes conversation context and
- * determines the next development phase with specific instructions for the LLM.
- */
-
-import { ConversationRequiredToolHandler } from './base-tool-handler.js';
-import type { ConversationContext } from '@codemcp/workflows-core';
-// TaskBackendManager and BeadsIntegration functionality now handled by injected components
-import { ServerContext } from '../types.js';
-
-/**
- * Arguments for the whats_next tool
- */
-export interface WhatsNextArgs {
-  context?: string;
-  user_input?: string;
-  conversation_summary?: string;
-  recent_messages?: Array<{
-    role: 'user' | 'assistant';
-    content: string;
-  }>;
-}
-
-/**
- * Response from the whats_next tool
- */
-export interface WhatsNextResult {
-  phase: string;
-  instructions: string;
-  plan_file_path: string;
-}
-
-/**
- * WhatsNext tool handler implementation
- */
-export class WhatsNextHandler extends ConversationRequiredToolHandler<
-  WhatsNextArgs,
-  WhatsNextResult
-> {
-  protected override async executeHandler(
-    args: WhatsNextArgs,
-    context: ServerContext
-  ): Promise<WhatsNextResult> {
-    let conversationContext;
-
-    try {
-      conversationContext = await this.getConversationContext(context);
-    } catch (_error) {
-      // Use standard CONVERSATION_NOT_FOUND error
-      throw new Error('CONVERSATION_NOT_FOUND');
-    }
-
-    return this.executeWithConversation(args, context, conversationContext);
-  }
-
-  protected async executeWithConversation(
-    args: WhatsNextArgs,
-    context: ServerContext,
-    conversationContext: ConversationContext
-  ): Promise<WhatsNextResult> {
-    const {
-      context: requestContext = '',
-      user_input = '',
-      conversation_summary = '',
-      recent_messages = [],
-    } = args;
-
-    const conversationId = conversationContext.conversationId;
-    const currentPhase = conversationContext.currentPhase;
-
-    this.logger.debug('Processing whats_next request', {
-      conversationId,
-      currentPhase,
-      hasContext: !!requestContext,
-      hasUserInput: !!user_input,
-    });
-
-    // Ensure state machine is loaded for this project
-    this.ensureStateMachineForProject(
-      context,
-      conversationContext.projectPath,
-      conversationContext.workflowName
-    );
-
-    // Ensure plan file exists
-    await context.planManager.ensurePlanFile(
-      conversationContext.planFilePath,
-      conversationContext.projectPath,
-      conversationContext.gitBranch
-    );
-
-    // Analyze phase transition
-    const transitionResult =
-      await context.transitionEngine.analyzePhaseTransition({
-        currentPhase,
-        projectPath: conversationContext.projectPath,
-        userInput: user_input,
-        context: requestContext,
-        conversationSummary: conversation_summary,
-        recentMessages: recent_messages,
-        conversationId: conversationContext.conversationId,
-      });
-
-    // Update conversation state if phase changed
-    if (transitionResult.newPhase !== currentPhase) {
-      const shouldUpdateState = await this.shouldUpdateConversationState(
-        currentPhase,
-        transitionResult.newPhase,
-        conversationContext,
-        context
-      );
-
-      if (shouldUpdateState) {
-        await context.conversationManager.updateConversationState(
-          conversationId,
-          { currentPhase: transitionResult.newPhase }
-        );
-      }
-
-      // If this was a first-call auto-transition, regenerate the plan file
-      if (
-        transitionResult.transitionReason.includes(
-          'Starting development - defining criteria'
-        )
-      ) {
-        this.logger.info(
-          'Regenerating plan file after first-call auto-transition',
-          {
-            from: currentPhase,
-            to: transitionResult.newPhase,
-            planFilePath: conversationContext.planFilePath,
-          }
-        );
-
-        await context.planManager.ensurePlanFile(
-          conversationContext.planFilePath,
-          conversationContext.projectPath,
-          conversationContext.gitBranch
-        );
-      }
-
-      this.logger.info('Phase transition completed', {
-        from: currentPhase,
-        to: transitionResult.newPhase,
-        reason: transitionResult.transitionReason,
-      });
-    }
-
-    // Check if plan file exists
-    const planInfo = await context.planManager.getPlanFileInfo(
-      conversationContext.planFilePath
-    );
-
-    // Generate enhanced instructions
-    const instructions =
-      await context.instructionGenerator.generateInstructions(
-        transitionResult.instructions,
-        {
-          phase: transitionResult.newPhase,
-          conversationContext: {
-            ...conversationContext,
-            currentPhase: transitionResult.newPhase,
-          },
-          transitionReason: transitionResult.transitionReason,
-          isModeled: transitionResult.isModeled,
-          planFileExists: planInfo.exists,
-          instructionSource: 'whats_next',
-        }
-      );
-
-    // Note: Commit behavior now handled by CommitPlugin
-    // Note: Beads-specific instructions are now handled by BeadsInstructionGenerator via strategy pattern
-
-    // Prepare response
-    const response: WhatsNextResult = {
-      phase: transitionResult.newPhase,
-      instructions: instructions.instructions,
-      plan_file_path: conversationContext.planFilePath,
-    };
-
-    // Log interaction
-    await this.logInteraction(
-      context,
-      conversationId,
-      'whats_next',
-      args,
-      response,
-      transitionResult.newPhase
-    );
-
-    return response;
-  }
-
-  /**
-   * Determines whether conversation state should be updated for a phase transition
-   */
-  private async shouldUpdateConversationState(
-    currentPhase: string,
-    newPhase: string,
-    conversationContext: ConversationContext,
-    context: ServerContext
-  ): Promise<boolean> {
-    if (!conversationContext.requireReviewsBeforePhaseTransition) {
-      return true;
-    }
-
-    const stateMachine = context.workflowManager.loadWorkflowForProject(
-      conversationContext.projectPath,
-      conversationContext.workflowName
-    );
-
-    const currentState = stateMachine.states[currentPhase];
-    if (!currentState) {
-      return true;
-    }
-
-    const transition = currentState.transitions.find(t => t.to === newPhase);
-    if (!transition) {
-      return true;
-    }
-
-    const hasReviewPerspectives =
-      transition.review_perspectives &&
-      transition.review_perspectives.length > 0;
-
-    if (hasReviewPerspectives) {
-      this.logger.debug(
-        'Preventing state update - review required for transition',
-        {
-          from: currentPhase,
-          to: newPhase,
-          reviewPerspectives: transition.review_perspectives?.length || 0,
-        }
-      );
-      return false;
-    }
-
-    return true;
-  }
-
-  // Beads-specific instruction logic has been moved to BeadsInstructionGenerator strategy
-
-  // Utility methods moved to strategy implementations where needed
-}

package/src/types.ts

@@ -1,135 +0,0 @@
-/**
- * Core types and interfaces for the refactored server architecture
- */
-
-import { ConversationManager } from '@codemcp/workflows-core';
-import { TransitionEngine } from '@codemcp/workflows-core';
-import { IPlanManager } from '@codemcp/workflows-core';
-import { IInstructionGenerator } from '@codemcp/workflows-core';
-import { WorkflowManager } from '@codemcp/workflows-core';
-import { InteractionLogger } from '@codemcp/workflows-core';
-import type { TaskBackendConfig } from '@codemcp/workflows-core';
-import type { IPluginRegistry } from './plugin-system/plugin-interfaces.js';
-
-/**
- * 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: IPlanManager;
-  instructionGenerator: IInstructionGenerator;
-  workflowManager: WorkflowManager;
-  interactionLogger?: InteractionLogger;
-  projectPath: string;
-  pluginRegistry?: IPluginRegistry;
-}
-
-/**
- * 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;
-  /** Task backend configuration override (for testing) */
-  taskBackend?: TaskBackendConfig;
-}

package/src/version-info.ts

@@ -1,213 +0,0 @@
-/**
- * Version Information Utility
- *
- * Provides version information for the MCP server, supporting both
- * build-time injection and runtime determination for local development.
- */
-
-import { execSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createLogger } from '@codemcp/workflows-core';
-
-const logger = createLogger('VersionInfo');
-
-/**
- * Structure for version information
- */
-export interface VersionInfo {
-  /** The semantic version (e.g., "4.8.0") */
-  version: string;
-  /** Git commit hash (short form, e.g., "bbb06ba") */
-  commit?: string;
-  /** Whether working directory has uncommitted changes */
-  isDirty?: boolean;
-  /** Full git describe output (e.g., "v4.8.0-1-gbbb06ba-dirty") */
-  gitDescribe?: string;
-  /** Source of version information */
-  source: 'package.json' | 'git' | 'build-time' | 'fallback';
-}
-
-/**
- * Build-time version information (injected during build process)
- * This will be replaced by the build system with actual values
- */
-// @ts-ignore - This is replaced at build time
-const BUILD_TIME_VERSION: VersionInfo | null = null;
-
-/**
- * Gets version information from package.json
- */
-function getVersionFromPackageJson(): VersionInfo | null {
-  try {
-    // Get the directory of this module
-    const currentDir = dirname(fileURLToPath(import.meta.url));
-
-    // Try to find package.json - first in the mcp-server package, then root
-    const packageJsonPaths = [
-      join(currentDir, '..', 'package.json'),
-      join(currentDir, '..', '..', '..', 'package.json'),
-    ];
-
-    for (const packageJsonPath of packageJsonPaths) {
-      try {
-        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-        if (packageJson.version) {
-          logger.debug('Found version in package.json', {
-            path: packageJsonPath,
-            version: packageJson.version,
-          });
-
-          return {
-            version: packageJson.version,
-            source: 'package.json',
-          };
-        }
-      } catch (error) {
-        logger.debug('Could not read package.json', {
-          path: packageJsonPath,
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
-    }
-
-    return null;
-  } catch (error) {
-    logger.debug('Error getting version from package.json', { error });
-    return null;
-  }
-}
-
-/**
- * Gets version information from git
- */
-function getVersionFromGit(): VersionInfo | null {
-  try {
-    // Get git describe output
-    const gitDescribe = execSync('git describe --tags --always --dirty', {
-      encoding: 'utf-8',
-      stdio: 'pipe',
-    }).trim();
-
-    logger.debug('Git describe output', { gitDescribe });
-
-    // Parse git describe output (e.g., "v4.8.0-1-gbbb06ba-dirty")
-    const isDirty = gitDescribe.endsWith('-dirty');
-    const cleanDescribe = isDirty ? gitDescribe.slice(0, -6) : gitDescribe;
-
-    // Try to extract version and commit
-    const parts = cleanDescribe.split('-');
-    let version: string;
-    let commit: string | undefined;
-
-    if (parts.length >= 3 && parts[0]?.startsWith('v')) {
-      // Format: v4.8.0-1-gbbb06ba
-      version = parts[0].slice(1); // Remove 'v' prefix
-      commit = parts[2]?.startsWith('g') ? parts[2].slice(1) : parts[2];
-    } else if (parts.length === 1 && parts[0]?.startsWith('v')) {
-      // Format: v4.8.0 (exact tag)
-      version = parts[0].slice(1);
-    } else if (parts.length === 1) {
-      // Format: commit hash only
-      version = 'unknown';
-      commit = parts[0];
-    } else {
-      // Fallback
-      version = 'unknown';
-    }
-
-    return {
-      version,
-      commit,
-      isDirty,
-      gitDescribe,
-      source: 'git',
-    };
-  } catch (error) {
-    logger.debug('Error getting version from git', {
-      error: error instanceof Error ? error.message : String(error),
-    });
-    return null;
-  }
-}
-
-/**
- * Gets comprehensive version information, trying multiple sources
- */
-export function getVersionInfo(): VersionInfo {
-  logger.debug('Determining version information');
-
-  // Try build-time version first (will be null in development)
-  if (BUILD_TIME_VERSION) {
-    logger.info('Using build-time version information', {
-      version: BUILD_TIME_VERSION.version,
-      source: BUILD_TIME_VERSION.source,
-    });
-    return BUILD_TIME_VERSION;
-  }
-
-  // Try git version info (best for development)
-  const gitVersion = getVersionFromGit();
-  if (gitVersion) {
-    // If we have git info, try to enhance with package.json version
-    const packageVersion = getVersionFromPackageJson();
-    if (packageVersion && gitVersion.version === 'unknown') {
-      logger.info('Using package.json version with git commit info', {
-        version: packageVersion.version,
-        commit: gitVersion.commit || 'unknown',
-        isDirty: String(gitVersion.isDirty || false),
-      });
-
-      return {
-        ...gitVersion,
-        version: packageVersion.version,
-        source: 'git' as const,
-      };
-    }
-
-    logger.info('Using git version information', {
-      version: gitVersion.version,
-      source: gitVersion.source,
-      commit: gitVersion.commit || 'none',
-      isDirty: String(gitVersion.isDirty || false),
-    });
-    return gitVersion;
-  }
-
-  // Fallback to package.json only
-  const packageVersion = getVersionFromPackageJson();
-  if (packageVersion) {
-    logger.info('Using package.json version information', {
-      version: packageVersion.version,
-      source: packageVersion.source,
-    });
-    return packageVersion;
-  }
-
-  // Final fallback
-  logger.warn('Could not determine version information, using fallback');
-  return {
-    version: 'unknown',
-    source: 'fallback',
-  };
-}
-
-/**
- * Gets a formatted version string suitable for display
- */
-export function getFormattedVersion(): string {
-  const versionInfo = getVersionInfo();
-
-  let formatted = versionInfo.version;
-
-  if (versionInfo.commit) {
-    formatted += `+${versionInfo.commit}`;
-  }
-
-  if (versionInfo.isDirty) {
-    formatted += '.dirty';
-  }
-
-  return formatted;
-}