@stackmemoryai/stackmemory 0.4.2 → 0.5.0

package/dist/integrations/ralph/patterns/oracle-worker-pattern.js

@@ -0,0 +1,384 @@
+import { v4 as uuidv4 } from "uuid";
+import { logger } from "../../../core/monitoring/logger.js";
+import { SwarmCoordinator } from "../swarm/swarm-coordinator.js";
+import { RalphStackMemoryBridge } from "../bridge/ralph-stackmemory-bridge.js";
+class OracleWorkerCoordinator extends SwarmCoordinator {
+  oracle;
+  workerPool;
+  reviewerPool;
+  costTracker;
+  constructor(config) {
+    super({
+      maxAgents: config.maxWorkers + 2,
+      // Workers + Oracle + Reviewer
+      coordinationInterval: config.coordinationInterval,
+      enableDynamicPlanning: true,
+      pathologicalBehaviorDetection: true
+    });
+    this.oracle = config.oracle;
+    this.workerPool = config.workers;
+    this.reviewerPool = config.reviewers;
+    this.costTracker = {
+      oracleSpent: 0,
+      workerSpent: 0,
+      reviewerSpent: 0,
+      totalBudget: config.costBudget || 10
+      // $10 default
+    };
+    logger.info("Oracle/Worker coordinator initialized", {
+      oracle: this.oracle.model,
+      workers: this.workerPool.length,
+      budget: this.costTracker.totalBudget
+    });
+  }
+  /**
+   * Launch swarm with Oracle/Worker pattern
+   */
+  async launchOracleWorkerSwarm(projectDescription, taskHints) {
+    logger.info("Launching Oracle/Worker swarm", {
+      project: projectDescription.substring(0, 100)
+    });
+    const oracleTaskId = await this.createOracleTask(
+      "project_planning",
+      projectDescription,
+      taskHints
+    );
+    const decomposition = await this.executeOracleTask(oracleTaskId);
+    const workerTasks = this.allocateTasksToWorkers(decomposition);
+    const workerPromises = workerTasks.map(
+      (task) => this.executeWorkerTask(task)
+    );
+    const reviewTaskId = await this.scheduleOracleReview(decomposition);
+    const [workerResults, reviewResult] = await Promise.all([
+      Promise.allSettled(workerPromises),
+      this.executeOracleTask(reviewTaskId)
+    ]);
+    const swarmId = await this.integrateResults(workerResults, reviewResult);
+    this.logCostAnalysis();
+    return swarmId;
+  }
+  /**
+   * Create planning task for Oracle
+   */
+  async createOracleTask(type, description, hints) {
+    const taskId = uuidv4();
+    const oraclePrompt = this.buildOraclePrompt(type, description, hints);
+    const estimatedTokens = this.estimateTokens(oraclePrompt);
+    logger.info("Oracle task created", {
+      taskId,
+      type,
+      estimatedTokens,
+      estimatedCost: estimatedTokens * this.oracle.costPerToken
+    });
+    return taskId;
+  }
+  /**
+   * Build specialized prompt for Oracle model
+   */
+  buildOraclePrompt(type, description, hints) {
+    const basePrompt = `
+# ORACLE ROLE: Strategic Planning & Coordination
+
+You are the Oracle in an Oracle/Worker pattern. Your role:
+- HIGH-LEVEL STRATEGIC thinking
+- TASK DECOMPOSITION for worker agents  
+- QUALITY CONTROL and review
+- COORDINATION between workers
+- ERROR CORRECTION and replanning
+
+## Project Context
+${description}
+
+${hints ? `## Hints & Context
+${hints.map((h) => `- ${h}`).join("\n")}` : ""}
+
+## Your Oracle Responsibilities
+1. **Decompose** this project into discrete, parallelizable tasks
+2. **Assign complexity levels** (low/medium/high) to guide worker selection
+3. **Define acceptance criteria** for each task
+4. **Identify dependencies** between tasks
+5. **Plan coordination touchpoints** for integration
+
+## Worker Constraints
+- Workers are smaller models optimized for focused execution
+- Workers excel at: implementation, testing, documentation, simple analysis
+- Workers struggle with: complex architecture, strategic decisions, cross-cutting concerns
+
+## Output Required
+Provide a detailed task decomposition in JSON format:
+
+\`\`\`json
+{
+  "project_summary": "Brief overview",
+  "task_decomposition": [
+    {
+      "id": "unique-id",
+      "title": "Task name",
+      "description": "Detailed description",
+      "complexity": "low|medium|high",
+      "type": "implementation|testing|documentation|analysis",
+      "estimated_effort": "1-5 scale",
+      "worker_requirements": ["specific capabilities needed"],
+      "acceptance_criteria": ["criterion 1", "criterion 2"],
+      "dependencies": ["task-id-1", "task-id-2"]
+    }
+  ],
+  "coordination_plan": {
+    "integration_points": ["When to sync between workers"],
+    "review_checkpoints": ["When Oracle should review progress"],
+    "risk_mitigation": ["Potential issues and solutions"]
+  }
+}
+\`\`\`
+
+Remember: Your intelligence is expensive. Focus on high-value strategic thinking that workers cannot do effectively.
+    `;
+    return basePrompt;
+  }
+  /**
+   * Execute Oracle task with high-end model
+   */
+  async executeOracleTask(taskId) {
+    logger.info("Executing Oracle task", { taskId });
+    const ralph = new RalphStackMemoryBridge({
+      baseDir: `.oracle/${taskId}`,
+      maxIterations: 3,
+      // Oracle should be efficient
+      useStackMemory: true
+    });
+    const result = await ralph.run();
+    const tokens = this.estimateTokens(result);
+    const cost = tokens * this.oracle.costPerToken;
+    this.costTracker.oracleSpent += cost;
+    logger.info("Oracle task completed", {
+      taskId,
+      tokensUsed: tokens,
+      cost: cost.toFixed(4)
+    });
+    return this.parseTaskDecomposition(result);
+  }
+  /**
+   * Allocate decomposed tasks to worker models
+   */
+  allocateTasksToWorkers(decomposition) {
+    const allocatedTasks = [];
+    for (const task of decomposition) {
+      const workerModel = this.selectWorkerForTask(task);
+      const workerPrompt = this.buildWorkerPrompt(task, workerModel);
+      allocatedTasks.push({
+        ...task,
+        assignedModel: "worker"
+      });
+      logger.debug("Task allocated to worker", {
+        taskId: task.id,
+        complexity: task.complexity,
+        worker: workerModel.model
+      });
+    }
+    return allocatedTasks;
+  }
+  /**
+   * Select optimal worker model for task complexity
+   */
+  selectWorkerForTask(task) {
+    if (task.complexity === "high") {
+      return this.workerPool[0];
+    } else {
+      return this.workerPool.reduce(
+        (cheapest, current) => current.costPerToken < cheapest.costPerToken ? current : cheapest
+      );
+    }
+  }
+  /**
+   * Build focused prompt for worker models
+   */
+  buildWorkerPrompt(task, worker) {
+    return `
+# WORKER ROLE: Focused Task Execution
+
+You are a specialized worker in an Oracle/Worker pattern.
+
+## Your Task
+${task.type}: ${task.title}
+
+${task.description}
+
+## Success Criteria
+${task.acceptanceCriteria.map((c) => `- ${c}`).join("\n")}
+
+## Worker Guidelines
+- FOCUS on this specific task only
+- IMPLEMENT according to the specifications provided
+- ASK for clarification if requirements are unclear
+- COMMUNICATE progress through shared context
+- COMPLETE the task efficiently without over-engineering
+
+## Constraints
+- You are optimized for execution, not planning
+- Stay within your assigned scope
+- Collaborate with other workers through shared context
+- The Oracle will handle integration and review
+
+Execute your task now.
+    `;
+  }
+  /**
+   * Execute worker task with cost tracking
+   */
+  async executeWorkerTask(task) {
+    logger.info("Executing worker task", {
+      taskId: task.id,
+      complexity: task.complexity
+    });
+    const ralph = new RalphStackMemoryBridge({
+      baseDir: `.workers/${task.id}`,
+      maxIterations: task.complexity === "low" ? 3 : 7,
+      useStackMemory: true
+    });
+    const result = await ralph.run();
+    const workerModel = this.selectWorkerForTask(task);
+    const tokens = this.estimateTokens(result);
+    const cost = tokens * workerModel.costPerToken;
+    this.costTracker.workerSpent += cost;
+    logger.info("Worker task completed", {
+      taskId: task.id,
+      tokensUsed: tokens,
+      cost: cost.toFixed(4)
+    });
+    return result;
+  }
+  /**
+   * Schedule Oracle review of worker progress
+   */
+  async scheduleOracleReview(decomposition) {
+    const reviewTaskId = uuidv4();
+    logger.info("Oracle review scheduled", {
+      reviewTaskId,
+      tasksToReview: decomposition.length
+    });
+    return reviewTaskId;
+  }
+  /**
+   * Integrate worker results under Oracle coordination
+   */
+  async integrateResults(workerResults, reviewResult) {
+    const swarmId = uuidv4();
+    const successfulTasks = workerResults.filter(
+      (result) => result.status === "fulfilled"
+    ).length;
+    logger.info("Integration completed", {
+      swarmId,
+      totalTasks: workerResults.length,
+      successfulTasks,
+      successRate: (successfulTasks / workerResults.length * 100).toFixed(1)
+    });
+    return swarmId;
+  }
+  /**
+   * Parse task decomposition from Oracle output
+   */
+  parseTaskDecomposition(output) {
+    return [];
+  }
+  /**
+   * Estimate token usage for cost calculation
+   */
+  estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+  }
+  /**
+   * Log cost analysis and efficiency metrics
+   */
+  logCostAnalysis() {
+    const total = this.costTracker.oracleSpent + this.costTracker.workerSpent + this.costTracker.reviewerSpent;
+    const savings = this.calculateTraditionalCost() - total;
+    logger.info("Oracle/Worker Cost Analysis", {
+      oracleSpent: `$${this.costTracker.oracleSpent.toFixed(4)}`,
+      workerSpent: `$${this.costTracker.workerSpent.toFixed(4)}`,
+      totalSpent: `$${total.toFixed(4)}`,
+      budgetUsed: `${(total / this.costTracker.totalBudget * 100).toFixed(1)}%`,
+      estimatedSavings: `$${savings.toFixed(4)}`,
+      efficiency: `${(this.costTracker.workerSpent / total * 100).toFixed(1)}% worker tasks`
+    });
+  }
+  /**
+   * Calculate what this would cost with all-Oracle approach
+   */
+  calculateTraditionalCost() {
+    const totalSpent = this.costTracker.oracleSpent + this.costTracker.workerSpent + this.costTracker.reviewerSpent;
+    const avgWorkerCost = this.workerPool[0]?.costPerToken || 1e-3;
+    const workerTokensAsOracle = this.costTracker.workerSpent / avgWorkerCost;
+    return this.costTracker.oracleSpent + workerTokensAsOracle * this.oracle.costPerToken;
+  }
+}
+const defaultModelConfigs = {
+  oracle: [
+    {
+      tier: "oracle",
+      provider: "claude",
+      model: "claude-3-opus-20240229",
+      costPerToken: 0.015,
+      // $15/1M input tokens
+      capabilities: [
+        "strategic_planning",
+        "complex_reasoning",
+        "task_decomposition",
+        "quality_review",
+        "error_correction"
+      ]
+    }
+  ],
+  worker: [
+    {
+      tier: "worker",
+      provider: "claude",
+      model: "claude-3-haiku-20240307",
+      costPerToken: 25e-5,
+      // $0.25/1M input tokens
+      capabilities: [
+        "code_implementation",
+        "unit_testing",
+        "documentation",
+        "simple_analysis",
+        "data_processing"
+      ]
+    },
+    {
+      tier: "worker",
+      provider: "openai",
+      model: "gpt-4o-mini",
+      costPerToken: 15e-5,
+      // $0.15/1M input tokens  
+      capabilities: [
+        "rapid_prototyping",
+        "script_writing",
+        "basic_testing",
+        "formatting",
+        "simple_refactoring"
+      ]
+    }
+  ],
+  reviewer: [
+    {
+      tier: "reviewer",
+      provider: "claude",
+      model: "claude-3-sonnet-20240229",
+      costPerToken: 3e-3,
+      // $3/1M input tokens
+      capabilities: [
+        "code_review",
+        "quality_assessment",
+        "integration_testing",
+        "performance_analysis",
+        "security_review"
+      ]
+    }
+  ]
+};
+var oracle_worker_pattern_default = OracleWorkerCoordinator;
+export {
+  OracleWorkerCoordinator,
+  oracle_worker_pattern_default as default,
+  defaultModelConfigs
+};
+//# sourceMappingURL=oracle-worker-pattern.js.map

package/dist/integrations/ralph/patterns/oracle-worker-pattern.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/integrations/ralph/patterns/oracle-worker-pattern.ts"],
+  "sourcesContent": ["/**\n * Oracle/Worker Pattern Implementation for StackMemory Swarms\n * \n * Uses high-end model (Oracle) for planning, review, and coordination\n * Uses smaller models (Workers) for task execution and implementation\n * \n * Cost-effective scaling: Intelligence where needed, efficiency for execution\n */\n\nimport { v4 as uuidv4 } from 'uuid';\nimport { logger } from '../../../core/monitoring/logger.js';\nimport { SwarmCoordinator } from '../swarm/swarm-coordinator.js';\nimport { RalphStackMemoryBridge } from '../bridge/ralph-stackmemory-bridge.js';\n\n// Model tiers based on capability and cost\nexport type ModelTier = 'oracle' | 'worker' | 'reviewer';\n\nexport interface ModelConfig {\n  tier: ModelTier;\n  provider: 'claude' | 'openai' | 'anthropic';\n  model: string;\n  costPerToken: number;\n  capabilities: string[];\n}\n\nexport interface OracleWorkerConfig {\n  oracle: ModelConfig;\n  workers: ModelConfig[];\n  reviewers: ModelConfig[];\n  maxWorkers: number;\n  coordinationInterval: number;\n  costBudget?: number;\n}\n\nexport interface TaskDecomposition {\n  id: string;\n  type: 'planning' | 'implementation' | 'review' | 'coordination';\n  priority: number;\n  complexity: 'low' | 'medium' | 'high';\n  estimatedTokens: number;\n  assignedModel: ModelTier;\n  dependencies: string[];\n  acceptanceCriteria: string[];\n}\n\n/**\n * Oracle/Worker Pattern Coordinator\n * Implements cost-effective multi-model orchestration\n */\nexport class OracleWorkerCoordinator extends SwarmCoordinator {\n  private oracle: ModelConfig;\n  private workerPool: ModelConfig[];\n  private reviewerPool: ModelConfig[];\n  private costTracker: {\n    oracleSpent: number;\n    workerSpent: number;\n    reviewerSpent: number;\n    totalBudget: number;\n  };\n  \n  constructor(config: OracleWorkerConfig) {\n    super({\n      maxAgents: config.maxWorkers + 2, // Workers + Oracle + Reviewer\n      coordinationInterval: config.coordinationInterval,\n      enableDynamicPlanning: true,\n      pathologicalBehaviorDetection: true,\n    });\n\n    this.oracle = config.oracle;\n    this.workerPool = config.workers;\n    this.reviewerPool = config.reviewers;\n    \n    this.costTracker = {\n      oracleSpent: 0,\n      workerSpent: 0,\n      reviewerSpent: 0,\n      totalBudget: config.costBudget || 10.0, // $10 default\n    };\n\n    logger.info('Oracle/Worker coordinator initialized', {\n      oracle: this.oracle.model,\n      workers: this.workerPool.length,\n      budget: this.costTracker.totalBudget,\n    });\n  }\n\n  /**\n   * Launch swarm with Oracle/Worker pattern\n   */\n  async launchOracleWorkerSwarm(\n    projectDescription: string,\n    taskHints?: string[]\n  ): Promise<string> {\n    logger.info('Launching Oracle/Worker swarm', {\n      project: projectDescription.substring(0, 100),\n    });\n\n    // Phase 1: Oracle Planning\n    const oracleTaskId = await this.createOracleTask(\n      'project_planning',\n      projectDescription,\n      taskHints\n    );\n    \n    const decomposition = await this.executeOracleTask(oracleTaskId);\n    \n    // Phase 2: Worker Assignment\n    const workerTasks = this.allocateTasksToWorkers(decomposition);\n    \n    // Phase 3: Parallel Worker Execution\n    const workerPromises = workerTasks.map(task => \n      this.executeWorkerTask(task)\n    );\n    \n    // Phase 4: Oracle Review & Coordination\n    const reviewTaskId = await this.scheduleOracleReview(decomposition);\n    \n    // Execute workers in parallel, oracle coordinates\n    const [workerResults, reviewResult] = await Promise.all([\n      Promise.allSettled(workerPromises),\n      this.executeOracleTask(reviewTaskId)\n    ]);\n\n    // Phase 5: Final Integration\n    const swarmId = await this.integrateResults(workerResults, reviewResult);\n    \n    this.logCostAnalysis();\n    return swarmId;\n  }\n\n  /**\n   * Create planning task for Oracle\n   */\n  private async createOracleTask(\n    type: string,\n    description: string,\n    hints?: string[]\n  ): Promise<string> {\n    const taskId = uuidv4();\n    \n    const oraclePrompt = this.buildOraclePrompt(type, description, hints);\n    const estimatedTokens = this.estimateTokens(oraclePrompt);\n    \n    logger.info('Oracle task created', {\n      taskId,\n      type,\n      estimatedTokens,\n      estimatedCost: estimatedTokens * this.oracle.costPerToken,\n    });\n\n    return taskId;\n  }\n\n  /**\n   * Build specialized prompt for Oracle model\n   */\n  private buildOraclePrompt(\n    type: string,\n    description: string,\n    hints?: string[]\n  ): string {\n    const basePrompt = `\n# ORACLE ROLE: Strategic Planning & Coordination\n\nYou are the Oracle in an Oracle/Worker pattern. Your role:\n- HIGH-LEVEL STRATEGIC thinking\n- TASK DECOMPOSITION for worker agents  \n- QUALITY CONTROL and review\n- COORDINATION between workers\n- ERROR CORRECTION and replanning\n\n## Project Context\n${description}\n\n${hints ? `## Hints & Context\\n${hints.map(h => `- ${h}`).join('\\n')}` : ''}\n\n## Your Oracle Responsibilities\n1. **Decompose** this project into discrete, parallelizable tasks\n2. **Assign complexity levels** (low/medium/high) to guide worker selection\n3. **Define acceptance criteria** for each task\n4. **Identify dependencies** between tasks\n5. **Plan coordination touchpoints** for integration\n\n## Worker Constraints\n- Workers are smaller models optimized for focused execution\n- Workers excel at: implementation, testing, documentation, simple analysis\n- Workers struggle with: complex architecture, strategic decisions, cross-cutting concerns\n\n## Output Required\nProvide a detailed task decomposition in JSON format:\n\n\\`\\`\\`json\n{\n  \"project_summary\": \"Brief overview\",\n  \"task_decomposition\": [\n    {\n      \"id\": \"unique-id\",\n      \"title\": \"Task name\",\n      \"description\": \"Detailed description\",\n      \"complexity\": \"low|medium|high\",\n      \"type\": \"implementation|testing|documentation|analysis\",\n      \"estimated_effort\": \"1-5 scale\",\n      \"worker_requirements\": [\"specific capabilities needed\"],\n      \"acceptance_criteria\": [\"criterion 1\", \"criterion 2\"],\n      \"dependencies\": [\"task-id-1\", \"task-id-2\"]\n    }\n  ],\n  \"coordination_plan\": {\n    \"integration_points\": [\"When to sync between workers\"],\n    \"review_checkpoints\": [\"When Oracle should review progress\"],\n    \"risk_mitigation\": [\"Potential issues and solutions\"]\n  }\n}\n\\`\\`\\`\n\nRemember: Your intelligence is expensive. Focus on high-value strategic thinking that workers cannot do effectively.\n    `;\n\n    return basePrompt;\n  }\n\n  /**\n   * Execute Oracle task with high-end model\n   */\n  private async executeOracleTask(taskId: string): Promise<TaskDecomposition[]> {\n    logger.info('Executing Oracle task', { taskId });\n    \n    // Create Ralph loop with Oracle model configuration\n    const ralph = new RalphStackMemoryBridge({\n      baseDir: `.oracle/${taskId}`,\n      maxIterations: 3, // Oracle should be efficient\n      useStackMemory: true,\n    });\n\n    // Execute with Oracle model (implementation would integrate with actual model APIs)\n    const result = await ralph.run();\n    \n    // Track Oracle costs\n    const tokens = this.estimateTokens(result);\n    const cost = tokens * this.oracle.costPerToken;\n    this.costTracker.oracleSpent += cost;\n    \n    logger.info('Oracle task completed', {\n      taskId,\n      tokensUsed: tokens,\n      cost: cost.toFixed(4),\n    });\n\n    return this.parseTaskDecomposition(result);\n  }\n\n  /**\n   * Allocate decomposed tasks to worker models\n   */\n  private allocateTasksToWorkers(\n    decomposition: TaskDecomposition[]\n  ): TaskDecomposition[] {\n    const allocatedTasks: TaskDecomposition[] = [];\n\n    for (const task of decomposition) {\n      // Select optimal worker model based on task complexity\n      const workerModel = this.selectWorkerForTask(task);\n      \n      // Create worker-specific prompt\n      const workerPrompt = this.buildWorkerPrompt(task, workerModel);\n      \n      allocatedTasks.push({\n        ...task,\n        assignedModel: 'worker' as ModelTier,\n      });\n\n      logger.debug('Task allocated to worker', {\n        taskId: task.id,\n        complexity: task.complexity,\n        worker: workerModel.model,\n      });\n    }\n\n    return allocatedTasks;\n  }\n\n  /**\n   * Select optimal worker model for task complexity\n   */\n  private selectWorkerForTask(task: TaskDecomposition): ModelConfig {\n    // Simple allocation strategy - can be enhanced\n    if (task.complexity === 'high') {\n      // Use best available worker for complex tasks\n      return this.workerPool[0];\n    } else {\n      // Use cheapest worker for simple tasks\n      return this.workerPool.reduce((cheapest, current) => \n        current.costPerToken < cheapest.costPerToken ? current : cheapest\n      );\n    }\n  }\n\n  /**\n   * Build focused prompt for worker models\n   */\n  private buildWorkerPrompt(\n    task: TaskDecomposition,\n    worker: ModelConfig\n  ): string {\n    return `\n# WORKER ROLE: Focused Task Execution\n\nYou are a specialized worker in an Oracle/Worker pattern.\n\n## Your Task\n${task.type}: ${task.title}\n\n${task.description}\n\n## Success Criteria\n${task.acceptanceCriteria.map(c => `- ${c}`).join('\\n')}\n\n## Worker Guidelines\n- FOCUS on this specific task only\n- IMPLEMENT according to the specifications provided\n- ASK for clarification if requirements are unclear\n- COMMUNICATE progress through shared context\n- COMPLETE the task efficiently without over-engineering\n\n## Constraints\n- You are optimized for execution, not planning\n- Stay within your assigned scope\n- Collaborate with other workers through shared context\n- The Oracle will handle integration and review\n\nExecute your task now.\n    `;\n  }\n\n  /**\n   * Execute worker task with cost tracking\n   */\n  private async executeWorkerTask(task: TaskDecomposition): Promise<any> {\n    logger.info('Executing worker task', { \n      taskId: task.id,\n      complexity: task.complexity \n    });\n\n    const ralph = new RalphStackMemoryBridge({\n      baseDir: `.workers/${task.id}`,\n      maxIterations: task.complexity === 'low' ? 3 : 7,\n      useStackMemory: true,\n    });\n\n    const result = await ralph.run();\n    \n    // Track worker costs\n    const workerModel = this.selectWorkerForTask(task);\n    const tokens = this.estimateTokens(result);\n    const cost = tokens * workerModel.costPerToken;\n    this.costTracker.workerSpent += cost;\n\n    logger.info('Worker task completed', {\n      taskId: task.id,\n      tokensUsed: tokens,\n      cost: cost.toFixed(4),\n    });\n\n    return result;\n  }\n\n  /**\n   * Schedule Oracle review of worker progress\n   */\n  private async scheduleOracleReview(\n    decomposition: TaskDecomposition[]\n  ): Promise<string> {\n    const reviewTaskId = uuidv4();\n    \n    // Oracle reviews worker outputs and coordinates integration\n    logger.info('Oracle review scheduled', { \n      reviewTaskId,\n      tasksToReview: decomposition.length \n    });\n\n    return reviewTaskId;\n  }\n\n  /**\n   * Integrate worker results under Oracle coordination\n   */\n  private async integrateResults(\n    workerResults: PromiseSettledResult<any>[],\n    reviewResult: any\n  ): Promise<string> {\n    const swarmId = uuidv4();\n    \n    const successfulTasks = workerResults.filter(\n      result => result.status === 'fulfilled'\n    ).length;\n\n    logger.info('Integration completed', {\n      swarmId,\n      totalTasks: workerResults.length,\n      successfulTasks,\n      successRate: (successfulTasks / workerResults.length * 100).toFixed(1),\n    });\n\n    return swarmId;\n  }\n\n  /**\n   * Parse task decomposition from Oracle output\n   */\n  private parseTaskDecomposition(output: string): TaskDecomposition[] {\n    // Parse JSON from Oracle output\n    // Implementation would extract the JSON task decomposition\n    return [];\n  }\n\n  /**\n   * Estimate token usage for cost calculation\n   */\n  private estimateTokens(text: string): number {\n    // Rough estimation: ~4 characters per token\n    return Math.ceil(text.length / 4);\n  }\n\n  /**\n   * Log cost analysis and efficiency metrics\n   */\n  private logCostAnalysis(): void {\n    const total = this.costTracker.oracleSpent + \n                 this.costTracker.workerSpent + \n                 this.costTracker.reviewerSpent;\n\n    const savings = this.calculateTraditionalCost() - total;\n\n    logger.info('Oracle/Worker Cost Analysis', {\n      oracleSpent: `$${this.costTracker.oracleSpent.toFixed(4)}`,\n      workerSpent: `$${this.costTracker.workerSpent.toFixed(4)}`,\n      totalSpent: `$${total.toFixed(4)}`,\n      budgetUsed: `${(total / this.costTracker.totalBudget * 100).toFixed(1)}%`,\n      estimatedSavings: `$${savings.toFixed(4)}`,\n      efficiency: `${(this.costTracker.workerSpent / total * 100).toFixed(1)}% worker tasks`,\n    });\n  }\n\n  /**\n   * Calculate what this would cost with all-Oracle approach\n   */\n  private calculateTraditionalCost(): number {\n    const totalSpent = this.costTracker.oracleSpent + \n                      this.costTracker.workerSpent + \n                      this.costTracker.reviewerSpent;\n    \n    // Estimate if everything was done with Oracle model\n    const avgWorkerCost = this.workerPool[0]?.costPerToken || 0.001;\n    const workerTokensAsOracle = this.costTracker.workerSpent / avgWorkerCost;\n    \n    return this.costTracker.oracleSpent + \n           (workerTokensAsOracle * this.oracle.costPerToken);\n  }\n}\n\n/**\n * Default model configurations for Oracle/Worker pattern\n */\nexport const defaultModelConfigs: Record<ModelTier, ModelConfig[]> = {\n  oracle: [\n    {\n      tier: 'oracle',\n      provider: 'claude',\n      model: 'claude-3-opus-20240229',\n      costPerToken: 0.015, // $15/1M input tokens\n      capabilities: [\n        'strategic_planning',\n        'complex_reasoning',\n        'task_decomposition',\n        'quality_review',\n        'error_correction'\n      ]\n    }\n  ],\n  \n  worker: [\n    {\n      tier: 'worker',\n      provider: 'claude', \n      model: 'claude-3-haiku-20240307',\n      costPerToken: 0.00025, // $0.25/1M input tokens\n      capabilities: [\n        'code_implementation',\n        'unit_testing',\n        'documentation',\n        'simple_analysis',\n        'data_processing'\n      ]\n    },\n    {\n      tier: 'worker',\n      provider: 'openai',\n      model: 'gpt-4o-mini',\n      costPerToken: 0.00015, // $0.15/1M input tokens  \n      capabilities: [\n        'rapid_prototyping',\n        'script_writing',\n        'basic_testing',\n        'formatting',\n        'simple_refactoring'\n      ]\n    }\n  ],\n\n  reviewer: [\n    {\n      tier: 'reviewer',\n      provider: 'claude',\n      model: 'claude-3-sonnet-20240229', \n      costPerToken: 0.003, // $3/1M input tokens\n      capabilities: [\n        'code_review',\n        'quality_assessment',\n        'integration_testing',\n        'performance_analysis',\n        'security_review'\n      ]\n    }\n  ]\n};\n\nexport default OracleWorkerCoordinator;"],
+  "mappings": "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",
+  "names": []
+}

package/dist/integrations/ralph/swarm/git-workflow-manager.js

@@ -28,16 +28,38 @@ class GitWorkflowManager {
    */
   async initializeAgentWorkflow(agent, task) {
     if (!this.config.enableGitWorkflow) return;
-    const branchName = this.generateBranchName(agent, task);
+    let branchName = this.generateBranchName(agent, task);
     try {
-      this.createBranch(branchName);
+      if (this.branchExists(branchName)) {
+        const existingHasChanges = this.branchHasUnmergedChanges(branchName);
+        if (existingHasChanges) {
+          const timestamp = Date.now();
+          branchName = `${branchName}-${timestamp}`;
+          logger.info(
+            `Branch already exists with changes, creating unique branch: ${branchName}`
+          );
+          this.createBranch(branchName);
+        } else {
+          logger.info(
+            `Reusing existing branch for agent ${agent.role}: ${branchName}`
+          );
+          this.checkoutBranch(branchName);
+        }
+      } else {
+        this.createBranch(branchName);
+        logger.info(
+          `Created git branch for agent ${agent.role}: ${branchName}`
+        );
+      }
       this.agentBranches.set(agent.id, branchName);
-      logger.info(`Created git branch for agent ${agent.role}: ${branchName}`);
       if (this.config.autoCommit) {
         this.scheduleAutoCommit(agent, task);
       }
     } catch (error) {
-      logger.error(`Failed to initialize git workflow for agent ${agent.role}`, error);
+      logger.error(
+        `Failed to initialize git workflow for agent ${agent.role}`,
+        error
+      );
     }
   }
   /**
@@ -122,7 +144,9 @@ class GitWorkflowManager {
       this.mergeBranch(integrationBranch);
       logger.info("Successfully integrated all agent work");
     } else {
-      logger.warn("Integration tests failed, keeping changes in branch: " + integrationBranch);
+      logger.warn(
+        "Integration tests failed, keeping changes in branch: " + integrationBranch
+      );
     }
   }
   /**
@@ -131,7 +155,9 @@ class GitWorkflowManager {
   async resolveConflicts(agent) {
     const conflicts = this.getConflictedFiles();
     if (conflicts.length === 0) return;
-    logger.warn(`Agent ${agent.role} encountering merge conflicts: ${conflicts.join(", ")}`);
+    logger.warn(
+      `Agent ${agent.role} encountering merge conflicts: ${conflicts.join(", ")}`
+    );
     for (const file of conflicts) {
       try {
         if (this.isAgentFile(file, agent)) {
@@ -150,12 +176,16 @@ class GitWorkflowManager {
       execSync("git commit --no-edit", { encoding: "utf8" });
       logger.info("All conflicts resolved automatically");
     } else {
-      logger.error(`Manual intervention needed for: ${remainingConflicts.join(", ")}`);
+      logger.error(
+        `Manual intervention needed for: ${remainingConflicts.join(", ")}`
+      );
     }
   }
   // Private helper methods
   getCurrentBranch() {
-    return execSync("git rev-parse --abbrev-ref HEAD", { encoding: "utf8" }).trim();
+    return execSync("git rev-parse --abbrev-ref HEAD", {
+      encoding: "utf8"
+    }).trim();
   }
   getMainBranch() {
     try {
@@ -207,7 +237,9 @@ class GitWorkflowManager {
     switch (strategy) {
       case "squash":
         execSync(`git merge --squash ${branchName}`, { encoding: "utf8" });
-        execSync('git commit -m "Squashed agent changes"', { encoding: "utf8" });
+        execSync('git commit -m "Squashed agent changes"', {
+          encoding: "utf8"
+        });
         break;
       case "rebase":
         execSync(`git rebase ${branchName}`, { encoding: "utf8" });
@@ -249,7 +281,11 @@ class GitWorkflowManager {
   scheduleAutoCommit(agent, task) {
     const intervalMs = this.config.commitFrequency * 60 * 1e3;
     setInterval(async () => {
-      await this.commitAgentWork(agent, task, `[${agent.role}] Auto-commit: ${task.title}`);
+      await this.commitAgentWork(
+        agent,
+        task,
+        `[${agent.role}] Auto-commit: ${task.title}`
+      );
     }, intervalMs);
   }
   async createPullRequest(agent, task, branchName) {
@@ -268,9 +304,12 @@ ${task.acceptanceCriteria.map((c) => `- ${c}`).join("\n")}
 
 Generated by Swarm Coordinator
       `;
-      execSync(`gh pr create --title "${title}" --body "${body}" --base ${this.baselineBranch}`, {
-        encoding: "utf8"
-      });
+      execSync(
+        `gh pr create --title "${title}" --body "${body}" --base ${this.baselineBranch}`,
+        {
+          encoding: "utf8"
+        }
+      );
       logger.info(`Created PR for agent ${agent.role}`);
     } catch (error) {
       logger.warn(`Could not create PR: ${error}`);
@@ -284,6 +323,18 @@ Generated by Swarm Coordinator
       return false;
     }
   }
+  branchHasUnmergedChanges(branchName) {
+    try {
+      const currentBranch = this.getCurrentBranch();
+      const unmerged = execSync(
+        `git log ${currentBranch}..${branchName} --oneline`,
+        { encoding: "utf8", stdio: "pipe" }
+      );
+      return unmerged.trim().length > 0;
+    } catch {
+      return true;
+    }
+  }
   /**
    * Get status of all agent branches
    */
@@ -291,11 +342,13 @@ Generated by Swarm Coordinator
     const status = {
       enabled: this.config.enableGitWorkflow,
       currentBranch: this.getCurrentBranch(),
-      agentBranches: Array.from(this.agentBranches.entries()).map(([agentId, branch]) => ({
-        agentId,
-        branch,
-        exists: this.branchExists(branch)
-      })),
+      agentBranches: Array.from(this.agentBranches.entries()).map(
+        ([agentId, branch]) => ({
+          agentId,
+          branch,
+          exists: this.branchExists(branch)
+        })
+      ),
       hasUncommittedChanges: this.hasUncommittedChanges()
     };
     return status;