@krotovm/gitlab-ai-review 1.0.16 → 1.0.18

package/dist/cli.js

@@ -2,8 +2,11 @@
 /** @format */
 import OpenAI from "openai";
 import { readFile } from "node:fs/promises";
-import { buildAnswer, buildPrompt, DEFAULT_PROMPT_LIMITS, } from "./prompt/index.js";
-import { fetchFileAtRef, fetchMergeRequestChanges, generateAICompletion, postMergeRequestNote, searchRepository, } from "./gitlab/services.js";
+import { DEFAULT_MAX_FINDINGS, DEFAULT_REVIEW_CONCURRENCY, } from "./prompt/index.js";
+import { envOrDefault, envOrUndefined, hasDebugFlag, hasForceToolsFlag, hasIgnoredExtension, hasModeFlag, parseDiffFileFlag, parseIgnoreExtensions, parseMode, parseNumberFlag, parsePromptLimits, requireEnvs, } from "./cli/args.js";
+import { diffFromFile, localDiffLastCommit, localDiffWorktree, reviewDiffToConsole, reviewDiffToConsoleWithToolsLocal, } from "./cli/local-review.js";
+import { reviewMergeRequestMultiPass } from "./cli/ci-review.js";
+import { fetchMergeRequestChanges, postMergeRequestNote, } from "./gitlab/services.js";
 function printHelp() {
     process.stdout.write([
         "gitlab-ai-review",
@@ -25,10 +28,13 @@ function printHelp() {
         "",
         "Debug:",
         "  --debug        Print full error details (stack, API error fields).",
+        "  --force-tools  Force at least one tool-call round in tool-enabled review paths.",
         "  --ignore-ext   Ignore file extensions (comma-separated only). Example: --ignore-ext=md,lock",
         "  --max-diffs=50",
         "  --max-diff-chars=16000",
         "  --max-total-prompt-chars=220000",
+        "  --max-findings=5          Max findings in final review (CI multi-pass only).",
+        "  --max-review-concurrency=5  Parallel per-file review calls (CI multi-pass only).",
         "",
         "Env vars:",
         "  OPENAI_API_KEY (required)  OpenAI API key.",
@@ -44,146 +50,16 @@ function printHelp() {
         "",
     ].join("\n"));
 }
-function requiredEnv(name) {
-    const value = process.env[name];
-    if (value == null || value.trim() === "") {
-        throw new Error(`Missing required env var: ${name}`);
-    }
-    return value;
-}
-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;
-}
-function envOrDefault(name, defaultValue) {
-    const value = process.env[name];
-    if (value == null)
-        return defaultValue;
-    const trimmed = value.trim();
-    return trimmed === "" ? defaultValue : trimmed;
-}
-function envOrUndefined(name) {
-    const value = process.env[name];
-    if (value == null)
-        return undefined;
-    const trimmed = value.trim();
-    return trimmed === "" ? undefined : trimmed;
-}
-function hasDebugFlag(argv) {
-    const args = new Set(argv.slice(2));
-    return args.has("--debug");
-}
-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));
-}
-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;
-}
-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),
-    };
-}
-function parseDiffFileFlag(argv) {
-    const args = argv.slice(2);
-    for (const current of args) {
-        if (current === "--diff-file") {
-            throw new Error("Use equals format: --diff-file=./path/to/file.diff");
-        }
-        if (!current.startsWith("--diff-file="))
-            continue;
-        const value = current.slice("--diff-file=".length).trim();
-        if (value === "") {
-            throw new Error("Missing value for --diff-file. Example: --diff-file=./changes.diff");
-        }
-        return value;
-    }
-    return undefined;
-}
-function hasModeFlag(argv) {
-    const args = new Set(argv.slice(2));
-    return (args.has("--ci") || args.has("--worktree") || args.has("--last-commit"));
-}
-function hasIgnoredExtension(filePath, ignoredExtensions) {
-    const lowerPath = filePath.toLowerCase();
-    return ignoredExtensions.some((ext) => lowerPath.endsWith(ext));
-}
-function buildGitExcludePathspecs(ignoredExtensions) {
-    return ignoredExtensions.map((ext) => `:(exclude,glob)**/*${ext}`);
-}
-function parseMode(argv) {
-    const args = new Set(argv.slice(2));
-    if (args.has("--help") || args.has("-h")) {
-        printHelp();
-        process.exit(0);
-    }
-    const hasCi = args.has("--ci");
-    const hasWorktree = args.has("--worktree");
-    const hasLastCommit = args.has("--last-commit");
-    const count = Number(hasCi) + Number(hasWorktree) + Number(hasLastCommit);
-    if (count > 1) {
-        throw new Error("Choose only one mode: --ci, --worktree, or --last-commit");
-    }
-    if (hasCi)
-        return "ci";
-    if (hasWorktree)
-        return "worktree";
-    if (hasLastCommit)
-        return "last-commit";
-    const mergeRequestIid = process.env.CI_MERGE_REQUEST_IID;
-    if (mergeRequestIid != null && mergeRequestIid.trim() !== "")
-        return "ci";
-    return "worktree";
-}
+const DEBUG_MODE = hasDebugFlag(process.argv);
+const FORCE_TOOLS = hasForceToolsFlag(process.argv);
 function logStep(message) {
     process.stdout.write(`${message}\n`);
 }
+function logDebug(message) {
+    if (!DEBUG_MODE)
+        return;
+    process.stdout.write(`[debug] ${message}\n`);
+}
 async function getCliVersion() {
     try {
         const packageJsonUrl = new URL("../package.json", import.meta.url);
@@ -198,384 +74,6 @@ async function getCliVersion() {
     }
     return "unknown";
 }
-async function runGit(args) {
-    const { spawn } = await import("node:child_process");
-    return await new Promise((resolve, reject) => {
-        const child = spawn("git", args, { stdio: ["ignore", "pipe", "pipe"] });
-        let stdout = "";
-        let stderr = "";
-        child.stdout.on("data", (d) => {
-            stdout += String(d);
-        });
-        child.stderr.on("data", (d) => {
-            stderr += String(d);
-        });
-        child.on("error", reject);
-        child.on("close", (code) => {
-            if (code === 0)
-                return resolve(stdout);
-            reject(new Error(stderr.trim() ||
-                `git ${args.join(" ")} failed with exit code ${code}`));
-        });
-    });
-}
-async function localDiffWorktree() {
-    const ignoreExtensions = parseIgnoreExtensions(process.argv);
-    const pathspecs = buildGitExcludePathspecs(ignoreExtensions);
-    const unstagedArgs = pathspecs.length > 0 ? ["diff", "--", ...pathspecs] : ["diff"];
-    const stagedArgs = pathspecs.length > 0
-        ? ["diff", "--staged", "--", ...pathspecs]
-        : ["diff", "--staged"];
-    const unstaged = await runGit(unstagedArgs);
-    const staged = await runGit(stagedArgs);
-    const combined = [staged.trim(), unstaged.trim()]
-        .filter(Boolean)
-        .join("\n\n");
-    return combined;
-}
-async function localDiffLastCommit() {
-    const ignoreExtensions = parseIgnoreExtensions(process.argv);
-    const pathspecs = buildGitExcludePathspecs(ignoreExtensions);
-    // show patch for HEAD, but avoid commit message metadata
-    const args = pathspecs.length > 0
-        ? ["show", "--format=", "HEAD", "--", ...pathspecs]
-        : ["show", "--format=", "HEAD"];
-    return await runGit(args);
-}
-async function diffFromFile(filePath) {
-    const text = await readFile(filePath, "utf8");
-    return text;
-}
-function editDistanceAtMostTwo(a, b) {
-    const la = a.length;
-    const lb = b.length;
-    if (Math.abs(la - lb) > 2)
-        return 3;
-    const dp = Array.from({ length: la + 1 }, (_, i) => Array.from({ length: lb + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0)));
-    for (let i = 1; i <= la; i += 1) {
-        let rowMin = Number.POSITIVE_INFINITY;
-        for (let j = 1; j <= lb; j += 1) {
-            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-            dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
-            rowMin = Math.min(rowMin, dp[i][j]);
-        }
-        if (rowMin > 2)
-            return 3;
-    }
-    return dp[la][lb];
-}
-function collectCallIdentifiersFromDiffLines(lines, prefixes) {
-    const out = new Set();
-    const callPattern = /\b([A-Za-z_$][A-Za-z0-9_$]*)\s*\(/g;
-    for (const line of lines) {
-        if (!prefixes.some((p) => line.startsWith(p)))
-            continue;
-        const code = line.slice(1);
-        let match;
-        while ((match = callPattern.exec(code)) != null) {
-            const ident = match[1];
-            // Ignore common JS control keywords.
-            if (ident === "if" ||
-                ident === "for" ||
-                ident === "while" ||
-                ident === "switch" ||
-                ident === "catch") {
-                continue;
-            }
-            out.add(ident);
-        }
-    }
-    return out;
-}
-function findDeterministicDiffFindings(diff) {
-    const lines = diff.split(/\r?\n/);
-    const addedCalls = collectCallIdentifiersFromDiffLines(lines, ["+"]);
-    const nearbyCalls = collectCallIdentifiersFromDiffLines(lines, [
-        " ",
-        "-",
-        "+",
-    ]);
-    const findings = [];
-    for (const added of addedCalls) {
-        if (added.length < 7)
-            continue;
-        let closest;
-        let closestDistance = 3;
-        for (const candidate of nearbyCalls) {
-            if (candidate === added)
-                continue;
-            const distance = editDistanceAtMostTwo(added, candidate);
-            if (distance < closestDistance) {
-                closestDistance = distance;
-                closest = candidate;
-            }
-        }
-        if (closest != null && closestDistance <= 2) {
-            findings.push({
-                title: "Possible symbol typo",
-                detail: `Call \`${added}(...)\` is very close to \`${closest}(...)\` and may be a misspelling causing runtime/reference errors.`,
-            });
-        }
-    }
-    // De-duplicate repeated matches.
-    return Array.from(new Map(findings.map((f) => [`${f.title}:${f.detail}`, f])).values()).slice(0, 3);
-}
-function injectDeterministicFindings(answer, findings) {
-    if (findings.length === 0)
-        return answer;
-    const noIssues = answer.includes("No confirmed bugs or high-value optimizations found.");
-    if (!noIssues)
-        return answer;
-    const bullets = findings
-        .map((f) => `- [high] ${f.title}: ${f.detail}`)
-        .join("\n");
-    const disclaimerIndex = answer.indexOf("\n---\n_This comment was generated by an artificial intelligence duck._");
-    const disclaimer = disclaimerIndex >= 0
-        ? answer.slice(disclaimerIndex)
-        : "\n---\n_This comment was generated by an artificial intelligence duck._";
-    return `${bullets}${disclaimer}`;
-}
-async function reviewDiffToConsole(diff, openaiApiKey, aiModel, promptLimits) {
-    if (diff.trim() === "") {
-        process.stdout.write("No diff found. Skipping review.\n");
-        return;
-    }
-    const messageParams = buildPrompt({
-        changes: [{ diff }],
-        limits: promptLimits,
-    });
-    const openaiInstance = new OpenAI({ apiKey: openaiApiKey });
-    const completion = await generateAICompletion(messageParams, openaiInstance, aiModel);
-    const answer = buildAnswer(completion);
-    const deterministicFindings = findDeterministicDiffFindings(diff);
-    const finalAnswer = injectDeterministicFindings(answer, deterministicFindings);
-    process.stdout.write(`${finalAnswer}\n`);
-}
-const TOOL_NAME_GET_FILE = "get_file_at_ref";
-const TOOL_NAME_GREP = "grep_repository";
-const MAX_TOOL_ROUNDS = 12;
-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 reviewMergeRequestWithTools(params) {
-    const { openaiInstance, aiModel, promptLimits, changes, refs, gitLabProjectApiUrl, projectId, headers, } = params;
-    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: "auto",
-        });
-        const message = completion.choices[0]?.message;
-        if (message == null)
-            return buildAnswer(completion);
-        const toolCalls = message.tool_calls ?? [];
-        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 ?? "{}";
-            let toolContent;
-            if (toolCall.function.name === TOOL_NAME_GET_FILE) {
-                try {
-                    const parsed = JSON.parse(argsRaw);
-                    const path = parsed.path?.trim();
-                    const ref = parsed.ref?.trim();
-                    if (path == null || path === "" || ref == null || ref === "") {
-                        toolContent = JSON.stringify({
-                            ok: false,
-                            error: "Both path and ref are required.",
-                        });
-                    }
-                    else {
-                        const fileText = await fetchFileAtRef({
-                            gitLabBaseUrl: gitLabProjectApiUrl,
-                            headers,
-                            filePath: path,
-                            ref,
-                        });
-                        if (fileText instanceof Error) {
-                            toolContent = JSON.stringify({
-                                ok: false,
-                                path,
-                                ref,
-                                error: fileText.message,
-                            });
-                        }
-                        else {
-                            toolContent = JSON.stringify({
-                                ok: true,
-                                path,
-                                ref,
-                                content: fileText.slice(0, 30000),
-                                truncated: fileText.length > 30000,
-                            });
-                        }
-                    }
-                }
-                catch (error) {
-                    toolContent = JSON.stringify({
-                        ok: false,
-                        error: `Failed to parse tool arguments: ${String(error?.message ?? error)}`,
-                        raw: argsRaw,
-                    });
-                }
-            }
-            else if (toolCall.function.name === TOOL_NAME_GREP) {
-                try {
-                    const parsed = JSON.parse(argsRaw);
-                    const query = parsed.query?.trim();
-                    if (query == null || query === "") {
-                        toolContent = JSON.stringify({
-                            ok: false,
-                            error: "query is required.",
-                        });
-                    }
-                    else {
-                        const ref = parsed.ref?.trim() || refs.head;
-                        const results = await searchRepository({
-                            gitLabBaseUrl: gitLabProjectApiUrl,
-                            headers,
-                            query,
-                            ref,
-                            projectId,
-                        });
-                        if (results instanceof Error) {
-                            toolContent = JSON.stringify({
-                                ok: false,
-                                query,
-                                ref,
-                                error: results.message,
-                            });
-                        }
-                        else {
-                            const trimmed = results.map((r) => ({
-                                path: r.path,
-                                startline: r.startline,
-                                data: r.data.slice(0, 2000),
-                            }));
-                            toolContent = JSON.stringify({
-                                ok: true,
-                                query,
-                                ref,
-                                matches: trimmed,
-                            });
-                        }
-                    }
-                }
-                catch (error) {
-                    toolContent = JSON.stringify({
-                        ok: false,
-                        error: `Failed to parse tool arguments: ${String(error?.message ?? error)}`,
-                        raw: argsRaw,
-                    });
-                }
-            }
-            else {
-                toolContent = JSON.stringify({
-                    ok: false,
-                    error: `Unknown tool "${toolCall.function.name}"`,
-                });
-            }
-            messages.push({
-                role: "tool",
-                tool_call_id: toolCall.id,
-                content: toolContent,
-            });
-        }
-    }
-    // Graceful fallback: ask model for a final best-effort answer
-    // using already collected context, without allowing more tool calls.
-    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,
-        stream: false,
-        messages,
-    });
-    return buildAnswer(finalCompletion);
-}
 async function main() {
     const cliVersion = await getCliVersion();
     logStep(`gitlab-ai-review v${cliVersion}`);
@@ -583,35 +81,69 @@ async function main() {
     if (diffFilePath != null && hasModeFlag(process.argv)) {
         throw new Error("Do not combine --diff-file with --ci/--worktree/--last-commit");
     }
-    const mode = diffFilePath != null ? "worktree" : parseMode(process.argv);
+    const mode = diffFilePath != null
+        ? "worktree"
+        : parseMode(process.argv, printHelp, process.env.CI_MERGE_REQUEST_IID);
     const ignoredExtensions = parseIgnoreExtensions(process.argv);
     const promptLimits = parsePromptLimits(process.argv);
+    const maxFindings = parseNumberFlag(process.argv, "max-findings", DEFAULT_MAX_FINDINGS, 1);
+    const reviewConcurrency = parseNumberFlag(process.argv, "max-review-concurrency", DEFAULT_REVIEW_CONCURRENCY, 1);
     const aiModel = envOrDefault("AI_MODEL", "gpt-4o-mini");
+    const loggers = { logStep, logDebug };
     if (diffFilePath != null) {
         logStep(`Reading diff file: ${diffFilePath}`);
-        const openaiEnvs = requireEnvs(["OPENAI_API_KEY"]);
-        const openaiApiKey = openaiEnvs["OPENAI_API_KEY"];
+        const openaiApiKey = requireEnvs(["OPENAI_API_KEY"])["OPENAI_API_KEY"];
         const diff = await diffFromFile(diffFilePath);
         logStep(`Requesting AI completion with model: ${aiModel}`);
-        await reviewDiffToConsole(diff, openaiApiKey, aiModel, promptLimits);
-        return;
-    }
-    if (mode === "worktree") {
-        logStep("Collecting local changes");
-        const openaiEnvs = requireEnvs(["OPENAI_API_KEY"]);
-        const openaiApiKey = openaiEnvs["OPENAI_API_KEY"];
-        const diff = await localDiffWorktree();
-        logStep(`Requesting AI completion with model: ${aiModel}`);
-        await reviewDiffToConsole(diff, openaiApiKey, aiModel, promptLimits);
+        if (FORCE_TOOLS) {
+            await reviewDiffToConsoleWithToolsLocal({
+                diff,
+                openaiApiKey,
+                aiModel,
+                promptLimits,
+                forceTools: FORCE_TOOLS,
+                loggers,
+            });
+        }
+        else {
+            await reviewDiffToConsole({
+                diff,
+                openaiApiKey,
+                aiModel,
+                promptLimits,
+                forceTools: FORCE_TOOLS,
+                loggers,
+            });
+        }
         return;
     }
-    if (mode === "last-commit") {
-        logStep("Collecting HEAD diff");
-        const openaiEnvs = requireEnvs(["OPENAI_API_KEY"]);
-        const openaiApiKey = openaiEnvs["OPENAI_API_KEY"];
-        const diff = await localDiffLastCommit();
+    if (mode === "worktree" || mode === "last-commit") {
+        logStep(mode === "worktree" ? "Collecting local changes" : "Collecting HEAD diff");
+        const openaiApiKey = requireEnvs(["OPENAI_API_KEY"])["OPENAI_API_KEY"];
+        const diff = mode === "worktree"
+            ? await localDiffWorktree(process.argv)
+            : await localDiffLastCommit(process.argv);
         logStep(`Requesting AI completion with model: ${aiModel}`);
-        await reviewDiffToConsole(diff, openaiApiKey, aiModel, promptLimits);
+        if (FORCE_TOOLS) {
+            await reviewDiffToConsoleWithToolsLocal({
+                diff,
+                openaiApiKey,
+                aiModel,
+                promptLimits,
+                forceTools: FORCE_TOOLS,
+                loggers,
+            });
+        }
+        else {
+            await reviewDiffToConsole({
+                diff,
+                openaiApiKey,
+                aiModel,
+                promptLimits,
+                forceTools: FORCE_TOOLS,
+                loggers,
+            });
+        }
         return;
     }
     const projectAccessToken = envOrUndefined("PROJECT_ACCESS_TOKEN") ?? envOrUndefined("GITLAB_TOKEN");
@@ -621,44 +153,37 @@ async function main() {
         "CI_PROJECT_ID",
         "CI_MERGE_REQUEST_IID",
     ];
-    if (projectAccessToken == null) {
+    if (projectAccessToken == null)
         gitlabRequired.push("CI_JOB_TOKEN");
-    }
-    const gitlabEnvs = requireEnvs(gitlabRequired);
-    const openaiApiKey = gitlabEnvs["OPENAI_API_KEY"];
-    const ciApiV4Url = gitlabEnvs["CI_API_V4_URL"];
-    const projectId = gitlabEnvs["CI_PROJECT_ID"];
-    const mergeRequestIid = gitlabEnvs["CI_MERGE_REQUEST_IID"];
-    const gitLabBaseUrl = new URL(ciApiV4Url);
+    const envs = requireEnvs(gitlabRequired);
+    const openaiApiKey = envs["OPENAI_API_KEY"];
+    const ciApiV4Url = envs["CI_API_V4_URL"];
+    const projectId = envs["CI_PROJECT_ID"];
+    const mergeRequestIid = envs["CI_MERGE_REQUEST_IID"];
     const headers = {};
-    if (projectAccessToken != null) {
+    if (projectAccessToken != null)
         headers["PRIVATE-TOKEN"] = projectAccessToken;
-    }
-    else {
-        headers["JOB-TOKEN"] = gitlabEnvs["CI_JOB_TOKEN"];
-    }
+    else
+        headers["JOB-TOKEN"] = envs["CI_JOB_TOKEN"];
     logStep("Fetching merge request changes");
     const mrChanges = await fetchMergeRequestChanges({
-        gitLabBaseUrl,
+        gitLabBaseUrl: new URL(ciApiV4Url),
         headers,
         projectId,
         mergeRequestIid,
     });
     if (mrChanges instanceof Error)
         throw mrChanges;
-    const changes = mrChanges.changes ?? [];
-    const filteredChanges = ignoredExtensions.length === 0
-        ? changes
-        : changes.filter((change) => !hasIgnoredExtension(change.new_path, ignoredExtensions) &&
-            !hasIgnoredExtension(change.old_path, ignoredExtensions));
+    const filteredChanges = (mrChanges.changes ?? []).filter((change) => ignoredExtensions.length === 0 ||
+        (!hasIgnoredExtension(change.new_path, ignoredExtensions) &&
+            !hasIgnoredExtension(change.old_path, ignoredExtensions)));
     if (filteredChanges.length === 0) {
         process.stdout.write("No changes found in merge request. Skipping review.\n");
         return;
     }
-    logStep(`Requesting AI completion with model: ${aiModel}`);
-    const openaiInstance = new OpenAI({ apiKey: openaiApiKey });
-    const answer = await reviewMergeRequestWithTools({
-        openaiInstance,
+    logStep(`Requesting AI review with model: ${aiModel} (multi-pass pipeline)`);
+    const answer = await reviewMergeRequestMultiPass({
+        openaiInstance: new OpenAI({ apiKey: openaiApiKey }),
         aiModel,
         promptLimits,
         changes: filteredChanges,
@@ -669,6 +194,10 @@ async function main() {
         gitLabProjectApiUrl: new URL(`${ciApiV4Url}/projects/${projectId}`),
         projectId,
         headers,
+        maxFindings,
+        reviewConcurrency,
+        forceTools: FORCE_TOOLS,
+        loggers,
     });
     logStep("Posting AI review note to merge request");
     const noteRes = await postMergeRequestNote({