Super Agentification
AI Agent Automation

// Data-Driven Pipeline Execution (proxy/server.js)
async executePipelineStages(pipeline, userContext, workingDir, ws) {
  const results = {};
  const stageMap = {};

  pipeline.stages.forEach(stage => stageMap[stage.id] = stage);

  let currentStageId = pipeline.stages[0]?.id;
  let executionCount = 0;
  const maxExecutions = 20; // Prevent infinite loops

  while (currentStageId && executionCount < maxExecutions) {
    const stage = stageMap[currentStageId];
    if (!stage) break;

    executionCount++;

    // Load agent configuration from JSON
    const agentPath = path.join(__dirname, '../agents', `${stage.agent}.json`);
    const agentConfig = JSON.parse(fs.readFileSync(agentPath, 'utf8'));
    let agentPrompt = agentConfig.systemPrompt;

    // Auto-inject decision instructions if stage has branches
    if (stage.decisions && stage.decisions.length > 0) {
      agentPrompt += '\n\nIMPORTANT: End with one of these:\n';
      stage.decisions.forEach(d => {
        agentPrompt += `- DECISION: ${d.choice} (${d.description})\n`;
      });
    }

    // Execute Claude agent
    const result = await this.executeClaudeWithMCP(
      stage.agent, agentPrompt, stageInput, workingDir
    );

    results[stage.id] = result;

    // Conditional routing based on agent decision
    currentStageId = this.determineNextStage(pipeline, stage.id, result);
  }

  return results;
}

// Conditional Flow - Decision Extraction & Routing
determineNextStage(pipeline, currentStageId, stageResult) {
  const connections = pipeline.flow?.connections || [];
  const fromConnections = connections.filter(
    conn => conn.from === currentStageId
  );

  if (fromConnections.length === 0) return null; // Pipeline ends

  // Extract "DECISION: VALUE" from agent output
  const decision = this.extractDecision(stageResult);

  // Match condition string against extracted decision
  for (const connection of fromConnections) {
    const condition = typeof connection.condition === 'object'
      ? connection.condition.value
      : connection.condition;

    // Auto-complete: plan_complete, execution_complete
    if (condition && condition.endsWith('_complete')) {
      return connection.to;
    }

    // Decision routing: APPROVED, REJECTED, etc.
    if (decision && condition &&
        decision.toUpperCase() === condition.toUpperCase()) {
      return connection.to;
    }
  }

  return fromConnections[0].to; // Default fallback
}