@juspay/yama 2.2.2 → 2.4.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [2.4.0](https://github.com/juspay/yama/compare/v2.3.0...v2.4.0) (2026-04-15)
+
+
+### Features
+
+* **v2:** bootstrap repo standards from recent PRs before review ([8c5b1cd](https://github.com/juspay/yama/commit/8c5b1cdd38b684397e7445e04b4db4bc45b5f2a8))
+
+# [2.3.0](https://github.com/juspay/yama/compare/v2.2.2...v2.3.0) (2026-04-01)
+
+
+### Features
+
+* **memory:** add per-repo memory management and configuration ([0b1fd5d](https://github.com/juspay/yama/commit/0b1fd5de8f0e46402f3c54766a5e0c7bd937cca2))
+
 ## [2.2.2](https://github.com/juspay/yama/compare/v2.2.1...v2.2.2) (2026-03-26)
 
 

package/README.md

@@ -28,6 +28,8 @@
 ```
 YamaOrchestrator
     ↓
+MemoryManager (per-repo condensed memory)
+    ↓
 NeuroLink AI Agent (Autonomous)
     ↓
 MCP Tools (Bitbucket + Jira)
@@ -38,6 +40,7 @@ Pull Request Operations
 ### AI Autonomous Workflow
 
 1. **Context Gathering** (AI-driven)
+   - Reads per-repo memory (past review learnings)
    - Reads PR details
    - Finds and reads Jira ticket
    - Loads project standards from memory-bank
@@ -311,6 +314,17 @@ AI uses tools to understand code:
 - `get_file_content()` - Read related files
 - `list_directory_content()` - Explore structure
 
+### Per-Repo Memory
+
+AI learns from past reviews and remembers across PRs:
+
+- Reads condensed memory before each review for context
+- Writes learnings after PR merge (false positives, missed issues, team conventions)
+- LLM-powered condensation keeps memory within a configurable word limit
+- Per-repo isolation — each repository gets independent memory keyed by `workspace-repository`
+- Storage as `.md` files at configurable path (e.g., `memory-bank/yama/memory/`)
+- Environment variable overrides for all settings (`YAMA_MEMORY_ENABLED`, `YAMA_MEMORY_MAX_WORDS`, etc.)
+
 ## Blocking Criteria
 
 AI applies these criteria automatically:

package/dist/index.d.ts

@@ -3,12 +3,14 @@
  * Main export file
  */
 export { YamaOrchestrator, createYama, YamaOrchestrator as YamaV2Orchestrator, createYama as createYamaV2, } from "./v2/core/YamaV2Orchestrator.js";
+export { LearningOrchestrator, createLearningOrchestrator, } from "./v2/core/LearningOrchestrator.js";
 export { ConfigLoader } from "./v2/config/ConfigLoader.js";
 export { MCPServerManager } from "./v2/core/MCPServerManager.js";
 export { SessionManager } from "./v2/core/SessionManager.js";
 export { PromptBuilder } from "./v2/prompts/PromptBuilder.js";
+export { MemoryManager } from "./v2/memory/MemoryManager.js";
 export type { LocalReviewFinding, LocalReviewRequest, LocalReviewResult, ReviewRequest, ReviewMode, ReviewResult, ReviewUpdate, ReviewSession, ReviewStatistics, IssuesBySeverity, TokenUsage, UnifiedReviewRequest, } from "./v2/types/v2.types.js";
-export type { YamaConfig, YamaInitOptions, YamaConfig as YamaV2Config, AIConfig, MCPServersConfig, ReviewConfig, DescriptionEnhancementConfig, } from "./v2/types/config.types.js";
+export type { YamaConfig, YamaInitOptions, YamaConfig as YamaV2Config, AIConfig, MCPServersConfig, ReviewConfig, DescriptionEnhancementConfig, MemoryConfig, } from "./v2/types/config.types.js";
 export type { GetPullRequestResponse, GetPullRequestDiffResponse, GetIssueResponse, SearchCodeResponse, } from "./v2/types/mcp.types.js";
 export declare const VERSION = "2.2.1";
 export { createYama as default } from "./v2/core/YamaV2Orchestrator.js";

package/dist/index.js

@@ -6,10 +6,12 @@
 // Core Exports
 // ============================================================================
 export { YamaOrchestrator, createYama, YamaOrchestrator as YamaV2Orchestrator, createYama as createYamaV2, } from "./v2/core/YamaV2Orchestrator.js";
+export { LearningOrchestrator, createLearningOrchestrator, } from "./v2/core/LearningOrchestrator.js";
 export { ConfigLoader } from "./v2/config/ConfigLoader.js";
 export { MCPServerManager } from "./v2/core/MCPServerManager.js";
 export { SessionManager } from "./v2/core/SessionManager.js";
 export { PromptBuilder } from "./v2/prompts/PromptBuilder.js";
+export { MemoryManager } from "./v2/memory/MemoryManager.js";
 // ============================================================================
 // Version Information
 // ============================================================================

package/dist/v2/config/ConfigLoader.d.ts

@@ -42,6 +42,21 @@ export declare class ConfigLoader {
      * Apply environment variable overrides
      */
     private applyEnvironmentOverrides;
+    /**
+     * Apply memory-related environment variable overrides.
+     *
+     * Env vars (YAMA_MEMORY_*) take precedence over yaml config.
+     * If YAMA_MEMORY_ENABLED is set but no memory config exists in yaml,
+     * a default config is created so the other overrides have a target.
+     *
+     * Supported env vars:
+     *   YAMA_MEMORY_ENABLED       — "true" / "false"
+     *   YAMA_MEMORY_STORAGE_PATH  — e.g. "memory-bank/yama/memory"
+     *   YAMA_MEMORY_MAX_WORDS     — e.g. "200"
+     *   YAMA_MEMORY_AUTO_COMMIT   — "true" / "false"
+     *   YAMA_MEMORY_PROMPT        — custom condensation prompt
+     */
+    private applyMemoryOverrides;
     /**
      * Basic configuration validation
      */

package/dist/v2/config/ConfigLoader.js

@@ -32,6 +32,7 @@ export class ConfigLoader {
         else {
             console.log("   Using default configuration (no config file found)");
         }
+        config.memory = this.applyMemoryOverrides(config.memory);
         // Layer 4: Apply SDK instance overrides (highest priority)
         if (instanceOverrides) {
             config = this.mergeConfigs(config, instanceOverrides);
@@ -179,13 +180,19 @@ export class ConfigLoader {
         if (process.env.AI_MODEL) {
             config.ai.model = process.env.AI_MODEL;
         }
-        // Override temperature if env var set
+        // Override temperature if env var set (ignore non-finite values)
         if (process.env.AI_TEMPERATURE) {
-            config.ai.temperature = parseFloat(process.env.AI_TEMPERATURE);
+            const temperature = Number(process.env.AI_TEMPERATURE);
+            if (Number.isFinite(temperature)) {
+                config.ai.temperature = temperature;
+            }
         }
-        // Override max tokens if env var set
+        // Override max tokens if env var set (ignore non-integer / non-positive values)
         if (process.env.AI_MAX_TOKENS) {
-            config.ai.maxTokens = parseInt(process.env.AI_MAX_TOKENS, 10);
+            const maxTokens = Number.parseInt(process.env.AI_MAX_TOKENS, 10);
+            if (Number.isInteger(maxTokens) && maxTokens > 0) {
+                config.ai.maxTokens = maxTokens;
+            }
         }
         if (process.env.AI_ENABLE_TOOL_FILTERING) {
             config.ai.enableToolFiltering =
@@ -197,8 +204,69 @@ export class ConfigLoader {
                 config.ai.toolFilteringMode = mode;
             }
         }
+        if (process.env.AI_EXPLORE_ENABLED) {
+            config.ai.explore.enabled = process.env.AI_EXPLORE_ENABLED === "true";
+        }
+        if (process.env.AI_EXPLORE_PROVIDER) {
+            config.ai.explore.provider = process.env.AI_EXPLORE_PROVIDER;
+        }
+        if (process.env.AI_EXPLORE_MODEL) {
+            config.ai.explore.model = process.env.AI_EXPLORE_MODEL;
+        }
+        if (process.env.AI_EXPLORE_TEMPERATURE) {
+            const temperature = Number(process.env.AI_EXPLORE_TEMPERATURE);
+            if (Number.isFinite(temperature)) {
+                config.ai.explore.temperature = temperature;
+            }
+        }
+        if (process.env.AI_EXPLORE_MAX_TOKENS) {
+            const maxTokens = Number.parseInt(process.env.AI_EXPLORE_MAX_TOKENS, 10);
+            if (Number.isInteger(maxTokens) && maxTokens > 0) {
+                config.ai.explore.maxTokens = maxTokens;
+            }
+        }
+        if (process.env.AI_EXPLORE_TIMEOUT) {
+            config.ai.explore.timeout = process.env.AI_EXPLORE_TIMEOUT;
+        }
+        if (process.env.AI_EXPLORE_CACHE_RESULTS) {
+            config.ai.explore.cacheResults =
+                process.env.AI_EXPLORE_CACHE_RESULTS === "true";
+        }
         return config;
     }
+    /**
+     * Apply memory-related environment variable overrides.
+     *
+     * Env vars (YAMA_MEMORY_*) take precedence over yaml config.
+     * If YAMA_MEMORY_ENABLED is set but no memory config exists in yaml,
+     * a default config is created so the other overrides have a target.
+     *
+     * Supported env vars:
+     *   YAMA_MEMORY_ENABLED       — "true" / "false"
+     *   YAMA_MEMORY_STORAGE_PATH  — e.g. "memory-bank/yama/memory"
+     *   YAMA_MEMORY_MAX_WORDS     — e.g. "200"
+     *   YAMA_MEMORY_AUTO_COMMIT   — "true" / "false"
+     *   YAMA_MEMORY_PROMPT        — custom condensation prompt
+     */
+    applyMemoryOverrides(memory) {
+        const env = process.env;
+        if (env.YAMA_MEMORY_ENABLED) {
+            memory.enabled = env.YAMA_MEMORY_ENABLED === "true";
+        }
+        if (env.YAMA_MEMORY_STORAGE_PATH) {
+            memory.storagePath = env.YAMA_MEMORY_STORAGE_PATH;
+        }
+        if (env.YAMA_MEMORY_MAX_WORDS) {
+            memory.maxWords = parseInt(env.YAMA_MEMORY_MAX_WORDS, 10);
+        }
+        if (env.YAMA_MEMORY_AUTO_COMMIT) {
+            memory.autoCommit = env.YAMA_MEMORY_AUTO_COMMIT === "true";
+        }
+        if (env.YAMA_MEMORY_PROMPT) {
+            memory.prompt = env.YAMA_MEMORY_PROMPT;
+        }
+        return memory;
+    }
     /**
      * Basic configuration validation
      */

package/dist/v2/config/DefaultConfig.js

@@ -31,6 +31,15 @@ export class DefaultConfig {
                     maxTurnsPerSession: 300,
                     enableSummarization: false,
                 },
+                explore: {
+                    enabled: true,
+                    provider: "auto",
+                    model: "gemini-2.5-flash",
+                    temperature: 0.1,
+                    maxTokens: 32000,
+                    timeout: "5m",
+                    cacheResults: true,
+                },
             },
             mcpServers: {
                 bitbucket: {
@@ -158,6 +167,11 @@ export class DefaultConfig {
                 summaryRetentionCount: 20,
                 autoCommit: false,
             },
+            memory: {
+                enabled: false,
+                storagePath: ".yama/memory",
+                maxWords: 200,
+            },
             projectStandards: {
                 customPromptsPath: "config/prompts/",
                 additionalFocusAreas: [],

package/dist/v2/core/LearningOrchestrator.d.ts

@@ -9,6 +9,7 @@ export declare class LearningOrchestrator {
     private mcpManager;
     private configLoader;
     private promptManager;
+    private memoryManager;
     private config;
     private initialized;
     constructor();

package/dist/v2/core/LearningOrchestrator.js

@@ -8,12 +8,14 @@ import { MCPServerManager } from "./MCPServerManager.js";
 import { ConfigLoader } from "../config/ConfigLoader.js";
 import { LangfusePromptManager } from "../prompts/LangfusePromptManager.js";
 import { KnowledgeBaseManager } from "../learning/KnowledgeBaseManager.js";
+import { MemoryManager } from "../memory/MemoryManager.js";
 import { buildObservabilityConfigFromEnv, validateObservabilityConfig, } from "../utils/ObservabilityConfig.js";
 export class LearningOrchestrator {
     neurolink;
     mcpManager;
     configLoader;
     promptManager;
+    memoryManager = null;
     config;
     initialized = false;
     constructor() {
@@ -32,7 +34,12 @@ export class LearningOrchestrator {
         try {
             // Load configuration
             this.config = await this.configLoader.loadConfig(configPath);
-            // Initialize NeuroLink
+            // Initialize Memory Manager (if enabled) — must happen before NeuroLink
+            if (this.config.memory?.enabled) {
+                this.memoryManager = new MemoryManager(this.config.memory, this.config.ai.provider, this.config.ai.model);
+                console.log("   🧠 Per-repo memory enabled\n");
+            }
+            // Initialize NeuroLink with memory config injected
             console.log("   🔧 Initializing NeuroLink AI engine...");
             this.neurolink = this.initializeNeurolink();
             console.log("   ✅ NeuroLink initialized\n");
@@ -126,6 +133,52 @@ export class LearningOrchestrator {
             if (duplicateCount > 0) {
                 console.log(`   ⏭️  Skipped ${duplicateCount} duplicates`);
             }
+            // Resolve commit mode: commitMode takes precedence, fall back to legacy commit flag
+            const commitMode = request.commitMode ||
+                (request.commit || this.config.knowledgeBase.autoCommit
+                    ? "kb"
+                    : undefined);
+            const shouldCommitMemory = commitMode === "memory" || commitMode === "all";
+            const shouldCommitKb = commitMode === "kb" || commitMode === "all";
+            // Store learnings in per-repo memory via NeuroLink
+            // read: false (we don't need to read memory here)
+            // write: true (condense learnings into memory file)
+            if (this.memoryManager && addedCount > 0 && shouldCommitMemory) {
+                try {
+                    const byCategory = new Map();
+                    for (const l of learnings) {
+                        const cat = l.category.replace(/_/g, " ");
+                        if (!byCategory.has(cat)) {
+                            byCategory.set(cat, []);
+                        }
+                        byCategory.get(cat).push(l.learning);
+                    }
+                    const parts = [];
+                    for (const [category, items] of byCategory) {
+                        parts.push(`${category}: ${items.join("; ")}`);
+                    }
+                    const ownerId = MemoryManager.buildOwnerId(request.workspace, request.repository);
+                    await this.neurolink.generate({
+                        input: { text: parts.join(". ") },
+                        provider: this.config.ai.provider,
+                        model: this.config.ai.model,
+                        temperature: 0.1,
+                        maxTokens: 100,
+                        disableTools: true,
+                        context: {
+                            userId: ownerId,
+                            operation: "memory-store-learnings",
+                        },
+                        memory: { read: false, write: true },
+                    });
+                    console.log(`   🧠 Learning memory stored for ${ownerId}`);
+                    // Auto-commit and push memory files to repo
+                    await this.memoryManager.commitMemoryChanges();
+                }
+                catch (error) {
+                    console.warn(`   ⚠️ Failed to store learning memory: ${error.message}`);
+                }
+            }
             // Check if summarization is needed
             let summarized = false;
             if (request.summarize || (await kbManager.needsSummarization())) {
@@ -134,9 +187,9 @@ export class LearningOrchestrator {
                 summarized = true;
                 console.log("   ✅ Summarization complete");
             }
-            // Commit if requested
+            // Commit knowledge base if requested
             let committed = false;
-            if (request.commit || this.config.knowledgeBase.autoCommit) {
+            if (shouldCommitKb) {
                 console.log("\n📤 Committing knowledge base...");
                 await kbManager.commit(request.pullRequestId, addedCount);
                 committed = true;
@@ -352,8 +405,15 @@ Analyze the PR data above and extract learnings.
      */
     initializeNeurolink() {
         const observabilityConfig = buildObservabilityConfigFromEnv();
+        const conversationMemory = {
+            ...this.config.ai.conversationMemory,
+        };
+        if (this.memoryManager) {
+            conversationMemory.memory =
+                this.memoryManager.buildNeuroLinkMemoryConfig();
+        }
         const neurolinkConfig = {
-            conversationMemory: this.config.ai.conversationMemory,
+            conversationMemory,
         };
         if (observabilityConfig &&
             validateObservabilityConfig(observabilityConfig)) {

package/dist/v2/core/SessionManager.d.ts

@@ -2,7 +2,7 @@
  * Session Manager for Yama
  * Tracks review sessions, tool calls, and maintains state
  */
-import { ReviewSession, ReviewRequest, ReviewResult, SessionMetadata } from "../types/v2.types.js";
+import { ReviewSession, ReviewRequest, ReviewResult, SessionMetadata, ExplorationResult } from "../types/v2.types.js";
 export declare class SessionManager {
     private sessions;
     private maxSessions;
@@ -22,6 +22,8 @@ export declare class SessionManager {
      * Update session metadata
      */
     updateMetadata(sessionId: string, updates: Partial<SessionMetadata>): void;
+    recordExploration(sessionId: string, cacheKey: string, task: string, focus: string[], result: ExplorationResult, cached?: boolean): void;
+    findExploration(sessionId: string, cacheKey: string): ExplorationResult | null;
     /**
      * Mark session as completed
      */

package/dist/v2/core/SessionManager.js

@@ -25,6 +25,7 @@ export class SessionManager {
                 totalCost: 0,
                 cacheHitRatio: 0,
             },
+            explorations: [],
         };
         this.sessions.set(sessionId, session);
         // Clean up old sessions if we exceed max
@@ -68,6 +69,26 @@ export class SessionManager {
             ...updates,
         };
     }
+    recordExploration(sessionId, cacheKey, task, focus, result, cached = false) {
+        const session = this.getSession(sessionId);
+        session.explorations = session.explorations || [];
+        session.explorations.push({
+            task,
+            cacheKey,
+            focus,
+            result,
+            createdAt: new Date(),
+            cached,
+        });
+    }
+    findExploration(sessionId, cacheKey) {
+        const session = this.getSession(sessionId);
+        const match = (session.explorations || [])
+            .slice()
+            .reverse()
+            .find((exploration) => exploration.cacheKey === cacheKey);
+        return match?.result || null;
+    }
     /**
      * Mark session as completed
      */
@@ -166,6 +187,15 @@ export class SessionManager {
                 // Don't include full result in export (can be very large)
                 resultSummary: this.summarizeToolResult(tc.result),
             })),
+            explorations: (session.explorations || []).map((exploration) => ({
+                task: exploration.task,
+                cacheKey: exploration.cacheKey,
+                focus: exploration.focus,
+                createdAt: exploration.createdAt.toISOString(),
+                cached: exploration.cached,
+                // Don't include full result in export (can be very large / may contain sensitive data)
+                resultSummary: this.summarizeToolResult(exploration.result),
+            })),
         };
     }
     /**

package/dist/v2/core/YamaV2Orchestrator.d.ts

@@ -6,16 +6,21 @@ import { LocalReviewRequest, LocalReviewResult, ReviewRequest, ReviewResult, Rev
 import { YamaInitOptions } from "../types/config.types.js";
 export declare class YamaOrchestrator {
     private neurolink;
+    private explorer;
     private mcpManager;
     private configLoader;
     private promptBuilder;
     private sessionManager;
+    private memoryManager;
     private localDiffSource;
     private config;
     private initialized;
     private mcpInitialized;
     private localGitMcpInitialized;
+    private exploreToolRegistered;
+    private currentToolContext;
     private initOptions;
+    private bootstrapStandardsCache;
     constructor(options?: YamaInitOptions);
     /**
      * Initialize Yama with configuration and MCP servers
@@ -64,10 +69,10 @@ export declare class YamaOrchestrator {
      * Export session data
      */
     exportSession(sessionId: string): any;
-    /**
-     * Create tool context for AI
-     */
+    private getUserId;
     private createToolContext;
+    private createLocalToolContext;
+    private setToolContext;
     /**
      * Parse AI response into structured review result
      */
@@ -105,10 +110,6 @@ export declare class YamaOrchestrator {
      */
     private calculateCost;
     private toSafeNumber;
-    /**
-     * Generate userId for NeuroLink context from repository and branch/PR
-     */
-    private generateUserId;
     private isLocalReviewRequest;
     /**
      * Query-level tool filtering for PR mode.
@@ -125,6 +126,14 @@ export declare class YamaOrchestrator {
      * Initialize NeuroLink with observability configuration
      */
     private initializeNeurolink;
+    private registerExploreTool;
+    /**
+     * Bootstrap repo-level standards by delegating to explore_context.
+     * Runs once per (workspace/repository) per process lifetime.
+     * Output is injected into the review prompt as <bootstrapped-standards>.
+     * Graceful: any failure returns empty and the review proceeds without it.
+     */
+    private getBootstrappedStandards;
     /**
      * Ensure orchestrator is initialized
      */