@juspay/yama 2.2.2 → 2.3.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [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);
@@ -199,6 +200,39 @@ export class ConfigLoader {
         }
         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

@@ -158,6 +158,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/YamaV2Orchestrator.d.ts

@@ -10,6 +10,7 @@ export declare class YamaOrchestrator {
     private configLoader;
     private promptBuilder;
     private sessionManager;
+    private memoryManager;
     private localDiffSource;
     private config;
     private initialized;
@@ -64,9 +65,7 @@ export declare class YamaOrchestrator {
      * Export session data
      */
     exportSession(sessionId: string): any;
-    /**
-     * Create tool context for AI
-     */
+    private getUserId;
     private createToolContext;
     /**
      * Parse AI response into structured review result
@@ -105,10 +104,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.

package/dist/v2/core/YamaV2Orchestrator.js

@@ -7,6 +7,7 @@ import { MCPServerManager } from "./MCPServerManager.js";
 import { ConfigLoader } from "../config/ConfigLoader.js";
 import { PromptBuilder } from "../prompts/PromptBuilder.js";
 import { SessionManager } from "./SessionManager.js";
+import { MemoryManager } from "../memory/MemoryManager.js";
 import { LocalDiffSource } from "./LocalDiffSource.js";
 import { buildObservabilityConfigFromEnv, validateObservabilityConfig, } from "../utils/ObservabilityConfig.js";
 export class YamaOrchestrator {
@@ -15,6 +16,7 @@ export class YamaOrchestrator {
     configLoader;
     promptBuilder;
     sessionManager;
+    memoryManager = null;
     localDiffSource;
     config;
     initialized = false;
@@ -40,13 +42,18 @@ export class YamaOrchestrator {
                 const resolvedConfigPath = configPath || this.initOptions.configPath;
                 this.config = await this.configLoader.loadConfig(resolvedConfigPath, this.initOptions.configOverrides);
                 this.showBanner();
-                // Step 2: Initialize NeuroLink
+                // Step 2: Initialize
+                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");
+                }
+                // Step 3: Initialize NeuroLink with memory config injected
                 console.log("🧠 Initializing NeuroLink AI engine...");
                 this.neurolink = this.initializeNeurolink();
                 console.log("✅ NeuroLink initialized\n");
                 this.initialized = true;
             }
-            // Step 3: Mode-specific setup
+            // Step 4: Mode-specific setup
             if (mode === "pr" && !this.mcpInitialized) {
                 await this.mcpManager.setupMCPServers(this.neurolink, this.config.mcpServers);
                 this.mcpInitialized = true;
@@ -55,7 +62,7 @@ export class YamaOrchestrator {
                 await this.mcpManager.setupLocalGitMCPServer(this.neurolink);
                 this.localGitMcpInitialized = true;
             }
-            // Step 4: Mode-specific validation
+            // Step 5: Mode-specific validation
             await this.configLoader.validate(mode);
             console.log("✅ Yama initialized successfully\n");
             console.log("═".repeat(60) + "\n");
@@ -92,6 +99,7 @@ export class YamaOrchestrator {
             // Execute autonomous AI review
             console.log("🤖 Starting autonomous AI review...");
             console.log("   AI will now make decisions and execute actions autonomously\n");
+            // Review call: RETRIEVE memory (for context), but DON'T STORE
             const aiResponse = await this.neurolink.generate({
                 input: { text: instructions },
                 provider: this.config.ai.provider,
@@ -103,10 +111,11 @@ export class YamaOrchestrator {
                 ...this.getPRToolFilteringOptions(instructions),
                 context: {
                     sessionId,
-                    userId: this.generateUserId(request),
+                    userId: this.getUserId(request),
                     operation: "code-review",
                     metadata: toolContext.metadata,
                 },
+                memory: { read: true, write: false },
                 enableAnalytics: this.config.ai.enableAnalytics,
                 enableEvaluation: this.config.ai.enableEvaluation,
             });
@@ -229,8 +238,9 @@ export class YamaOrchestrator {
                 ...this.getPRToolFilteringOptions(instructions),
                 context: {
                     sessionId,
-                    userId: this.generateUserId(request),
+                    userId: this.getUserId(request),
                 },
+                memory: { enabled: false },
                 enableAnalytics: true,
             });
             yield {
@@ -290,10 +300,11 @@ export class YamaOrchestrator {
                 ...this.getPRToolFilteringOptions(reviewInstructions),
                 context: {
                     sessionId,
-                    userId: this.generateUserId(request),
+                    userId: this.getUserId(request),
                     operation: "code-review",
                     metadata: toolContext.metadata,
                 },
+                memory: { read: true, write: false },
                 enableAnalytics: this.config.ai.enableAnalytics,
                 enableEvaluation: this.config.ai.enableEvaluation,
             });
@@ -322,10 +333,11 @@ export class YamaOrchestrator {
                     ...this.getPRToolFilteringOptions(enhanceInstructions),
                     context: {
                         sessionId, // SAME sessionId = AI remembers review context
-                        userId: this.generateUserId(request),
+                        userId: this.getUserId(request),
                         operation: "description-enhancement",
                         metadata: toolContext.metadata,
                     },
+                    memory: { enabled: false },
                     enableAnalytics: this.config.ai.enableAnalytics,
                     enableEvaluation: this.config.ai.enableEvaluation,
                 });
@@ -368,9 +380,10 @@ export class YamaOrchestrator {
                 ...this.getPRToolFilteringOptions(instructions),
                 context: {
                     sessionId,
-                    userId: this.generateUserId(request),
+                    userId: this.getUserId(request),
                     operation: "description-enhancement",
                 },
+                memory: { enabled: false },
                 enableAnalytics: true,
             });
             this.recordToolCallsFromResponse(sessionId, aiResponse);
@@ -404,9 +417,9 @@ export class YamaOrchestrator {
     exportSession(sessionId) {
         return this.sessionManager.exportSession(sessionId);
     }
-    /**
-     * Create tool context for AI
-     */
+    getUserId(request) {
+        return `${request.workspace}-${request.repository}`.toLowerCase();
+    }
     createToolContext(sessionId, request) {
         return {
             sessionId,
@@ -825,14 +838,6 @@ export class YamaOrchestrator {
         const parsed = Number(value);
         return Number.isFinite(parsed) ? parsed : 0;
     }
-    /**
-     * Generate userId for NeuroLink context from repository and branch/PR
-     */
-    generateUserId(request) {
-        const repo = request.repository;
-        const identifier = request.branch || `pr-${request.pullRequestId}`;
-        return `${repo}-${identifier}`;
-    }
     isLocalReviewRequest(request) {
         return (request.mode === "local" ||
             (!("workspace" in request) && !("repository" in request)));
@@ -912,8 +917,15 @@ export class YamaOrchestrator {
     initializeNeurolink() {
         try {
             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) {
                 // Validate observability config

package/dist/v2/learning/types.d.ts

@@ -58,12 +58,22 @@ export interface KnowledgeBase {
 /**
  * Request for the learn command
  */
+/**
+ * Controls which storage systems are committed after learning extraction.
+ * - "kb"     — commit only the knowledge base file (existing behavior)
+ * - "memory" — commit only per-repo memory files (via NeuroLink + git push)
+ * - "all"    — commit both knowledge base and per-repo memory
+ */
+export type LearnCommitMode = "kb" | "memory" | "all";
 export interface LearnRequest {
     workspace: string;
     repository: string;
     pullRequestId: number;
     dryRun?: boolean;
+    /** @deprecated Use commitMode instead */
     commit?: boolean;
+    /** Controls which storage systems are committed after extraction */
+    commitMode?: LearnCommitMode;
     summarize?: boolean;
     outputPath?: string;
     outputFormat?: "md" | "json";

package/dist/v2/memory/MemoryManager.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Memory Manager
+ *
+ * Provides per-repository condensed memory configuration for NeuroLink.
+ *
+ * This manager builds the NeuroLink-compatible memory SDK config with
+ * file-based custom storage, so that NeuroLink's generate()/stream() calls
+ * can retrieve and store memory using context.userId as the per-repo key.
+ *
+ * Callers control WHEN memory is read/written via per-call flags:
+ *   memory: { enabled: true, read: true, write: false }
+ *
+ * This avoids noise from operational calls (e.g., fetching PR data)
+ * polluting the condensed memory.
+ *
+ * Storage: file-based (.yama/memory/{workspace}-{repository}.txt) (lowercased)
+ * Condensation: LLM-powered via NeuroLink's built-in Hippocampus
+ */
+import { MemoryConfig } from "../types/config.types.js";
+export declare class MemoryManager {
+    private readonly config;
+    private readonly projectRoot;
+    private readonly aiProvider;
+    private readonly aiModel;
+    constructor(config: MemoryConfig, aiProvider: string, aiModel: string, projectRoot?: string);
+    /**
+     * Resolve the storage directory path (handles both absolute and relative paths).
+     */
+    private resolveStorageDir;
+    /**
+     * Build the NeuroLink-compatible Memory config object.
+     *
+     * Passed to NeuroLink constructor as `conversationMemory.memory`.
+     * NeuroLink internally initializes Hippocampus with our file-based
+     * storage and review-specific condensation prompt.
+     */
+    buildNeuroLinkMemoryConfig(): Record<string, unknown>;
+    /**
+     * Build a deterministic owner ID from workspace and repository.
+     * This value is passed as `context.userId` in generate() calls.
+     */
+    static buildOwnerId(workspace: string, repository: string): string;
+    /**
+     * Commit memory files to the repository if autoCommit is enabled.
+     *
+     * Checks git status for changes in the storagePath directory,
+     * then stages, commits, and pushes. Uses [skip ci] to prevent
+     * infinite CI loops. Never throws — failures are logged and ignored
+     * so they never block the review result.
+     */
+    commitMemoryChanges(): Promise<boolean>;
+    /**
+     * Map an ownerId to a safe file path.
+     */
+    private ownerIdToFilePath;
+}
+//# sourceMappingURL=MemoryManager.d.ts.map

package/dist/v2/memory/MemoryManager.js

@@ -0,0 +1,185 @@
+/**
+ * Memory Manager
+ *
+ * Provides per-repository condensed memory configuration for NeuroLink.
+ *
+ * This manager builds the NeuroLink-compatible memory SDK config with
+ * file-based custom storage, so that NeuroLink's generate()/stream() calls
+ * can retrieve and store memory using context.userId as the per-repo key.
+ *
+ * Callers control WHEN memory is read/written via per-call flags:
+ *   memory: { enabled: true, read: true, write: false }
+ *
+ * This avoids noise from operational calls (e.g., fetching PR data)
+ * polluting the condensed memory.
+ *
+ * Storage: file-based (.yama/memory/{workspace}-{repository}.txt) (lowercased)
+ * Condensation: LLM-powered via NeuroLink's built-in Hippocampus
+ */
+import { readFile, writeFile, mkdir, unlink } from "fs/promises";
+import { existsSync } from "fs";
+import { join, dirname, isAbsolute } from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
+const execFileAsync = promisify(execFile);
+// ============================================================================
+// Constants
+// ============================================================================
+/**
+ * Condensation prompt tailored for code review memory.
+ * Guides the LLM to retain review patterns, team conventions, and
+ * frequently flagged issues rather than individual PR details.
+ */
+const REVIEW_MEMORY_CONDENSATION_PROMPT = `You are a memory condensation engine for an AI code reviewer called Yama.
+You receive:
+1. OLD_MEMORY: the existing condensed memory for a specific repository (may be empty)
+2. NEW_CONTENT: new information from a recent code review or learning extraction
+
+Your job: merge old memory with the new information into a single condensed summary.
+
+Rules:
+- Output ONLY the condensed memory text, nothing else
+- Maximum {{MAX_WORDS}} words
+- PRIORITIZE retaining (most important first):
+  1. False positive patterns: things the team confirmed are NOT issues
+  2. Team coding conventions and style preferences
+  3. Recurring review themes and common issue categories
+  4. Repository-specific domain knowledge and architecture decisions
+  5. Patterns the AI missed that developers caught
+  6. Review outcome trends (approval rate, common blocking reasons)
+- DROP: individual PR numbers, timestamps, one-off issues, greeting text
+- Keep learnings GENERIC and applicable to future reviews
+- If NEW_CONTENT has nothing worth remembering, return OLD_MEMORY unchanged
+- If both are empty, return empty string`;
+// ============================================================================
+// Manager
+// ============================================================================
+export class MemoryManager {
+    config;
+    projectRoot;
+    aiProvider;
+    aiModel;
+    constructor(config, aiProvider, aiModel, projectRoot) {
+        this.config = config;
+        this.aiProvider = aiProvider;
+        this.aiModel = aiModel;
+        this.projectRoot = projectRoot || process.cwd();
+    }
+    /**
+     * Resolve the storage directory path (handles both absolute and relative paths).
+     */
+    resolveStorageDir() {
+        return isAbsolute(this.config.storagePath)
+            ? this.config.storagePath
+            : join(this.projectRoot, this.config.storagePath);
+    }
+    /**
+     * Build the NeuroLink-compatible Memory config object.
+     *
+     * Passed to NeuroLink constructor as `conversationMemory.memory`.
+     * NeuroLink internally initializes Hippocampus with our file-based
+     * storage and review-specific condensation prompt.
+     */
+    buildNeuroLinkMemoryConfig() {
+        const storageDir = this.resolveStorageDir();
+        return {
+            enabled: true,
+            storage: this.config.storage || {
+                type: "custom",
+                onGet: async (ownerId) => {
+                    const filePath = this.ownerIdToFilePath(storageDir, ownerId);
+                    if (!existsSync(filePath)) {
+                        return null;
+                    }
+                    try {
+                        return await readFile(filePath, "utf-8");
+                    }
+                    catch {
+                        return null;
+                    }
+                },
+                onSet: async (ownerId, memory) => {
+                    const filePath = this.ownerIdToFilePath(storageDir, ownerId);
+                    const dir = dirname(filePath);
+                    if (!existsSync(dir)) {
+                        await mkdir(dir, { recursive: true });
+                    }
+                    await writeFile(filePath, memory, "utf-8");
+                },
+                onDelete: async (ownerId) => {
+                    const filePath = this.ownerIdToFilePath(storageDir, ownerId);
+                    if (existsSync(filePath)) {
+                        await unlink(filePath);
+                    }
+                },
+            },
+            neurolink: this.config.neurolink || {
+                provider: this.aiProvider,
+                model: this.aiModel,
+                temperature: 0.1,
+            },
+            maxWords: this.config.maxWords,
+            prompt: this.config.prompt || REVIEW_MEMORY_CONDENSATION_PROMPT,
+        };
+    }
+    /**
+     * Build a deterministic owner ID from workspace and repository.
+     * This value is passed as `context.userId` in generate() calls.
+     */
+    static buildOwnerId(workspace, repository) {
+        return `${workspace}-${repository}`.toLowerCase();
+    }
+    /**
+     * Commit memory files to the repository if autoCommit is enabled.
+     *
+     * Checks git status for changes in the storagePath directory,
+     * then stages, commits, and pushes. Uses [skip ci] to prevent
+     * infinite CI loops. Never throws — failures are logged and ignored
+     * so they never block the review result.
+     */
+    async commitMemoryChanges() {
+        if (!this.config.autoCommit) {
+            return false;
+        }
+        const storageDir = this.resolveStorageDir();
+        if (!existsSync(storageDir)) {
+            return false;
+        }
+        try {
+            // Check if there are any changes to commit
+            const { stdout: statusOutput } = await execFileAsync("git", ["status", "--porcelain", storageDir], { cwd: this.projectRoot });
+            if (!statusOutput.trim()) {
+                console.log("   🧠 No memory changes to commit");
+                return false;
+            }
+            const commitMessage = this.config.commitMessage ||
+                "chore: update yama review memory [skip ci]";
+            // Stage memory files
+            await execFileAsync("git", ["add", storageDir], {
+                cwd: this.projectRoot,
+            });
+            // Commit with [skip ci] to prevent infinite loops
+            await execFileAsync("git", ["commit", "-m", commitMessage], {
+                cwd: this.projectRoot,
+            });
+            // Push to the current branch
+            await execFileAsync("git", ["push"], {
+                cwd: this.projectRoot,
+            });
+            console.log("   🧠 Memory changes committed and pushed");
+            return true;
+        }
+        catch (error) {
+            console.warn(`   ⚠️ Memory auto-commit failed: ${error.message}`);
+            return false;
+        }
+    }
+    /**
+     * Map an ownerId to a safe file path.
+     */
+    ownerIdToFilePath(storageDir, ownerId) {
+        const safeId = ownerId.replace(/[^a-zA-Z0-9-]/g, "-");
+        return join(storageDir, `${safeId}.md`);
+    }
+}
+//# sourceMappingURL=MemoryManager.js.map

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

@@ -12,6 +12,7 @@ export interface YamaConfig {
     descriptionEnhancement: DescriptionEnhancementConfig;
     memoryBank: MemoryBankConfig;
     knowledgeBase: KnowledgeBaseConfig;
+    memory: MemoryConfig;
     projectStandards?: ProjectStandardsConfig;
     monitoring: MonitoringConfig;
     performance: PerformanceConfig;
@@ -114,6 +115,56 @@ export interface KnowledgeBaseConfig {
     /** Auto-commit knowledge base changes (default for --commit flag) */
     autoCommit: boolean;
 }
+/** Storage backend configuration for Hippocampus memory */
+export type MemoryStorageConfig = {
+    type: "sqlite";
+    path?: string;
+} | {
+    type: "redis";
+    host?: string;
+    port?: number;
+    password?: string;
+    db?: number;
+    keyPrefix?: string;
+    ttl?: number;
+} | {
+    type: "s3";
+    bucket: string;
+    prefix?: string;
+} | {
+    type: "custom";
+    onGet: (ownerId: string) => Promise<string | null>;
+    onSet: (ownerId: string, memory: string) => Promise<void>;
+    onDelete: (ownerId: string) => Promise<void>;
+    onClose?: () => Promise<void>;
+};
+/**
+ * Yama-specific memory configuration.
+ * Mirrors NeuroLink's Memory type (HippocampusConfig & { enabled }) with
+ * Yama-specific fields for file-based storage.
+ */
+export interface MemoryConfig {
+    /** Enable per-repo condensed memory feature */
+    enabled: boolean;
+    /** Directory for file-based memory storage (relative to project root) */
+    storagePath: string;
+    /** Maximum word count for condensed memory per repository (default: 50) */
+    maxWords?: number;
+    /** Custom condensation prompt (overrides default review-specific prompt) */
+    prompt?: string;
+    /** Storage backend configuration (default: file-based custom storage managed by Yama) */
+    storage?: MemoryStorageConfig;
+    /** AI provider/model for memory condensation (defaults to main AI provider) */
+    neurolink?: {
+        provider?: string;
+        model?: string;
+        temperature?: number;
+    };
+    /** Auto-commit memory files to the repo after review (default: false) */
+    autoCommit?: boolean;
+    /** Git commit message for memory auto-commits (default: "chore: update yama review memory [skip ci]") */
+    commitMessage?: string;
+}
 export interface ProjectStandardsConfig {
     customPromptsPath: string;
     additionalFocusAreas: FocusArea[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/yama",
-  "version": "2.2.2",
+  "version": "2.3.0",
   "description": "Enterprise-grade Pull Request automation toolkit with AI-powered code review and description enhancement",
   "keywords": [
     "pr",
@@ -89,7 +89,7 @@
     "check:all": "npm run lint && npm run format --check && npm run validate && npm run validate:commit"
   },
   "dependencies": {
-    "@juspay/neurolink": "^9.18.0",
+    "@juspay/neurolink": "^9.42.0",
     "langfuse": "^3.35.0",
     "@nexus2520/bitbucket-mcp-server": "2.0.1",
     "@nexus2520/jira-mcp-server": "^1.1.1",

package/yama.config.example.yaml

@@ -231,6 +231,21 @@ knowledgeBase:
   # Automatically commit knowledge base changes (with --commit flag)
   autoCommit: false
 
+# Per-repo condensed memory
+# Memory accumulates durable facts about each repository across reviews
+memory:
+  enabled: true
+  storagePath: ".yama/memory"
+  # Maximum word count for condensed memory per repository (default: 50)
+  maxWords: 200
+  # prompt: "Your custom condensation prompt here..."
+  # neurolink:
+  #   provider: google-ai
+  #   model: gemini-2.0-flash
+  #   temperature: 0.1
+  autoCommit: true # Auto-commit memory files to repo after each review (persists across CI builds)
+  # commitMessage: "chore: update yama review memory [skip ci]"
+
 # ============================================================================
 # Project-Specific Standards (Override in your repository)
 # ============================================================================