@krotovm/gitlab-ai-review 1.0.17 → 1.0.19

package/README.md

@@ -2,13 +2,13 @@
 
 # AI Code Reviewer
 
-Gitlab AI Code Review is a CLI tool that leverages OpenAI models to automatically review code changes and output a Markdown review (either to GitLab merge requests via CI, or to your local console).
+Gitlab AI Code Review is a CLI tool that leverages OpenAI models to automatically review code changes and post a Markdown review to GitLab merge requests from CI.
 
 ## Features
 
 - Automatically reviews code changes in GitLab repositories
 - Provides feedback on bugs and optimization opportunities
-- Generates Markdown-formatted responses for easy readability in GitLab
+- Generates Markdown-formatted responses for easy readability in GitLab as merge request comment
 
 ## Usage
 
@@ -27,25 +27,7 @@ ai_review:
   rules:
     - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
   script:
-    - npx -y @krotovm/gitlab-ai-review --ci
-```
-
-### Local CLI
-
-Run locally to review diffs and print the review to stdout.
-
-```bash
-# review local uncommitted changes
-npx -y @krotovm/gitlab-ai-review --worktree
-
-# review last commit and ignore docs/lock changes by extension
-npx -y @krotovm/gitlab-ai-review --last-commit --ignore-ext=md,lock
-
-# review a prepared git diff from file
-npx -y @krotovm/gitlab-ai-review --diff-file=./changes.diff
-
-# use a custom OpenAI-compatible endpoint
-OPENAI_BASE_URL="https://api.openai.com/v1" npx -y @krotovm/gitlab-ai-review --worktree
+    - npx -y @krotovm/gitlab-ai-review
 ```
 
 ## Env variables
@@ -69,14 +51,10 @@ GitLab provides these automatically in Merge Request pipelines:
 
 ## Flags
 
-- `--ci` - Run in GitLab MR pipeline mode and post a new MR note.
-- `--worktree` - Review local uncommitted changes (staged + unstaged).
-- `--last-commit` - Review the last commit (`HEAD`).
-- `--diff-file=./changes.diff` - Review git-diff content from a file and print to stdout.
 - `--ignore-ext=md,lock` - Exclude file extensions from review (comma-separated only).
 - `--max-diffs=50` - Max number of diffs included in the prompt.
-- `--max-diff-chars=16000` - Max chars per diff chunk (local modes / single-pass fallback).
-- `--max-total-prompt-chars=220000` - Final hard cap for prompt size (local modes / single-pass fallback).
+- `--max-diff-chars=16000` - Max chars per diff chunk (single-pass fallback only).
+- `--max-total-prompt-chars=220000` - Final hard cap for prompt size (single-pass fallback only).
 - `--max-findings=5` - Max findings in the final review (CI multi-pass only).
 - `--max-review-concurrency=5` - Parallel per-file review API calls (CI multi-pass only).
 - `--debug` - Print full error details (stack and API error fields).
@@ -84,7 +62,7 @@ GitLab provides these automatically in Merge Request pipelines:
 
 ## Architecture
 
-In CI MR mode, the reviewer uses a three-pass pipeline optimised for large merge requests:
+The reviewer uses a three-pass pipeline optimised for large merge requests:
 
 1. **Triage** — a fast LLM call classifies each changed file as `NEEDS_REVIEW` or `SKIP` (cosmetic-only changes, docs, config) and produces a short MR summary.
 2. **Per-file review** — only `NEEDS_REVIEW` files are reviewed, each in a dedicated LLM call running in parallel (with tool access to fetch full files or grep the repository). Each file gets full model attention instead of competing for it across a single giant prompt.
@@ -92,4 +70,4 @@ In CI MR mode, the reviewer uses a three-pass pipeline optimised for large merge
 
 If the triage pass fails (API error, unparseable response), the pipeline falls back to the original single-pass approach automatically.
 
-Local modes (`--worktree`, `--last-commit`, `--diff-file`) use a simpler single-pass pipeline.
+The CI pipeline falls back to a simpler single-pass review automatically when triage cannot be used.

package/dist/cli/args.js

@@ -0,0 +1,89 @@
+/** @format */
+import { DEFAULT_PROMPT_LIMITS, } from "../prompt/index.js";
+export function requireEnvs(names) {
+    const missing = names.filter((name) => {
+        const value = process.env[name];
+        return value == null || value.trim() === "";
+    });
+    if (missing.length > 0) {
+        throw new Error(`Missing required env vars: ${missing.join(", ")}`);
+    }
+    const result = {};
+    for (const name of names) {
+        result[name] = process.env[name].trim();
+    }
+    return result;
+}
+export function envOrDefault(name, defaultValue) {
+    const value = process.env[name];
+    if (value == null)
+        return defaultValue;
+    const trimmed = value.trim();
+    return trimmed === "" ? defaultValue : trimmed;
+}
+export function envOrUndefined(name) {
+    const value = process.env[name];
+    if (value == null)
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed === "" ? undefined : trimmed;
+}
+export function hasDebugFlag(argv) {
+    const args = new Set(argv.slice(2));
+    return args.has("--debug");
+}
+export function hasForceToolsFlag(argv) {
+    const args = new Set(argv.slice(2));
+    return args.has("--force-tools");
+}
+export function parseIgnoreExtensions(argv) {
+    const parsed = [];
+    const args = argv.slice(2);
+    for (const current of args) {
+        if (current === "--ignore-ext") {
+            throw new Error("Use comma-separated format: --ignore-ext=md,lock");
+        }
+        if (!current.startsWith("--ignore-ext="))
+            continue;
+        const value = current.slice("--ignore-ext=".length);
+        if (value.trim() === "")
+            continue;
+        const pieces = value
+            .split(",")
+            .map((part) => part.trim().toLowerCase())
+            .filter(Boolean);
+        for (const piece of pieces) {
+            parsed.push(piece.startsWith(".") ? piece : `.${piece}`);
+        }
+    }
+    return Array.from(new Set(parsed));
+}
+export function parseNumberFlag(argv, flagName, defaultValue, minValue) {
+    const prefix = `--${flagName}=`;
+    let value = defaultValue;
+    for (const arg of argv.slice(2)) {
+        if (!arg.startsWith(prefix))
+            continue;
+        const raw = arg.slice(prefix.length).trim();
+        if (raw === "") {
+            throw new Error(`Missing value for --${flagName}. Expected integer.`);
+        }
+        const parsed = Number(raw);
+        if (!Number.isInteger(parsed) || parsed < minValue) {
+            throw new Error(`Invalid value for --${flagName}: "${raw}". Expected integer >= ${minValue}.`);
+        }
+        value = parsed;
+    }
+    return value;
+}
+export function parsePromptLimits(argv) {
+    return {
+        maxDiffs: parseNumberFlag(argv, "max-diffs", DEFAULT_PROMPT_LIMITS.maxDiffs, 0),
+        maxDiffChars: parseNumberFlag(argv, "max-diff-chars", DEFAULT_PROMPT_LIMITS.maxDiffChars, 1),
+        maxTotalPromptChars: parseNumberFlag(argv, "max-total-prompt-chars", DEFAULT_PROMPT_LIMITS.maxTotalPromptChars, 1),
+    };
+}
+export function hasIgnoredExtension(filePath, ignoredExtensions) {
+    const lowerPath = filePath.toLowerCase();
+    return ignoredExtensions.some((ext) => lowerPath.endsWith(ext));
+}

package/dist/cli/ci-review.js

@@ -0,0 +1,440 @@
+/** @format */
+import OpenAI from "openai";
+import { AI_MAX_OUTPUT_TOKENS, buildAnswer, buildConsolidatePrompt, buildFileReviewPrompt, buildPrompt, buildTriagePrompt, extractCompletionText, parseTriageResponse, } from "../prompt/index.js";
+import { fetchFileAtRef, searchRepository, } from "../gitlab/services.js";
+import { logToolUsageMinimal, MAX_FILE_TOOL_ROUNDS, MAX_TOOL_ROUNDS, TOOL_NAME_GET_FILE, TOOL_NAME_GREP, } from "./tooling.js";
+function buildReviewMetadata(changes, refs) {
+    const files = changes.map((change, index) => ({
+        index: index + 1,
+        old_path: change.old_path,
+        new_path: change.new_path,
+        new_file: change.new_file ?? false,
+        deleted_file: change.deleted_file ?? false,
+        renamed_file: change.renamed_file ?? false,
+    }));
+    return JSON.stringify({
+        refs,
+        changed_files: files,
+        tool_usage_guidance: [
+            "If diff context is insufficient, call get_file_at_ref to read a specific file.",
+            "Use grep_repository to search for usages, definitions, or patterns across the codebase.",
+            "Use refs.base to inspect pre-change content and refs.head for current content.",
+            "Prefer targeted searches and file fetches; avoid broad context requests.",
+        ],
+    }, null, 2);
+}
+async function handleGetFileTool(argsRaw, gitLabProjectApiUrl, headers) {
+    try {
+        const parsed = JSON.parse(argsRaw);
+        const path = parsed.path?.trim();
+        const ref = parsed.ref?.trim();
+        if (!path || !ref) {
+            return JSON.stringify({ ok: false, error: "Both path and ref are required." });
+        }
+        const fileText = await fetchFileAtRef({
+            gitLabBaseUrl: gitLabProjectApiUrl,
+            headers,
+            filePath: path,
+            ref,
+        });
+        if (fileText instanceof Error) {
+            return JSON.stringify({
+                ok: false,
+                path,
+                ref,
+                error: fileText.message,
+            });
+        }
+        return JSON.stringify({
+            ok: true,
+            path,
+            ref,
+            content: fileText.slice(0, 30000),
+            truncated: fileText.length > 30000,
+        });
+    }
+    catch (error) {
+        return JSON.stringify({
+            ok: false,
+            error: `Failed to parse tool arguments: ${String(error?.message ?? error)}`,
+            raw: argsRaw,
+        });
+    }
+}
+async function handleGrepTool(argsRaw, defaultRef, gitLabProjectApiUrl, headers, projectId) {
+    try {
+        const parsed = JSON.parse(argsRaw);
+        const query = parsed.query?.trim();
+        if (!query)
+            return JSON.stringify({ ok: false, error: "query is required." });
+        const ref = parsed.ref?.trim() || defaultRef;
+        const results = await searchRepository({
+            gitLabBaseUrl: gitLabProjectApiUrl,
+            headers,
+            query,
+            ref,
+            projectId,
+        });
+        if (results instanceof Error) {
+            return JSON.stringify({
+                ok: false,
+                query,
+                ref,
+                error: results.message,
+            });
+        }
+        const trimmed = results.map((r) => ({
+            path: r.path,
+            startline: r.startline,
+            data: r.data.slice(0, 2000),
+        }));
+        return JSON.stringify({ ok: true, query, ref, matches: trimmed });
+    }
+    catch (error) {
+        return JSON.stringify({
+            ok: false,
+            error: `Failed to parse tool arguments: ${String(error?.message ?? error)}`,
+            raw: argsRaw,
+        });
+    }
+}
+async function mapWithConcurrency(items, concurrency, fn) {
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    async function worker() {
+        while (nextIndex < items.length) {
+            const idx = nextIndex;
+            nextIndex += 1;
+            results[idx] = await fn(items[idx]);
+        }
+    }
+    const workers = Array.from({ length: Math.min(concurrency, items.length) }, () => worker());
+    await Promise.all(workers);
+    return results;
+}
+export async function reviewMergeRequestWithTools(params) {
+    const { openaiInstance, aiModel, promptLimits, changes, refs, gitLabProjectApiUrl, projectId, headers, forceTools, loggers, } = params;
+    const { logDebug, logStep } = loggers;
+    const messages = buildPrompt({
+        changes: changes.map((change) => ({ diff: change.diff })),
+        limits: promptLimits,
+        allowTools: true,
+    });
+    messages.push({
+        role: "user",
+        content: `Merge request metadata:\n${buildReviewMetadata(changes, refs)}`,
+    });
+    const tools = [
+        {
+            type: "function",
+            function: {
+                name: TOOL_NAME_GET_FILE,
+                description: "Fetch raw file content at a specific git ref for review context.",
+                parameters: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        path: { type: "string", description: "Repository file path." },
+                        ref: {
+                            type: "string",
+                            description: `Git ref or sha. Prefer "${refs.base}" (base) or "${refs.head}" (head).`,
+                        },
+                    },
+                    required: ["path", "ref"],
+                },
+            },
+        },
+        {
+            type: "function",
+            function: {
+                name: TOOL_NAME_GREP,
+                description: "Search the repository for a keyword or pattern. Returns up to 10 matching code fragments with file paths and line numbers.",
+                parameters: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        query: {
+                            type: "string",
+                            description: "Search string (keyword, function name, variable, etc.).",
+                        },
+                        ref: {
+                            type: "string",
+                            description: `Git ref to search in. Prefer "${refs.head}" (head).`,
+                        },
+                    },
+                    required: ["query"],
+                },
+            },
+        },
+    ];
+    for (let round = 0; round < MAX_TOOL_ROUNDS; round += 1) {
+        const completion = await openaiInstance.chat.completions.create({
+            model: aiModel,
+            temperature: 0.2,
+            stream: false,
+            messages,
+            tools,
+            tool_choice: forceTools && round === 0 ? "required" : "auto",
+        });
+        const message = completion.choices[0]?.message;
+        if (message == null)
+            return buildAnswer(completion);
+        const toolCalls = message.tool_calls ?? [];
+        logDebug(`main-review round=${round + 1} tool_calls=${toolCalls.length} finish_reason=${completion.choices[0]?.finish_reason ?? "unknown"}`);
+        if (toolCalls.length === 0)
+            return buildAnswer(completion);
+        messages.push({
+            role: "assistant",
+            content: message.content ?? "",
+            tool_calls: toolCalls,
+        });
+        for (const toolCall of toolCalls) {
+            const argsRaw = toolCall.function.arguments ?? "{}";
+            logToolUsageMinimal(logStep, toolCall.function.name, argsRaw);
+            let toolContent;
+            if (toolCall.function.name === TOOL_NAME_GET_FILE) {
+                toolContent = await handleGetFileTool(argsRaw, gitLabProjectApiUrl, headers);
+            }
+            else if (toolCall.function.name === TOOL_NAME_GREP) {
+                toolContent = await handleGrepTool(argsRaw, refs.head, gitLabProjectApiUrl, headers, projectId);
+            }
+            else {
+                toolContent = JSON.stringify({
+                    ok: false,
+                    error: `Unknown tool "${toolCall.function.name}"`,
+                });
+            }
+            messages.push({
+                role: "tool",
+                tool_call_id: toolCall.id,
+                content: toolContent,
+            });
+            logDebug(`tool response id=${toolCall.id} name=${toolCall.function.name} payload=${toolContent.slice(0, 300)}`);
+        }
+    }
+    messages.push({
+        role: "user",
+        content: `Tool-call limit reached (${MAX_TOOL_ROUNDS}). Do not call any tools. Provide your best-effort final review now, strictly following the required output format. If confidence is low, return the exact no-issues sentence.`,
+    });
+    const finalCompletion = await openaiInstance.chat.completions.create({
+        model: aiModel,
+        temperature: 0.2,
+        max_tokens: AI_MAX_OUTPUT_TOKENS,
+        stream: false,
+        messages,
+    });
+    return buildAnswer(finalCompletion);
+}
+async function runFileReviewWithTools(params) {
+    const { openaiInstance, aiModel, filePath, fileDiff, summary, otherChangedFiles, refs, gitLabProjectApiUrl, projectId, headers, forceTools, loggers, } = params;
+    const { logDebug, logStep } = loggers;
+    const messages = buildFileReviewPrompt({
+        filePath,
+        fileDiff,
+        summary,
+        otherChangedFiles,
+        allowTools: true,
+    });
+    const tools = [
+        {
+            type: "function",
+            function: {
+                name: TOOL_NAME_GET_FILE,
+                description: "Fetch raw file content at a specific git ref for review context.",
+                parameters: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        path: { type: "string", description: "Repository file path." },
+                        ref: {
+                            type: "string",
+                            description: `Git ref or sha. Prefer "${refs.base}" (base) or "${refs.head}" (head).`,
+                        },
+                    },
+                    required: ["path", "ref"],
+                },
+            },
+        },
+        {
+            type: "function",
+            function: {
+                name: TOOL_NAME_GREP,
+                description: "Search the repository for a keyword or pattern. Returns up to 10 matching code fragments with file paths and line numbers.",
+                parameters: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        query: {
+                            type: "string",
+                            description: "Search string (keyword, function name, variable, etc.).",
+                        },
+                        ref: {
+                            type: "string",
+                            description: `Git ref to search in. Prefer "${refs.head}" (head).`,
+                        },
+                    },
+                    required: ["query"],
+                },
+            },
+        },
+    ];
+    for (let round = 0; round < MAX_FILE_TOOL_ROUNDS; round += 1) {
+        const completion = await openaiInstance.chat.completions.create({
+            model: aiModel,
+            temperature: 0.2,
+            stream: false,
+            messages,
+            tools,
+            tool_choice: forceTools && round === 0 ? "required" : "auto",
+        });
+        const msg = completion.choices[0]?.message;
+        if (msg == null)
+            return extractCompletionText(completion) ?? "No issues found.";
+        const toolCalls = msg.tool_calls ?? [];
+        logDebug(`file-review path=${filePath} round=${round + 1} tool_calls=${toolCalls.length} finish_reason=${completion.choices[0]?.finish_reason ?? "unknown"}`);
+        if (toolCalls.length === 0)
+            return extractCompletionText(completion) ?? "No issues found.";
+        messages.push({
+            role: "assistant",
+            content: msg.content ?? "",
+            tool_calls: toolCalls,
+        });
+        for (const toolCall of toolCalls) {
+            const argsRaw = toolCall.function.arguments ?? "{}";
+            logToolUsageMinimal(logStep, toolCall.function.name, argsRaw, filePath);
+            let toolContent;
+            if (toolCall.function.name === TOOL_NAME_GET_FILE) {
+                toolContent = await handleGetFileTool(argsRaw, gitLabProjectApiUrl, headers);
+            }
+            else if (toolCall.function.name === TOOL_NAME_GREP) {
+                toolContent = await handleGrepTool(argsRaw, refs.head, gitLabProjectApiUrl, headers, projectId);
+            }
+            else {
+                toolContent = JSON.stringify({
+                    ok: false,
+                    error: `Unknown tool "${toolCall.function.name}"`,
+                });
+            }
+            messages.push({
+                role: "tool",
+                tool_call_id: toolCall.id,
+                content: toolContent,
+            });
+            logDebug(`tool response file=${filePath} id=${toolCall.id} name=${toolCall.function.name} payload=${toolContent.slice(0, 300)}`);
+        }
+    }
+    messages.push({
+        role: "user",
+        content: "Tool-call limit reached. Provide your final review now without any tool calls.",
+    });
+    const final = await openaiInstance.chat.completions.create({
+        model: aiModel,
+        temperature: 0.2,
+        max_tokens: AI_MAX_OUTPUT_TOKENS,
+        stream: false,
+        messages,
+    });
+    return extractCompletionText(final) ?? "No issues found.";
+}
+export async function reviewMergeRequestMultiPass(params) {
+    const { openaiInstance, aiModel, promptLimits, changes, refs, gitLabProjectApiUrl, projectId, headers, maxFindings, reviewConcurrency, forceTools, loggers, } = params;
+    const { logStep } = loggers;
+    logStep(`Pass 1/3: triaging ${changes.length} file(s)`);
+    const triageInputs = changes.map((c) => ({
+        path: c.new_path,
+        new_file: c.new_file,
+        deleted_file: c.deleted_file,
+        renamed_file: c.renamed_file,
+        diff: c.diff,
+    }));
+    const triageMessages = buildTriagePrompt(triageInputs);
+    let triageResult = null;
+    try {
+        const triageCompletion = await openaiInstance.chat.completions.create({
+            model: aiModel,
+            temperature: 0.1,
+            stream: false,
+            messages: triageMessages,
+            response_format: { type: "json_object" },
+        });
+        const triageText = extractCompletionText(triageCompletion);
+        if (triageText != null)
+            triageResult = parseTriageResponse(triageText);
+    }
+    catch (error) {
+        logStep(`Triage pass failed: ${error?.message ?? error}. Falling back to single-pass.`);
+    }
+    if (triageResult == null) {
+        logStep("Triage parse failed. Falling back to single-pass pipeline.");
+        return await reviewMergeRequestWithTools({
+            openaiInstance,
+            aiModel,
+            promptLimits,
+            changes,
+            refs,
+            gitLabProjectApiUrl,
+            projectId,
+            headers,
+            forceTools,
+            loggers,
+        });
+    }
+    const triageMap = new Map(triageResult.files.map((f) => [f.path, f.verdict]));
+    const reviewFiles = changes.filter((c) => triageMap.get(c.new_path) !== "SKIP");
+    const skippedCount = changes.length - reviewFiles.length;
+    logStep(`Triage: ${reviewFiles.length} file(s) to review, ${skippedCount} skipped. Summary: ${triageResult.summary.slice(0, 120)}...`);
+    if (reviewFiles.length === 0) {
+        const DISCLAIMER = "This comment was generated by an artificial intelligence duck.";
+        return `No confirmed bugs or high-value optimizations found.\n\n---\n_${DISCLAIMER}_`;
+    }
+    logStep(`Pass 2/3: reviewing ${reviewFiles.length} file(s) (concurrency=${reviewConcurrency})`);
+    const allChangedPaths = changes.map((c) => c.new_path);
+    const perFileFindings = await mapWithConcurrency(reviewFiles, reviewConcurrency, async (change) => {
+        const otherFiles = allChangedPaths.filter((p) => p !== change.new_path);
+        const findings = await runFileReviewWithTools({
+            openaiInstance,
+            aiModel,
+            filePath: change.new_path,
+            fileDiff: change.diff,
+            summary: triageResult.summary,
+            otherChangedFiles: otherFiles,
+            refs,
+            gitLabProjectApiUrl,
+            projectId,
+            headers,
+            forceTools,
+            loggers,
+        });
+        return { path: change.new_path, findings };
+    });
+    logStep("Pass 3/3: consolidating findings");
+    const consolidateMessages = buildConsolidatePrompt({
+        perFileFindings,
+        summary: triageResult.summary,
+        maxFindings,
+    });
+    if (consolidateMessages == null) {
+        const DISCLAIMER = "This comment was generated by an artificial intelligence duck.";
+        return `No confirmed bugs or high-value optimizations found.\n\n---\n_${DISCLAIMER}_`;
+    }
+    try {
+        const consolidateCompletion = await openaiInstance.chat.completions.create({
+            model: aiModel,
+            temperature: 0.1,
+            max_tokens: AI_MAX_OUTPUT_TOKENS,
+            stream: false,
+            messages: consolidateMessages,
+        });
+        return buildAnswer(consolidateCompletion);
+    }
+    catch (error) {
+        logStep(`Consolidation failed: ${error?.message ?? error}. Returning raw per-file findings.`);
+        const DISCLAIMER = "This comment was generated by an artificial intelligence duck.";
+        const raw = perFileFindings
+            .filter((f) => !f.findings.includes("No issues found.") &&
+            !f.findings.includes("No confirmed bugs"))
+            .map((f) => f.findings)
+            .join("\n");
+        return `${raw || "No confirmed bugs or high-value optimizations found."}\n\n---\n_${DISCLAIMER}_`;
+    }
+}

package/dist/cli/tooling.js

@@ -0,0 +1,27 @@
+/** @format */
+export const TOOL_NAME_GET_FILE = "get_file_at_ref";
+export const TOOL_NAME_GREP = "grep_repository";
+export const MAX_TOOL_ROUNDS = 12;
+export const MAX_FILE_TOOL_ROUNDS = 5;
+export function logToolUsageMinimal(logStep, toolName, argsRaw, contextFile) {
+    try {
+        const parsed = JSON.parse(argsRaw);
+        if (toolName === TOOL_NAME_GET_FILE) {
+            const path = parsed.path?.trim() || "(unknown-path)";
+            const suffix = contextFile ? ` review_file=${contextFile}` : "";
+            logStep(`[tools] ${toolName} path=${path}${suffix}`);
+            return;
+        }
+        if (toolName === TOOL_NAME_GREP) {
+            const query = parsed.query?.trim() || "(empty-query)";
+            const suffix = contextFile ? ` review_file=${contextFile}` : "";
+            logStep(`[tools] ${toolName} query=${query}${suffix}`);
+            return;
+        }
+    }
+    catch {
+        // Fall through to raw args logging.
+    }
+    const suffix = contextFile ? ` review_file=${contextFile}` : "";
+    logStep(`[tools] ${toolName} args=${argsRaw.slice(0, 120)}${suffix}`);
+}