@codemcp/workflows 5.3.0 → 6.0.2

package/packages/visualizer/dist/services/BundledWorkflows.ts

@@ -0,0 +1,35 @@
+import { workflowList } from './workflow-list';
+
+// Bundled workflows configuration - imported from generated list
+const bundledWorkflows = workflowList;
+
+export function getBundledWorkflowNames(): string[] {
+  return bundledWorkflows;
+}
+
+export function getBundledWorkflow(name: string): string {
+  if (!bundledWorkflows.includes(name)) {
+    throw new Error(`Workflow '${name}' not found in bundled workflows`);
+  }
+  return `/workflows/${name}.yaml`;
+}
+
+export function getBundledWorkflowMetadata(name?: string) {
+  if (name) {
+    if (!bundledWorkflows.includes(name)) {
+      throw new Error(`Workflow '${name}' not found in bundled workflows`);
+    }
+    return {
+      name,
+      path: `/workflows/${name}.yaml`,
+      bundled: true,
+    };
+  }
+  return bundledWorkflows.map(name => ({
+    name,
+    path: `/workflows/${name}.yaml`,
+    bundled: true,
+  }));
+}
+
+export default bundledWorkflows;

package/packages/visualizer/dist/services/FileUploadHandler.ts

@@ -0,0 +1,166 @@
+/**
+ * File upload handling service
+ * Manages file upload UI interactions and validation
+ */
+
+import { YamlStateMachine, AppError } from '../types/ui-types';
+import { WorkflowLoader } from './WorkflowLoader';
+
+export class FileUploadHandler {
+  private readonly workflowLoader: WorkflowLoader;
+  private readonly fileInput: HTMLInputElement;
+  private readonly boundHandleFileSelection: (event: Event) => void;
+
+  constructor(
+    fileInputElement: HTMLInputElement,
+    workflowLoader: WorkflowLoader
+  ) {
+    this.workflowLoader = workflowLoader;
+    this.fileInput = fileInputElement;
+    this.boundHandleFileSelection = this.handleFileSelection.bind(this);
+    this.setupEventListeners();
+  }
+
+  /**
+   * Set up event listeners for file upload
+   */
+  private setupEventListeners(): void {
+    this.fileInput.addEventListener('change', this.boundHandleFileSelection);
+  }
+
+  /**
+   * Handle file selection from input
+   */
+  private async handleFileSelection(event: Event): Promise<void> {
+    const target = event.target as HTMLInputElement;
+    const files = target.files;
+
+    if (!files || files.length === 0) {
+      return;
+    }
+
+    const file = files[0];
+
+    try {
+      const workflow = await this.processUploadedFile(file);
+      this.onWorkflowLoaded(workflow, file.name);
+    } catch (error) {
+      this.onUploadError(error as AppError);
+    } finally {
+      // Clear the input so the same file can be uploaded again
+      target.value = '';
+    }
+  }
+
+  /**
+   * Process an uploaded file and return the parsed workflow
+   */
+  public async processUploadedFile(file: File): Promise<YamlStateMachine> {
+    console.log(`Processing uploaded file: ${file.name} (${file.size} bytes)`);
+
+    try {
+      const workflow = await this.workflowLoader.loadUploadedWorkflow(file);
+      console.log(`Successfully processed uploaded workflow: ${workflow.name}`);
+      return workflow;
+    } catch (error) {
+      console.error(`Error processing uploaded file:`, error);
+      // Re-throw with additional context
+      if (error instanceof Error) {
+        throw this.createUploadError(`Upload failed: ${error.message}`);
+      }
+      throw this.createUploadError(`Upload failed: ${String(error)}`);
+    }
+  }
+
+  /**
+   * Validate file before processing
+   */
+  public validateFile(file: File): void {
+    // Check file type
+    if (!this.isValidFileType(file)) {
+      throw this.createUploadError(
+        'Invalid file type. Please select a .yaml or .yml file.'
+      );
+    }
+
+    // Check file size (1MB limit)
+    const maxSizeBytes = 1024 * 1024;
+    if (file.size > maxSizeBytes) {
+      throw this.createUploadError(
+        `File too large. Maximum size is ${maxSizeBytes / 1024 / 1024}MB.`
+      );
+    }
+
+    // Check if file is empty
+    if (file.size === 0) {
+      throw this.createUploadError('File is empty.');
+    }
+  }
+
+  /**
+   * Check if file type is valid
+   */
+  private isValidFileType(file: File): boolean {
+    const validExtensions = ['.yaml', '.yml'];
+    const fileName = file.name.toLowerCase();
+
+    return validExtensions.some(ext => fileName.endsWith(ext));
+  }
+
+  /**
+   * Handle successful workflow loading
+   * This method should be overridden by the consumer
+   */
+  public onWorkflowLoaded: (
+    workflow: YamlStateMachine,
+    fileName: string
+  ) => void = () => {
+    console.log('FileUploadHandler: onWorkflowLoaded not implemented');
+  };
+
+  /**
+   * Handle upload errors
+   * This method should be overridden by the consumer
+   */
+  public onUploadError: (error: AppError) => void = () => {
+    console.error('FileUploadHandler: onUploadError not implemented');
+  };
+
+  /**
+   * Programmatically trigger file selection dialog
+   */
+  public triggerFileSelection(): void {
+    this.fileInput.click();
+  }
+
+  /**
+   * Get the current file input element
+   */
+  public getFileInput(): HTMLInputElement {
+    return this.fileInput;
+  }
+
+  /**
+   * Reset the file input
+   */
+  public resetFileInput(): void {
+    this.fileInput.value = '';
+  }
+
+  /**
+   * Create an upload error
+   */
+  private createUploadError(message: string): AppError {
+    return {
+      type: 'validation',
+      message: message,
+    } as AppError;
+  }
+
+  /**
+   * Destroy the handler and clean up event listeners
+   */
+  public destroy(): void {
+    this.fileInput.removeEventListener('change', this.boundHandleFileSelection);
+  }
+}

package/packages/visualizer/dist/services/WorkflowLoader.ts

@@ -0,0 +1,198 @@
+/**
+ * Workflow loading service
+ * Handles loading workflows from built-in resources and uploaded files
+ */
+
+import {
+  YamlStateMachine,
+  WorkflowMetadata,
+  AppError,
+} from '../types/ui-types';
+import { YamlParser } from './YamlParser';
+import {
+  getBundledWorkflow,
+  getBundledWorkflowNames,
+  getBundledWorkflowMetadata,
+} from './BundledWorkflows';
+
+export class WorkflowLoader {
+  private readonly yamlParser: YamlParser;
+
+  constructor() {
+    this.yamlParser = new YamlParser();
+  }
+
+  /**
+   * Get list of available built-in workflows (dynamically generated)
+   */
+  public getAvailableWorkflows(): WorkflowMetadata[] {
+    const workflowNames = getBundledWorkflowNames();
+
+    return workflowNames.map(name => {
+      // Use pre-parsed metadata from build time
+      const metadata = getBundledWorkflowMetadata(name);
+
+      return {
+        name,
+        displayName: this.formatDisplayName(name),
+        source: 'builtin' as const,
+        domain: metadata?.domain,
+      };
+    });
+  }
+
+  /**
+   * Format a workflow name into a display name
+   */
+  private formatDisplayName(name: string): string {
+    return name
+      .split(/[-_]/)
+      .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(' ');
+  }
+
+  /**
+   * Load a built-in workflow by name
+   */
+  public async loadBuiltinWorkflow(
+    workflowName: string
+  ): Promise<YamlStateMachine> {
+    const availableWorkflows = this.getAvailableWorkflows();
+    const workflowMetadata = availableWorkflows.find(
+      w => w.name === workflowName
+    );
+
+    if (!workflowMetadata) {
+      throw this.createNetworkError(`Unknown workflow: ${workflowName}`);
+    }
+
+    try {
+      const yamlContent = getBundledWorkflow(workflowName);
+
+      if (!yamlContent) {
+        throw this.createNetworkError(
+          `Bundled workflow "${workflowName}" not found`
+        );
+      }
+
+      if (!yamlContent.trim()) {
+        throw this.createNetworkError(
+          `Workflow file "${workflowName}" is empty`
+        );
+      }
+
+      const workflow = this.yamlParser.parseWorkflow(yamlContent);
+
+      return workflow;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('validation')) {
+        throw error;
+      }
+
+      if (error instanceof Error && error.message.includes('parsing')) {
+        throw error;
+      }
+
+      throw this.createNetworkError(
+        `Failed to load workflow "${workflowName}": ${String(error)}`
+      );
+    }
+  }
+
+  /**
+   * Load a workflow from an uploaded file
+   */
+  public async loadUploadedWorkflow(file: File): Promise<YamlStateMachine> {
+    try {
+      // Validate file type
+      if (!this.isValidYamlFile(file)) {
+        throw this.createValidationError(
+          'Invalid file type. Please upload a .yaml or .yml file.'
+        );
+      }
+
+      // Validate file size (limit to 1MB)
+      const maxSizeBytes = 1024 * 1024; // 1MB
+      if (file.size > maxSizeBytes) {
+        throw this.createValidationError(
+          `File too large. Maximum size is ${maxSizeBytes / 1024 / 1024}MB.`
+        );
+      }
+
+      // Read file content
+      const yamlContent = await this.readFileAsText(file);
+
+      if (!yamlContent.trim()) {
+        throw this.createValidationError('Uploaded file is empty');
+      }
+
+      // Parse and validate the workflow
+      return this.yamlParser.parseWorkflow(yamlContent);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('validation')) {
+        throw error;
+      }
+
+      if (error instanceof Error && error.message.includes('parsing')) {
+        throw error;
+      }
+
+      throw this.createNetworkError(
+        `Failed to process uploaded file: ${String(error)}`
+      );
+    }
+  }
+
+  /**
+   * Check if the uploaded file is a valid YAML file
+   */
+  private isValidYamlFile(file: File): boolean {
+    const validExtensions = ['.yaml', '.yml'];
+    const fileName = file.name.toLowerCase();
+
+    return validExtensions.some(ext => fileName.endsWith(ext));
+  }
+
+  /**
+   * Read file content as text
+   */
+  private readFileAsText(file: File): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+
+      reader.onload = (event: ProgressEvent<FileReader>) => {
+        if (event.target?.result) {
+          resolve(event.target.result as string);
+        } else {
+          reject(new Error('Failed to read file content'));
+        }
+      };
+
+      reader.onerror = () => {
+        reject(new Error('Error reading file'));
+      };
+
+      reader.readAsText(file);
+    });
+  }
+
+  /**
+   * Create a validation error
+   */
+  private createValidationError(message: string): AppError {
+    return {
+      type: 'validation',
+      message: message,
+    } as AppError;
+  }
+
+  /**
+   * Create a network error
+   */
+  private createNetworkError(message: string): AppError {
+    return {
+      type: 'network',
+      message: message,
+    } as AppError;
+  }
+}

package/packages/visualizer/dist/services/YamlParser.ts

@@ -0,0 +1,248 @@
+/**
+ * YAML parsing and validation service
+ * Handles parsing YAML content and validating workflow structure
+ */
+
+import * as yaml from 'js-yaml';
+import { YamlStateMachine, YamlState, YamlTransition } from '../types/ui-types';
+import { AppError } from '../types/ui-types';
+
+export class YamlParser {
+  /**
+   * Parse YAML content into a workflow state machine
+   */
+  public parseWorkflow(yamlContent: string): YamlStateMachine {
+    try {
+      const parsed = yaml.load(yamlContent) as unknown;
+
+      if (!parsed) {
+        throw this.createValidationError('Empty YAML content');
+      }
+
+      const workflow = this.validateWorkflowStructure(parsed);
+      return workflow;
+    } catch (error) {
+      if (error instanceof yaml.YAMLException) {
+        throw this.createParsingError(`YAML syntax error: ${error.message}`);
+      }
+
+      if (error instanceof Error && error.message.includes('validation')) {
+        throw error;
+      }
+
+      throw this.createParsingError(`Failed to parse YAML: ${String(error)}`);
+    }
+  }
+
+  /**
+   * Validate the structure of a parsed workflow object
+   */
+  private validateWorkflowStructure(parsed: unknown): YamlStateMachine {
+    // Check required top-level fields
+    this.validateRequiredField(parsed, 'name', 'string');
+    this.validateRequiredField(parsed, 'description', 'string');
+    this.validateRequiredField(parsed, 'initial_state', 'string');
+    this.validateRequiredField(parsed, 'states', 'object');
+
+    // Cast parsed to unknown for property access
+    const parsedData = parsed as Record<string, unknown>;
+
+    // Validate states structure
+    const states = this.validateStates(parsedData.states);
+
+    // Validate initial state exists
+    if (!states[parsedData.initial_state as string]) {
+      throw this.createValidationError(
+        `Initial state "${parsedData.initial_state}" not found in states`
+      );
+    }
+
+    // Validate state transitions reference valid states
+    this.validateStateReferences(states);
+
+    return {
+      name: parsedData.name as string,
+      description: parsedData.description as string,
+      initial_state: parsedData.initial_state as string,
+      states: states,
+      metadata: parsedData.metadata as YamlStateMachine['metadata'],
+    };
+  }
+
+  /**
+   * Validate states object structure
+   */
+  private validateStates(statesObj: unknown): Record<string, YamlState> {
+    if (!statesObj || typeof statesObj !== 'object') {
+      throw this.createValidationError('States must be an object');
+    }
+
+    const validatedStates: Record<string, YamlState> = {};
+
+    for (const [stateName, stateValue] of Object.entries(statesObj)) {
+      if (!stateValue || typeof stateValue !== 'object') {
+        throw this.createValidationError(
+          `State "${stateName}" must be an object`
+        );
+      }
+
+      const state = stateValue as unknown;
+
+      // Validate required state fields
+      this.validateRequiredField(
+        state,
+        'description',
+        'string',
+        `State "${stateName}"`
+      );
+      this.validateRequiredField(
+        state,
+        'default_instructions',
+        'string',
+        `State "${stateName}"`
+      );
+      // Cast state to Record for property access
+      const stateData = state as Record<string, unknown>;
+
+      this.validateRequiredField(
+        stateData,
+        'transitions',
+        'object',
+        `State "${stateName}"`
+      );
+
+      // Validate transitions
+      const transitions = this.validateTransitions(
+        stateData.transitions,
+        stateName
+      );
+
+      validatedStates[stateName] = {
+        description: stateData.description as string,
+        default_instructions: stateData.default_instructions as string,
+        transitions: transitions,
+      };
+    }
+
+    return validatedStates;
+  }
+
+  /**
+   * Validate transitions array structure
+   */
+  private validateTransitions(
+    transitionsArray: unknown,
+    stateName: string
+  ): YamlTransition[] {
+    if (!Array.isArray(transitionsArray)) {
+      throw this.createValidationError(
+        `Transitions for state "${stateName}" must be an array`
+      );
+    }
+
+    return transitionsArray.map((transition: unknown, index: number) => {
+      if (!transition || typeof transition !== 'object') {
+        throw this.createValidationError(
+          `Transition ${index} in state "${stateName}" must be an object`
+        );
+      }
+
+      // Cast transition to Record for property access
+      const transitionData = transition as Record<string, unknown>;
+
+      // Validate required transition fields
+      this.validateRequiredField(
+        transitionData,
+        'trigger',
+        'string',
+        `Transition ${index} in state "${stateName}"`
+      );
+      this.validateRequiredField(
+        transitionData,
+        'to',
+        'string',
+        `Transition ${index} in state "${stateName}"`
+      );
+      this.validateRequiredField(
+        transitionData,
+        'transition_reason',
+        'string',
+        `Transition ${index} in state "${stateName}"`
+      );
+
+      return {
+        trigger: transitionData.trigger as string,
+        to: transitionData.to as string,
+        instructions: transitionData.instructions as string,
+        additional_instructions:
+          transitionData.additional_instructions as string,
+        transition_reason: transitionData.transition_reason as string,
+        review_perspectives: transitionData.review_perspectives as Array<{
+          perspective: string;
+          prompt: string;
+        }>,
+      };
+    });
+  }
+
+  /**
+   * Validate that all transition targets reference valid states
+   */
+  private validateStateReferences(states: Record<string, YamlState>): void {
+    const stateNames = Object.keys(states);
+
+    for (const [stateName, state] of Object.entries(states)) {
+      for (const transition of state.transitions) {
+        if (!stateNames.includes(transition.to)) {
+          throw this.createValidationError(
+            `Transition in state "${stateName}" references unknown state "${transition.to}"`
+          );
+        }
+      }
+    }
+  }
+
+  /**
+   * Validate that a required field exists and has the correct type
+   */
+  private validateRequiredField(
+    obj: unknown,
+    fieldName: string,
+    expectedType: string,
+    context: string = 'Workflow'
+  ): void {
+    const objData = obj as Record<string, unknown>;
+    if (!(fieldName in objData)) {
+      throw this.createValidationError(
+        `${context}: Missing required field "${fieldName}"`
+      );
+    }
+
+    const actualType = typeof objData[fieldName];
+    if (actualType !== expectedType) {
+      throw this.createValidationError(
+        `${context}: Field "${fieldName}" must be ${expectedType}, got ${actualType}`
+      );
+    }
+  }
+
+  /**
+   * Create a validation error
+   */
+  private createValidationError(message: string): AppError {
+    return {
+      type: 'validation',
+      message: `Validation error: ${message}`,
+    } as AppError;
+  }
+
+  /**
+   * Create a parsing error
+   */
+  private createParsingError(message: string): AppError {
+    return {
+      type: 'parsing',
+      message: message,
+    } as AppError;
+  }
+}

package/packages/visualizer/dist/services/workflow-list.ts

@@ -0,0 +1,23 @@
+// Auto-generated workflow list
+export const workflowList = [
+  'adr',
+  'big-bang-conversion',
+  'boundary-testing',
+  'bugfix',
+  'business-analysis',
+  'c4-analysis',
+  'epcc',
+  'game-beginner',
+  'greenfield',
+  'minor',
+  'posts',
+  'sdd-bugfix',
+  'sdd-bugfix-crowd',
+  'sdd-feature',
+  'sdd-feature-crowd',
+  'sdd-greenfield',
+  'sdd-greenfield-crowd',
+  'slides',
+  'tdd',
+  'waterfall',
+];