@juspay/yama 2.2.2 → 2.4.0

package/dist/v2/core/YamaV2Orchestrator.js

@@ -7,20 +7,27 @@ 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 { ContextExplorerService } from "../exploration/ContextExplorerService.js";
 import { buildObservabilityConfigFromEnv, validateObservabilityConfig, } from "../utils/ObservabilityConfig.js";
 export class YamaOrchestrator {
     neurolink;
+    explorer = null;
     mcpManager;
     configLoader;
     promptBuilder;
     sessionManager;
+    memoryManager = null;
     localDiffSource;
     config;
     initialized = false;
     mcpInitialized = false;
     localGitMcpInitialized = false;
+    exploreToolRegistered = false;
+    currentToolContext = null;
     initOptions;
+    bootstrapStandardsCache = new Map();
     constructor(options = {}) {
         this.initOptions = options;
         this.configLoader = new ConfigLoader();
@@ -40,22 +47,35 @@ 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();
+                this.explorer = new ContextExplorerService(this.config, this.sessionManager, this.memoryManager);
+                this.registerExploreTool();
                 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);
+                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 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");
@@ -74,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`);
@@ -83,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,
@@ -92,6 +113,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 +125,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,
             });
@@ -152,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,
@@ -175,7 +193,7 @@ export class YamaOrchestrator {
                 ...this.getLocalToolFilteringOptions(),
                 context: {
                     sessionId,
-                    userId: `local-${sessionId}`,
+                    userId: this.getUserId(pseudoRequest),
                     operation: "local-review",
                     metadata: {
                         repoPath: diffContext.repoPath,
@@ -203,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",
@@ -229,8 +248,9 @@ export class YamaOrchestrator {
                 ...this.getPRToolFilteringOptions(instructions),
                 context: {
                     sessionId,
-                    userId: this.generateUserId(request),
+                    userId: this.getUserId(request),
                 },
+                memory: { enabled: false },
                 enableAnalytics: true,
             });
             yield {
@@ -262,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,
@@ -290,10 +311,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 +344,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,
                 });
@@ -359,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,
@@ -368,9 +391,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,12 +428,13 @@ 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,
+            mode: "pr",
             workspace: request.workspace,
             repository: request.repository,
             pullRequestId: request.pullRequestId,
@@ -421,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
      */
@@ -825,14 +871,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 +950,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
@@ -934,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