@stackmemoryai/stackmemory 1.12.0 → 1.14.0

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

@@ -1,308 +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 { 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
-};

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

@@ -1,354 +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 { logger } from "../../../core/monitoring/logger.js";
-import { FrameManager } from "../../../core/context/index.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();
-      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) {
-    return [];
-  }
-  /**
-   * Load recent decisions that might be relevant
-   */
-  async loadRecentDecisions() {
-    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
-};

package/dist/src/integrations/ralph/index.js

@@ -1,17 +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 { RalphStackMemoryBridge } from "./bridge/ralph-stackmemory-bridge.js";
-import { ContextBudgetManager } from "./context/context-budget-manager.js";
-import { StateReconciler } from "./state/state-reconciler.js";
-import { IterationLifecycle } from "./lifecycle/iteration-lifecycle.js";
-import { PerformanceOptimizer } from "./performance/performance-optimizer.js";
-export * from "./types.js";
-export {
-  ContextBudgetManager,
-  IterationLifecycle,
-  PerformanceOptimizer,
-  RalphStackMemoryBridge,
-  StateReconciler
-};