@juspay/yama 2.3.0 → 2.4.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [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)
 
 

package/dist/v2/config/ConfigLoader.js

@@ -180,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 =
@@ -198,6 +204,34 @@ 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;
     }
     /**

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: {

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,6 +6,7 @@ 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;
@@ -16,7 +17,10 @@ export declare class YamaOrchestrator {
     private initialized;
     private mcpInitialized;
     private localGitMcpInitialized;
+    private exploreToolRegistered;
+    private currentToolContext;
     private initOptions;
+    private bootstrapStandardsCache;
     constructor(options?: YamaInitOptions);
     /**
      * Initialize Yama with configuration and MCP servers
@@ -67,6 +71,8 @@ export declare class YamaOrchestrator {
     exportSession(sessionId: string): any;
     private getUserId;
     private createToolContext;
+    private createLocalToolContext;
+    private setToolContext;
     /**
      * Parse AI response into structured review result
      */
@@ -120,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
      */

package/dist/v2/core/YamaV2Orchestrator.js

@@ -9,9 +9,11 @@ import { PromptBuilder } from "../prompts/PromptBuilder.js";
 import { SessionManager } from "./SessionManager.js";
 import { MemoryManager } from "../memory/MemoryManager.js";
 import { LocalDiffSource } from "./LocalDiffSource.js";
+import { ContextExplorerService } from "../exploration/ContextExplorerService.js";
 import { buildObservabilityConfigFromEnv, validateObservabilityConfig, } from "../utils/ObservabilityConfig.js";
 export class YamaOrchestrator {
     neurolink;
+    explorer = null;
     mcpManager;
     configLoader;
     promptBuilder;
@@ -22,7 +24,10 @@ export class YamaOrchestrator {
     initialized = false;
     mcpInitialized = false;
     localGitMcpInitialized = false;
+    exploreToolRegistered = false;
+    currentToolContext = null;
     initOptions;
+    bootstrapStandardsCache = new Map();
     constructor(options = {}) {
         this.initOptions = options;
         this.configLoader = new ConfigLoader();
@@ -50,16 +55,24 @@ export class YamaOrchestrator {
                 // Step 3: Initialize NeuroLink with memory config injected
                 console.log("🧠 Initializing NeuroLink AI engine...");
                 this.neurolink = this.initializeNeurolink();
+                this.explorer = new ContextExplorerService(this.config, this.sessionManager, this.memoryManager);
+                this.registerExploreTool();
                 console.log("✅ NeuroLink initialized\n");
                 this.initialized = true;
             }
             // Step 4: Mode-specific setup
             if (mode === "pr" && !this.mcpInitialized) {
                 await this.mcpManager.setupMCPServers(this.neurolink, this.config.mcpServers);
+                if (this.explorer && this.config.ai.explore.enabled) {
+                    await this.explorer.initialize("pr");
+                }
                 this.mcpInitialized = true;
             }
             else if (mode === "local" && !this.localGitMcpInitialized) {
                 await this.mcpManager.setupLocalGitMCPServer(this.neurolink);
+                if (this.explorer && this.config.ai.explore.enabled) {
+                    await this.explorer.initialize("local");
+                }
                 this.localGitMcpInitialized = true;
             }
             // Step 5: Mode-specific validation
@@ -81,8 +94,9 @@ export class YamaOrchestrator {
         const sessionId = this.sessionManager.createSession(request);
         this.logReviewStart(request, sessionId);
         try {
+            const bootstrapStandards = await this.getBootstrappedStandards(request, sessionId);
             // Build comprehensive AI instructions
-            const instructions = await this.promptBuilder.buildReviewInstructions(request, this.config);
+            const instructions = await this.promptBuilder.buildReviewInstructions(request, this.config, bootstrapStandards);
             if (this.config.display.verboseToolCalls) {
                 console.log("\n📝 AI Instructions built:");
                 console.log(`   Instruction length: ${instructions.length} characters\n`);
@@ -90,7 +104,7 @@ export class YamaOrchestrator {
             // Create tool context for AI
             const toolContext = this.createToolContext(sessionId, request);
             // Set tool context in NeuroLink (using type assertion as setToolContext is documented but may not be in type definitions)
-            this.neurolink.setToolContext(toolContext);
+            this.setToolContext(toolContext);
             // Update session metadata
             this.sessionManager.updateMetadata(sessionId, {
                 aiProvider: this.config.ai.provider,
@@ -161,19 +175,14 @@ export class YamaOrchestrator {
         try {
             const diffContext = this.localDiffSource.getDiffContext(request);
             const instructions = await this.promptBuilder.buildLocalReviewInstructions(request, this.config, diffContext);
+            const toolContext = this.createLocalToolContext(sessionId, pseudoRequest, diffContext);
+            this.setToolContext(toolContext);
             const aiResponse = await this.neurolink.generate({
                 input: { text: instructions },
                 provider: this.config.ai.provider,
                 model: this.config.ai.model,
                 temperature: this.config.ai.temperature,
                 maxTokens: Math.min(this.config.ai.maxTokens, 16_000),
-                maxSteps: 100,
-                prepareStep: async ({ stepNumber }) => {
-                    if (stepNumber >= 5) {
-                        return { toolChoice: "none" };
-                    }
-                    return undefined;
-                },
                 timeout: this.config.ai.timeout,
                 enableAnalytics: this.config.ai.enableAnalytics,
                 enableEvaluation: this.config.ai.enableEvaluation,
@@ -184,7 +193,7 @@ export class YamaOrchestrator {
                 ...this.getLocalToolFilteringOptions(),
                 context: {
                     sessionId,
-                    userId: `local-${sessionId}`,
+                    userId: this.getUserId(pseudoRequest),
                     operation: "local-review",
                     metadata: {
                         repoPath: diffContext.repoPath,
@@ -212,11 +221,12 @@ export class YamaOrchestrator {
         await this.ensureInitialized("pr", request.configPath);
         const sessionId = this.sessionManager.createSession(request);
         try {
+            const bootstrapStandards = await this.getBootstrappedStandards(request, sessionId);
             // Build instructions
-            const instructions = await this.promptBuilder.buildReviewInstructions(request, this.config);
+            const instructions = await this.promptBuilder.buildReviewInstructions(request, this.config, bootstrapStandards);
             // Create tool context
             const toolContext = this.createToolContext(sessionId, request);
-            this.neurolink.setToolContext(toolContext);
+            this.setToolContext(toolContext);
             // Stream AI execution
             yield {
                 type: "progress",
@@ -272,15 +282,16 @@ export class YamaOrchestrator {
             // ========================================================================
             // PHASE 1: Code Review
             // ========================================================================
+            const bootstrapStandards = await this.getBootstrappedStandards(request, sessionId);
             // Build review instructions
-            const reviewInstructions = await this.promptBuilder.buildReviewInstructions(request, this.config);
+            const reviewInstructions = await this.promptBuilder.buildReviewInstructions(request, this.config, bootstrapStandards);
             if (this.config.display.verboseToolCalls) {
                 console.log("\n📝 Review instructions built:");
                 console.log(`   Instruction length: ${reviewInstructions.length} characters\n`);
             }
             // Create tool context
             const toolContext = this.createToolContext(sessionId, request);
-            this.neurolink.setToolContext(toolContext);
+            this.setToolContext(toolContext);
             // Update session metadata
             this.sessionManager.updateMetadata(sessionId, {
                 aiProvider: this.config.ai.provider,
@@ -371,7 +382,7 @@ export class YamaOrchestrator {
             console.log("\n📝 Enhancing PR description...\n");
             const instructions = await this.promptBuilder.buildDescriptionEnhancementInstructions(request, this.config);
             const toolContext = this.createToolContext(sessionId, request);
-            this.neurolink.setToolContext(toolContext);
+            this.setToolContext(toolContext);
             const aiResponse = await this.neurolink.generate({
                 input: { text: instructions },
                 provider: this.config.ai.provider,
@@ -423,6 +434,7 @@ export class YamaOrchestrator {
     createToolContext(sessionId, request) {
         return {
             sessionId,
+            mode: "pr",
             workspace: request.workspace,
             repository: request.repository,
             pullRequestId: request.pullRequestId,
@@ -434,6 +446,27 @@ export class YamaOrchestrator {
             },
         };
     }
+    createLocalToolContext(sessionId, request, diffContext) {
+        return {
+            sessionId,
+            mode: "local",
+            workspace: request.workspace,
+            repository: request.repository,
+            dryRun: request.dryRun || false,
+            metadata: {
+                yamaVersion: "2.2.1",
+                startTime: new Date().toISOString(),
+                repoPath: diffContext.repoPath,
+                diffSource: diffContext.diffSource,
+                baseRef: diffContext.baseRef,
+                headRef: diffContext.headRef,
+            },
+        };
+    }
+    setToolContext(context) {
+        this.currentToolContext = context;
+        this.neurolink.setToolContext(context);
+    }
     /**
      * Parse AI response into structured review result
      */
@@ -946,6 +979,139 @@ export class YamaOrchestrator {
             throw new Error(`NeuroLink initialization failed: ${error}`);
         }
     }
+    registerExploreTool() {
+        if (this.exploreToolRegistered || !this.config.ai.explore.enabled) {
+            return;
+        }
+        this.neurolink.registerTool("explore_context", {
+            name: "explore_context",
+            description: "Delegate non-trivial research to an isolated Explore worker. Use it for function definitions, project-wide search, logic tracing, commit history, rules/context lookup, or any analysis that would otherwise require broad manual scanning.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    task: {
+                        type: "string",
+                        description: "The exact research task for Explore to investigate and answer.",
+                    },
+                    focus: {
+                        type: "array",
+                        description: "Optional list of files, symbols, commits, tickets, or context areas Explore should prioritize.",
+                        items: {
+                            type: "string",
+                        },
+                    },
+                },
+                required: ["task"],
+            },
+            execute: async (params, context) => {
+                if (!this.explorer) {
+                    throw new Error("Explore service is not initialized");
+                }
+                const rawParams = (params || {});
+                const mergedContext = {
+                    ...(this.currentToolContext || {}),
+                    ...(context && typeof context === "object"
+                        ? context
+                        : {}),
+                };
+                const runtimeMode = mergedContext.mode === "local" ? "local" : "pr";
+                const runtimeContext = {
+                    sessionId: String(mergedContext.sessionId || this.currentToolContext?.sessionId || ""),
+                    mode: runtimeMode,
+                    workspace: String(mergedContext.workspace || "local"),
+                    repository: String(mergedContext.repository || "repository"),
+                    pullRequestId: typeof mergedContext.pullRequestId === "number"
+                        ? mergedContext.pullRequestId
+                        : undefined,
+                    branch: typeof mergedContext.branch === "string"
+                        ? mergedContext.branch
+                        : undefined,
+                    dryRun: typeof mergedContext.dryRun === "boolean"
+                        ? mergedContext.dryRun
+                        : false,
+                    metadata: mergedContext.metadata &&
+                        typeof mergedContext.metadata === "object" &&
+                        !Array.isArray(mergedContext.metadata)
+                        ? mergedContext.metadata
+                        : {},
+                };
+                const focus = Array.isArray(rawParams.focus)
+                    ? rawParams.focus.filter((value) => typeof value === "string")
+                    : undefined;
+                const { result, cached } = await this.explorer.explore({
+                    task: String(rawParams.task || "").trim(),
+                    focus,
+                }, runtimeContext);
+                return {
+                    success: true,
+                    data: {
+                        ...result,
+                        cached,
+                    },
+                };
+            },
+        });
+        this.exploreToolRegistered = true;
+    }
+    /**
+     * 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.
+     */
+    async getBootstrappedStandards(request, sessionId) {
+        if (!this.config.ai.explore.enabled || !this.explorer) {
+            return "";
+        }
+        const cacheKey = `${request.workspace}/${request.repository}`.toLowerCase();
+        const cached = this.bootstrapStandardsCache.get(cacheKey);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const task = `Bootstrap repo review standards for ${request.workspace}/${request.repository}. Inspect the last 15 merged pull requests on this repository. For each, collect inline and summary comments left by HUMAN reviewers (ignore bot authors like "Yama", "yama-bot", "yama-review", "euler.bot"). Focus on comments that asked for code changes, flagged bugs, pushed back on an approach, or cited a convention. Distill the recurring patterns and anti-patterns the human reviewers care about — especially things that a static config rule set would miss (naming, error-handling idioms, module boundaries, test expectations, migration rules, review etiquette). Return a concise bullet list of 10-20 patterns. Each bullet: one sentence stating the pattern, optionally one sentence of rationale. Do NOT include PR numbers, author names, or raw quotes — just distilled patterns.`;
+        try {
+            console.log(`   🧭 Bootstrapping repo standards from recent PRs (one-time per process)...`);
+            const { result } = await this.explorer.explore({ task, focus: [request.repository] }, {
+                sessionId,
+                mode: "pr",
+                workspace: request.workspace,
+                repository: request.repository,
+                pullRequestId: request.pullRequestId,
+                branch: request.branch,
+                dryRun: request.dryRun || false,
+                metadata: { bootstrap: true },
+            });
+            const parts = [];
+            if (result.summary && result.summary.trim().length > 0) {
+                parts.push(result.summary.trim());
+            }
+            if (result.findings && result.findings.length > 0) {
+                const bullets = result.findings.map((f) => `- ${f.claim}`).join("\n");
+                parts.push(bullets);
+            }
+            const combined = parts.join("\n\n").trim();
+            if (combined.length > 0) {
+                console.log(`   ✅ Bootstrap standards ready (${combined.length} chars)`);
+                if (this.config.display.verboseToolCalls) {
+                    console.log("   ───────── bootstrapped-standards ─────────");
+                    for (const line of combined.split("\n")) {
+                        console.log(`   ${line}`);
+                    }
+                    console.log("   ──────────────────────────────────────────");
+                }
+            }
+            else {
+                console.log(`   ⚠️  Bootstrap returned no standards — proceeding without them`);
+            }
+            this.bootstrapStandardsCache.set(cacheKey, combined);
+            return combined;
+        }
+        catch (error) {
+            console.warn(`   ⚠️  Bootstrap standards failed, proceeding without: ${error.message}`);
+            this.bootstrapStandardsCache.set(cacheKey, "");
+            return "";
+        }
+    }
     /**
      * Ensure orchestrator is initialized
      */

package/dist/v2/exploration/ContextExplorerService.d.ts

@@ -0,0 +1,39 @@
+import { YamaConfig } from "../types/config.types.js";
+import { SessionManager } from "../core/SessionManager.js";
+import { MemoryManager } from "../memory/MemoryManager.js";
+import { ExploreContextInput, ExploreExecutionResult, ExploreRuntimeContext } from "./types.js";
+export declare class ContextExplorerService {
+    private readonly config;
+    private readonly sessionManager;
+    private readonly memoryManager;
+    private readonly projectRoot;
+    private readonly promptBuilder;
+    private readonly rulesContextLoader;
+    private readonly mcpManager;
+    private neurolink;
+    private prMcpInitialized;
+    private localMcpInitialized;
+    constructor(config: YamaConfig, sessionManager: SessionManager, memoryManager: MemoryManager | null, projectRoot?: string);
+    initialize(mode: "pr" | "local"): Promise<void>;
+    explore(input: ExploreContextInput, runtimeContext: ExploreRuntimeContext): Promise<ExploreExecutionResult>;
+    private normalizeInput;
+    private buildCacheKey;
+    private getToolFilteringOptions;
+    private shouldExcludeTool;
+    private normalizeToolName;
+    private normalizeResult;
+    private buildExtractionPrompt;
+    private truncateForExtraction;
+    private shouldCacheResult;
+    private normalizeFindings;
+    private normalizeEvidence;
+    private normalizeConfidence;
+    private normalizeSourceType;
+    private normalizeNextStep;
+    private extractJsonPayload;
+    private loadProjectStandards;
+    private loadKnowledgeBase;
+    private loadRepositoryMemory;
+    private initializeNeurolink;
+}
+//# sourceMappingURL=ContextExplorerService.d.ts.map