@stackmemoryai/stackmemory 1.12.0 → 1.14.0

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

@@ -1,387 +0,0 @@
-import { fileURLToPath as __fileURLToPath } from 'url';
-import { dirname as __pathDirname } from 'path';
-const __filename = __fileURLToPath(import.meta.url);
-const __dirname = __pathDirname(__filename);
-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-sonnet-4-5-20250929",
-      costPerToken: 3e-3,
-      // $3/1M input tokens
-      capabilities: [
-        "strategic_planning",
-        "complex_reasoning",
-        "task_decomposition",
-        "quality_review",
-        "error_correction"
-      ]
-    }
-  ],
-  worker: [
-    {
-      tier: "worker",
-      provider: "claude",
-      model: "claude-haiku-4-5-20251001",
-      costPerToken: 8e-4,
-      // $0.80/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
-};