@stackmemoryai/stackmemory 0.3.22 → 0.3.24

package/dist/integrations/ralph/context/context-budget-manager.js

@@ -0,0 +1,297 @@
+import { logger } from "../../../core/monitoring/logger.js";
+class ContextBudgetManager {
+  config;
+  tokenUsage = /* @__PURE__ */ new Map();
+  DEFAULT_MAX_TOKENS = 4e3;
+  TOKEN_CHAR_RATIO = 0.25;
+  // Rough estimate: 1 token ≈ 4 chars
+  constructor(config) {
+    this.config = {
+      maxTokens: config?.maxTokens || this.DEFAULT_MAX_TOKENS,
+      priorityWeights: {
+        task: config?.priorityWeights?.task || 0.3,
+        recentWork: config?.priorityWeights?.recentWork || 0.25,
+        feedback: config?.priorityWeights?.feedback || 0.2,
+        gitHistory: config?.priorityWeights?.gitHistory || 0.15,
+        dependencies: config?.priorityWeights?.dependencies || 0.1
+      },
+      compressionEnabled: config?.compressionEnabled ?? true,
+      adaptiveBudgeting: config?.adaptiveBudgeting ?? true
+    };
+  }
+  /**
+   * Estimate tokens for a given text
+   */
+  estimateTokens(text) {
+    if (!text) return 0;
+    const baseTokens = text.length * this.TOKEN_CHAR_RATIO;
+    const codeMultiplier = this.detectCodeContent(text) ? 1.2 : 1;
+    const jsonMultiplier = this.detectJsonContent(text) ? 0.9 : 1;
+    return Math.ceil(baseTokens * codeMultiplier * jsonMultiplier);
+  }
+  /**
+   * Allocate token budget across different context categories
+   */
+  allocateBudget(context) {
+    const currentTokens = this.calculateCurrentTokens(context);
+    if (currentTokens <= this.config.maxTokens) {
+      logger.debug("Context within budget", {
+        used: currentTokens,
+        max: this.config.maxTokens
+      });
+      return context;
+    }
+    logger.info("Context exceeds budget, optimizing...", {
+      current: currentTokens,
+      max: this.config.maxTokens
+    });
+    if (this.config.adaptiveBudgeting) {
+      return this.adaptiveBudgetAllocation(context, currentTokens);
+    }
+    return this.priorityBasedAllocation(context, currentTokens);
+  }
+  /**
+   * Compress context to fit within budget
+   */
+  compressContext(context) {
+    if (!this.config.compressionEnabled) {
+      return context;
+    }
+    const compressed = {
+      ...context,
+      task: this.compressTaskContext(context.task),
+      history: this.compressHistoryContext(context.history),
+      environment: this.compressEnvironmentContext(context.environment),
+      memory: this.compressMemoryContext(context.memory),
+      tokenCount: 0
+    };
+    compressed.tokenCount = this.calculateCurrentTokens(compressed);
+    logger.debug("Context compressed", {
+      original: context.tokenCount,
+      compressed: compressed.tokenCount,
+      reduction: `${Math.round((1 - compressed.tokenCount / context.tokenCount) * 100)}%`
+    });
+    return compressed;
+  }
+  /**
+   * Get current token usage statistics
+   */
+  getUsage() {
+    const categories = {};
+    let totalUsed = 0;
+    for (const [category, tokens] of this.tokenUsage) {
+      categories[category] = tokens;
+      totalUsed += tokens;
+    }
+    return {
+      used: totalUsed,
+      available: this.config.maxTokens - totalUsed,
+      categories
+    };
+  }
+  /**
+   * Calculate current token count for context
+   */
+  calculateCurrentTokens(context) {
+    this.tokenUsage.clear();
+    const taskTokens = this.estimateTokens(JSON.stringify(context.task));
+    const historyTokens = this.estimateTokens(JSON.stringify(context.history));
+    const envTokens = this.estimateTokens(JSON.stringify(context.environment));
+    const memoryTokens = this.estimateTokens(JSON.stringify(context.memory));
+    this.tokenUsage.set("task", taskTokens);
+    this.tokenUsage.set("history", historyTokens);
+    this.tokenUsage.set("environment", envTokens);
+    this.tokenUsage.set("memory", memoryTokens);
+    return taskTokens + historyTokens + envTokens + memoryTokens;
+  }
+  /**
+   * Adaptive budget allocation based on iteration phase
+   */
+  adaptiveBudgetAllocation(context, currentTokens) {
+    const reductionRatio = this.config.maxTokens / currentTokens;
+    const phase = this.determinePhase(context.task.currentIteration);
+    const adjustedWeights = this.getPhaseAdjustedWeights(phase);
+    return this.applyWeightedReduction(context, reductionRatio, adjustedWeights);
+  }
+  /**
+   * Priority-based allocation using fixed weights
+   */
+  priorityBasedAllocation(context, currentTokens) {
+    const reductionRatio = this.config.maxTokens / currentTokens;
+    return this.applyWeightedReduction(context, reductionRatio, this.config.priorityWeights);
+  }
+  /**
+   * Apply weighted reduction to context
+   */
+  applyWeightedReduction(context, reductionRatio, weights) {
+    const reduced = { ...context };
+    if (weights.recentWork < 1) {
+      const keepCount = Math.ceil(
+        context.history.recentIterations.length * reductionRatio * weights.recentWork
+      );
+      reduced.history = {
+        ...context.history,
+        recentIterations: context.history.recentIterations.slice(-keepCount)
+      };
+    }
+    if (weights.gitHistory < 1) {
+      const keepCount = Math.ceil(
+        context.history.gitCommits.length * reductionRatio * weights.gitHistory
+      );
+      reduced.history.gitCommits = context.history.gitCommits.slice(-keepCount);
+    }
+    if (weights.dependencies < 1) {
+      const keepCount = Math.ceil(
+        context.memory.relevantFrames.length * reductionRatio * weights.dependencies
+      );
+      reduced.memory = {
+        ...context.memory,
+        relevantFrames: context.memory.relevantFrames.sort((a, b) => (b.created_at || 0) - (a.created_at || 0)).slice(0, keepCount)
+      };
+    }
+    reduced.tokenCount = this.calculateCurrentTokens(reduced);
+    return reduced;
+  }
+  /**
+   * Compress task context
+   */
+  compressTaskContext(task) {
+    return {
+      ...task,
+      description: this.truncateWithEllipsis(task.description, 500),
+      criteria: task.criteria.slice(0, 5),
+      // Keep top 5 criteria
+      feedback: task.feedback ? this.truncateWithEllipsis(task.feedback, 300) : void 0
+    };
+  }
+  /**
+   * Compress history context
+   */
+  compressHistoryContext(history) {
+    return {
+      ...history,
+      recentIterations: history.recentIterations.slice(-5).map((iter) => ({
+        ...iter,
+        summary: this.truncateWithEllipsis(iter.summary, 100)
+      })),
+      gitCommits: history.gitCommits.slice(-10).map((commit) => ({
+        ...commit,
+        message: this.truncateWithEllipsis(commit.message, 80),
+        files: commit.files.slice(0, 5)
+        // Keep top 5 files
+      })),
+      changedFiles: history.changedFiles.slice(0, 20),
+      // Keep top 20 files
+      testResults: history.testResults.slice(-3)
+      // Keep last 3 test runs
+    };
+  }
+  /**
+   * Compress environment context
+   */
+  compressEnvironmentContext(env) {
+    return {
+      ...env,
+      dependencies: this.compressObject(env.dependencies, 20),
+      // Keep top 20 deps
+      configuration: this.compressObject(env.configuration, 10)
+      // Keep top 10 config items
+    };
+  }
+  /**
+   * Compress memory context
+   */
+  compressMemoryContext(memory) {
+    return {
+      ...memory,
+      relevantFrames: memory.relevantFrames.slice(0, 5),
+      // Keep top 5 frames
+      decisions: memory.decisions.filter((d) => d.impact !== "low").slice(-5),
+      // Keep last 5
+      patterns: memory.patterns.filter((p) => p.successRate > 0.7).slice(0, 3),
+      // Keep top 3
+      blockers: memory.blockers.filter((b) => !b.resolved)
+      // Keep unresolved only
+    };
+  }
+  /**
+   * Determine iteration phase
+   */
+  determinePhase(iteration) {
+    if (iteration <= 3) return "early";
+    if (iteration <= 10) return "middle";
+    return "late";
+  }
+  /**
+   * Get phase-adjusted weights
+   */
+  getPhaseAdjustedWeights(phase) {
+    switch (phase) {
+      case "early":
+        return {
+          task: 0.4,
+          recentWork: 0.1,
+          feedback: 0.2,
+          gitHistory: 0.2,
+          dependencies: 0.1
+        };
+      case "middle":
+        return this.config.priorityWeights;
+      case "late":
+        return {
+          task: 0.2,
+          recentWork: 0.35,
+          feedback: 0.25,
+          gitHistory: 0.15,
+          dependencies: 0.05
+        };
+    }
+  }
+  /**
+   * Detect if text contains code
+   */
+  detectCodeContent(text) {
+    const codePatterns = [
+      /function\s+\w+\s*\(/,
+      /class\s+\w+/,
+      /const\s+\w+\s*=/,
+      /import\s+.*from/,
+      /\{[\s\S]*\}/
+    ];
+    return codePatterns.some((pattern) => pattern.test(text));
+  }
+  /**
+   * Detect if text contains JSON
+   */
+  detectJsonContent(text) {
+    try {
+      JSON.parse(text);
+      return true;
+    } catch {
+      return text.includes('"') && text.includes(":") && text.includes("{");
+    }
+  }
+  /**
+   * Truncate text with ellipsis
+   */
+  truncateWithEllipsis(text, maxLength) {
+    if (text.length <= maxLength) return text;
+    return text.substring(0, maxLength - 3) + "...";
+  }
+  /**
+   * Compress object by keeping only top N entries
+   */
+  compressObject(obj, maxEntries) {
+    const entries = Object.entries(obj);
+    if (entries.length <= maxEntries) return obj;
+    const compressed = {};
+    entries.slice(0, maxEntries).forEach(([key, value]) => {
+      compressed[key] = value;
+    });
+    return compressed;
+  }
+}
+export {
+  ContextBudgetManager
+};
+//# sourceMappingURL=context-budget-manager.js.map

package/dist/integrations/ralph/context/context-budget-manager.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/integrations/ralph/context/context-budget-manager.ts"],
+  "sourcesContent": ["/**\n * Context Budget Manager for Ralph-StackMemory Integration\n * Manages token allocation and context prioritization to prevent overwhelming iterations\n */\n\nimport { logger } from '../../../core/monitoring/logger.js';\nimport {\n  IterationContext,\n  TaskContext,\n  HistoryContext,\n  EnvironmentContext,\n  MemoryContext,\n  RalphStackMemoryConfig,\n  TokenEstimate,\n  IterationSummary,\n} from '../types.js';\n\nexport class ContextBudgetManager {\n  private config: RalphStackMemoryConfig['contextBudget'];\n  private tokenUsage: Map<string, number> = new Map();\n  private readonly DEFAULT_MAX_TOKENS = 4000;\n  private readonly TOKEN_CHAR_RATIO = 0.25; // Rough estimate: 1 token \u2248 4 chars\n\n  constructor(config?: Partial<RalphStackMemoryConfig['contextBudget']>) {\n    this.config = {\n      maxTokens: config?.maxTokens || this.DEFAULT_MAX_TOKENS,\n      priorityWeights: {\n        task: config?.priorityWeights?.task || 0.3,\n        recentWork: config?.priorityWeights?.recentWork || 0.25,\n        feedback: config?.priorityWeights?.feedback || 0.2,\n        gitHistory: config?.priorityWeights?.gitHistory || 0.15,\n        dependencies: config?.priorityWeights?.dependencies || 0.1,\n      },\n      compressionEnabled: config?.compressionEnabled ?? true,\n      adaptiveBudgeting: config?.adaptiveBudgeting ?? true,\n    };\n  }\n\n  /**\n   * Estimate tokens for a given text\n   */\n  estimateTokens(text: string): number {\n    if (!text) return 0;\n    \n    // More accurate estimation based on common patterns\n    const baseTokens = text.length * this.TOKEN_CHAR_RATIO;\n    \n    // Adjust for code content (typically more dense)\n    const codeMultiplier = this.detectCodeContent(text) ? 1.2 : 1.0;\n    \n    // Adjust for JSON content (typically less dense)\n    const jsonMultiplier = this.detectJsonContent(text) ? 0.9 : 1.0;\n    \n    return Math.ceil(baseTokens * codeMultiplier * jsonMultiplier);\n  }\n\n  /**\n   * Allocate token budget across different context categories\n   */\n  allocateBudget(context: IterationContext): IterationContext {\n    const currentTokens = this.calculateCurrentTokens(context);\n    \n    if (currentTokens <= this.config.maxTokens) {\n      logger.debug('Context within budget', { \n        used: currentTokens, \n        max: this.config.maxTokens \n      });\n      return context;\n    }\n\n    logger.info('Context exceeds budget, optimizing...', {\n      current: currentTokens,\n      max: this.config.maxTokens,\n    });\n\n    // Apply adaptive budgeting if enabled\n    if (this.config.adaptiveBudgeting) {\n      return this.adaptiveBudgetAllocation(context, currentTokens);\n    }\n\n    // Apply fixed priority-based budgeting\n    return this.priorityBasedAllocation(context, currentTokens);\n  }\n\n  /**\n   * Compress context to fit within budget\n   */\n  compressContext(context: IterationContext): IterationContext {\n    if (!this.config.compressionEnabled) {\n      return context;\n    }\n\n    const compressed: IterationContext = {\n      ...context,\n      task: this.compressTaskContext(context.task),\n      history: this.compressHistoryContext(context.history),\n      environment: this.compressEnvironmentContext(context.environment),\n      memory: this.compressMemoryContext(context.memory),\n      tokenCount: 0,\n    };\n\n    compressed.tokenCount = this.calculateCurrentTokens(compressed);\n    \n    logger.debug('Context compressed', {\n      original: context.tokenCount,\n      compressed: compressed.tokenCount,\n      reduction: `${Math.round((1 - compressed.tokenCount / context.tokenCount) * 100)}%`,\n    });\n\n    return compressed;\n  }\n\n  /**\n   * Get current token usage statistics\n   */\n  getUsage(): { used: number; available: number; categories: Record<string, number> } {\n    const categories: Record<string, number> = {};\n    let totalUsed = 0;\n\n    for (const [category, tokens] of this.tokenUsage) {\n      categories[category] = tokens;\n      totalUsed += tokens;\n    }\n\n    return {\n      used: totalUsed,\n      available: this.config.maxTokens - totalUsed,\n      categories,\n    };\n  }\n\n  /**\n   * Calculate current token count for context\n   */\n  private calculateCurrentTokens(context: IterationContext): number {\n    this.tokenUsage.clear();\n    \n    const taskTokens = this.estimateTokens(JSON.stringify(context.task));\n    const historyTokens = this.estimateTokens(JSON.stringify(context.history));\n    const envTokens = this.estimateTokens(JSON.stringify(context.environment));\n    const memoryTokens = this.estimateTokens(JSON.stringify(context.memory));\n\n    this.tokenUsage.set('task', taskTokens);\n    this.tokenUsage.set('history', historyTokens);\n    this.tokenUsage.set('environment', envTokens);\n    this.tokenUsage.set('memory', memoryTokens);\n\n    return taskTokens + historyTokens + envTokens + memoryTokens;\n  }\n\n  /**\n   * Adaptive budget allocation based on iteration phase\n   */\n  private adaptiveBudgetAllocation(\n    context: IterationContext,\n    currentTokens: number\n  ): IterationContext {\n    const reductionRatio = this.config.maxTokens / currentTokens;\n    \n    // Determine phase based on iteration number\n    const phase = this.determinePhase(context.task.currentIteration);\n    \n    // Adjust weights based on phase\n    const adjustedWeights = this.getPhaseAdjustedWeights(phase);\n    \n    return this.applyWeightedReduction(context, reductionRatio, adjustedWeights);\n  }\n\n  /**\n   * Priority-based allocation using fixed weights\n   */\n  private priorityBasedAllocation(\n    context: IterationContext,\n    currentTokens: number\n  ): IterationContext {\n    const reductionRatio = this.config.maxTokens / currentTokens;\n    return this.applyWeightedReduction(context, reductionRatio, this.config.priorityWeights);\n  }\n\n  /**\n   * Apply weighted reduction to context\n   */\n  private applyWeightedReduction(\n    context: IterationContext,\n    reductionRatio: number,\n    weights: Record<string, number>\n  ): IterationContext {\n    const reduced: IterationContext = { ...context };\n\n    // Reduce history based on weight\n    if (weights.recentWork < 1.0) {\n      const keepCount = Math.ceil(\n        context.history.recentIterations.length * reductionRatio * weights.recentWork\n      );\n      reduced.history = {\n        ...context.history,\n        recentIterations: context.history.recentIterations.slice(-keepCount),\n      };\n    }\n\n    // Reduce git history based on weight\n    if (weights.gitHistory < 1.0) {\n      const keepCount = Math.ceil(\n        context.history.gitCommits.length * reductionRatio * weights.gitHistory\n      );\n      reduced.history.gitCommits = context.history.gitCommits.slice(-keepCount);\n    }\n\n    // Reduce memory frames based on weight\n    if (weights.dependencies < 1.0) {\n      const keepCount = Math.ceil(\n        context.memory.relevantFrames.length * reductionRatio * weights.dependencies\n      );\n      reduced.memory = {\n        ...context.memory,\n        relevantFrames: context.memory.relevantFrames\n          .sort((a, b) => (b.created_at || 0) - (a.created_at || 0))\n          .slice(0, keepCount),\n      };\n    }\n\n    reduced.tokenCount = this.calculateCurrentTokens(reduced);\n    return reduced;\n  }\n\n  /**\n   * Compress task context\n   */\n  private compressTaskContext(task: TaskContext): TaskContext {\n    return {\n      ...task,\n      description: this.truncateWithEllipsis(task.description, 500),\n      criteria: task.criteria.slice(0, 5), // Keep top 5 criteria\n      feedback: task.feedback ? this.truncateWithEllipsis(task.feedback, 300) : undefined,\n    };\n  }\n\n  /**\n   * Compress history context\n   */\n  private compressHistoryContext(history: HistoryContext): HistoryContext {\n    return {\n      ...history,\n      recentIterations: history.recentIterations\n        .slice(-5) // Keep last 5 iterations\n        .map(iter => ({\n          ...iter,\n          summary: this.truncateWithEllipsis(iter.summary, 100),\n        })),\n      gitCommits: history.gitCommits\n        .slice(-10) // Keep last 10 commits\n        .map(commit => ({\n          ...commit,\n          message: this.truncateWithEllipsis(commit.message, 80),\n          files: commit.files.slice(0, 5), // Keep top 5 files\n        })),\n      changedFiles: history.changedFiles.slice(0, 20), // Keep top 20 files\n      testResults: history.testResults.slice(-3), // Keep last 3 test runs\n    };\n  }\n\n  /**\n   * Compress environment context\n   */\n  private compressEnvironmentContext(env: EnvironmentContext): EnvironmentContext {\n    return {\n      ...env,\n      dependencies: this.compressObject(env.dependencies, 20), // Keep top 20 deps\n      configuration: this.compressObject(env.configuration, 10), // Keep top 10 config items\n    };\n  }\n\n  /**\n   * Compress memory context\n   */\n  private compressMemoryContext(memory: MemoryContext): MemoryContext {\n    return {\n      ...memory,\n      relevantFrames: memory.relevantFrames.slice(0, 5), // Keep top 5 frames\n      decisions: memory.decisions\n        .filter(d => d.impact !== 'low') // Remove low impact decisions\n        .slice(-5), // Keep last 5\n      patterns: memory.patterns\n        .filter(p => p.successRate > 0.7) // Keep successful patterns only\n        .slice(0, 3), // Keep top 3\n      blockers: memory.blockers.filter(b => !b.resolved), // Keep unresolved only\n    };\n  }\n\n  /**\n   * Determine iteration phase\n   */\n  private determinePhase(iteration: number): 'early' | 'middle' | 'late' {\n    if (iteration <= 3) return 'early';\n    if (iteration <= 10) return 'middle';\n    return 'late';\n  }\n\n  /**\n   * Get phase-adjusted weights\n   */\n  private getPhaseAdjustedWeights(phase: 'early' | 'middle' | 'late'): Record<string, number> {\n    switch (phase) {\n      case 'early':\n        // Early phase: Focus on task understanding\n        return {\n          task: 0.4,\n          recentWork: 0.1,\n          feedback: 0.2,\n          gitHistory: 0.2,\n          dependencies: 0.1,\n        };\n      case 'middle':\n        // Middle phase: Balance all aspects\n        return this.config.priorityWeights;\n      case 'late':\n        // Late phase: Focus on recent work and feedback\n        return {\n          task: 0.2,\n          recentWork: 0.35,\n          feedback: 0.25,\n          gitHistory: 0.15,\n          dependencies: 0.05,\n        };\n    }\n  }\n\n  /**\n   * Detect if text contains code\n   */\n  private detectCodeContent(text: string): boolean {\n    const codePatterns = [\n      /function\\s+\\w+\\s*\\(/,\n      /class\\s+\\w+/,\n      /const\\s+\\w+\\s*=/,\n      /import\\s+.*from/,\n      /\\{[\\s\\S]*\\}/,\n    ];\n    return codePatterns.some(pattern => pattern.test(text));\n  }\n\n  /**\n   * Detect if text contains JSON\n   */\n  private detectJsonContent(text: string): boolean {\n    try {\n      JSON.parse(text);\n      return true;\n    } catch {\n      return text.includes('\"') && text.includes(':') && text.includes('{');\n    }\n  }\n\n  /**\n   * Truncate text with ellipsis\n   */\n  private truncateWithEllipsis(text: string, maxLength: number): string {\n    if (text.length <= maxLength) return text;\n    return text.substring(0, maxLength - 3) + '...';\n  }\n\n  /**\n   * Compress object by keeping only top N entries\n   */\n  private compressObject(obj: Record<string, any>, maxEntries: number): Record<string, any> {\n    const entries = Object.entries(obj);\n    if (entries.length <= maxEntries) return obj;\n    \n    const compressed: Record<string, any> = {};\n    entries.slice(0, maxEntries).forEach(([key, value]) => {\n      compressed[key] = value;\n    });\n    \n    return compressed;\n  }\n}"],
+  "mappings": "AAKA,SAAS,cAAc;AAYhB,MAAM,qBAAqB;AAAA,EACxB;AAAA,EACA,aAAkC,oBAAI,IAAI;AAAA,EACjC,qBAAqB;AAAA,EACrB,mBAAmB;AAAA;AAAA,EAEpC,YAAY,QAA2D;AACrE,SAAK,SAAS;AAAA,MACZ,WAAW,QAAQ,aAAa,KAAK;AAAA,MACrC,iBAAiB;AAAA,QACf,MAAM,QAAQ,iBAAiB,QAAQ;AAAA,QACvC,YAAY,QAAQ,iBAAiB,cAAc;AAAA,QACnD,UAAU,QAAQ,iBAAiB,YAAY;AAAA,QAC/C,YAAY,QAAQ,iBAAiB,cAAc;AAAA,QACnD,cAAc,QAAQ,iBAAiB,gBAAgB;AAAA,MACzD;AAAA,MACA,oBAAoB,QAAQ,sBAAsB;AAAA,MAClD,mBAAmB,QAAQ,qBAAqB;AAAA,IAClD;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,eAAe,MAAsB;AACnC,QAAI,CAAC,KAAM,QAAO;AAGlB,UAAM,aAAa,KAAK,SAAS,KAAK;AAGtC,UAAM,iBAAiB,KAAK,kBAAkB,IAAI,IAAI,MAAM;AAG5D,UAAM,iBAAiB,KAAK,kBAAkB,IAAI,IAAI,MAAM;AAE5D,WAAO,KAAK,KAAK,aAAa,iBAAiB,cAAc;AAAA,EAC/D;AAAA;AAAA;AAAA;AAAA,EAKA,eAAe,SAA6C;AAC1D,UAAM,gBAAgB,KAAK,uBAAuB,OAAO;AAEzD,QAAI,iBAAiB,KAAK,OAAO,WAAW;AAC1C,aAAO,MAAM,yBAAyB;AAAA,QACpC,MAAM;AAAA,QACN,KAAK,KAAK,OAAO;AAAA,MACnB,CAAC;AACD,aAAO;AAAA,IACT;AAEA,WAAO,KAAK,yCAAyC;AAAA,MACnD,SAAS;AAAA,MACT,KAAK,KAAK,OAAO;AAAA,IACnB,CAAC;AAGD,QAAI,KAAK,OAAO,mBAAmB;AACjC,aAAO,KAAK,yBAAyB,SAAS,aAAa;AAAA,IAC7D;AAGA,WAAO,KAAK,wBAAwB,SAAS,aAAa;AAAA,EAC5D;AAAA;AAAA;AAAA;AAAA,EAKA,gBAAgB,SAA6C;AAC3D,QAAI,CAAC,KAAK,OAAO,oBAAoB;AACnC,aAAO;AAAA,IACT;AAEA,UAAM,aAA+B;AAAA,MACnC,GAAG;AAAA,MACH,MAAM,KAAK,oBAAoB,QAAQ,IAAI;AAAA,MAC3C,SAAS,KAAK,uBAAuB,QAAQ,OAAO;AAAA,MACpD,aAAa,KAAK,2BAA2B,QAAQ,WAAW;AAAA,MAChE,QAAQ,KAAK,sBAAsB,QAAQ,MAAM;AAAA,MACjD,YAAY;AAAA,IACd;AAEA,eAAW,aAAa,KAAK,uBAAuB,UAAU;AAE9D,WAAO,MAAM,sBAAsB;AAAA,MACjC,UAAU,QAAQ;AAAA,MAClB,YAAY,WAAW;AAAA,MACvB,WAAW,GAAG,KAAK,OAAO,IAAI,WAAW,aAAa,QAAQ,cAAc,GAAG,CAAC;AAAA,IAClF,CAAC;AAED,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,WAAoF;AAClF,UAAM,aAAqC,CAAC;AAC5C,QAAI,YAAY;AAEhB,eAAW,CAAC,UAAU,MAAM,KAAK,KAAK,YAAY;AAChD,iBAAW,QAAQ,IAAI;AACvB,mBAAa;AAAA,IACf;AAEA,WAAO;AAAA,MACL,MAAM;AAAA,MACN,WAAW,KAAK,OAAO,YAAY;AAAA,MACnC;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,uBAAuB,SAAmC;AAChE,SAAK,WAAW,MAAM;AAEtB,UAAM,aAAa,KAAK,eAAe,KAAK,UAAU,QAAQ,IAAI,CAAC;AACnE,UAAM,gBAAgB,KAAK,eAAe,KAAK,UAAU,QAAQ,OAAO,CAAC;AACzE,UAAM,YAAY,KAAK,eAAe,KAAK,UAAU,QAAQ,WAAW,CAAC;AACzE,UAAM,eAAe,KAAK,eAAe,KAAK,UAAU,QAAQ,MAAM,CAAC;AAEvE,SAAK,WAAW,IAAI,QAAQ,UAAU;AACtC,SAAK,WAAW,IAAI,WAAW,aAAa;AAC5C,SAAK,WAAW,IAAI,eAAe,SAAS;AAC5C,SAAK,WAAW,IAAI,UAAU,YAAY;AAE1C,WAAO,aAAa,gBAAgB,YAAY;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA,EAKQ,yBACN,SACA,eACkB;AAClB,UAAM,iBAAiB,KAAK,OAAO,YAAY;AAG/C,UAAM,QAAQ,KAAK,eAAe,QAAQ,KAAK,gBAAgB;AAG/D,UAAM,kBAAkB,KAAK,wBAAwB,KAAK;AAE1D,WAAO,KAAK,uBAAuB,SAAS,gBAAgB,eAAe;AAAA,EAC7E;AAAA;AAAA;AAAA;AAAA,EAKQ,wBACN,SACA,eACkB;AAClB,UAAM,iBAAiB,KAAK,OAAO,YAAY;AAC/C,WAAO,KAAK,uBAAuB,SAAS,gBAAgB,KAAK,OAAO,eAAe;AAAA,EACzF;AAAA;AAAA;AAAA;AAAA,EAKQ,uBACN,SACA,gBACA,SACkB;AAClB,UAAM,UAA4B,EAAE,GAAG,QAAQ;AAG/C,QAAI,QAAQ,aAAa,GAAK;AAC5B,YAAM,YAAY,KAAK;AAAA,QACrB,QAAQ,QAAQ,iBAAiB,SAAS,iBAAiB,QAAQ;AAAA,MACrE;AACA,cAAQ,UAAU;AAAA,QAChB,GAAG,QAAQ;AAAA,QACX,kBAAkB,QAAQ,QAAQ,iBAAiB,MAAM,CAAC,SAAS;AAAA,MACrE;AAAA,IACF;AAGA,QAAI,QAAQ,aAAa,GAAK;AAC5B,YAAM,YAAY,KAAK;AAAA,QACrB,QAAQ,QAAQ,WAAW,SAAS,iBAAiB,QAAQ;AAAA,MAC/D;AACA,cAAQ,QAAQ,aAAa,QAAQ,QAAQ,WAAW,MAAM,CAAC,SAAS;AAAA,IAC1E;AAGA,QAAI,QAAQ,eAAe,GAAK;AAC9B,YAAM,YAAY,KAAK;AAAA,QACrB,QAAQ,OAAO,eAAe,SAAS,iBAAiB,QAAQ;AAAA,MAClE;AACA,cAAQ,SAAS;AAAA,QACf,GAAG,QAAQ;AAAA,QACX,gBAAgB,QAAQ,OAAO,eAC5B,KAAK,CAAC,GAAG,OAAO,EAAE,cAAc,MAAM,EAAE,cAAc,EAAE,EACxD,MAAM,GAAG,SAAS;AAAA,MACvB;AAAA,IACF;AAEA,YAAQ,aAAa,KAAK,uBAAuB,OAAO;AACxD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKQ,oBAAoB,MAAgC;AAC1D,WAAO;AAAA,MACL,GAAG;AAAA,MACH,aAAa,KAAK,qBAAqB,KAAK,aAAa,GAAG;AAAA,MAC5D,UAAU,KAAK,SAAS,MAAM,GAAG,CAAC;AAAA;AAAA,MAClC,UAAU,KAAK,WAAW,KAAK,qBAAqB,KAAK,UAAU,GAAG,IAAI;AAAA,IAC5E;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,uBAAuB,SAAyC;AACtE,WAAO;AAAA,MACL,GAAG;AAAA,MACH,kBAAkB,QAAQ,iBACvB,MAAM,EAAE,EACR,IAAI,WAAS;AAAA,QACZ,GAAG;AAAA,QACH,SAAS,KAAK,qBAAqB,KAAK,SAAS,GAAG;AAAA,MACtD,EAAE;AAAA,MACJ,YAAY,QAAQ,WACjB,MAAM,GAAG,EACT,IAAI,aAAW;AAAA,QACd,GAAG;AAAA,QACH,SAAS,KAAK,qBAAqB,OAAO,SAAS,EAAE;AAAA,QACrD,OAAO,OAAO,MAAM,MAAM,GAAG,CAAC;AAAA;AAAA,MAChC,EAAE;AAAA,MACJ,cAAc,QAAQ,aAAa,MAAM,GAAG,EAAE;AAAA;AAAA,MAC9C,aAAa,QAAQ,YAAY,MAAM,EAAE;AAAA;AAAA,IAC3C;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,2BAA2B,KAA6C;AAC9E,WAAO;AAAA,MACL,GAAG;AAAA,MACH,cAAc,KAAK,eAAe,IAAI,cAAc,EAAE;AAAA;AAAA,MACtD,eAAe,KAAK,eAAe,IAAI,eAAe,EAAE;AAAA;AAAA,IAC1D;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,sBAAsB,QAAsC;AAClE,WAAO;AAAA,MACL,GAAG;AAAA,MACH,gBAAgB,OAAO,eAAe,MAAM,GAAG,CAAC;AAAA;AAAA,MAChD,WAAW,OAAO,UACf,OAAO,OAAK,EAAE,WAAW,KAAK,EAC9B,MAAM,EAAE;AAAA;AAAA,MACX,UAAU,OAAO,SACd,OAAO,OAAK,EAAE,cAAc,GAAG,EAC/B,MAAM,GAAG,CAAC;AAAA;AAAA,MACb,UAAU,OAAO,SAAS,OAAO,OAAK,CAAC,EAAE,QAAQ;AAAA;AAAA,IACnD;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,eAAe,WAAgD;AACrE,QAAI,aAAa,EAAG,QAAO;AAC3B,QAAI,aAAa,GAAI,QAAO;AAC5B,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKQ,wBAAwB,OAA4D;AAC1F,YAAQ,OAAO;AAAA,MACb,KAAK;AAEH,eAAO;AAAA,UACL,MAAM;AAAA,UACN,YAAY;AAAA,UACZ,UAAU;AAAA,UACV,YAAY;AAAA,UACZ,cAAc;AAAA,QAChB;AAAA,MACF,KAAK;AAEH,eAAO,KAAK,OAAO;AAAA,MACrB,KAAK;AAEH,eAAO;AAAA,UACL,MAAM;AAAA,UACN,YAAY;AAAA,UACZ,UAAU;AAAA,UACV,YAAY;AAAA,UACZ,cAAc;AAAA,QAChB;AAAA,IACJ;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,kBAAkB,MAAuB;AAC/C,UAAM,eAAe;AAAA,MACnB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AACA,WAAO,aAAa,KAAK,aAAW,QAAQ,KAAK,IAAI,CAAC;AAAA,EACxD;AAAA;AAAA;AAAA;AAAA,EAKQ,kBAAkB,MAAuB;AAC/C,QAAI;AACF,WAAK,MAAM,IAAI;AACf,aAAO;AAAA,IACT,QAAQ;AACN,aAAO,KAAK,SAAS,GAAG,KAAK,KAAK,SAAS,GAAG,KAAK,KAAK,SAAS,GAAG;AAAA,IACtE;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,qBAAqB,MAAc,WAA2B;AACpE,QAAI,KAAK,UAAU,UAAW,QAAO;AACrC,WAAO,KAAK,UAAU,GAAG,YAAY,CAAC,IAAI;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA,EAKQ,eAAe,KAA0B,YAAyC;AACxF,UAAM,UAAU,OAAO,QAAQ,GAAG;AAClC,QAAI,QAAQ,UAAU,WAAY,QAAO;AAEzC,UAAM,aAAkC,CAAC;AACzC,YAAQ,MAAM,GAAG,UAAU,EAAE,QAAQ,CAAC,CAAC,KAAK,KAAK,MAAM;AACrD,iBAAW,GAAG,IAAI;AAAA,IACpB,CAAC;AAED,WAAO;AAAA,EACT;AACF;",
+  "names": []
+}

package/dist/integrations/ralph/context/stackmemory-context-loader.js

@@ -0,0 +1,356 @@
+import { logger } from "../../../core/monitoring/logger.js";
+import { FrameManager } from "../../../core/context/frame-manager.js";
+import { sharedContextLayer } from "../../../core/context/shared-context-layer.js";
+import { ContextRetriever } from "../../../core/retrieval/context-retriever.js";
+import { sessionManager } from "../../../core/session/index.js";
+import { ContextBudgetManager } from "./context-budget-manager.js";
+class StackMemoryContextLoader {
+  frameManager;
+  contextRetriever;
+  budgetManager;
+  config;
+  constructor(config) {
+    this.config = {
+      maxTokens: 3200,
+      // Leave room for task description
+      lookbackDays: 30,
+      similarityThreshold: 0.7,
+      patternDetectionEnabled: true,
+      includeFailedAttempts: true,
+      crossSessionSearch: true,
+      ...config
+    };
+    this.budgetManager = new ContextBudgetManager({
+      maxTokens: this.config.maxTokens,
+      priorityWeights: {
+        task: 0.15,
+        recentWork: 0.3,
+        patterns: 0.25,
+        decisions: 0.2,
+        dependencies: 0.1
+      }
+    });
+    logger.info("StackMemory context loader initialized", {
+      maxTokens: this.config.maxTokens,
+      lookbackDays: this.config.lookbackDays,
+      patternDetection: this.config.patternDetectionEnabled
+    });
+  }
+  async initialize() {
+    try {
+      await sessionManager.initialize();
+      await sharedContextLayer.initialize();
+      const session = await sessionManager.getOrCreateSession({});
+      if (session.database) {
+        this.frameManager = new FrameManager(session.database, session.projectId);
+        this.contextRetriever = new ContextRetriever(session.database);
+      }
+      logger.info("Context loader initialized successfully");
+    } catch (error) {
+      logger.error("Failed to initialize context loader", error);
+      throw error;
+    }
+  }
+  /**
+   * Load context for Ralph loop initialization
+   */
+  async loadInitialContext(request) {
+    logger.info("Loading initial context for Ralph loop", {
+      task: request.task.substring(0, 100),
+      usePatterns: request.usePatterns,
+      useSimilarTasks: request.useSimilarTasks
+    });
+    const sources = [];
+    let totalTokens = 0;
+    try {
+      if (request.useSimilarTasks) {
+        const similarTasks2 = await this.findSimilarTasks(request.task);
+        if (similarTasks2.length > 0) {
+          const tasksContext = await this.extractTaskContext(similarTasks2);
+          sources.push({
+            type: "similar_tasks",
+            weight: 0.3,
+            content: tasksContext,
+            tokens: this.budgetManager.estimateTokens(tasksContext)
+          });
+          totalTokens += sources[sources.length - 1].tokens;
+        }
+      }
+      if (request.usePatterns) {
+        const patterns2 = await this.extractRelevantPatterns(request.task);
+        if (patterns2.length > 0) {
+          const patternsContext = await this.formatPatterns(patterns2);
+          sources.push({
+            type: "historical_patterns",
+            weight: 0.25,
+            content: patternsContext,
+            tokens: this.budgetManager.estimateTokens(patternsContext)
+          });
+          totalTokens += sources[sources.length - 1].tokens;
+        }
+      }
+      const decisions = await this.loadRecentDecisions();
+      if (decisions.length > 0) {
+        const decisionsContext = this.formatDecisions(decisions);
+        sources.push({
+          type: "recent_decisions",
+          weight: 0.2,
+          content: decisionsContext,
+          tokens: this.budgetManager.estimateTokens(decisionsContext)
+        });
+        totalTokens += sources[sources.length - 1].tokens;
+      }
+      const projectContext = await this.loadProjectContext(request.task);
+      if (projectContext) {
+        sources.push({
+          type: "project_context",
+          weight: 0.15,
+          content: projectContext,
+          tokens: this.budgetManager.estimateTokens(projectContext)
+        });
+        totalTokens += sources[sources.length - 1].tokens;
+      }
+      const budgetedSources = this.budgetManager.allocateBudget({ sources });
+      const synthesizedContext = this.synthesizeContext(budgetedSources.sources);
+      logger.info("Context loaded successfully", {
+        totalSources: sources.length,
+        totalTokens,
+        budgetedTokens: budgetedSources.sources.reduce((sum, s) => sum + s.tokens, 0)
+      });
+      return {
+        context: synthesizedContext,
+        sources: budgetedSources.sources,
+        metadata: {
+          totalTokens: budgetedSources.sources.reduce((sum, s) => sum + s.tokens, 0),
+          sourcesCount: budgetedSources.sources.length,
+          patterns: request.usePatterns ? patterns : [],
+          similarTasks: request.useSimilarTasks ? similarTasks : []
+        }
+      };
+    } catch (error) {
+      logger.error("Failed to load context", error);
+      throw error;
+    }
+  }
+  /**
+   * Find similar tasks from StackMemory history
+   */
+  async findSimilarTasks(taskDescription) {
+    if (!this.frameManager || !this.contextRetriever) {
+      return [];
+    }
+    try {
+      const searchResults = await this.contextRetriever.search(taskDescription, {
+        maxResults: 10,
+        types: ["task", "subtask"],
+        timeFilter: {
+          days: this.config.lookbackDays
+        }
+      });
+      const similarities = [];
+      for (const result of searchResults) {
+        const similarity = this.calculateTaskSimilarity(taskDescription, result.content);
+        if (similarity >= this.config.similarityThreshold) {
+          similarities.push({
+            frameId: result.frameId,
+            task: result.content,
+            similarity,
+            outcome: await this.determineTaskOutcome(result.frameId),
+            createdAt: result.timestamp,
+            sessionId: result.sessionId || "unknown"
+          });
+        }
+      }
+      return similarities.sort((a, b) => {
+        const aScore = a.similarity * (a.outcome === "success" ? 1.2 : 1);
+        const bScore = b.similarity * (b.outcome === "success" ? 1.2 : 1);
+        return bScore - aScore;
+      }).slice(0, 5);
+    } catch (error) {
+      logger.error("Failed to find similar tasks", error);
+      return [];
+    }
+  }
+  /**
+   * Extract relevant patterns from historical data
+   */
+  async extractRelevantPatterns(taskDescription) {
+    try {
+      const context = await sharedContextLayer.getSharedContext();
+      if (!context) return [];
+      const relevantPatterns = [];
+      for (const pattern of context.globalPatterns) {
+        const relevance = this.calculatePatternRelevance(taskDescription, pattern.pattern);
+        if (relevance >= 0.5) {
+          relevantPatterns.push({
+            pattern: pattern.pattern,
+            type: pattern.type,
+            frequency: pattern.frequency,
+            lastSeen: pattern.lastSeen,
+            relevance,
+            resolution: pattern.resolution,
+            examples: await this.getPatternExamples(pattern.pattern)
+          });
+        }
+      }
+      return relevantPatterns.sort((a, b) => b.relevance * Math.log(b.frequency + 1) - a.relevance * Math.log(a.frequency + 1)).slice(0, 8);
+    } catch (error) {
+      logger.error("Failed to extract patterns", error);
+      return [];
+    }
+  }
+  /**
+   * Load recent decisions that might be relevant
+   */
+  async loadRecentDecisions() {
+    try {
+      const context = await sharedContextLayer.getSharedContext();
+      if (!context) return [];
+      const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1e3;
+      return context.decisionLog.filter((d) => d.timestamp >= cutoff && d.outcome === "success").sort((a, b) => b.timestamp - a.timestamp).slice(0, 5);
+    } catch (error) {
+      logger.error("Failed to load recent decisions", error);
+      return [];
+    }
+  }
+  /**
+   * Load project-specific context
+   */
+  async loadProjectContext(taskDescription) {
+    try {
+      if (!this.contextRetriever) return null;
+      const projectInfo = await this.contextRetriever.search(taskDescription, {
+        maxResults: 3,
+        types: ["task"],
+        projectSpecific: true
+      });
+      if (projectInfo.length === 0) return null;
+      const contextParts = [];
+      for (const info of projectInfo) {
+        contextParts.push(`Project context: ${info.content}`);
+      }
+      return contextParts.join("\n\n");
+    } catch (error) {
+      logger.error("Failed to load project context", error);
+      return null;
+    }
+  }
+  /**
+   * Calculate similarity between task descriptions
+   */
+  calculateTaskSimilarity(task1, task2) {
+    const words1 = new Set(task1.toLowerCase().split(/\s+/));
+    const words2 = new Set(task2.toLowerCase().split(/\s+/));
+    const intersection = new Set([...words1].filter((x) => words2.has(x)));
+    const union = /* @__PURE__ */ new Set([...words1, ...words2]);
+    return intersection.size / union.size;
+  }
+  /**
+   * Calculate pattern relevance to current task
+   */
+  calculatePatternRelevance(taskDescription, pattern) {
+    const taskWords = taskDescription.toLowerCase().split(/\s+/);
+    const patternWords = pattern.toLowerCase().split(/\s+/);
+    let matches = 0;
+    for (const word of taskWords) {
+      if (patternWords.some((p) => p.includes(word) || word.includes(p))) {
+        matches++;
+      }
+    }
+    return matches / taskWords.length;
+  }
+  /**
+   * Extract context from similar tasks
+   */
+  async extractTaskContext(similarities) {
+    const contextParts = [];
+    contextParts.push("Similar tasks from history:");
+    for (const sim of similarities) {
+      contextParts.push(`
+Task: ${sim.task}
+Outcome: ${sim.outcome}
+Similarity: ${Math.round(sim.similarity * 100)}%
+${sim.outcome === "success" ? "\u2705 Successfully completed" : "\u274C Had issues"}
+      `.trim());
+    }
+    return contextParts.join("\n\n");
+  }
+  /**
+   * Format patterns for context inclusion
+   */
+  async formatPatterns(patterns2) {
+    const contextParts = [];
+    contextParts.push("Relevant patterns from experience:");
+    for (const pattern of patterns2) {
+      contextParts.push(`
+Pattern: ${pattern.pattern}
+Type: ${pattern.type}
+Frequency: ${pattern.frequency} occurrences
+${pattern.resolution ? `Resolution: ${pattern.resolution}` : ""}
+Relevance: ${Math.round(pattern.relevance * 100)}%
+      `.trim());
+    }
+    return contextParts.join("\n\n");
+  }
+  /**
+   * Format decisions for context inclusion
+   */
+  formatDecisions(decisions) {
+    const contextParts = [];
+    contextParts.push("Recent successful decisions:");
+    for (const decision of decisions) {
+      contextParts.push(`
+Decision: ${decision.decision}
+Reasoning: ${decision.reasoning}
+Date: ${new Date(decision.timestamp).toLocaleDateString()}
+      `.trim());
+    }
+    return contextParts.join("\n\n");
+  }
+  /**
+   * Synthesize all context sources into coherent input
+   */
+  synthesizeContext(sources) {
+    if (sources.length === 0) {
+      return "No relevant historical context found.";
+    }
+    const contextParts = [];
+    contextParts.push("Context from StackMemory:");
+    const sortedSources = sources.sort((a, b) => b.weight - a.weight);
+    for (const source of sortedSources) {
+      contextParts.push(`
+--- ${source.type.replace("_", " ").toUpperCase()} ---`);
+      contextParts.push(source.content);
+    }
+    contextParts.push("\nUse this context to inform your approach to the current task.");
+    return contextParts.join("\n");
+  }
+  /**
+   * Determine task outcome from frame history
+   */
+  async determineTaskOutcome(frameId) {
+    try {
+      if (!this.frameManager) return "unknown";
+      const frame = await this.frameManager.getFrame(frameId);
+      if (!frame) return "unknown";
+      if (frame.state === "closed" && frame.outputs) {
+        return "success";
+      }
+      return frame.state === "closed" ? "failure" : "unknown";
+    } catch {
+      return "unknown";
+    }
+  }
+  /**
+   * Get examples of a specific pattern
+   */
+  async getPatternExamples(pattern) {
+    return [];
+  }
+}
+const stackMemoryContextLoader = new StackMemoryContextLoader();
+export {
+  StackMemoryContextLoader,
+  stackMemoryContextLoader
+};
+//# sourceMappingURL=stackmemory-context-loader.js.map