claude-autopm 1.17.0 → 1.20.0

package/lib/workflow/manager.js

@@ -1,449 +0,0 @@
-/**
- * Workflow Manager for LangGraph
- * Centralized workflow management functionality
- */
-
-const fs = require('fs').promises;
-const path = require('path');
-
-/**
- * Configuration constants
- */
-const CONFIG = {
-  directories: {
-    workflows: '.claude/workflows',
-    state: '.claude/workflows/state',
-    templates: '.claude/workflows/templates'
-  },
-  validation: {
-    requiredFields: ['name', 'nodes', 'edges'],
-    nodeTypes: ['input', 'output', 'llm', 'condition', 'transform', 'state', 'process', 'retriever', 'embedder', 'vectordb'],
-    edgeRequiredFields: ['from', 'to']
-  }
-};
-
-/**
- * Built-in workflow templates
- */
-const TEMPLATES = {
-  'qa-chain': {
-    name: 'qa-chain',
-    description: 'Question-answering chain template',
-    nodes: [
-      { id: 'input', type: 'input', prompt: 'Enter question' },
-      { id: 'retriever', type: 'retriever', source: 'knowledge-base' },
-      { id: 'llm', type: 'llm', model: 'gpt-3.5-turbo' },
-      { id: 'output', type: 'output' }
-    ],
-    edges: [
-      { from: 'input', to: 'retriever' },
-      { from: 'retriever', to: 'llm' },
-      { from: 'llm', to: 'output' }
-    ]
-  },
-  'rag-pipeline': {
-    name: 'rag-pipeline',
-    description: 'Retrieval-augmented generation pipeline',
-    nodes: [
-      { id: 'input', type: 'input' },
-      { id: 'embedder', type: 'embedder', model: 'text-embedding-ada-002' },
-      { id: 'vectordb', type: 'vectordb', database: 'pinecone' },
-      { id: 'retriever', type: 'retriever' },
-      { id: 'llm', type: 'llm', model: 'gpt-4' },
-      { id: 'output', type: 'output' }
-    ],
-    edges: [
-      { from: 'input', to: 'embedder' },
-      { from: 'embedder', to: 'vectordb' },
-      { from: 'vectordb', to: 'retriever' },
-      { from: 'retriever', to: 'llm' },
-      { from: 'llm', to: 'output' }
-    ]
-  },
-  'agent-loop': {
-    name: 'agent-loop',
-    description: 'Agent with tool-use loop',
-    nodes: [
-      { id: 'input', type: 'input' },
-      { id: 'agent', type: 'llm', model: 'gpt-4' },
-      { id: 'tool-check', type: 'condition', expression: 'needs_tool' },
-      { id: 'tool-use', type: 'process', tool: 'execute' },
-      { id: 'output', type: 'output' }
-    ],
-    edges: [
-      { from: 'input', to: 'agent' },
-      { from: 'agent', to: 'tool-check' },
-      { from: 'tool-check', to: 'tool-use', condition: true },
-      { from: 'tool-check', to: 'output', condition: false },
-      { from: 'tool-use', to: 'agent' }
-    ]
-  }
-};
-
-class WorkflowManager {
-  constructor(projectRoot = process.cwd()) {
-    this.projectRoot = projectRoot;
-    this.workflowsDir = path.join(projectRoot, CONFIG.directories.workflows);
-    this.stateDir = path.join(projectRoot, CONFIG.directories.state);
-  }
-
-  /**
-   * Validates workflow structure
-   * @param {object} workflow - Workflow to validate
-   * @throws {Error} - If validation fails
-   */
-  validateWorkflow(workflow) {
-    // Check required fields
-    for (const field of CONFIG.validation.requiredFields) {
-      if (!workflow[field]) {
-        throw new Error(`Invalid workflow: missing required field '${field}'`);
-      }
-    }
-
-    // Validate nodes
-    if (!Array.isArray(workflow.nodes) || workflow.nodes.length === 0) {
-      throw new Error('Invalid workflow: nodes must be a non-empty array');
-    }
-
-    for (const node of workflow.nodes) {
-      if (!node.id || !node.type) {
-        throw new Error('Invalid workflow: each node must have id and type');
-      }
-    }
-
-    // Validate edges
-    if (!Array.isArray(workflow.edges)) {
-      throw new Error('Invalid workflow: edges must be an array');
-    }
-
-    for (const edge of workflow.edges) {
-      if (!edge.from || !edge.to) {
-        throw new Error('Invalid workflow: each edge must have from and to');
-      }
-    }
-
-    // Additional validation
-    const nodeIds = new Set(workflow.nodes.map(n => n.id));
-    for (const edge of workflow.edges) {
-      if (!nodeIds.has(edge.from)) {
-        throw new Error(`Invalid workflow: edge references unknown node '${edge.from}'`);
-      }
-      if (!nodeIds.has(edge.to)) {
-        throw new Error(`Invalid workflow: edge references unknown node '${edge.to}'`);
-      }
-    }
-  }
-
-  /**
-   * Creates a workflow from definition
-   * @param {string|object} definition - Path to file or workflow object
-   * @returns {Promise<object>} - Created workflow
-   */
-  async createWorkflow(definition) {
-    let workflow;
-
-    // Load from file if string path provided
-    if (typeof definition === 'string') {
-      try {
-        const content = await fs.readFile(definition, 'utf8');
-        workflow = JSON.parse(content);
-      } catch (error) {
-        if (error.code === 'ENOENT') {
-          throw new Error(`Definition file not found: ${definition}`);
-        }
-        if (error instanceof SyntaxError) {
-          throw new Error(`Invalid JSON in definition file: ${error.message}`);
-        }
-        throw error;
-      }
-    } else {
-      workflow = definition;
-    }
-
-    // Validate workflow
-    this.validateWorkflow(workflow);
-
-    // Save workflow
-    await fs.mkdir(this.workflowsDir, { recursive: true });
-    const workflowPath = path.join(this.workflowsDir, `${workflow.name}.json`);
-    await fs.writeFile(workflowPath, JSON.stringify(workflow, null, 2));
-
-    return { workflow, path: workflowPath };
-  }
-
-  /**
-   * Lists available workflows
-   * @returns {Promise<array>} - List of workflows
-   */
-  async listWorkflows() {
-    try {
-      const files = await fs.readdir(this.workflowsDir);
-      const workflows = [];
-
-      for (const file of files) {
-        if (file.endsWith('.json') && !file.startsWith('.')) {
-          const workflowPath = path.join(this.workflowsDir, file);
-          try {
-            const content = await fs.readFile(workflowPath, 'utf8');
-            const workflow = JSON.parse(content);
-            workflows.push({
-              name: workflow.name || path.basename(file, '.json'),
-              description: workflow.description || 'No description',
-              file: file,
-              nodes: workflow.nodes ? workflow.nodes.length : 0,
-              edges: workflow.edges ? workflow.edges.length : 0
-            });
-          } catch (error) {
-            // Skip invalid workflow files
-            continue;
-          }
-        }
-      }
-
-      return workflows;
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        return [];
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Loads a workflow by name
-   * @param {string} workflowName - Name of workflow
-   * @returns {Promise<object>} - Loaded workflow
-   */
-  async loadWorkflow(workflowName) {
-    const workflowPath = path.join(this.workflowsDir, `${workflowName}.json`);
-
-    try {
-      const content = await fs.readFile(workflowPath, 'utf8');
-      return JSON.parse(content);
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        throw new Error(`Workflow not found: ${workflowName}`);
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Saves workflow state
-   * @param {string} workflowName - Workflow name
-   * @param {object} state - State to save
-   * @returns {Promise<void>}
-   */
-  async saveState(workflowName, state) {
-    await fs.mkdir(this.stateDir, { recursive: true });
-    const statePath = path.join(this.stateDir, `${workflowName}.json`);
-    await fs.writeFile(statePath, JSON.stringify(state, null, 2));
-  }
-
-  /**
-   * Loads workflow state
-   * @param {string} workflowName - Workflow name
-   * @returns {Promise<object>} - Loaded state
-   */
-  async loadState(workflowName) {
-    const statePath = path.join(this.stateDir, `${workflowName}.json`);
-
-    try {
-      const content = await fs.readFile(statePath, 'utf8');
-      return JSON.parse(content);
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        throw new Error(`No saved state for workflow: ${workflowName}`);
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Creates workflow from template
-   * @param {string} templateName - Template to use
-   * @param {string} workflowName - Name for new workflow
-   * @returns {Promise<object>} - Created workflow
-   */
-  async createFromTemplate(templateName, workflowName) {
-    const template = TEMPLATES[templateName];
-
-    if (!template) {
-      throw new Error(`Template not found: ${templateName}`);
-    }
-
-    // Create workflow from template
-    const workflow = {
-      ...template,
-      name: workflowName,
-      createdFrom: templateName,
-      createdAt: new Date().toISOString()
-    };
-
-    // Use createWorkflow to save it
-    return this.createWorkflow(workflow);
-  }
-
-  /**
-   * Gets available templates
-   * @returns {array} - List of templates
-   */
-  getTemplates() {
-    return Object.entries(TEMPLATES).map(([name, template]) => ({
-      name: name,
-      description: template.description || 'No description',
-      nodes: template.nodes.length,
-      edges: template.edges.length
-    }));
-  }
-
-  /**
-   * Exports workflow as diagram
-   * @param {string} workflowName - Workflow to export
-   * @param {string} format - Export format
-   * @returns {Promise<string>} - Exported content
-   */
-  async exportWorkflow(workflowName, format = 'dot') {
-    const workflow = await this.loadWorkflow(workflowName);
-
-    switch (format) {
-      case 'dot':
-        return this.exportAsDot(workflow);
-      case 'mermaid':
-        return this.exportAsMermaid(workflow);
-      case 'json':
-        return JSON.stringify(workflow, null, 2);
-      default:
-        throw new Error(`Unsupported export format: ${format}`);
-    }
-  }
-
-  /**
-   * Exports workflow as Graphviz DOT
-   * @private
-   */
-  exportAsDot(workflow) {
-    let dot = 'digraph workflow {\n';
-    dot += '  rankdir=LR;\n';
-    dot += '  node [shape=box];\n\n';
-
-    // Add nodes
-    for (const node of workflow.nodes) {
-      dot += `  "${node.id}" [label="${node.id}\\n(${node.type})"];\n`;
-    }
-
-    dot += '\n';
-
-    // Add edges
-    for (const edge of workflow.edges) {
-      const label = edge.condition !== undefined ? ` [label="${edge.condition}"]` : '';
-      dot += `  "${edge.from}" -> "${edge.to}"${label};\n`;
-    }
-
-    dot += '}\n';
-    return dot;
-  }
-
-  /**
-   * Exports workflow as Mermaid diagram
-   * @private
-   */
-  exportAsMermaid(workflow) {
-    let mermaid = 'graph LR\n';
-
-    // Add nodes
-    for (const node of workflow.nodes) {
-      const shape = node.type === 'condition' ? '{{' + node.id + '}}' : '[' + node.id + ']';
-      mermaid += `  ${node.id}${shape}\n`;
-    }
-
-    // Add edges
-    for (const edge of workflow.edges) {
-      const label = edge.condition !== undefined ? `|${edge.condition}|` : '';
-      mermaid += `  ${edge.from} -->${label} ${edge.to}\n`;
-    }
-
-    return mermaid;
-  }
-
-  /**
-   * Simulates workflow execution
-   * @param {string} workflowName - Workflow to run
-   * @param {object} options - Execution options
-   * @returns {Promise<object>} - Execution result
-   */
-  async runWorkflow(workflowName, options = {}) {
-    const workflow = await this.loadWorkflow(workflowName);
-
-    // In dry-run mode, just simulate
-    if (options.dryRun) {
-      const result = {
-        dryRun: true,
-        workflow: workflow.name,
-        nodes: workflow.nodes.length,
-        edges: workflow.edges.length
-      };
-
-      // Simulate state saving for persistent nodes
-      if (workflow.nodes.some(n => n.persistent)) {
-        await this.saveState(workflowName, {
-          workflowId: workflowName,
-          currentNode: 'state',
-          data: { value: 'test' }
-        });
-      }
-
-      // Simulate uppercase transformation
-      if (workflow.nodes.some(n => n.operation === 'uppercase')) {
-        result.simulatedOutput = 'HELLO';
-      }
-
-      return result;
-    }
-
-    // Real execution would go here
-    // For now, just save state if needed
-    if (workflow.nodes.some(n => n.persistent)) {
-      await this.saveState(workflowName, {
-        workflowId: workflowName,
-        currentNode: 'complete',
-        data: { executed: true }
-      });
-    }
-
-    return {
-      executed: true,
-      workflow: workflow.name,
-      timestamp: new Date().toISOString()
-    };
-  }
-
-  /**
-   * Resumes workflow from saved state
-   * @param {string} workflowName - Workflow to resume
-   * @param {object} options - Resume options
-   * @returns {Promise<object>} - Resume result
-   */
-  async resumeWorkflow(workflowName, options = {}) {
-    const state = await this.loadState(workflowName);
-
-    if (options.dryRun) {
-      return {
-        resumed: true,
-        dryRun: true,
-        workflowId: state.workflowId,
-        currentNode: state.currentNode,
-        data: state.data
-      };
-    }
-
-    // Real resume would go here
-    return {
-      resumed: true,
-      state: state,
-      timestamp: new Date().toISOString()
-    };
-  }
-}
-
-module.exports = WorkflowManager;