@codemcp/workflows-core 3.1.16

package/src/config-manager.ts

@@ -0,0 +1,96 @@
+/**
+ * Configuration Manager
+ *
+ * Handles loading and validation of project configuration from .vibe/config.yaml
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import yaml from 'js-yaml';
+import { createLogger } from './logger.js';
+
+const logger = createLogger('ConfigManager');
+
+export interface ProjectConfig {
+  enabled_workflows?: string[];
+}
+
+/**
+ * Manages project configuration loading and validation
+ */
+export class ConfigManager {
+  private static readonly CONFIG_FILENAME = 'config.yaml';
+
+  /**
+   * Load project configuration from .vibe/config.yaml
+   * Returns null if no config file exists (backward compatibility)
+   * Throws error for invalid configuration
+   */
+  public static loadProjectConfig(projectPath: string): ProjectConfig | null {
+    const configPath = path.join(projectPath, '.vibe', this.CONFIG_FILENAME);
+
+    // No config file = backward compatibility (all workflows available)
+    if (!fs.existsSync(configPath)) {
+      logger.debug('No config file found, using defaults', { configPath });
+      return null;
+    }
+
+    try {
+      const configContent = fs.readFileSync(configPath, 'utf-8');
+      const config = yaml.load(configContent) as ProjectConfig;
+
+      this.validateConfig(config, configPath);
+
+      logger.info('Loaded project configuration', {
+        configPath,
+        enabledWorkflows: config.enabled_workflows?.length || 0,
+      });
+
+      return config;
+    } catch (error) {
+      if (error instanceof yaml.YAMLException) {
+        throw new Error(
+          `Invalid YAML in config file ${configPath}: ${error.message}`
+        );
+      }
+      throw new Error(`Failed to load config file ${configPath}: ${error}`);
+    }
+  }
+
+  /**
+   * Validate configuration structure and content
+   */
+  private static validateConfig(
+    config: ProjectConfig,
+    configPath: string
+  ): void {
+    if (!config || typeof config !== 'object') {
+      throw new Error(
+        `Invalid config file ${configPath}: must be a YAML object`
+      );
+    }
+
+    if (config.enabled_workflows !== undefined) {
+      if (!Array.isArray(config.enabled_workflows)) {
+        throw new Error(
+          `Invalid config file ${configPath}: enabled_workflows must be an array`
+        );
+      }
+
+      if (config.enabled_workflows.length === 0) {
+        throw new Error(
+          `Invalid config file ${configPath}: enabled_workflows cannot be empty`
+        );
+      }
+
+      // Validate all entries are strings
+      for (const workflow of config.enabled_workflows) {
+        if (typeof workflow !== 'string' || workflow.trim() === '') {
+          throw new Error(
+            `Invalid config file ${configPath}: all workflow names must be non-empty strings`
+          );
+        }
+      }
+    }
+  }
+}

package/src/conversation-manager.ts

@@ -0,0 +1,492 @@
+/**
+ * Conversation Manager
+ *
+ * Handles conversation identification, state persistence, and coordination
+ * between components. Generates unique conversation identifiers from
+ * project path + git branch combination.
+ */
+
+import { execSync } from 'node:child_process';
+import { resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+import { createLogger } from './logger.js';
+import { Database } from './database.js';
+import type { ConversationState, ConversationContext } from './types.js';
+import { WorkflowManager } from './workflow-manager.js';
+import { PlanManager } from './plan-manager.js';
+
+const logger = createLogger('ConversationManager');
+
+export class ConversationManager {
+  private database: Database;
+  private projectPath: string;
+  private workflowManager: WorkflowManager;
+
+  constructor(
+    database: Database,
+    workflowManager: WorkflowManager,
+    projectPath: string
+  ) {
+    this.database = database;
+    this.workflowManager = workflowManager;
+    this.projectPath = projectPath;
+  }
+
+  /**
+   * Get conversation state by ID
+   */
+  async getConversationState(
+    conversationId: string
+  ): Promise<ConversationState | null> {
+    return await this.database.getConversationState(conversationId);
+  }
+
+  /**
+   * Get the current conversation context
+   *
+   * Detects the current project path and git branch, then retrieves an existing
+   * conversation state for this context. Does NOT create a new conversation.
+   *
+   * @throws Error if no conversation exists for this context
+   */
+  async getConversationContext(): Promise<ConversationContext> {
+    const projectPath = this.getProjectPath();
+    const gitBranch = this.getGitBranch(projectPath);
+
+    logger.debug('Getting conversation context', { projectPath, gitBranch });
+
+    // Generate a unique conversation ID based on project path and git branch
+    const conversationId = this.generateConversationId(projectPath, gitBranch);
+
+    // Try to find existing conversation state
+    const state = await this.database.getConversationState(conversationId);
+
+    // If no existing state, throw an error - conversation must be created with start_development first
+    if (!state) {
+      logger.warn('No conversation found for context', {
+        projectPath,
+        gitBranch,
+        conversationId,
+      });
+      throw new Error(
+        'No development conversation exists for this project. Use the start_development tool first to initialize development with a workflow.'
+      );
+    }
+
+    // Return the conversation context
+    return {
+      conversationId: state.conversationId,
+      projectPath: state.projectPath,
+      gitBranch: state.gitBranch,
+      currentPhase: state.currentPhase,
+      planFilePath: state.planFilePath,
+      workflowName: state.workflowName,
+    };
+  }
+
+  /**
+   * Create a new conversation context
+   *
+   * This should only be called by the start_development tool to explicitly
+   * create a new conversation with a selected workflow.
+   *
+   * @param workflowName - The workflow to use for this conversation
+   * @returns The newly created conversation context
+   */
+  async createConversationContext(
+    workflowName: string
+  ): Promise<ConversationContext> {
+    const projectPath = this.getProjectPath();
+    const gitBranch = this.getGitBranch(projectPath);
+
+    logger.debug('Creating conversation context', {
+      projectPath,
+      gitBranch,
+      workflowName,
+    });
+
+    // Generate a unique conversation ID based on project path and git branch
+    const conversationId = this.generateConversationId(projectPath, gitBranch);
+
+    // Check if a conversation already exists
+    const existingState =
+      await this.database.getConversationState(conversationId);
+
+    if (existingState) {
+      logger.debug('Conversation already exists, returning existing context', {
+        conversationId,
+      });
+      return {
+        conversationId: existingState.conversationId,
+        projectPath: existingState.projectPath,
+        gitBranch: existingState.gitBranch,
+        currentPhase: existingState.currentPhase,
+        planFilePath: existingState.planFilePath,
+        workflowName: existingState.workflowName,
+      };
+    }
+
+    // Create a new conversation state
+    const state = await this.createNewConversationState(
+      conversationId,
+      projectPath,
+      gitBranch,
+      workflowName
+    );
+
+    // Return the conversation context
+    return {
+      conversationId: state.conversationId,
+      projectPath: state.projectPath,
+      gitBranch: state.gitBranch,
+      currentPhase: state.currentPhase,
+      planFilePath: state.planFilePath,
+      workflowName: state.workflowName,
+    };
+  }
+
+  /**
+   * Update the conversation state
+   *
+   * @param conversationId - ID of the conversation to update
+   * @param updates - Partial state updates to apply
+   */
+  async updateConversationState(
+    conversationId: string,
+    updates: Partial<
+      Pick<
+        ConversationState,
+        | 'currentPhase'
+        | 'planFilePath'
+        | 'workflowName'
+        | 'gitCommitConfig'
+        | 'requireReviewsBeforePhaseTransition'
+      >
+    >
+  ): Promise<void> {
+    logger.debug('Updating conversation state', { conversationId, updates });
+
+    // Get current state
+    const currentState =
+      await this.database.getConversationState(conversationId);
+
+    if (!currentState) {
+      throw new Error(`Conversation state not found for ID: ${conversationId}`);
+    }
+
+    // Apply updates
+    const updatedState: ConversationState = {
+      ...currentState,
+      ...updates,
+      updatedAt: new Date().toISOString(),
+    };
+
+    // Save updated state
+    await this.database.saveConversationState(updatedState);
+
+    logger.info('Conversation state updated', {
+      conversationId,
+      currentPhase: updatedState.currentPhase,
+    });
+  }
+
+  /**
+   * Create a new conversation state
+   *
+   * @param conversationId - ID for the new conversation
+   * @param projectPath - Path to the project
+   * @param gitBranch - Git branch name
+   */
+  private async createNewConversationState(
+    conversationId: string,
+    projectPath: string,
+    gitBranch: string,
+    workflowName: string = 'waterfall'
+  ): Promise<ConversationState> {
+    logger.info('Creating new conversation state', {
+      conversationId,
+      projectPath,
+      gitBranch,
+    });
+
+    const timestamp = new Date().toISOString();
+
+    // Generate a plan file path based on the branch name
+    const planFileName =
+      gitBranch === 'main' || gitBranch === 'master'
+        ? 'development-plan.md'
+        : `development-plan-${gitBranch}.md`;
+
+    const planFilePath = resolve(projectPath, '.vibe', planFileName);
+
+    // Get initial state from the appropriate workflow
+    const stateMachine = this.workflowManager.loadWorkflowForProject(
+      projectPath,
+      workflowName
+    );
+    const initialPhase = stateMachine.initial_state;
+
+    // Create new state
+    const newState: ConversationState = {
+      conversationId,
+      projectPath,
+      gitBranch,
+      currentPhase: initialPhase,
+      planFilePath,
+      workflowName,
+      requireReviewsBeforePhaseTransition: false, // Default to false for new conversations
+      createdAt: timestamp,
+      updatedAt: timestamp,
+    };
+
+    // Save to database
+    await this.database.saveConversationState(newState);
+
+    logger.info('New conversation state created', {
+      conversationId,
+      planFilePath,
+      initialPhase,
+    });
+
+    return newState;
+  }
+
+  /**
+   * Generate a unique conversation ID based on project path and git branch
+   *
+   * @param projectPath - Path to the project
+   * @param gitBranch - Git branch name
+   */
+  private generateConversationId(
+    projectPath: string,
+    gitBranch: string
+  ): string {
+    // Extract project name from path
+    const projectName = projectPath.split('/').pop() || 'unknown-project';
+
+    // Clean branch name for use in ID
+    const cleanBranch = gitBranch
+      .replace(/[^a-zA-Z0-9-]/g, '-')
+      .replace(/-+/g, '-')
+      .replace(/^-|-$/g, '');
+
+    // For tests, use a deterministic ID
+    if (process.env.NODE_ENV === 'test') {
+      return `${projectName}-${cleanBranch}-p423k1`;
+    }
+
+    // Generate a deterministic ID based on project path and branch
+    // This ensures the same project/branch combination always gets the same conversation ID
+    let hash = 0;
+    const str = `${projectPath}:${gitBranch}`;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash; // Convert to 32-bit integer
+    }
+    const hashStr = Math.abs(hash).toString(36).substring(0, 6);
+
+    return `${projectName}-${cleanBranch}-${hashStr}`;
+  }
+
+  /**
+   * Get the current project path
+   */
+  private getProjectPath(): string {
+    return this.projectPath;
+  }
+
+  /**
+   * Get the current git branch for a project
+   *
+   * @param projectPath - Path to the project
+   */
+  private getGitBranch(projectPath: string): string {
+    try {
+      // Check if this is a git repository
+      if (!existsSync(`${projectPath}/.git`)) {
+        logger.debug('Not a git repository, using "default" as branch name', {
+          projectPath,
+        });
+        return 'default';
+      }
+
+      // Get current branch name
+      const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+        cwd: projectPath,
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'ignore'], // Suppress stderr to avoid "fatal: not a git repository" warnings
+      }).trim();
+
+      logger.debug('Detected git branch', { projectPath, branch });
+
+      return branch;
+    } catch (_error) {
+      logger.debug('Failed to get git branch, using "default" as branch name', {
+        projectPath,
+      });
+      return 'default';
+    }
+  }
+
+  /**
+   * Check if a conversation has any previous interactions
+   * Used to determine if this is the first interaction in a conversation
+   */
+  async hasInteractions(conversationId: string): Promise<boolean> {
+    try {
+      // Get all interactions for this conversation
+      const interactions =
+        await this.database.getInteractionsByConversationId(conversationId);
+      const count = interactions.length;
+
+      logger.debug('Checked interaction count for conversation', {
+        conversationId,
+        count,
+      });
+
+      return count > 0;
+    } catch (error) {
+      logger.error('Failed to check interaction count', error as Error, {
+        conversationId,
+      });
+      // If we can't check, assume this is the first interaction to be safe
+      return false;
+    }
+  }
+
+  /**
+   * Reset conversation data (hybrid approach)
+   */
+  async resetConversation(
+    confirm: boolean,
+    reason?: string
+  ): Promise<{
+    success: boolean;
+    resetItems: string[];
+    conversationId: string;
+    message: string;
+  }> {
+    logger.info('Starting conversation reset', { confirm, reason });
+
+    // Validate reset request
+    this.validateResetRequest(confirm);
+
+    const context = await this.getConversationContext();
+    const resetItems: string[] = [];
+
+    try {
+      // Step 1: Soft delete interaction logs
+      await this.database.softDeleteInteractionLogs(
+        context.conversationId,
+        reason
+      );
+      resetItems.push('interaction_logs');
+      logger.debug('Interaction logs soft deleted');
+
+      // Step 2: Hard delete conversation state
+      await this.database.deleteConversationState(context.conversationId);
+      resetItems.push('conversation_state');
+      logger.debug('Conversation state hard deleted');
+
+      // Step 3: Hard delete plan file
+      const planManager = new PlanManager();
+      await planManager.deletePlanFile(context.planFilePath);
+      resetItems.push('plan_file');
+      logger.debug('Plan file deleted');
+
+      // Verify cleanup
+      await this.verifyResetCleanup(
+        context.conversationId,
+        context.planFilePath
+      );
+
+      const message = `Successfully reset conversation ${context.conversationId}. Reset items: ${resetItems.join(', ')}${reason ? `. Reason: ${reason}` : ''}`;
+
+      logger.info('Conversation reset completed successfully', {
+        conversationId: context.conversationId,
+        resetItems,
+        reason,
+      });
+
+      return {
+        success: true,
+        resetItems,
+        conversationId: context.conversationId,
+        message,
+      };
+    } catch (error) {
+      logger.error('Failed to reset conversation', error as Error, {
+        conversationId: context.conversationId,
+        resetItems,
+        reason,
+      });
+
+      throw new Error(
+        `Reset failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+      );
+    }
+  }
+
+  /**
+   * Validate reset request parameters
+   */
+  private validateResetRequest(confirm: boolean): void {
+    if (!confirm) {
+      throw new Error(
+        'Reset operation requires explicit confirmation. Set confirm parameter to true.'
+      );
+    }
+  }
+
+  /**
+   * Verify that reset cleanup was successful
+   */
+  private async verifyResetCleanup(
+    conversationId: string,
+    planFilePath: string
+  ): Promise<void> {
+    logger.debug('Verifying reset cleanup', { conversationId, planFilePath });
+
+    try {
+      // Check that conversation state is deleted
+      const state = await this.database.getConversationState(conversationId);
+      if (state) {
+        throw new Error('Conversation state was not properly deleted');
+      }
+
+      // Check that plan file is deleted
+      const planManager = new PlanManager();
+      const isDeleted = await planManager.ensurePlanFileDeleted(planFilePath);
+      if (!isDeleted) {
+        throw new Error('Plan file was not properly deleted');
+      }
+
+      logger.debug('Reset cleanup verification successful');
+    } catch (error) {
+      logger.error('Reset cleanup verification failed', error as Error);
+      throw error;
+    }
+  }
+
+  /**
+   * Clean up conversation data (used internally)
+   */
+  async cleanupConversationData(conversationId: string): Promise<void> {
+    logger.debug('Cleaning up conversation data', { conversationId });
+
+    try {
+      // This method can be used for additional cleanup if needed
+      // Currently, the main cleanup is handled by resetConversation
+      await this.database.softDeleteInteractionLogs(conversationId);
+      await this.database.deleteConversationState(conversationId);
+
+      logger.debug('Conversation data cleanup completed', { conversationId });
+    } catch (error) {
+      logger.error('Failed to cleanup conversation data', error as Error, {
+        conversationId,
+      });
+      throw error;
+    }
+  }
+}