@juspay/yama 2.2.0 → 2.2.2

package/dist/v2/core/YamaV2Orchestrator.js

@@ -1,5 +1,5 @@
 /**
- * Yama V2 Orchestrator
+ * Yama Orchestrator
  * Main entry point for AI-native autonomous code review
  */
 import { NeuroLink } from "@juspay/neurolink";
@@ -7,44 +7,57 @@ import { MCPServerManager } from "./MCPServerManager.js";
 import { ConfigLoader } from "../config/ConfigLoader.js";
 import { PromptBuilder } from "../prompts/PromptBuilder.js";
 import { SessionManager } from "./SessionManager.js";
+import { LocalDiffSource } from "./LocalDiffSource.js";
 import { buildObservabilityConfigFromEnv, validateObservabilityConfig, } from "../utils/ObservabilityConfig.js";
-export class YamaV2Orchestrator {
+export class YamaOrchestrator {
     neurolink;
     mcpManager;
     configLoader;
     promptBuilder;
     sessionManager;
+    localDiffSource;
     config;
     initialized = false;
-    constructor() {
+    mcpInitialized = false;
+    localGitMcpInitialized = false;
+    initOptions;
+    constructor(options = {}) {
+        this.initOptions = options;
         this.configLoader = new ConfigLoader();
         this.mcpManager = new MCPServerManager();
         this.promptBuilder = new PromptBuilder();
         this.sessionManager = new SessionManager();
+        this.localDiffSource = new LocalDiffSource();
     }
     /**
-     * Initialize Yama V2 with configuration and MCP servers
+     * Initialize Yama with configuration and MCP servers
      */
-    async initialize(configPath) {
-        if (this.initialized) {
-            return;
-        }
-        this.showBanner();
-        console.log("🚀 Initializing Yama V2...\n");
+    async initialize(configPath, mode = "pr") {
         try {
-            // Step 1: Load configuration
-            this.config = await this.configLoader.loadConfig(configPath);
-            // Step 2: Initialize NeuroLink with observability
-            console.log("🧠 Initializing NeuroLink AI engine...");
-            this.neurolink = this.initializeNeurolink();
-            console.log("✅ NeuroLink initialized\n");
-            // Step 3: Setup MCP servers
-            await this.mcpManager.setupMCPServers(this.neurolink, this.config.mcpServers);
-            console.log("✅ MCP servers ready (tools managed by NeuroLink)\n");
-            // Step 4: Validate configuration
-            await this.configLoader.validate();
-            this.initialized = true;
-            console.log("✅ Yama V2 initialized successfully\n");
+            if (!this.initialized) {
+                console.log("🚀 Initializing Yama...\n");
+                // Step 1: Load configuration with SDK-style instance overrides
+                const resolvedConfigPath = configPath || this.initOptions.configPath;
+                this.config = await this.configLoader.loadConfig(resolvedConfigPath, this.initOptions.configOverrides);
+                this.showBanner();
+                // Step 2: Initialize NeuroLink
+                console.log("🧠 Initializing NeuroLink AI engine...");
+                this.neurolink = this.initializeNeurolink();
+                console.log("✅ NeuroLink initialized\n");
+                this.initialized = true;
+            }
+            // Step 3: Mode-specific setup
+            if (mode === "pr" && !this.mcpInitialized) {
+                await this.mcpManager.setupMCPServers(this.neurolink, this.config.mcpServers);
+                this.mcpInitialized = true;
+            }
+            else if (mode === "local" && !this.localGitMcpInitialized) {
+                await this.mcpManager.setupLocalGitMCPServer(this.neurolink);
+                this.localGitMcpInitialized = true;
+            }
+            // Step 4: Mode-specific validation
+            await this.configLoader.validate(mode);
+            console.log("✅ Yama initialized successfully\n");
             console.log("═".repeat(60) + "\n");
         }
         catch (error) {
@@ -56,7 +69,7 @@ export class YamaV2Orchestrator {
      * Start autonomous AI review
      */
     async startReview(request) {
-        await this.ensureInitialized();
+        await this.ensureInitialized("pr", request.configPath);
         const startTime = Date.now();
         const sessionId = this.sessionManager.createSession(request);
         this.logReviewStart(request, sessionId);
@@ -86,6 +99,8 @@ export class YamaV2Orchestrator {
                 temperature: this.config.ai.temperature,
                 maxTokens: this.config.ai.maxTokens,
                 timeout: this.config.ai.timeout,
+                skipToolPromptInjection: true,
+                ...this.getPRToolFilteringOptions(instructions),
                 context: {
                     sessionId,
                     userId: this.generateUserId(request),
@@ -95,6 +110,7 @@ export class YamaV2Orchestrator {
                 enableAnalytics: this.config.ai.enableAnalytics,
                 enableEvaluation: this.config.ai.enableEvaluation,
             });
+            this.recordToolCallsFromResponse(sessionId, aiResponse);
             // Extract and parse results
             const result = this.parseReviewResult(aiResponse, startTime, sessionId);
             // Update session with results
@@ -108,11 +124,83 @@ export class YamaV2Orchestrator {
             throw error;
         }
     }
+    /**
+     * Unified review entry for SDK consumers.
+     */
+    async review(request) {
+        if (this.isLocalReviewRequest(request)) {
+            return this.reviewLocalDiff(request);
+        }
+        return this.startReview(request);
+    }
+    /**
+     * Local SDK mode review from git diff (no PR/MCP dependency).
+     */
+    async reviewLocalDiff(request) {
+        await this.ensureInitialized("local", request.configPath);
+        const sessionSeed = request.repoPath || process.cwd();
+        const pseudoRequest = {
+            mode: "pr",
+            workspace: "local",
+            repository: sessionSeed.split("/").pop() || "local-repo",
+            dryRun: request.dryRun,
+            verbose: request.verbose,
+            configPath: request.configPath,
+        };
+        const sessionId = this.sessionManager.createSession(pseudoRequest);
+        const startTime = Date.now();
+        try {
+            const diffContext = this.localDiffSource.getDiffContext(request);
+            const instructions = await this.promptBuilder.buildLocalReviewInstructions(request, this.config, diffContext);
+            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,
+                // Request JSON output at the provider level (prompt-level mode; safe alongside tools).
+                output: { format: "json" },
+                // Tools are passed natively; avoids huge duplicated tool-schema prompt injection.
+                skipToolPromptInjection: true,
+                ...this.getLocalToolFilteringOptions(),
+                context: {
+                    sessionId,
+                    userId: `local-${sessionId}`,
+                    operation: "local-review",
+                    metadata: {
+                        repoPath: diffContext.repoPath,
+                        diffSource: diffContext.diffSource,
+                        baseRef: diffContext.baseRef,
+                        headRef: diffContext.headRef,
+                    },
+                },
+            });
+            this.recordToolCallsFromResponse(sessionId, aiResponse);
+            const result = this.parseLocalReviewResult(aiResponse, sessionId, startTime, request, diffContext);
+            // Stored as generic session payload for debugging/export parity.
+            this.sessionManager.completeSession(sessionId, result);
+            return result;
+        }
+        catch (error) {
+            this.sessionManager.failSession(sessionId, error);
+            throw error;
+        }
+    }
     /**
      * Stream review with real-time updates (for verbose mode)
      */
     async *streamReview(request) {
-        await this.ensureInitialized();
+        await this.ensureInitialized("pr", request.configPath);
         const sessionId = this.sessionManager.createSession(request);
         try {
             // Build instructions
@@ -137,6 +225,8 @@ export class YamaV2Orchestrator {
                 input: { text: instructions },
                 provider: this.config.ai.provider,
                 model: this.config.ai.model,
+                skipToolPromptInjection: true,
+                ...this.getPRToolFilteringOptions(instructions),
                 context: {
                     sessionId,
                     userId: this.generateUserId(request),
@@ -164,7 +254,7 @@ export class YamaV2Orchestrator {
      * This allows the AI to use knowledge gained during review to write better descriptions
      */
     async startReviewAndEnhance(request) {
-        await this.ensureInitialized();
+        await this.ensureInitialized("pr", request.configPath);
         const startTime = Date.now();
         const sessionId = this.sessionManager.createSession(request);
         this.logReviewStart(request, sessionId);
@@ -196,6 +286,8 @@ export class YamaV2Orchestrator {
                 temperature: this.config.ai.temperature,
                 maxTokens: this.config.ai.maxTokens,
                 timeout: this.config.ai.timeout,
+                skipToolPromptInjection: true,
+                ...this.getPRToolFilteringOptions(reviewInstructions),
                 context: {
                     sessionId,
                     userId: this.generateUserId(request),
@@ -205,6 +297,7 @@ export class YamaV2Orchestrator {
                 enableAnalytics: this.config.ai.enableAnalytics,
                 enableEvaluation: this.config.ai.enableEvaluation,
             });
+            this.recordToolCallsFromResponse(sessionId, reviewResponse);
             // Parse review results
             const reviewResult = this.parseReviewResult(reviewResponse, startTime, sessionId);
             console.log("\n✅ Phase 1 complete: Code review finished");
@@ -225,6 +318,8 @@ export class YamaV2Orchestrator {
                     temperature: this.config.ai.temperature,
                     maxTokens: this.config.ai.maxTokens,
                     timeout: this.config.ai.timeout,
+                    skipToolPromptInjection: true,
+                    ...this.getPRToolFilteringOptions(enhanceInstructions),
                     context: {
                         sessionId, // SAME sessionId = AI remembers review context
                         userId: this.generateUserId(request),
@@ -234,6 +329,7 @@ export class YamaV2Orchestrator {
                     enableAnalytics: this.config.ai.enableAnalytics,
                     enableEvaluation: this.config.ai.enableEvaluation,
                 });
+                this.recordToolCallsFromResponse(sessionId, enhanceResponse);
                 console.log("✅ Phase 2 complete: Description enhanced\n");
                 // Add enhancement status to result
                 reviewResult.descriptionEnhanced = true;
@@ -257,7 +353,7 @@ export class YamaV2Orchestrator {
      * Enhance PR description only (without full review)
      */
     async enhanceDescription(request) {
-        await this.ensureInitialized();
+        await this.ensureInitialized("pr", request.configPath);
         const sessionId = this.sessionManager.createSession(request);
         try {
             console.log("\n📝 Enhancing PR description...\n");
@@ -268,6 +364,8 @@ export class YamaV2Orchestrator {
                 input: { text: instructions },
                 provider: this.config.ai.provider,
                 model: this.config.ai.model,
+                skipToolPromptInjection: true,
+                ...this.getPRToolFilteringOptions(instructions),
                 context: {
                     sessionId,
                     userId: this.generateUserId(request),
@@ -275,6 +373,7 @@ export class YamaV2Orchestrator {
                 },
                 enableAnalytics: true,
             });
+            this.recordToolCallsFromResponse(sessionId, aiResponse);
             console.log("✅ Description enhanced successfully\n");
             return {
                 success: true,
@@ -317,7 +416,7 @@ export class YamaV2Orchestrator {
             branch: request.branch,
             dryRun: request.dryRun || false,
             metadata: {
-                yamaVersion: "2.0.0",
+                yamaVersion: "2.2.1",
                 startTime: new Date().toISOString(),
             },
         };
@@ -333,34 +432,321 @@ export class YamaV2Orchestrator {
         // Calculate statistics from session tool calls
         const statistics = this.calculateStatistics(session);
         return {
+            mode: "pr",
             prId: session.request.pullRequestId || 0,
             decision,
             statistics,
             summary: this.extractSummary(aiResponse),
             duration,
             tokenUsage: {
-                input: aiResponse.usage?.inputTokens || 0,
-                output: aiResponse.usage?.outputTokens || 0,
-                total: aiResponse.usage?.totalTokens || 0,
+                input: this.toSafeNumber(aiResponse?.usage?.inputTokens),
+                output: this.toSafeNumber(aiResponse?.usage?.outputTokens),
+                total: this.toSafeNumber(aiResponse?.usage?.totalTokens),
             },
             costEstimate: this.calculateCost(aiResponse.usage),
             sessionId,
         };
     }
+    recordToolCallsFromResponse(sessionId, aiResponse) {
+        const toolCalls = Array.isArray(aiResponse?.toolCalls)
+            ? aiResponse.toolCalls
+            : [];
+        const toolResults = Array.isArray(aiResponse?.toolResults)
+            ? aiResponse.toolResults
+            : [];
+        for (const call of toolCalls) {
+            const toolName = call?.toolName || call?.name || call?.tool || "unknown_tool";
+            const args = call?.parameters || call?.args || {};
+            const matchingResult = toolResults.find((result) => result?.toolCallId === call?.id || result?.toolName === toolName) || null;
+            this.sessionManager.recordToolCall(sessionId, toolName, args, matchingResult, 0, matchingResult?.error);
+        }
+    }
+    /**
+     * Parse local SDK mode response into strict LocalReviewResult.
+     */
+    parseLocalReviewResult(aiResponse, sessionId, startTime, request, diffContext) {
+        const rawContent = aiResponse?.content || aiResponse?.outputs?.text || "";
+        const parsed = this.extractJsonPayload(rawContent);
+        const usage = aiResponse?.usage || {};
+        const tokenUsage = {
+            input: this.toSafeNumber(usage.inputTokens),
+            output: this.toSafeNumber(usage.outputTokens),
+            total: this.toSafeNumber(usage.totalTokens),
+        };
+        if (!parsed) {
+            const fallbackIssue = {
+                id: "OUTPUT_FORMAT_VIOLATION",
+                severity: "MAJOR",
+                category: "review-engine",
+                title: "Model did not return structured JSON",
+                description: "Local review response was unstructured (likely tool-call trace or partial output), so findings cannot be trusted.",
+                suggestion: "Retry with a tool-calling capable model or reduce review scope (smaller diff / includePaths) to keep responses structured.",
+            };
+            const issuesBySeverity = this.countFindingsBySeverity([fallbackIssue]);
+            return {
+                mode: "local",
+                decision: "CHANGES_REQUESTED",
+                summary: this.sanitizeLocalSummary(rawContent) ||
+                    "Local review could not produce structured JSON output.",
+                issues: [fallbackIssue],
+                enhancements: [],
+                statistics: {
+                    filesChanged: diffContext.changedFiles.length,
+                    additions: diffContext.additions,
+                    deletions: diffContext.deletions,
+                    issuesFound: 1,
+                    enhancementsFound: 0,
+                    issuesBySeverity,
+                },
+                duration: Math.round((Date.now() - startTime) / 1000),
+                tokenUsage,
+                costEstimate: this.calculateCost(aiResponse?.usage),
+                sessionId,
+                schemaVersion: request.outputSchemaVersion || "1.0",
+                metadata: {
+                    repoPath: diffContext.repoPath,
+                    diffSource: diffContext.diffSource,
+                    baseRef: diffContext.baseRef,
+                    headRef: diffContext.headRef,
+                    truncated: diffContext.truncated,
+                },
+            };
+        }
+        const issues = this.normalizeFindings(parsed?.issues, "issue");
+        const enhancements = this.normalizeFindings(parsed?.enhancements, "enhancement");
+        const issuesBySeverity = this.countFindingsBySeverity(issues);
+        const fallbackForTruncatedNoFindings = diffContext.truncated && issues.length === 0 && enhancements.length === 0;
+        const decision = fallbackForTruncatedNoFindings
+            ? "CHANGES_REQUESTED"
+            : this.normalizeDecision(parsed?.decision, issuesBySeverity);
+        return {
+            mode: "local",
+            decision,
+            summary: this.sanitizeLocalSummary(parsed?.summary) ||
+                this.sanitizeLocalSummary(this.extractSummary(aiResponse)) ||
+                "Local review completed",
+            issues,
+            enhancements,
+            statistics: {
+                filesChanged: diffContext.changedFiles.length,
+                additions: diffContext.additions,
+                deletions: diffContext.deletions,
+                issuesFound: issues.length,
+                enhancementsFound: enhancements.length,
+                issuesBySeverity,
+            },
+            duration: Math.round((Date.now() - startTime) / 1000),
+            tokenUsage,
+            costEstimate: this.calculateCost(aiResponse?.usage),
+            sessionId,
+            schemaVersion: request.outputSchemaVersion || "1.0",
+            metadata: {
+                repoPath: diffContext.repoPath,
+                diffSource: diffContext.diffSource,
+                baseRef: diffContext.baseRef,
+                headRef: diffContext.headRef,
+                truncated: diffContext.truncated,
+            },
+        };
+    }
+    sanitizeLocalSummary(summary) {
+        if (typeof summary !== "string") {
+            return "";
+        }
+        // Use string splitting instead of backtracking [\s\S]*? regex to avoid ReDoS.
+        let result = this.removeDelimitedSections(summary, "<|tool_calls_section_begin|>", "<|tool_calls_section_end|>");
+        result = this.removeDelimitedSections(result, "<|tool_call_begin|>", "<|tool_call_end|>");
+        return result.replace(/\s+/g, " ").trim();
+    }
+    removeDelimitedSections(text, open, close) {
+        let result = "";
+        let pos = 0;
+        while (pos < text.length) {
+            const start = text.indexOf(open, pos);
+            if (start === -1) {
+                result += text.slice(pos);
+                break;
+            }
+            result += text.slice(pos, start);
+            const end = text.indexOf(close, start + open.length);
+            pos = end === -1 ? text.length : end + close.length;
+        }
+        return result;
+    }
+    extractJsonPayload(content) {
+        if (!content || typeof content !== "string") {
+            return null;
+        }
+        const trimmed = content.trim();
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            // Fall through to extraction strategies
+        }
+        // Use indexOf instead of backtracking [\s\S]*? regex to avoid ReDoS.
+        const fenceOpen = trimmed.toLowerCase().indexOf("```json");
+        if (fenceOpen !== -1) {
+            let contentStart = fenceOpen + 7; // length of "```json"
+            while (contentStart < trimmed.length &&
+                (trimmed[contentStart] === " " ||
+                    trimmed[contentStart] === "\n" ||
+                    trimmed[contentStart] === "\r")) {
+                contentStart++;
+            }
+            const fenceClose = trimmed.indexOf("```", contentStart);
+            if (fenceClose !== -1) {
+                try {
+                    return JSON.parse(trimmed.slice(contentStart, fenceClose).trim());
+                }
+                catch {
+                    // Continue
+                }
+            }
+        }
+        const start = trimmed.indexOf("{");
+        const end = trimmed.lastIndexOf("}");
+        if (start >= 0 && end > start) {
+            try {
+                return JSON.parse(trimmed.slice(start, end + 1));
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+    normalizeFindings(findings, prefix) {
+        if (!Array.isArray(findings)) {
+            return [];
+        }
+        return findings
+            .map((raw, index) => {
+            const value = (raw || {});
+            const severity = this.normalizeSeverity(value.severity);
+            if (!severity) {
+                return null;
+            }
+            const lineValue = typeof value.line === "number" ? value.line : undefined;
+            const finding = {
+                id: (typeof value.id === "string" && value.id.trim()) ||
+                    `${prefix}-${index + 1}`,
+                severity,
+                category: (typeof value.category === "string" && value.category.trim()) ||
+                    "general",
+                title: (typeof value.title === "string" && value.title.trim()) ||
+                    "Untitled finding",
+                description: (typeof value.description === "string" &&
+                    value.description.trim()) ||
+                    "",
+            };
+            if (typeof value.filePath === "string" && value.filePath.trim()) {
+                finding.filePath = value.filePath;
+            }
+            if (lineValue && lineValue > 0) {
+                finding.line = lineValue;
+            }
+            if (typeof value.suggestion === "string" && value.suggestion.trim()) {
+                finding.suggestion = value.suggestion;
+            }
+            return finding;
+        })
+            .filter((item) => item !== null);
+    }
+    normalizeSeverity(severity) {
+        if (typeof severity !== "string") {
+            return "MINOR";
+        }
+        const value = severity.toUpperCase();
+        if (value === "CRITICAL" ||
+            value === "MAJOR" ||
+            value === "MINOR" ||
+            value === "SUGGESTION") {
+            return value;
+        }
+        return "MINOR";
+    }
+    countFindingsBySeverity(findings) {
+        const counts = {
+            critical: 0,
+            major: 0,
+            minor: 0,
+            suggestions: 0,
+        };
+        for (const finding of findings) {
+            if (finding.severity === "CRITICAL") {
+                counts.critical += 1;
+            }
+            else if (finding.severity === "MAJOR") {
+                counts.major += 1;
+            }
+            else if (finding.severity === "MINOR") {
+                counts.minor += 1;
+            }
+            else {
+                counts.suggestions += 1;
+            }
+        }
+        return counts;
+    }
+    normalizeDecision(decision, issuesBySeverity) {
+        if (typeof decision === "string") {
+            const upper = decision.toUpperCase();
+            if (upper === "APPROVED" ||
+                upper === "CHANGES_REQUESTED" ||
+                upper === "BLOCKED") {
+                return upper;
+            }
+        }
+        if (issuesBySeverity.critical > 0) {
+            return "BLOCKED";
+        }
+        if (issuesBySeverity.major + issuesBySeverity.minor > 0) {
+            return "CHANGES_REQUESTED";
+        }
+        return "APPROVED";
+    }
     /**
      * Extract decision from AI response
      */
     extractDecision(aiResponse, session) {
-        // Check if AI called approve_pull_request or request_changes
+        // Derive final review state from tool calls.
+        // Supports both current Bitbucket MCP tools and legacy names.
         const toolCalls = session.toolCalls || [];
-        const approveCall = toolCalls.find((tc) => tc.toolName === "approve_pull_request");
-        const requestChangesCall = toolCalls.find((tc) => tc.toolName === "request_changes");
-        if (approveCall) {
-            return "APPROVED";
+        let requestedChanges;
+        let approved;
+        for (const tc of toolCalls) {
+            const name = tc?.toolName;
+            const args = tc?.args || {};
+            if (name === "set_review_status") {
+                if (typeof args.request_changes === "boolean") {
+                    requestedChanges = args.request_changes;
+                }
+            }
+            else if (name === "request_changes") {
+                requestedChanges = true;
+            }
+            else if (name === "remove_requested_changes") {
+                requestedChanges = false;
+            }
+            else if (name === "set_pr_approval") {
+                if (typeof args.approved === "boolean") {
+                    approved = args.approved;
+                }
+            }
+            else if (name === "approve_pull_request") {
+                approved = true;
+            }
+            else if (name === "unapprove_pull_request") {
+                approved = false;
+            }
         }
-        if (requestChangesCall) {
+        if (requestedChanges === true) {
             return "BLOCKED";
         }
+        if (approved === true) {
+            return "APPROVED";
+        }
         // Default to changes requested if unclear
         return "CHANGES_REQUESTED";
     }
@@ -428,9 +814,16 @@ export class YamaV2Orchestrator {
         // Rough estimates (update with actual pricing)
         const inputCostPer1M = 0.25; // $0.25 per 1M input tokens (Gemini 2.0 Flash)
         const outputCostPer1M = 1.0; // $1.00 per 1M output tokens
-        const inputCost = (usage.inputTokens / 1_000_000) * inputCostPer1M;
-        const outputCost = (usage.outputTokens / 1_000_000) * outputCostPer1M;
-        return Number((inputCost + outputCost).toFixed(4));
+        const inputTokens = this.toSafeNumber(usage.inputTokens);
+        const outputTokens = this.toSafeNumber(usage.outputTokens);
+        const inputCost = (inputTokens / 1_000_000) * inputCostPer1M;
+        const outputCost = (outputTokens / 1_000_000) * outputCostPer1M;
+        const totalCost = inputCost + outputCost;
+        return Number.isFinite(totalCost) ? Number(totalCost.toFixed(4)) : 0;
+    }
+    toSafeNumber(value) {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : 0;
     }
     /**
      * Generate userId for NeuroLink context from repository and branch/PR
@@ -440,6 +833,79 @@ export class YamaV2Orchestrator {
         const identifier = request.branch || `pr-${request.pullRequestId}`;
         return `${repo}-${identifier}`;
     }
+    isLocalReviewRequest(request) {
+        return (request.mode === "local" ||
+            (!("workspace" in request) && !("repository" in request)));
+    }
+    /**
+     * Query-level tool filtering for PR mode.
+     * Conservative strategy: only exclude Jira tools when there is no Jira signal.
+     */
+    getPRToolFilteringOptions(inputText) {
+        if (!this.config.ai.enableToolFiltering) {
+            return {};
+        }
+        const mode = this.config.ai.toolFilteringMode || "active";
+        if (mode === "off") {
+            return {};
+        }
+        const hasJiraSignal = /\b[A-Z]{2,}-\d+\b/.test(inputText) || /\bjira\b/i.test(inputText);
+        if (hasJiraSignal) {
+            return {};
+        }
+        try {
+            const externalTools = this.neurolink.getExternalMCPTools?.();
+            const jiraToolNames = Array.isArray(externalTools)
+                ? externalTools
+                    .filter((tool) => tool?.serverId === "jira")
+                    .map((tool) => tool?.name)
+                    .filter((name) => typeof name === "string")
+                : [];
+            if (jiraToolNames.length === 0) {
+                return {};
+            }
+            if (mode === "log-only") {
+                console.log(`   [tool-filter] log-only: would exclude ${jiraToolNames.length} Jira tools`);
+                return {};
+            }
+            return { excludeTools: jiraToolNames };
+        }
+        catch {
+            // Non-fatal: fallback to all tools.
+            return {};
+        }
+    }
+    /**
+     * Query-level read-only filtering for local-git MCP tools.
+     * Uses regex-based mutation detection instead of hardcoded tool-name lists.
+     */
+    getLocalToolFilteringOptions() {
+        try {
+            const externalTools = this.neurolink.getExternalMCPTools?.();
+            if (!Array.isArray(externalTools)) {
+                return {};
+            }
+            const mutatingGitToolPattern = /^git_(commit|push|add|checkout|create_branch|merge|rebase|cherry_pick|reset|revert|tag|rm|clean|stash|apply)\b/i;
+            // High-volume read operations can flood context with huge payloads.
+            const highVolumeGitToolPattern = /^git_(diff|diff_staged|diff_unstaged|log|show)\b/i;
+            const excludeTools = externalTools
+                .filter((tool) => tool?.serverId === "local-git")
+                .map((tool) => tool?.name)
+                .filter((name) => typeof name === "string")
+                .filter((name) => mutatingGitToolPattern.test(this.normalizeToolName(name)) ||
+                highVolumeGitToolPattern.test(this.normalizeToolName(name)));
+            if (excludeTools.length === 0) {
+                return {};
+            }
+            return { excludeTools };
+        }
+        catch {
+            return {};
+        }
+    }
+    normalizeToolName(name) {
+        return name.split(/[.:/]/).pop() || name;
+    }
     /**
      * Initialize NeuroLink with observability configuration
      */
@@ -471,13 +937,11 @@ export class YamaV2Orchestrator {
     /**
      * Ensure orchestrator is initialized
      */
-    async ensureInitialized() {
-        if (!this.initialized) {
-            await this.initialize();
-        }
+    async ensureInitialized(mode = "pr", configPath) {
+        await this.initialize(configPath, mode);
     }
     /**
-     * Show Yama V2 banner
+     * Show Yama banner
      */
     showBanner() {
         if (!this.config?.display?.showBanner) {
@@ -485,9 +949,9 @@ export class YamaV2Orchestrator {
         }
         console.log("\n" + "═".repeat(60));
         console.log(`
-    ⚔️  YAMA V2 - AI-Native Code Review Guardian
+    ⚔️  YAMA - AI-Native Code Review Guardian
 
-    Version: 2.0.0
+    Version: 2.2.1
     Mode: Autonomous AI-Powered Review
     Powered by: NeuroLink + MCP Tools
     `);
@@ -543,7 +1007,11 @@ export class YamaV2Orchestrator {
     }
 }
 // Export factory function
-export function createYamaV2() {
-    return new YamaV2Orchestrator();
+export function createYamaV2(options = {}) {
+    return createYama(options);
+}
+export function createYama(options = {}) {
+    return new YamaOrchestrator(options);
 }
+export { YamaOrchestrator as YamaV2Orchestrator };
 //# sourceMappingURL=YamaV2Orchestrator.js.map