@krotovm/gitlab-ai-review 1.0.18 → 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

@@ -83,54 +83,7 @@ export function parsePromptLimits(argv) {
         maxTotalPromptChars: parseNumberFlag(argv, "max-total-prompt-chars", DEFAULT_PROMPT_LIMITS.maxTotalPromptChars, 1),
     };
 }
-export 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;
-}
-export function hasModeFlag(argv) {
-    const args = new Set(argv.slice(2));
-    return (args.has("--ci") || args.has("--worktree") || args.has("--last-commit"));
-}
 export function hasIgnoredExtension(filePath, ignoredExtensions) {
     const lowerPath = filePath.toLowerCase();
     return ignoredExtensions.some((ext) => lowerPath.endsWith(ext));
 }
-export function buildGitExcludePathspecs(ignoredExtensions) {
-    return ignoredExtensions.map((ext) => `:(exclude,glob)**/*${ext}`);
-}
-export function parseMode(argv, onHelp, mergeRequestIid) {
-    const args = new Set(argv.slice(2));
-    if (args.has("--help") || args.has("-h")) {
-        onHelp();
-        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";
-    if (mergeRequestIid != null && mergeRequestIid.trim() !== "")
-        return "ci";
-    return "worktree";
-}
-//# sourceMappingURL=args.js.map

package/dist/cli/ci-review.js

@@ -438,4 +438,3 @@ export async function reviewMergeRequestMultiPass(params) {
         return `${raw || "No confirmed bugs or high-value optimizations found."}\n\n---\n_${DISCLAIMER}_`;
     }
 }
-//# sourceMappingURL=ci-review.js.map

package/dist/cli/tooling.js

@@ -25,4 +25,3 @@ export function logToolUsageMinimal(logStep, toolName, argsRaw, contextFile) {
     const suffix = contextFile ? ` review_file=${contextFile}` : "";
     logStep(`[tools] ${toolName} args=${argsRaw.slice(0, 120)}${suffix}`);
 }
-//# sourceMappingURL=tooling.js.map

package/dist/cli.js

@@ -3,8 +3,7 @@
 import OpenAI from "openai";
 import { readFile } from "node:fs/promises";
 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 { envOrDefault, envOrUndefined, hasDebugFlag, hasForceToolsFlag, hasIgnoredExtension, parseIgnoreExtensions, parseNumberFlag, parsePromptLimits, requireEnvs, } from "./cli/args.js";
 import { reviewMergeRequestMultiPass } from "./cli/ci-review.js";
 import { fetchMergeRequestChanges, postMergeRequestNote, } from "./gitlab/services.js";
 function printHelp() {
@@ -12,19 +11,10 @@ function printHelp() {
         "gitlab-ai-review",
         "",
         "Usage:",
-        "  gitlab-ai-review --ci",
-        "  gitlab-ai-review --worktree",
-        "  gitlab-ai-review --last-commit",
-        "  gitlab-ai-review --diff-file=./changes.diff",
+        "  gitlab-ai-review",
         "  gitlab-ai-review --help",
         "  gitlab-ai-review --debug",
-        "  gitlab-ai-review --ci --ignore-ext=md,lock",
-        "",
-        "Modes (choose one):",
-        "  --ci           Run in GitLab MR pipeline: fetch MR changes and post a new MR note.",
-        "  --worktree     Review local uncommitted changes (staged + unstaged) and print to stdout.",
-        "  --last-commit  Review last commit (HEAD) and print to stdout.",
-        "  --diff-file    Review git-diff content from a file and print to stdout.",
+        "  gitlab-ai-review --ignore-ext=md,lock",
         "",
         "Debug:",
         "  --debug        Print full error details (stack, API error fields).",
@@ -45,9 +35,6 @@ function printHelp() {
         "CI-only env vars (provided by GitLab):",
         "  CI_API_V4_URL, CI_PROJECT_ID, CI_MERGE_REQUEST_IID, CI_JOB_TOKEN (only if PROJECT_ACCESS_TOKEN is not set)",
         "",
-        "Notes:",
-        "  - If no mode is specified, it defaults to --ci when CI_MERGE_REQUEST_IID is set, otherwise --worktree.",
-        "",
     ].join("\n"));
 }
 const DEBUG_MODE = hasDebugFlag(process.argv);
@@ -75,77 +62,19 @@ async function getCliVersion() {
     return "unknown";
 }
 async function main() {
+    const args = new Set(process.argv.slice(2));
+    if (args.has("--help") || args.has("-h")) {
+        printHelp();
+        return;
+    }
     const cliVersion = await getCliVersion();
     logStep(`gitlab-ai-review v${cliVersion}`);
-    const diffFilePath = parseDiffFileFlag(process.argv);
-    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, 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 openaiApiKey = requireEnvs(["OPENAI_API_KEY"])["OPENAI_API_KEY"];
-        const diff = await diffFromFile(diffFilePath);
-        logStep(`Requesting AI completion with model: ${aiModel}`);
-        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 === "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}`);
-        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");
     const gitlabRequired = [
         "OPENAI_API_KEY",
@@ -241,4 +170,3 @@ main().catch((err) => {
     }
     process.exitCode = 1;
 });
-//# sourceMappingURL=cli.js.map

package/dist/errors.js

@@ -11,4 +11,3 @@ export class BaseError extends Error {
         this.statusCode = statusCode;
     }
 }
-//# sourceMappingURL=errors.js.map

package/dist/gitlab/services.js

@@ -218,4 +218,3 @@ export const fetchMergeRequestChanges = async ({ gitLabBaseUrl, headers, project
     }
     return (await res.json());
 };
-//# sourceMappingURL=services.js.map

package/dist/gitlab/types.js

@@ -3,4 +3,3 @@ export class GitLabError extends BaseError {
 }
 export class OpenAIError extends BaseError {
 }
-//# sourceMappingURL=types.js.map

package/dist/prompt/index.js

@@ -238,4 +238,3 @@ export const buildAnswer = (completion) => {
     const safe = sanitizeGitLabMarkdown(content);
     return `${safe}\n\n---\n_${DISCLAIMER}_`;
 };
-//# sourceMappingURL=index.js.map

package/dist/prompt/messages.js

@@ -143,4 +143,3 @@ export const FILE_REVIEW_SYSTEM = {
     role: "system",
     content: FILE_REVIEW_SYSTEM_LINES.join("\n"),
 };
-//# sourceMappingURL=messages.js.map

package/dist/prompt/utils.js

@@ -12,4 +12,3 @@ export function sanitizeGitLabMarkdown(input) {
     const withClosedFence = fenceCount % 2 === 1 ? `${normalized}\n\`\`\`` : normalized;
     return withClosedFence;
 }
-//# sourceMappingURL=utils.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@krotovm/gitlab-ai-review",
-  "version": "1.0.18",
+  "version": "1.0.19",
   "description": "CLI tool to generate AI code reviews for GitLab merge requests and local diffs.",
   "main": "dist/cli.js",
   "bin": {
@@ -9,7 +9,6 @@
   },
   "files": [
     "dist/**/*.js",
-    "dist/**/*.d.ts",
     "README.md",
     "LICENSE"
   ],

package/dist/cli/local-review.js

@@ -1,467 +0,0 @@
-/** @format */
-import OpenAI from "openai";
-import { readFile } from "node:fs/promises";
-import { AI_MAX_OUTPUT_TOKENS, buildAnswer, buildPrompt, extractCompletionText, } from "../prompt/index.js";
-import { generateAICompletion } from "../gitlab/services.js";
-import { buildGitExcludePathspecs, parseIgnoreExtensions, } from "./args.js";
-import { logToolUsageMinimal, MAX_TOOL_ROUNDS, TOOL_NAME_GET_FILE, TOOL_NAME_GREP, } from "./tooling.js";
-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 runCommand(command, args) {
-    const { spawn } = await import("node:child_process");
-    return await new Promise((resolve, reject) => {
-        const child = spawn(command, 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() ||
-                `${command} ${args.join(" ")} failed with exit code ${code}`));
-        });
-    });
-}
-export async function localDiffWorktree(argv) {
-    const ignoreExtensions = parseIgnoreExtensions(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);
-    return [staged.trim(), unstaged.trim()].filter(Boolean).join("\n\n");
-}
-export async function localDiffLastCommit(argv) {
-    const ignoreExtensions = parseIgnoreExtensions(argv);
-    const pathspecs = buildGitExcludePathspecs(ignoreExtensions);
-    const args = pathspecs.length > 0
-        ? ["show", "--format=", "HEAD", "--", ...pathspecs]
-        : ["show", "--format=", "HEAD"];
-    return await runGit(args);
-}
-export async function diffFromFile(filePath) {
-    return await readFile(filePath, "utf8");
-}
-function parseChangedPathsFromDiff(diff) {
-    const paths = [];
-    const lines = diff.split(/\r?\n/);
-    for (const line of lines) {
-        if (!line.startsWith("diff --git "))
-            continue;
-        const match = /^diff --git a\/(.+?) b\/(.+)$/.exec(line);
-        if (match == null)
-            continue;
-        const bPath = match[2]?.trim();
-        if (bPath && bPath !== "/dev/null")
-            paths.push(bPath);
-    }
-    return Array.from(new Set(paths));
-}
-async function readLocalFileIfExists(path) {
-    try {
-        return await readFile(path, "utf8");
-    }
-    catch {
-        return null;
-    }
-}
-async function readFileAtHead(path) {
-    try {
-        return await runGit(["show", `HEAD:${path}`]);
-    }
-    catch {
-        return null;
-    }
-}
-async function buildLocalReviewContext(diff) {
-    const paths = parseChangedPathsFromDiff(diff).slice(0, 8);
-    if (paths.length === 0)
-        return "";
-    const blocks = [];
-    for (const path of paths) {
-        const worktreeText = await readLocalFileIfExists(path);
-        const headText = await readFileAtHead(path);
-        const current = worktreeText?.slice(0, 1200);
-        const previous = headText?.slice(0, 1200);
-        if (current == null && previous == null)
-            continue;
-        blocks.push([
-            `File: ${path}`,
-            current != null
-                ? `Current snippet:\n\`\`\`\n${current}\n\`\`\``
-                : "Current snippet: (unavailable)",
-            previous != null
-                ? `HEAD snippet:\n\`\`\`\n${previous}\n\`\`\``
-                : "HEAD snippet: (unavailable)",
-        ].join("\n"));
-    }
-    return blocks.join("\n\n");
-}
-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];
-            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.`,
-            });
-        }
-    }
-    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;
-    if (!answer.includes("No confirmed bugs or high-value optimizations found.")) {
-        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 handleLocalGetFileTool(argsRaw) {
-    try {
-        const parsed = JSON.parse(argsRaw);
-        const path = parsed.path?.trim();
-        const ref = (parsed.ref?.trim() || "WORKTREE").toUpperCase();
-        if (!path)
-            return JSON.stringify({ ok: false, error: "path is required." });
-        if (ref === "WORKTREE") {
-            const text = await readLocalFileIfExists(path);
-            if (text == null) {
-                return JSON.stringify({
-                    ok: false,
-                    path,
-                    ref,
-                    error: "File not found in worktree.",
-                });
-            }
-            return JSON.stringify({
-                ok: true,
-                path,
-                ref,
-                content: text.slice(0, 30000),
-                truncated: text.length > 30000,
-            });
-        }
-        const text = await runGit(["show", `${ref}:${path}`]);
-        return JSON.stringify({
-            ok: true,
-            path,
-            ref,
-            content: text.slice(0, 30000),
-            truncated: text.length > 30000,
-        });
-    }
-    catch (error) {
-        return JSON.stringify({
-            ok: false,
-            error: `Failed local get_file_at_ref: ${String(error?.message ?? error)}`,
-            raw: argsRaw,
-        });
-    }
-}
-async function handleLocalGrepTool(argsRaw, logDebug) {
-    function parseSearchOutput(raw) {
-        return raw
-            .split(/\r?\n/)
-            .filter(Boolean)
-            .map((line) => {
-            const m = /^(.+?):(\d+):(.*)$/.exec(line);
-            if (m == null)
-                return null;
-            return {
-                path: m[1],
-                startline: Number(m[2]),
-                data: (m[3] ?? "").slice(0, 2000),
-            };
-        })
-            .filter((v) => v != null)
-            .slice(0, 10);
-    }
-    try {
-        const parsed = JSON.parse(argsRaw);
-        const query = parsed.query?.trim();
-        if (!query)
-            return JSON.stringify({ ok: false, error: "query is required." });
-        let raw = "";
-        let searchBackend = "rg";
-        try {
-            raw = await runCommand("rg", ["-n", "--no-heading", "--max-count", "30", query, "."]);
-        }
-        catch (error) {
-            if (String(error?.message ?? error).includes("spawn rg ENOENT")) {
-                searchBackend = "grep";
-                raw = await runCommand("grep", ["-R", "-n", "-m", "30", "--", query, "."]);
-            }
-            else {
-                throw error;
-            }
-        }
-        const matches = parseSearchOutput(raw);
-        logDebug(`local grep backend=${searchBackend} query="${query}" matches=${matches.length}`);
-        return JSON.stringify({
-            ok: true,
-            query,
-            ref: (parsed.ref?.trim() || "WORKTREE").toUpperCase(),
-            matches,
-        });
-    }
-    catch (error) {
-        return JSON.stringify({
-            ok: false,
-            error: `Failed local grep_repository: ${String(error?.message ?? error)}`,
-            raw: argsRaw,
-        });
-    }
-}
-export async function reviewDiffToConsole(params) {
-    const { diff, openaiApiKey, aiModel, promptLimits, forceTools, loggers } = params;
-    const { logStep } = loggers;
-    if (diff.trim() === "") {
-        process.stdout.write("No diff found. Skipping review.\n");
-        return;
-    }
-    const localContext = await buildLocalReviewContext(diff);
-    const messageParams = buildPrompt({
-        changes: [{ diff }],
-        limits: promptLimits,
-        additionalContext: localContext,
-    });
-    const openaiInstance = new OpenAI({ apiKey: openaiApiKey });
-    const completion = await generateAICompletion(messageParams, openaiInstance, aiModel);
-    if (extractCompletionText(completion) == null) {
-        logStep("Primary completion was empty. Retrying once with local tool-enabled flow.");
-        await reviewDiffToConsoleWithToolsLocal({
-            diff,
-            openaiApiKey,
-            aiModel,
-            promptLimits,
-            forceTools,
-            loggers,
-        });
-        return;
-    }
-    const answer = buildAnswer(completion);
-    const finalAnswer = injectDeterministicFindings(answer, findDeterministicDiffFindings(diff));
-    process.stdout.write(`${finalAnswer}\n`);
-}
-export async function reviewDiffToConsoleWithToolsLocal(params) {
-    const { diff, openaiApiKey, aiModel, promptLimits, forceTools, loggers } = params;
-    const { logDebug, logStep } = loggers;
-    if (diff.trim() === "") {
-        process.stdout.write("No diff found. Skipping review.\n");
-        return;
-    }
-    const localContext = await buildLocalReviewContext(diff);
-    const messages = buildPrompt({
-        changes: [{ diff }],
-        limits: promptLimits,
-        allowTools: true,
-        additionalContext: localContext,
-    });
-    messages.push({
-        role: "user",
-        content: "Local review context: use ref=WORKTREE for current files, ref=HEAD for last commit snapshot.",
-    });
-    const openaiInstance = new OpenAI({ apiKey: openaiApiKey });
-    const toolResultCache = new Map();
-    const tools = [
-        {
-            type: "function",
-            function: {
-                name: TOOL_NAME_GET_FILE,
-                description: "Fetch local file content. Use ref=WORKTREE for current file, ref=HEAD for committed snapshot.",
-                parameters: {
-                    type: "object",
-                    additionalProperties: false,
-                    properties: {
-                        path: { type: "string", description: "Repository file path." },
-                        ref: {
-                            type: "string",
-                            description: 'Ref value: "WORKTREE" or "HEAD". Defaults to WORKTREE.',
-                        },
-                    },
-                    required: ["path"],
-                },
-            },
-        },
-        {
-            type: "function",
-            function: {
-                name: TOOL_NAME_GREP,
-                description: "Search current local repository with ripgrep. Returns up to 10 matches.",
-                parameters: {
-                    type: "object",
-                    additionalProperties: false,
-                    properties: {
-                        query: {
-                            type: "string",
-                            description: "Search string (keyword, function, symbol).",
-                        },
-                        ref: {
-                            type: "string",
-                            description: "Optional logical ref (WORKTREE/HEAD); search runs on current tree.",
-                        },
-                    },
-                    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) {
-            process.stdout.write(`${buildAnswer(completion)}\n`);
-            return;
-        }
-        const toolCalls = message.tool_calls ?? [];
-        logDebug(`local-review round=${round + 1} tool_calls=${toolCalls.length} finish_reason=${completion.choices[0]?.finish_reason ?? "unknown"}`);
-        if (toolCalls.length === 0) {
-            process.stdout.write(`${buildAnswer(completion)}\n`);
-            return;
-        }
-        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);
-            logDebug(`tool request local id=${toolCall.id} name=${toolCall.function.name} args=${argsRaw.slice(0, 300)}`);
-            const cacheKey = `${toolCall.function.name}:${argsRaw}`;
-            const cached = toolResultCache.get(cacheKey);
-            let toolContent;
-            if (cached != null) {
-                toolContent = cached;
-            }
-            else if (toolCall.function.name === TOOL_NAME_GET_FILE) {
-                toolContent = await handleLocalGetFileTool(argsRaw);
-                toolResultCache.set(cacheKey, toolContent);
-            }
-            else if (toolCall.function.name === TOOL_NAME_GREP) {
-                toolContent = await handleLocalGrepTool(argsRaw, logDebug);
-                toolResultCache.set(cacheKey, toolContent);
-            }
-            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 local id=${toolCall.id} name=${toolCall.function.name} payload=${toolContent.slice(0, 300)}`);
-        }
-    }
-    messages.push({
-        role: "user",
-        content: "Tool-call limit reached. Do not call tools anymore. Provide final review now in required format.",
-    });
-    const finalCompletion = await openaiInstance.chat.completions.create({
-        model: aiModel,
-        temperature: 0.2,
-        max_tokens: AI_MAX_OUTPUT_TOKENS,
-        stream: false,
-        messages,
-    });
-    process.stdout.write(`${buildAnswer(finalCompletion)}\n`);
-}
-//# sourceMappingURL=local-review.js.map