@mrkaran/hodor 0.4.1

package/dist/chunk-QGUJENIG.js

@@ -0,0 +1,1722 @@
+// src/utils/logger.ts
+import chalk from "chalk";
+var currentLevel = "warn";
+var LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+function setLogLevel(level) {
+  currentLevel = level;
+}
+function shouldLog(level) {
+  return LEVELS[level] >= LEVELS[currentLevel];
+}
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var logger = {
+  debug(msg) {
+    if (shouldLog("debug")) {
+      process.stderr.write(`${chalk.gray(timestamp())} ${chalk.gray("DEBUG")} ${msg}
+`);
+    }
+  },
+  info(msg) {
+    if (shouldLog("info")) {
+      process.stderr.write(`${chalk.gray(timestamp())} ${chalk.blue("INFO")}  ${msg}
+`);
+    }
+  },
+  warn(msg) {
+    if (shouldLog("warn")) {
+      process.stderr.write(`${chalk.gray(timestamp())} ${chalk.yellow("WARN")}  ${msg}
+`);
+    }
+  },
+  error(msg) {
+    if (shouldLog("error")) {
+      process.stderr.write(`${chalk.gray(timestamp())} ${chalk.red("ERROR")} ${msg}
+`);
+    }
+  }
+};
+
+// src/prompt.ts
+import { readFileSync } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+
+// src/utils/exec.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function exec(cmd, args, opts) {
+  const { stdout, stderr } = await execFileAsync(cmd, args, {
+    cwd: opts?.cwd,
+    env: opts?.env ?? process.env,
+    maxBuffer: 50 * 1024 * 1024
+    // 50MB
+  });
+  return { stdout, stderr };
+}
+async function execJson(cmd, args, opts) {
+  const { stdout } = await exec(cmd, args, opts);
+  return JSON.parse(stdout.trim());
+}
+
+// src/gitlab.ts
+var DEFAULT_GITLAB_HOST = "gitlab.com";
+function parseGlabPaginatedJson(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return [];
+  const chunks = [];
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  let start = -1;
+  for (let i = 0; i < trimmed.length; i++) {
+    const ch = trimmed[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\" && inString) {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (ch === "[") {
+      if (depth === 0) start = i;
+      depth++;
+    } else if (ch === "]") {
+      depth--;
+      if (depth === 0 && start >= 0) {
+        chunks.push(trimmed.slice(start, i + 1));
+        start = -1;
+      }
+    }
+  }
+  const results = [];
+  for (const chunk of chunks) {
+    const parsed = JSON.parse(chunk);
+    if (Array.isArray(parsed)) {
+      results.push(...parsed);
+    }
+  }
+  return results;
+}
+var GitLabAPIError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GitLabAPIError";
+  }
+};
+function normalizeBaseUrl(host) {
+  const candidate = host || process.env.GITLAB_HOST || process.env.CI_SERVER_URL || DEFAULT_GITLAB_HOST;
+  const trimmed = candidate.trim() || DEFAULT_GITLAB_HOST;
+  if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+    return trimmed.replace(/\/+$/, "");
+  }
+  return `https://${trimmed}`.replace(/\/+$/, "");
+}
+function encodedProjectPath(owner, repo) {
+  const projectPath = [owner.replace(/^\/+|\/+$/g, ""), repo.replace(/^\/+|\/+$/g, "")].filter(Boolean).join("/");
+  return encodeURIComponent(projectPath);
+}
+function glabEnv(host) {
+  const env = { ...process.env };
+  const baseUrl = normalizeBaseUrl(host);
+  const hostname = baseUrl.replace(/^https?:\/\//, "");
+  env.GITLAB_HOST = hostname;
+  return env;
+}
+async function fetchGitlabMrInfo(owner, repo, mrNumber, host, options) {
+  const encoded = encodedProjectPath(owner, repo);
+  const env = glabEnv(host);
+  let mrData;
+  try {
+    mrData = await execJson(
+      "glab",
+      ["api", `projects/${encoded}/merge_requests/${mrNumber}`],
+      { env }
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new GitLabAPIError(`Failed to fetch MR !${mrNumber}: ${msg}`);
+  }
+  const metadata = {
+    title: mrData.title,
+    description: mrData.description ?? "",
+    source_branch: mrData.source_branch,
+    target_branch: mrData.target_branch,
+    changes_count: mrData.changes_count,
+    labels: mrData.labels,
+    author: mrData.author,
+    pipeline: mrData.pipeline,
+    state: mrData.state
+  };
+  if (options?.includeComments) {
+    try {
+      const { stdout: rawNotes } = await exec(
+        "glab",
+        ["api", `projects/${encoded}/merge_requests/${mrNumber}/notes`, "--paginate"],
+        { env }
+      );
+      const notes = parseGlabPaginatedJson(rawNotes);
+      metadata.Notes = notes.map((n) => ({
+        body: n.body ?? "",
+        author: n.author,
+        created_at: n.created_at,
+        system: n.system
+      }));
+    } catch (err) {
+      logger.warn(`Failed to fetch MR notes: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+  return metadata;
+}
+async function postGitlabMrComment(owner, repo, mrNumber, body, host) {
+  const encoded = encodedProjectPath(owner, repo);
+  const env = glabEnv(host);
+  try {
+    await exec(
+      "glab",
+      [
+        "api",
+        `projects/${encoded}/merge_requests/${mrNumber}/notes`,
+        "--method",
+        "POST",
+        "--field",
+        `body=${body}`
+      ],
+      { env }
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new GitLabAPIError(`Failed to post comment to MR !${mrNumber}: ${msg}`);
+  }
+}
+function summarizeGitlabNotes(notes, maxEntries = 5) {
+  if (!notes || notes.length === 0) return "";
+  const trivialPatterns = /* @__PURE__ */ new Set([
+    "lgtm",
+    "+1",
+    "-1",
+    "\u{1F44D}",
+    "\u{1F44E}",
+    "thanks",
+    "thank you",
+    "looks good",
+    "approved",
+    "\u{1F680}",
+    "\u2705",
+    "\u274C"
+  ]);
+  const filtered = [];
+  for (const note of notes) {
+    const body = (note.body ?? "").trim();
+    if (!body) continue;
+    if (note.system) continue;
+    if (body.length < 20) continue;
+    const bodyLower = body.toLowerCase();
+    let isTrivial = false;
+    for (const pattern of trivialPatterns) {
+      if (bodyLower.includes(pattern) && body.length < 50) {
+        isTrivial = true;
+        break;
+      }
+    }
+    if (isTrivial) continue;
+    const username = note.author?.username ?? note.author?.name ?? "unknown";
+    filtered.push({ username, body, createdAt: note.created_at ?? "" });
+  }
+  filtered.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  const recent = filtered.slice(-maxEntries);
+  const lines = [];
+  for (const { username, body, createdAt } of recent) {
+    let timestampStr = "";
+    if (createdAt) {
+      try {
+        const dt = new Date(createdAt);
+        timestampStr = dt.toISOString().replace("T", " ").slice(0, 16);
+      } catch {
+        timestampStr = createdAt.slice(0, 10);
+      }
+    }
+    const header = timestampStr ? `- ${timestampStr} @${username}:` : `- @${username}:`;
+    const indentedBody = body.split("\n").join("\n  ");
+    lines.push(`${header}
+  ${indentedBody}`);
+  }
+  return lines.join("\n");
+}
+
+// src/prompt.ts
+function getTemplatesDir() {
+  const currentDir = dirname(fileURLToPath(import.meta.url));
+  return resolve(currentDir, "..", "templates");
+}
+function buildPrReviewPrompt(opts) {
+  const {
+    prUrl,
+    platform,
+    targetBranch = "main",
+    diffBaseSha,
+    mrMetadata,
+    customInstructions,
+    customPromptFile,
+    embeddedDiff,
+    previousReviewSha,
+    localMode = false
+  } = opts;
+  let templateFile;
+  if (customPromptFile) {
+    templateFile = customPromptFile;
+    logger.info(`Using custom prompt file: ${templateFile}`);
+  } else {
+    templateFile = resolve(getTemplatesDir(), "tool-review.md");
+    logger.info("Using tool-based review template");
+  }
+  let templateText;
+  try {
+    templateText = readFileSync(templateFile, "utf-8");
+  } catch (err) {
+    throw new Error(`Failed to load prompt template from ${templateFile}: ${err}`);
+  }
+  const dangerousChars = /[;\|`$&<>(){}\n\r\0\\!]/;
+  if (dangerousChars.test(targetBranch)) {
+    throw new Error(`Invalid target branch name: ${targetBranch}`);
+  }
+  if (diffBaseSha && dangerousChars.test(diffBaseSha)) {
+    throw new Error(`Invalid diff base SHA: ${diffBaseSha}`);
+  }
+  if (previousReviewSha && !/^[a-f0-9]{40}$/.test(previousReviewSha)) {
+    throw new Error(`Invalid previous review SHA: ${previousReviewSha}`);
+  }
+  let prDiffCmd;
+  let gitDiffCmd;
+  if (previousReviewSha) {
+    prDiffCmd = `git --no-pager diff ${previousReviewSha}...HEAD --name-only`;
+    gitDiffCmd = `git --no-pager diff ${previousReviewSha}...HEAD`;
+    logger.info(`Incremental review: diffing from ${previousReviewSha.slice(0, 8)} to HEAD`);
+  } else if (localMode) {
+    prDiffCmd = `git --no-pager diff ${targetBranch} --name-only`;
+    gitDiffCmd = `git --no-pager diff ${targetBranch}`;
+  } else if (platform === "github") {
+    prDiffCmd = `git --no-pager diff origin/${targetBranch}...HEAD --name-only`;
+    gitDiffCmd = `git --no-pager diff origin/${targetBranch}...HEAD`;
+  } else {
+    if (diffBaseSha) {
+      prDiffCmd = `git --no-pager diff ${diffBaseSha} HEAD --name-only`;
+      gitDiffCmd = `git --no-pager diff ${diffBaseSha} HEAD`;
+      logger.info(`Using GitLab CI_MERGE_REQUEST_DIFF_BASE_SHA: ${diffBaseSha.slice(0, 8)}`);
+    } else {
+      prDiffCmd = `git --no-pager diff origin/${targetBranch}...HEAD --name-only`;
+      gitDiffCmd = `git --no-pager diff origin/${targetBranch}...HEAD`;
+    }
+  }
+  let diffExplanation;
+  if (previousReviewSha) {
+    diffExplanation = `**Incremental mode**: Showing only changes since the last hodor review (commit \`${previousReviewSha.slice(0, 8)}\`).`;
+  } else if (diffBaseSha) {
+    diffExplanation = `**GitLab CI Advantage**: This uses GitLab's pre-calculated merge base SHA (\`CI_MERGE_REQUEST_DIFF_BASE_SHA\`), which matches exactly what the GitLab UI shows. This is more reliable than three-dot syntax because it handles force pushes, rebases, and messy histories correctly.`;
+  } else {
+    diffExplanation = `**Three-dot syntax** shows ONLY changes introduced on the source branch, excluding changes already on \`${targetBranch}\`.`;
+  }
+  const { contextSection, notesSection, reminderSection } = buildMrSections(mrMetadata);
+  let incrementalSection = "";
+  if (previousReviewSha) {
+    incrementalSection = `## Incremental Review Mode
+
+This is a follow-up review. A previous hodor review was done at commit \`${previousReviewSha.slice(0, 8)}\`. The diff below shows ONLY changes since that review. Focus on:
+1. New code changes introduced since the last review
+2. Whether previous findings (shown in MR notes above) are still applicable
+3. Do NOT re-report issues that are already mentioned in existing notes
+
+`;
+  }
+  let embeddedDiffSection;
+  let diffFetchInstructions;
+  let reviewProcessSection;
+  let startInstruction;
+  if (embeddedDiff) {
+    embeddedDiffSection = "## Full Diff (Pre-fetched)\n\nThe complete diff for this PR is provided below. Analyze it directly. Use `read` or `grep` only if you need additional file context beyond what the diff shows.\n\n````diff\n" + embeddedDiff + "\n````\n";
+    diffFetchInstructions = `## Review the Diff Above
+
+### Critical Rules
+- ONLY review files that appear in the diff above
+- ONLY analyze actual code changes (+ and - lines in the diff)
+- NEVER review files not in the diff
+- NEVER flag "files will be deleted when merging" (outdated branch)
+- NEVER flag "dependency version downgrade" (branch not rebased)
+- NEVER compare entire codebase to ${targetBranch} - DIFF ONLY
+`;
+    reviewProcessSection = "## Review Process\n\n1. Analyze the embedded diff above thoroughly\n2. Use `grep` to search for patterns if needed\n3. Use `read` only when surrounding context is essential\n4. Submit your review using `submit_review`\n";
+    startInstruction = "Analyze the diff provided above, then submit your review using `submit_review`.";
+  } else {
+    embeddedDiffSection = "";
+    diffFetchInstructions = "## Step 1: List Changed Files (MANDATORY FIRST STEP)\n\n**Run this command FIRST to get the list of changed files:**\n```bash\n" + prDiffCmd + "\n```\n\nThis lists ONLY the filenames changed in this PR. **Do NOT dump the entire diff here** - you'll inspect each file individually in Step 2. Only review files that appear in this output.\n\n## Step 2: Review Changed Files Only\n\n### Critical Rules\n- ONLY review files that appear in the diff from Step 1\n- ONLY analyze actual code changes (+ and - lines in the diff)\n- Use the most reliable diff command: `" + gitDiffCmd + `\`
+- NEVER review files not in the diff
+- NEVER flag "files will be deleted when merging" (outdated branch)
+- NEVER flag "dependency version downgrade" (branch not rebased)
+- NEVER compare entire codebase to ${targetBranch} - DIFF ONLY
+
+### Git Diff Command
+
+**Most reliable command to see changes:**
+\`\`\`bash
+` + gitDiffCmd + "\n```\n\n" + diffExplanation;
+    reviewProcessSection = `## Review Process
+
+**Efficient Sequential Workflow:**
+
+1. **List files first**: Run \`${prDiffCmd}\` to get the list of changed files (NOT full diff)
+2. **Per-file analysis**: For each file, run \`${gitDiffCmd} -- path/to/file\` to see its specific changes
+3. **Batch pattern search**: Use \`grep\` across multiple files to find common bug patterns (null, undefined, TODO, FIXME, etc.)
+4. **Selective deep dive**: Only use \`read\` to read full file context when the diff alone is insufficient
+5. **Group related files**: Analyze related files together (e.g., implementation + tests, interfaces + implementations)
+6. **Avoid redundancy**: Don't re-read files unnecessarily; make decisions based on diff context
+`;
+    startInstruction = `Start by running \`${prDiffCmd}\` to list the changed files, then analyze each file individually using \`${gitDiffCmd} -- path/to/file\`.`;
+  }
+  let prompt = templateText.replace(/\{pr_url\}/g, prUrl).replace(/\{pr_diff_cmd\}/g, prDiffCmd).replace(/\{git_diff_cmd\}/g, gitDiffCmd).replace(/\{target_branch\}/g, targetBranch).replace(/\{diff_explanation\}/g, diffExplanation).replace(/\{mr_context_section\}/g, contextSection).replace(/\{mr_notes_section\}/g, notesSection).replace(/\{mr_reminder_section\}/g, reminderSection).replace(/\{incremental_section\}/g, incrementalSection).replace(/\{embedded_diff_section\}/g, embeddedDiffSection).replace(/\{diff_fetch_instructions\}/g, diffFetchInstructions).replace(/\{review_process_section\}/g, reviewProcessSection).replace(/\{start_instruction\}/g, startInstruction);
+  if (customInstructions) {
+    prompt += `
+
+## Additional Instructions
+
+${customInstructions}
+`;
+    logger.info("Appended custom instructions to prompt");
+  }
+  return prompt;
+}
+function buildMrSections(mrMetadata) {
+  if (!mrMetadata) {
+    return { contextSection: "", notesSection: "", reminderSection: "" };
+  }
+  const contextLines = [];
+  if (mrMetadata.title) {
+    contextLines.push(`- Title: ${mrMetadata.title}`);
+  }
+  const author = mrMetadata.author?.username ?? mrMetadata.author?.name;
+  if (author) {
+    contextLines.push(`- Author: @${author}`);
+  }
+  if (mrMetadata.source_branch && mrMetadata.target_branch) {
+    contextLines.push(
+      `- Branches: ${mrMetadata.source_branch} \u2192 ${mrMetadata.target_branch}`
+    );
+  }
+  if (mrMetadata.changes_count) {
+    contextLines.push(`- Files changed: ${mrMetadata.changes_count}`);
+  }
+  const pipelineStatus = mrMetadata.pipeline?.status;
+  const pipelineUrl = mrMetadata.pipeline?.web_url;
+  if (pipelineStatus) {
+    const statusText = pipelineStatus.replace(/_/g, " ");
+    contextLines.push(
+      pipelineUrl ? `- Pipeline: ${statusText} (${pipelineUrl})` : `- Pipeline: ${statusText}`
+    );
+  }
+  let labelNames = normalizeLabelNames(mrMetadata.label_details);
+  if (labelNames.length === 0) {
+    labelNames = normalizeLabelNames(mrMetadata.labels);
+  }
+  if (labelNames.length > 0) {
+    contextLines.push(`- Labels: ${labelNames.join(", ")}`);
+  }
+  const description = (mrMetadata.description ?? "").trim();
+  let descriptionSection = "";
+  if (description) {
+    descriptionSection = "**Author Description:**\n" + truncateBlock(description, 800);
+  }
+  let contextSection = "";
+  if (contextLines.length > 0 || descriptionSection) {
+    contextSection = "## MR Context\n" + contextLines.join("\n");
+    if (descriptionSection) {
+      contextSection += "\n\n" + descriptionSection;
+    }
+    contextSection += "\n";
+  }
+  let notesSection = "";
+  const notesSummary = summarizeGitlabNotes(mrMetadata.Notes);
+  if (notesSummary) {
+    notesSection = `## Existing MR Notes
+${notesSummary}
+`;
+  }
+  let reminderSection = "";
+  if (notesSummary) {
+    reminderSection = "## Review Note Deduplication\n\nThe discussions above may already cover some issues. Before reporting a finding:\n1. Check if it's already mentioned in existing notes\n2. Only report if your finding is materially different or more specific\n3. If an existing note is incorrect/outdated, explain why in your finding\n\nFocus on discovering NEW issues not yet discussed.\n";
+  }
+  return { contextSection, notesSection, reminderSection };
+}
+function truncateBlock(text, limit) {
+  const trimmed = text.trim();
+  if (trimmed.length <= limit) return trimmed;
+  return trimmed.slice(0, limit - 1).trimEnd() + "\u2026";
+}
+function normalizeLabelNames(rawLabels) {
+  if (!rawLabels) return [];
+  const names = [];
+  function addLabel(value) {
+    let name = "";
+    if (typeof value === "string") {
+      name = value.trim();
+    } else if (typeof value === "object" && value !== null) {
+      const labelValue = value.name;
+      if (typeof labelValue === "string") {
+        name = labelValue.trim();
+      }
+    } else if (value != null) {
+      name = String(value).trim();
+    }
+    if (name) names.push(name);
+  }
+  if (Array.isArray(rawLabels)) {
+    for (const label of rawLabels) addLabel(label);
+  } else {
+    addLabel(rawLabels);
+  }
+  return names;
+}
+
+// src/model.ts
+function parseModelString(model) {
+  const trimmed = model.trim();
+  if (!trimmed) throw new Error("Model name must be provided");
+  const parts = trimmed.split("/");
+  if (parts.length >= 2) {
+    const first = parts[0].toLowerCase();
+    if (first === "bedrock") {
+      let modelId = parts.slice(1).join("/");
+      if (modelId.startsWith("converse/")) {
+        modelId = modelId.slice("converse/".length);
+      }
+      return { provider: "amazon-bedrock", modelId };
+    }
+    if (["anthropic", "openai"].includes(first)) {
+      return { provider: first, modelId: parts.slice(1).join("/") };
+    }
+  }
+  const lower = trimmed.toLowerCase();
+  if (lower.includes("claude") || lower.includes("anthropic")) {
+    return { provider: "anthropic", modelId: trimmed };
+  }
+  if (lower.startsWith("gpt") || lower.startsWith("o1") || lower.startsWith("o3") || lower.startsWith("o4") || lower.includes("openai")) {
+    return { provider: "openai", modelId: trimmed };
+  }
+  return { provider: "anthropic", modelId: trimmed };
+}
+function mapReasoningEffort(effort) {
+  if (!effort) return void 0;
+  switch (effort.toLowerCase()) {
+    case "low":
+      return "low";
+    case "medium":
+      return "medium";
+    case "high":
+    case "xhigh":
+      return "high";
+    default:
+      return void 0;
+  }
+}
+function getApiKey(model) {
+  const llmKey = process.env.LLM_API_KEY;
+  if (llmKey) return llmKey;
+  if (model) {
+    const { provider } = parseModelString(model);
+    if (provider === "amazon-bedrock") return null;
+    if (provider === "anthropic") {
+      const key = process.env.ANTHROPIC_API_KEY;
+      if (key) return key;
+    }
+    if (provider === "openai") {
+      const key = process.env.OPENAI_API_KEY;
+      if (key) return key;
+    }
+  }
+  if (process.env.ANTHROPIC_API_KEY) return process.env.ANTHROPIC_API_KEY;
+  if (process.env.OPENAI_API_KEY) return process.env.OPENAI_API_KEY;
+  throw new Error(
+    "No LLM API key found. Please set one of: LLM_API_KEY, ANTHROPIC_API_KEY, or OPENAI_API_KEY"
+  );
+}
+
+// src/metrics.ts
+import chalk2 from "chalk";
+function tok(value) {
+  if (value >= 1e6) return `${(value / 1e6).toFixed(2)}M`;
+  if (value >= 1e3) return `${(value / 1e3).toFixed(1)}K`;
+  return String(value);
+}
+function formatDuration(seconds) {
+  if (seconds >= 60) {
+    const m = Math.floor(seconds / 60);
+    const s = seconds % 60;
+    return s > 0 ? `${m}m ${s}s` : `${m}m`;
+  }
+  return `${seconds}s`;
+}
+function formatMetricsMarkdown(metrics) {
+  const totalInput = metrics.inputTokens + metrics.cacheReadTokens;
+  const parts = [`in \`${tok(totalInput)}\``];
+  if (metrics.cacheReadTokens > 0) {
+    parts.push(`cached \`${tok(metrics.cacheReadTokens)}\``);
+  }
+  parts.push(`out \`${tok(metrics.outputTokens)}\``);
+  const lines = [
+    `**Review Metrics** \u2014 ${metrics.turns} turns, ${metrics.toolCalls} tool calls, ${formatDuration(metrics.durationSeconds)}`,
+    `- Tokens: ${parts.join(" | ")} (total \`${tok(metrics.totalTokens)}\`)`
+  ];
+  if (metrics.cost > 0) {
+    lines.push(`- Cost: \`$${metrics.cost.toFixed(4)}\``);
+  }
+  return lines.join("\n");
+}
+function printMetrics(metrics, stream = process.stderr) {
+  const dim = chalk2.dim;
+  const bold = chalk2.bold;
+  const cyan = chalk2.cyan;
+  const write = (line) => stream.write(line + "\n");
+  write("");
+  write(dim("\u2500".repeat(50)));
+  const totalInput = metrics.inputTokens + metrics.cacheReadTokens;
+  let tokenLine = `${dim("Tokens:")}  ${bold(tok(totalInput))} in`;
+  if (metrics.cacheReadTokens > 0) {
+    const hitPct = (metrics.cacheReadTokens / totalInput * 100).toFixed(0);
+    tokenLine += dim(` (${tok(metrics.cacheReadTokens)} cached ${hitPct}% \xB7 ${tok(metrics.inputTokens)} fresh)`);
+  }
+  tokenLine += `  ${bold(tok(metrics.outputTokens))} out`;
+  tokenLine += dim(`  (${tok(metrics.totalTokens)} total)`);
+  write(tokenLine);
+  write(
+    `${dim("Agent:")}   ${bold(String(metrics.turns))} turns  ${bold(String(metrics.toolCalls))} tool calls  ${cyan(formatDuration(metrics.durationSeconds))}`
+  );
+  if (metrics.cost > 0) {
+    write(`${dim("Cost:")}    ${bold("$" + metrics.cost.toFixed(4))}`);
+  }
+  write(dim("\u2500".repeat(50)));
+}
+async function pushMetrics(opts) {
+  const { pushgatewayUrl, metrics, labels = {} } = opts;
+  const labelPairs = Object.entries(labels).map(([k, v]) => `${k}="${v.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`).join(",");
+  const labelSuffix = labelPairs ? `{${labelPairs}}` : "";
+  const totalInput = metrics.inputTokens + metrics.cacheReadTokens;
+  const lines = [
+    `# HELP hodor_review_input_tokens_total Total input tokens (fresh + cached)`,
+    `# TYPE hodor_review_input_tokens_total gauge`,
+    `hodor_review_input_tokens_total${labelSuffix} ${totalInput}`,
+    `# HELP hodor_review_output_tokens_total Total output tokens`,
+    `# TYPE hodor_review_output_tokens_total gauge`,
+    `hodor_review_output_tokens_total${labelSuffix} ${metrics.outputTokens}`,
+    `# HELP hodor_review_cache_read_tokens_total Tokens served from prompt cache`,
+    `# TYPE hodor_review_cache_read_tokens_total gauge`,
+    `hodor_review_cache_read_tokens_total${labelSuffix} ${metrics.cacheReadTokens}`,
+    `# HELP hodor_review_cost_dollars Cost of the review in USD`,
+    `# TYPE hodor_review_cost_dollars gauge`,
+    `hodor_review_cost_dollars${labelSuffix} ${metrics.cost}`,
+    `# HELP hodor_review_turns_total Number of agent turns`,
+    `# TYPE hodor_review_turns_total gauge`,
+    `hodor_review_turns_total${labelSuffix} ${metrics.turns}`,
+    `# HELP hodor_review_tool_calls_total Number of tool calls`,
+    `# TYPE hodor_review_tool_calls_total gauge`,
+    `hodor_review_tool_calls_total${labelSuffix} ${metrics.toolCalls}`,
+    `# HELP hodor_review_duration_seconds Review duration in seconds`,
+    `# TYPE hodor_review_duration_seconds gauge`,
+    `hodor_review_duration_seconds${labelSuffix} ${metrics.durationSeconds}`,
+    ""
+  ];
+  const body = lines.join("\n");
+  const baseUrl = pushgatewayUrl.replace(/\/+$/, "");
+  const url = `${baseUrl}/metrics/job/hodor`;
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "text/plain" },
+      body,
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      logger.warn(`Pushgateway returned ${res.status}: ${text.slice(0, 200)}`);
+    } else {
+      logger.info("Metrics pushed to Pushgateway");
+    }
+  } catch (err) {
+    logger.warn(`Failed to push metrics to Pushgateway: ${err instanceof Error ? err.message : err}`);
+  }
+}
+
+// src/review.ts
+import { isAbsolute } from "path";
+import { Type } from "@sinclair/typebox";
+var REVIEW_PRIORITY_TAGS = /* @__PURE__ */ new Map([
+  ["[P0]", 0],
+  ["[P1]", 1],
+  ["[P2]", 2],
+  ["[P3]", 3]
+]);
+var REVIEW_LOCATION_SCHEMA = Type.Object(
+  {
+    absolute_file_path: Type.String({ minLength: 1 }),
+    line_range: Type.Object(
+      {
+        start: Type.Integer({ minimum: 1 }),
+        end: Type.Integer({ minimum: 1 })
+      },
+      { additionalProperties: false }
+    )
+  },
+  { additionalProperties: false }
+);
+var REVIEW_FINDING_SCHEMA = Type.Object(
+  {
+    title: Type.String({ minLength: 1 }),
+    body: Type.String({ minLength: 1 }),
+    priority: Type.Integer({ minimum: 0, maximum: 3 }),
+    code_location: REVIEW_LOCATION_SCHEMA
+  },
+  { additionalProperties: false }
+);
+var SUBMIT_REVIEW_SCHEMA = Type.Object(
+  {
+    findings: Type.Array(REVIEW_FINDING_SCHEMA),
+    overall_correctness: Type.Union([
+      Type.Literal("patch is correct"),
+      Type.Literal("patch is incorrect")
+    ]),
+    overall_explanation: Type.String({ minLength: 1 })
+  },
+  { additionalProperties: false }
+);
+function validateReviewOutput(review) {
+  if (review.overall_explanation.trim().length === 0) {
+    throw new Error("submit_review overall_explanation must be non-empty");
+  }
+  for (const [index, finding] of review.findings.entries()) {
+    const label = `submit_review finding ${index + 1}`;
+    if (finding.title.trim().length === 0) {
+      throw new Error(`${label} title must be non-empty`);
+    }
+    if (finding.body.trim().length === 0) {
+      throw new Error(`${label} body must be non-empty`);
+    }
+    const taggedPriority = getPriorityFromTitle(finding.title);
+    if (taggedPriority == null) {
+      throw new Error(`${label} title must start with [P0], [P1], [P2], or [P3]`);
+    }
+    if (finding.priority !== taggedPriority) {
+      throw new Error(
+        `${label} priority ${finding.priority} does not match title tag ${taggedPriority}`
+      );
+    }
+    const { absolute_file_path: filePath, line_range: lineRange } = finding.code_location;
+    if (!isAbsolute(filePath)) {
+      throw new Error(`${label} code_location.absolute_file_path must be absolute`);
+    }
+    if (lineRange.start > lineRange.end) {
+      throw new Error(`${label} code_location line_range start must be <= end`);
+    }
+  }
+  return review;
+}
+function getPriorityFromTitle(title) {
+  const match = title.match(/^\[(P[0-3])\]/);
+  if (!match) return null;
+  return REVIEW_PRIORITY_TAGS.get(`[${match[1]}]`) ?? null;
+}
+
+// src/agent.ts
+import { existsSync } from "fs";
+import { join as join2 } from "path";
+
+// src/github.ts
+var GitHubAPIError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GitHubAPIError";
+  }
+};
+async function fetchGithubPrInfo(owner, repo, prNumber) {
+  const fields = [
+    "number",
+    "title",
+    "body",
+    "author",
+    "baseRefName",
+    "headRefName",
+    "baseRefOid",
+    "headRefOid",
+    "changedFiles",
+    "labels",
+    "comments",
+    "state",
+    "isDraft",
+    "createdAt",
+    "updatedAt",
+    "mergeable",
+    "url"
+  ];
+  const repoFullPath = `${owner}/${repo}`;
+  try {
+    return await execJson("gh", [
+      "pr",
+      "view",
+      String(prNumber),
+      "-R",
+      repoFullPath,
+      "--json",
+      fields.join(",")
+    ]);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new GitHubAPIError(msg);
+  }
+}
+function normalizeGithubMetadata(raw) {
+  const author = raw.author ?? {};
+  const labels = raw.labels ?? [];
+  const comments = raw.comments;
+  return {
+    title: raw.title,
+    description: raw.body ?? "",
+    source_branch: raw.headRefName,
+    target_branch: raw.baseRefName,
+    changes_count: raw.changedFiles,
+    labels: labels.map((lbl) => ({ name: lbl.name ?? lbl.id })),
+    author: {
+      username: author.login ?? author.name,
+      name: author.name
+    },
+    Notes: githubCommentsToNotes(comments)
+  };
+}
+function githubCommentsToNotes(comments) {
+  if (!comments) return [];
+  let nodes;
+  if (Array.isArray(comments)) {
+    nodes = comments;
+  } else if (typeof comments === "object") {
+    nodes = comments.nodes ?? comments.edges ?? [];
+    if (nodes.length > 0 && typeof nodes[0] === "object" && "node" in nodes[0]) {
+      nodes = nodes.map(
+        (edge) => edge.node ?? {}
+      );
+    }
+  } else {
+    nodes = [];
+  }
+  return nodes.map((node) => {
+    const author = node.author ?? {};
+    return {
+      body: node.body ?? "",
+      author: {
+        username: author.login ?? author.name,
+        name: author.name
+      },
+      created_at: node.createdAt
+    };
+  });
+}
+
+// src/workspace.ts
+import { mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+var WorkspaceError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WorkspaceError";
+  }
+};
+function detectCiWorkspace(owner, repo) {
+  if (process.env.GITLAB_CI === "true") {
+    const projectDir = process.env.CI_PROJECT_DIR;
+    const projectPath = process.env.CI_PROJECT_PATH;
+    const targetBranch = process.env.CI_MERGE_REQUEST_TARGET_BRANCH_NAME ?? null;
+    const diffBaseSha = process.env.CI_MERGE_REQUEST_DIFF_BASE_SHA ?? null;
+    if (projectDir && projectPath) {
+      const expected = `${owner}/${repo}`;
+      if (projectPath === expected || projectPath.endsWith(`/${expected}`)) {
+        logger.info(`Detected GitLab CI environment (target: ${targetBranch ?? "unknown"})`);
+        return { path: projectDir, targetBranch, diffBaseSha };
+      }
+    }
+  }
+  if (process.env.GITHUB_ACTIONS === "true") {
+    const workspaceDir = process.env.GITHUB_WORKSPACE;
+    const repository = process.env.GITHUB_REPOSITORY;
+    const baseRef = process.env.GITHUB_BASE_REF ?? null;
+    if (workspaceDir && repository) {
+      const expected = `${owner}/${repo}`;
+      if (repository === expected) {
+        logger.info(`Detected GitHub Actions environment (base: ${baseRef ?? "unknown"})`);
+        return { path: workspaceDir, targetBranch: baseRef, diffBaseSha: null };
+      }
+    }
+  }
+  return { path: null, targetBranch: null, diffBaseSha: null };
+}
+async function isSameRepo(workspace, owner, repo) {
+  try {
+    const { stdout } = await exec("git", ["remote", "get-url", "origin"], { cwd: workspace });
+    const remoteUrl = stdout.trim();
+    const match = remoteUrl.match(/[/:]([\w.\-\/]+?)(?:\.git)?$/);
+    if (!match) return false;
+    const remotePath = match[1];
+    const expectedPath = `${owner}/${repo}`;
+    return remotePath === expectedPath;
+  } catch {
+    return false;
+  }
+}
+async function getGithubBaseBranch(workspace, prNumber) {
+  try {
+    const prInfo = await execJson(
+      "gh",
+      ["pr", "view", prNumber, "--json", "headRefName,baseRefName"],
+      { cwd: workspace }
+    );
+    const baseBranch = prInfo.baseRefName ?? "main";
+    logger.info(`Base branch: ${baseBranch}`);
+    return baseBranch;
+  } catch {
+    logger.warn("Could not fetch PR metadata for base branch detection");
+    return "main";
+  }
+}
+async function fetchAndCheckoutGithubPr(workspace, prNumber) {
+  logger.info(`Fetching and checking out PR #${prNumber} in existing workspace`);
+  await exec("git", ["fetch", "origin"], { cwd: workspace });
+  try {
+    await exec("gh", ["pr", "checkout", prNumber], { cwd: workspace });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new WorkspaceError(`Failed to checkout PR #${prNumber}: ${msg}`);
+  }
+  return getGithubBaseBranch(workspace, prNumber);
+}
+async function cloneAndCheckoutGithubPr(workspace, owner, repo, prNumber) {
+  logger.info(`Setting up GitHub workspace for ${owner}/${repo}/pull/${prNumber}`);
+  try {
+    await exec("gh", ["version"]);
+  } catch {
+    throw new WorkspaceError("GitHub CLI (gh) is not available. Install it: https://cli.github.com");
+  }
+  logger.info(`Cloning repository ${owner}/${repo}...`);
+  try {
+    await exec("gh", ["repo", "clone", `${owner}/${repo}`, workspace]);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new WorkspaceError(`Failed to clone repository ${owner}/${repo}: ${msg}`);
+  }
+  logger.info(`Checking out PR #${prNumber}...`);
+  try {
+    await exec("gh", ["pr", "checkout", prNumber], { cwd: workspace });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new WorkspaceError(`Failed to checkout PR #${prNumber}: ${msg}`);
+  }
+  return getGithubBaseBranch(workspace, prNumber);
+}
+async function getGitlabMrBranches(owner, repo, prNumber, host) {
+  const gitlabHost = host || process.env.GITLAB_HOST || "gitlab.com";
+  let mrInfo;
+  try {
+    mrInfo = await fetchGitlabMrInfo(owner, repo, Number(prNumber), gitlabHost);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new WorkspaceError(`Failed to fetch MR info for !${prNumber}: ${msg}`);
+  }
+  const sourceBranch = mrInfo.source_branch;
+  if (!sourceBranch) {
+    throw new WorkspaceError(`Could not determine source branch for MR !${prNumber}`);
+  }
+  return { sourceBranch, targetBranch: mrInfo.target_branch ?? "main" };
+}
+async function checkoutGitlabBranch(workspace, sourceBranch) {
+  try {
+    await exec("git", ["checkout", "-b", sourceBranch, `origin/${sourceBranch}`], {
+      cwd: workspace
+    });
+  } catch {
+    try {
+      await exec("git", ["checkout", sourceBranch], { cwd: workspace });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new WorkspaceError(`Failed to checkout MR branch '${sourceBranch}': ${msg}`);
+    }
+  }
+}
+async function fetchAndCheckoutGitlabMr(workspace, owner, repo, prNumber, host) {
+  logger.info(`Fetching and checking out MR !${prNumber} in existing workspace`);
+  await exec("git", ["fetch", "origin"], { cwd: workspace });
+  const { sourceBranch, targetBranch } = await getGitlabMrBranches(owner, repo, prNumber, host);
+  logger.info(`Source branch: ${sourceBranch}, Target branch: ${targetBranch}`);
+  await checkoutGitlabBranch(workspace, sourceBranch);
+  return targetBranch;
+}
+async function cloneAndCheckoutGitlabMr(workspace, owner, repo, prNumber, host) {
+  const gitlabHost = host || process.env.GITLAB_HOST || "gitlab.com";
+  logger.info(`Setting up GitLab workspace for ${owner}/${repo}/merge_requests/${prNumber}`);
+  try {
+    await exec("glab", ["version"]);
+  } catch {
+    throw new WorkspaceError(
+      "GitLab CLI (glab) is not available. Install it: https://gitlab.com/gitlab-org/cli"
+    );
+  }
+  const cloneUrl = `https://${gitlabHost}/${owner}/${repo}.git`;
+  logger.info(`Cloning from ${cloneUrl}...`);
+  try {
+    await exec("git", ["clone", cloneUrl, workspace]);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("Permission denied") || msg.includes("publickey")) {
+      throw new WorkspaceError(
+        `Failed to clone ${owner}/${repo}: SSH authentication failed. Ensure your SSH key is available (ssh-add) or configure a GITLAB_TOKEN and use HTTPS: git config --global url."https://oauth2:$GITLAB_TOKEN@${gitlabHost}/".insteadOf "git@${gitlabHost}:"`
+      );
+    }
+    throw new WorkspaceError(`Failed to clone ${owner}/${repo}: ${msg}`);
+  }
+  const { sourceBranch, targetBranch } = await getGitlabMrBranches(owner, repo, prNumber, host);
+  logger.info(`Source branch: ${sourceBranch}, Target branch: ${targetBranch}`);
+  await checkoutGitlabBranch(workspace, sourceBranch);
+  return targetBranch;
+}
+async function setupWorkspace(opts) {
+  const { platform, owner, repo, prNumber, host, workingDir, reuse = true } = opts;
+  try {
+    const ci = detectCiWorkspace(owner, repo);
+    let detectedTargetBranch = ci.targetBranch;
+    const detectedDiffBaseSha = ci.diffBaseSha;
+    let workspace;
+    let isTemporary = false;
+    if (ci.path) {
+      workspace = ci.path;
+    } else if (!workingDir) {
+      workspace = await mkdtemp(join(tmpdir(), "hodor-review-"));
+      isTemporary = true;
+      logger.info(`Created temporary workspace: ${workspace}`);
+    } else {
+      workspace = workingDir;
+      const { mkdir } = await import("fs/promises");
+      await mkdir(workspace, { recursive: true });
+      if (reuse && await isSameRepo(workspace, owner, repo)) {
+        logger.info(`Reusing existing workspace: ${workspace}`);
+        if (platform === "github") {
+          const tb = await fetchAndCheckoutGithubPr(workspace, prNumber);
+          if (!detectedTargetBranch) detectedTargetBranch = tb;
+        } else if (platform === "gitlab") {
+          const tb = await fetchAndCheckoutGitlabMr(workspace, owner, repo, prNumber, host);
+          if (!detectedTargetBranch) detectedTargetBranch = tb;
+        }
+        const finalTargetBranch2 = detectedTargetBranch ?? "main";
+        logger.info(
+          `Workspace ready at: ${workspace} (target: ${finalTargetBranch2}, diff_base_sha: ${detectedDiffBaseSha?.slice(0, 8) ?? "N/A"})`
+        );
+        return { workspace, targetBranch: finalTargetBranch2, diffBaseSha: detectedDiffBaseSha, isTemporary: false };
+      }
+    }
+    if (!ci.path) {
+      if (platform === "github") {
+        const tb = await cloneAndCheckoutGithubPr(workspace, owner, repo, prNumber);
+        if (!detectedTargetBranch) detectedTargetBranch = tb;
+      } else if (platform === "gitlab") {
+        const tb = await cloneAndCheckoutGitlabMr(workspace, owner, repo, prNumber, host);
+        if (!detectedTargetBranch) detectedTargetBranch = tb;
+      } else {
+        throw new WorkspaceError(`Unsupported platform: ${platform}`);
+      }
+    }
+    const finalTargetBranch = detectedTargetBranch ?? "main";
+    logger.info(
+      `Workspace ready at: ${workspace} (target: ${finalTargetBranch}, diff_base_sha: ${detectedDiffBaseSha?.slice(0, 8) ?? "N/A"})`
+    );
+    return { workspace, targetBranch: finalTargetBranch, diffBaseSha: detectedDiffBaseSha, isTemporary };
+  } catch (err) {
+    if (err instanceof WorkspaceError) throw err;
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new WorkspaceError(`Failed to setup workspace: ${msg}`);
+  }
+}
+async function cleanupWorkspace(workspace) {
+  try {
+    await rm(workspace, { recursive: true, force: true });
+    logger.info(`Cleaned up workspace: ${workspace}`);
+  } catch (err) {
+    logger.warn(`Failed to cleanup workspace ${workspace}: ${err}`);
+  }
+}
+
+// src/system-prompt.ts
+var REVIEW_SYSTEM_PROMPT = `You are a code review agent. You analyze pull request diffs to find production bugs.
+
+<ROLE>
+* You are in READ-ONLY mode. Do NOT modify any files, create files, commit, or install dependencies.
+* Your only job is to analyze the diff, identify bugs, and produce a review.
+* Submit the final review via the \`submit_review\` tool. Do NOT output the final review as normal assistant text.
+* Be proportional: scale your analysis depth to the diff size. A small, single-file diff needs only a few iterations; a large multi-file refactor warrants deeper investigation.
+* Do NOT write to PLAN.md or AGENTS.md.
+* Do NOT run package managers (npm install, go mod download, pip install, etc.).
+* Follow the instructions in the user prompt exactly as given.
+</ROLE>
+
+<EFFICIENCY>
+* Combine multiple bash commands where possible (e.g. \`cmd1 && cmd2\`).
+* Use the grep and find tools for code search \u2014 do not shell out to grep/find.
+* Prefer \`git diff\` to see changes for specific files. Only use read when you need surrounding context that the diff alone cannot provide.
+* Do not use cat/head/tail to read files.
+* Keep reasoning proportional to the task. A small diff does not need extensive deliberation.
+</EFFICIENCY>`;
+
+// src/agent.ts
+function detectPlatform(prUrl) {
+  const url = new URL(prUrl);
+  const hostname = url.hostname;
+  if (prUrl.includes("/-/merge_requests/") || hostname.includes("gitlab")) {
+    return "gitlab";
+  }
+  if (prUrl.includes("/pull/") || hostname.includes("github")) {
+    return "github";
+  }
+  throw new Error(
+    `Cannot detect platform for URL: ${prUrl}. Expected a GitHub pull request (/pull/) or GitLab merge request (/-/merge_requests/) URL.`
+  );
+}
+function parsePrUrl(prUrl) {
+  const url = new URL(prUrl);
+  const pathParts = url.pathname.split("/").filter(Boolean);
+  const host = url.host;
+  if (pathParts.length >= 4 && pathParts[2] === "pull") {
+    const prNumber = parseInt(pathParts[3], 10);
+    if (!Number.isSafeInteger(prNumber) || prNumber <= 0) {
+      throw new Error(`Invalid PR number in URL: ${prUrl}. Expected a positive integer after /pull/.`);
+    }
+    return {
+      owner: pathParts[0],
+      repo: pathParts[1],
+      prNumber,
+      host
+    };
+  }
+  const mrIndex = pathParts.indexOf("merge_requests");
+  if (mrIndex >= 0) {
+    if (mrIndex < 2 || mrIndex + 1 >= pathParts.length) {
+      throw new Error(
+        `Invalid GitLab MR URL format: ${prUrl}. Expected .../-/merge_requests/<number>`
+      );
+    }
+    if (pathParts[mrIndex - 1] !== "-") {
+      throw new Error(
+        `Invalid GitLab MR URL format: ${prUrl}. Missing '/-/' segment before merge_requests.`
+      );
+    }
+    const repo = pathParts[mrIndex - 2];
+    const ownerParts = pathParts.slice(0, mrIndex - 2);
+    const owner = ownerParts.length > 0 ? ownerParts.join("/") : pathParts[0];
+    const prNumber = parseInt(pathParts[mrIndex + 1], 10);
+    if (!Number.isSafeInteger(prNumber) || prNumber <= 0) {
+      throw new Error(`Invalid MR number in URL: ${prUrl}. Expected a positive integer after /merge_requests/.`);
+    }
+    return { owner, repo, prNumber, host };
+  }
+  throw new Error(
+    `Invalid PR/MR URL format: ${prUrl}. Expected GitHub pull request or GitLab merge request URL.`
+  );
+}
+async function postReviewComment(opts) {
+  const { prUrl, reviewText, model, metricsFooter, headSha } = opts;
+  const platform = detectPlatform(prUrl);
+  logger.info(`Posting comment to ${platform} PR/MR: ${prUrl}`);
+  let parsed;
+  try {
+    parsed = parsePrUrl(prUrl);
+  } catch (err) {
+    return { success: false, error: String(err) };
+  }
+  let body = reviewText;
+  if (headSha) {
+    body = `<!-- hodor:sha:${headSha} -->
+${body}`;
+  }
+  if (model) {
+    body = `${body}
+
+---
+
+Review generated by Hodor (model: \`${model}\`)`;
+  }
+  if (metricsFooter) {
+    body = `${body}
+
+${metricsFooter}`;
+  }
+  try {
+    if (platform === "github") {
+      await exec("gh", [
+        "pr",
+        "review",
+        String(parsed.prNumber),
+        "--repo",
+        `${parsed.owner}/${parsed.repo}`,
+        "--comment",
+        "--body",
+        body
+      ]);
+      logger.info(`Successfully posted review to GitHub PR #${parsed.prNumber}`);
+      return { success: true, platform: "github", prNumber: parsed.prNumber };
+    } else {
+      await postGitlabMrComment(
+        parsed.owner,
+        parsed.repo,
+        parsed.prNumber,
+        body,
+        parsed.host
+      );
+      logger.info(
+        `Successfully posted review to GitLab MR !${parsed.prNumber}`
+      );
+      return {
+        success: true,
+        platform: "gitlab",
+        mrNumber: parsed.prNumber
+      };
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.error(`Failed to post comment: ${msg}`);
+    return { success: false, error: msg };
+  }
+}
+async function reviewPr(opts) {
+  const {
+    prUrl,
+    model = "anthropic/claude-sonnet-4-5-20250929",
+    reasoningEffort,
+    customPrompt,
+    promptFile,
+    cleanup = true,
+    workspaceDir,
+    includeMetricsFooter = false,
+    onEvent,
+    bedrockTags,
+    localMode = false,
+    diffAgainst
+  } = opts;
+  logger.info(`Starting PR review for: ${localMode ? "local diff" : prUrl}`);
+  let owner = "", repo = "", host = "";
+  let prNumber = 0;
+  let platform = "github";
+  if (!localMode && prUrl) {
+    const urlParsed = parsePrUrl(prUrl);
+    owner = urlParsed.owner;
+    repo = urlParsed.repo;
+    prNumber = urlParsed.prNumber;
+    host = urlParsed.host;
+    platform = detectPlatform(prUrl);
+    logger.info(`Platform: ${platform}, Repo: ${owner}/${repo}, PR: ${prNumber}, Host: ${host}`);
+  }
+  const parsed = parseModelString(model);
+  const thinkingLevel = mapReasoningEffort(reasoningEffort);
+  const apiKey = getApiKey(model);
+  const envSnapshot = {
+    ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY,
+    OPENAI_API_KEY: process.env.OPENAI_API_KEY,
+    AWS_REGION: process.env.AWS_REGION
+  };
+  if (apiKey) {
+    if (parsed.provider === "anthropic") {
+      process.env.ANTHROPIC_API_KEY = apiKey;
+    } else if (parsed.provider === "openai") {
+      process.env.OPENAI_API_KEY = apiKey;
+    }
+  }
+  const {
+    createAgentSession,
+    DefaultResourceLoader,
+    SessionManager,
+    SettingsManager,
+    createReadTool,
+    createBashTool,
+    createGrepTool,
+    createFindTool,
+    createLsTool,
+    AuthStorage,
+    ModelRegistry
+  } = await import("@mariozechner/pi-coding-agent");
+  const { getModel } = await import("@mariozechner/pi-ai");
+  const authStorage = AuthStorage.inMemory();
+  const modelRegistry = new ModelRegistry(authStorage);
+  let piModel;
+  if (parsed.modelId.startsWith("arn:")) {
+    const arnParts = parsed.modelId.split(":");
+    const region = arnParts.length >= 4 ? arnParts[3] : "us-east-1";
+    if (!process.env.AWS_REGION && !process.env.AWS_DEFAULT_REGION) {
+      process.env.AWS_REGION = region;
+    }
+    piModel = {
+      id: parsed.modelId,
+      name: parsed.modelId,
+      api: "bedrock-converse-stream",
+      provider: "amazon-bedrock",
+      baseUrl: `https://bedrock-runtime.${region}.amazonaws.com`,
+      reasoning: false,
+      input: ["text"],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: 2e5,
+      maxTokens: 16384
+    };
+    logger.info(`Custom bedrock ARN model \u2014 region: ${region}`);
+  } else {
+    try {
+      piModel = getModel(parsed.provider, parsed.modelId);
+    } catch (err) {
+      throw new Error(
+        `Unsupported model "${model}": ${err instanceof Error ? err.message : err}`
+      );
+    }
+  }
+  logger.info("Preflight OK \u2014 model and credentials validated");
+  let workspacePath;
+  let targetBranch;
+  let diffBaseSha = null;
+  let isTemporary = false;
+  if (localMode) {
+    const cwd = workspaceDir ?? process.cwd();
+    try {
+      const { stdout: toplevel } = await exec("git", ["rev-parse", "--show-toplevel"], { cwd });
+      workspacePath = toplevel.trim();
+    } catch {
+      workspacePath = cwd;
+    }
+    targetBranch = diffAgainst ?? "origin/main";
+    logger.info(`Local mode: workspace=${workspacePath}, diffAgainst=${targetBranch}`);
+  } else {
+    const wsResult = await setupWorkspace({
+      platform,
+      owner,
+      repo,
+      prNumber: String(prNumber),
+      host,
+      workingDir: workspaceDir ?? void 0,
+      reuse: workspaceDir != null
+    });
+    workspacePath = wsResult.workspace;
+    targetBranch = wsResult.targetBranch;
+    diffBaseSha = wsResult.diffBaseSha;
+    isTemporary = wsResult.isTemporary;
+  }
+  try {
+    let formatToolArgs2 = function(_toolName, args) {
+      if (typeof args === "string") return args.slice(0, 200);
+      const obj = args;
+      if (!obj) return "";
+      if (obj.command) {
+        return String(obj.command).replace(new RegExp(`cd ${workspacePath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")} && `), "").slice(0, 200);
+      }
+      if (obj.pattern) {
+        const path = obj.path ? ` in ${obj.path}` : "";
+        return `${obj.pattern}${path}`;
+      }
+      if (obj.path || obj.file_path) return String(obj.path ?? obj.file_path);
+      return JSON.stringify(obj).slice(0, 200);
+    }, formatToolResult2 = function(result) {
+      if (typeof result === "string") return result;
+      const obj = result;
+      if (!obj) return "";
+      const content = obj.content;
+      if (Array.isArray(content)) {
+        return content.filter((c) => c.type === "text" && c.text).map((c) => c.text).join("\n");
+      }
+      return JSON.stringify(result)?.slice(0, 500) ?? "";
+    };
+    var formatToolArgs = formatToolArgs2, formatToolResult = formatToolResult2;
+    let mrMetadata = null;
+    if (!localMode && platform === "gitlab") {
+      try {
+        mrMetadata = await fetchGitlabMrInfo(owner, repo, prNumber, host, {
+          includeComments: true
+        });
+      } catch (err) {
+        logger.warn(`Failed to fetch GitLab metadata: ${err}`);
+      }
+    } else if (!localMode && platform === "github") {
+      try {
+        const githubRaw = await fetchGithubPrInfo(owner, repo, prNumber);
+        mrMetadata = normalizeGithubMetadata(githubRaw);
+      } catch (err) {
+        logger.warn(`Failed to fetch GitHub metadata: ${err}`);
+      }
+    }
+    let previousReviewSha = null;
+    if (mrMetadata?.Notes) {
+      for (const note of mrMetadata.Notes) {
+        const match = note.body?.match(/<!-- hodor:sha:([a-f0-9]{40}) -->/);
+        if (match) {
+          previousReviewSha = match[1];
+        }
+      }
+    }
+    if (previousReviewSha) {
+      try {
+        const { stdout: objType } = await exec("git", ["cat-file", "-t", previousReviewSha], { cwd: workspacePath });
+        if (objType.trim() !== "commit") throw new Error("not a commit");
+        await exec("git", ["merge-base", "--is-ancestor", previousReviewSha, "HEAD"], { cwd: workspacePath });
+        logger.info(`Incremental mode: previous review at ${previousReviewSha.slice(0, 8)}`);
+      } catch {
+        logger.info(`Previous review SHA ${previousReviewSha.slice(0, 8)} not valid ancestor of HEAD, doing full review`);
+        previousReviewSha = null;
+      }
+    }
+    let headSha = null;
+    if (!localMode) {
+      const { stdout: headShaRaw } = await exec("git", ["rev-parse", "HEAD"], { cwd: workspacePath });
+      headSha = headShaRaw.trim();
+    }
+    const MAX_EMBED_BYTES = 200 * 1024;
+    let embeddedDiff = null;
+    try {
+      const diffArgs = previousReviewSha ? ["--no-pager", "diff", `${previousReviewSha}...HEAD`] : diffBaseSha ? ["--no-pager", "diff", diffBaseSha, "HEAD"] : localMode ? ["--no-pager", "diff", targetBranch] : ["--no-pager", "diff", `origin/${targetBranch}...HEAD`];
+      const { stdout: rawDiff } = await exec("git", diffArgs, { cwd: workspacePath });
+      if (Buffer.byteLength(rawDiff, "utf-8") <= MAX_EMBED_BYTES) {
+        embeddedDiff = rawDiff;
+        logger.info(`Embedding diff in prompt (${Buffer.byteLength(rawDiff, "utf-8")} bytes)`);
+      } else {
+        logger.info(`Diff too large to embed (${Buffer.byteLength(rawDiff, "utf-8")} bytes), using command mode`);
+      }
+    } catch (err) {
+      logger.warn(`Failed to pre-fetch diff, falling back to command mode: ${err}`);
+    }
+    const prompt = buildPrReviewPrompt({
+      prUrl: prUrl ?? `local diff (against ${targetBranch})`,
+      platform,
+      targetBranch,
+      diffBaseSha,
+      mrMetadata,
+      customInstructions: customPrompt,
+      customPromptFile: promptFile,
+      embeddedDiff,
+      previousReviewSha,
+      localMode
+    });
+    const startTime = Date.now();
+    const settingsManager = SettingsManager.inMemory({
+      compaction: { enabled: true }
+    });
+    const skillPaths = [
+      join2(workspacePath, ".pi", "skills"),
+      join2(workspacePath, ".hodor", "skills")
+    ].filter((p) => existsSync(p));
+    const resourceLoader = new DefaultResourceLoader({
+      cwd: workspacePath,
+      settingsManager,
+      systemPrompt: REVIEW_SYSTEM_PROMPT,
+      appendSystemPrompt: "",
+      noExtensions: true,
+      noSkills: true,
+      noPromptTemplates: true,
+      noThemes: true,
+      additionalSkillPaths: skillPaths,
+      agentsFilesOverride: () => ({ agentsFiles: [] })
+    });
+    await resourceLoader.reload();
+    const { skills, diagnostics: skillDiagnostics } = resourceLoader.getSkills();
+    if (skills.length > 0) {
+      logger.info(`Discovered ${skills.length} repository skill(s)`);
+      for (const skill of skills) {
+        logger.info(`Found skill: ${skill.name} (${skill.filePath})`);
+      }
+    }
+    for (const diagnostic of skillDiagnostics) {
+      const path = diagnostic.path ? ` (${diagnostic.path})` : "";
+      logger.warn(`Skill diagnostic: ${diagnostic.message}${path}`);
+    }
+    let submittedReview = null;
+    let submitReviewCalls = 0;
+    const submitReviewTool = {
+      name: "submit_review",
+      label: "Submit Review",
+      description: "Submit the final structured review after the analysis is complete.",
+      promptSnippet: "Submit the final structured review (call exactly once when done)",
+      parameters: SUBMIT_REVIEW_SCHEMA,
+      execute: async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        submitReviewCalls++;
+        if (submittedReview) {
+          logger.warn("Agent called submit_review more than once; ignoring duplicate submission");
+          return {
+            content: [{
+              type: "text",
+              text: "Review already submitted. Do not call submit_review again."
+            }],
+            details: { ignoredDuplicate: true }
+          };
+        }
+        submittedReview = validateReviewOutput(params);
+        logger.info(
+          `Received structured review via submit_review (${submittedReview.findings.length} finding(s))`
+        );
+        return {
+          content: [{
+            type: "text",
+            text: "Review received. Do not output the review as normal text."
+          }],
+          details: {}
+        };
+      }
+    };
+    const { session } = await createAgentSession({
+      cwd: workspacePath,
+      model: piModel,
+      thinkingLevel,
+      tools: [
+        createReadTool(workspacePath),
+        createBashTool(workspacePath),
+        createGrepTool(workspacePath),
+        createFindTool(workspacePath),
+        createLsTool(workspacePath)
+      ],
+      customTools: [submitReviewTool],
+      sessionManager: SessionManager.inMemory(),
+      settingsManager,
+      resourceLoader,
+      authStorage,
+      modelRegistry
+    });
+    if (bedrockTags && parsed.provider === "bedrock") {
+      const agent = session.agent;
+      const originalStreamFn = agent.streamFn;
+      agent.streamFn = (...args) => {
+        const options = args[2] ?? {};
+        return originalStreamFn(args[0], args[1], { ...options, requestMetadata: bedrockTags });
+      };
+      logger.info(`Bedrock cost allocation tags: ${JSON.stringify(bedrockTags)}`);
+    }
+    let turnCount = 0;
+    let toolCallCount = 0;
+    session.subscribe((event) => {
+      switch (event.type) {
+        case "agent_start":
+          onEvent?.({ type: "agent_start" });
+          break;
+        case "agent_end":
+          onEvent?.({ type: "agent_end" });
+          break;
+        case "turn_start":
+          turnCount++;
+          onEvent?.({ type: "turn_start", turnIndex: turnCount });
+          break;
+        case "turn_end":
+          onEvent?.({ type: "turn_end", turnIndex: turnCount });
+          break;
+        case "tool_execution_start":
+          toolCallCount++;
+          onEvent?.({
+            type: "tool_start",
+            toolName: event.toolName,
+            toolArgs: formatToolArgs2(event.toolName, event.args)
+          });
+          break;
+        case "tool_execution_end":
+          onEvent?.({
+            type: "tool_end",
+            toolName: event.toolName,
+            isError: event.isError,
+            result: formatToolResult2(event.result)
+          });
+          break;
+        case "message_start":
+          onEvent?.({ type: "thinking" });
+          break;
+        case "message_update": {
+          const msgEvent = event.assistantMessageEvent;
+          if (!msgEvent?.delta) break;
+          if (msgEvent.type === "text_delta") {
+            onEvent?.({ type: "text_delta", delta: msgEvent.delta });
+          } else if (msgEvent.type === "thinking_delta") {
+            onEvent?.({ type: "thinking_delta", delta: msgEvent.delta });
+          }
+          break;
+        }
+      }
+    });
+    logger.info("Sending prompt to agent...");
+    await session.prompt(prompt);
+    const agentError = session.state?.error;
+    if (agentError) {
+      throw new Error(`LLM request failed: ${agentError}`);
+    }
+    if (!submittedReview) {
+      const rawText = session.getLastAssistantText() ?? "";
+      if (rawText) {
+        logger.debug(`Last assistant text without submit_review (first 500 chars): ${rawText.slice(0, 500)}`);
+      } else {
+        const messages = session.state?.messages;
+        const lastMsg = messages?.[messages.length - 1];
+        logger.debug(`Last message: ${JSON.stringify(lastMsg)?.slice(0, 500)}`);
+      }
+      if (submitReviewCalls > 0) {
+        throw new Error("Agent called submit_review but did not provide a valid review payload");
+      }
+      throw new Error("Agent did not call submit_review");
+    }
+    const review = submittedReview;
+    if (submitReviewCalls > 1) {
+      logger.warn(`Agent called submit_review ${submitReviewCalls} times; using the first valid submission`);
+    }
+    logger.info(
+      `Captured ${review.findings.length} finding(s), verdict: ${review.overall_correctness}`
+    );
+    const durationSeconds = (Date.now() - startTime) / 1e3;
+    logger.info(`Review complete (${review.findings.length} finding(s))`);
+    const allMessages = session.state?.messages ?? [];
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadTokens = 0;
+    let cacheWriteTokens = 0;
+    let totalTokens = 0;
+    let cost = 0;
+    for (const msg of allMessages) {
+      if (msg.role === "assistant" && msg.usage) {
+        inputTokens += msg.usage.input ?? 0;
+        outputTokens += msg.usage.output ?? 0;
+        cacheReadTokens += msg.usage.cacheRead ?? 0;
+        cacheWriteTokens += msg.usage.cacheWrite ?? 0;
+        totalTokens += msg.usage.totalTokens ?? 0;
+        cost += msg.usage.cost?.total ?? 0;
+      }
+    }
+    const metrics = {
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      totalTokens,
+      cost,
+      turns: turnCount,
+      toolCalls: toolCallCount,
+      durationSeconds: Math.round(durationSeconds)
+    };
+    printMetrics(metrics);
+    let metricsFooter = null;
+    if (includeMetricsFooter) {
+      metricsFooter = formatMetricsMarkdown(metrics);
+    }
+    return { review, metricsFooter, headSha, metrics };
+  } finally {
+    for (const [key, val] of Object.entries(envSnapshot)) {
+      if (val === void 0) {
+        delete process.env[key];
+      } else {
+        process.env[key] = val;
+      }
+    }
+    if (cleanup && isTemporary) {
+      logger.info("Cleaning up workspace...");
+      await cleanupWorkspace(workspacePath);
+    }
+  }
+}
+
+// src/render.ts
+function renderMarkdown(review) {
+  const lines = [];
+  const critical = [];
+  const important = [];
+  const minor = [];
+  for (const f of review.findings) {
+    const p = f.priority;
+    if (p <= 1) critical.push(f);
+    else if (p === 2) important.push(f);
+    else minor.push(f);
+  }
+  lines.push("### Issues Found");
+  lines.push("");
+  if (review.findings.length === 0) {
+    lines.push("No issues found.");
+    lines.push("");
+  }
+  if (critical.length > 0) {
+    lines.push("**Critical (P0/P1)**");
+    for (const f of critical) {
+      lines.push(formatFinding(f));
+    }
+    lines.push("");
+  }
+  if (important.length > 0) {
+    lines.push("**Important (P2)**");
+    for (const f of important) {
+      lines.push(formatFinding(f));
+    }
+    lines.push("");
+  }
+  if (minor.length > 0) {
+    lines.push("**Minor (P3)**");
+    for (const f of minor) {
+      lines.push(formatFinding(f));
+    }
+    lines.push("");
+  }
+  lines.push("### Summary");
+  lines.push(
+    `Total issues: ${critical.length} critical, ${important.length} important, ${minor.length} minor.`
+  );
+  lines.push("");
+  lines.push("### Overall Verdict");
+  const isCorrect = review.overall_correctness === "patch is correct";
+  lines.push(
+    `**Status**: ${isCorrect ? "Patch is correct" : "Patch has blocking issues"}`
+  );
+  lines.push("");
+  if (review.overall_explanation) {
+    lines.push(`**Explanation**: ${review.overall_explanation}`);
+  }
+  return lines.join("\n").trimEnd() + "\n";
+}
+function formatFinding(f) {
+  const loc = ` (\`${formatLocation(f.code_location)}\`)`;
+  const title = `- **${f.title}**${loc}`;
+  const body = `  - ${f.body}`;
+  return `${title}
+${body}`;
+}
+function formatLocation(loc) {
+  let filePath = loc.absolute_file_path;
+  const buildsMatch = filePath.match(/\/builds\/[^/]+\/[^/]+\/(.+)/);
+  if (buildsMatch) {
+    filePath = buildsMatch[1];
+  } else if (filePath.includes("/workspace/")) {
+    filePath = filePath.slice(filePath.indexOf("/workspace/") + "/workspace/".length);
+  } else {
+    filePath = filePath.replace(/^.*\/hodor-review-[^/]+\//, "");
+  }
+  const { start, end } = loc.line_range;
+  return start === end ? `${filePath}:${start}` : `${filePath}:${start}-${end}`;
+}
+
+export {
+  setLogLevel,
+  buildPrReviewPrompt,
+  parseModelString,
+  mapReasoningEffort,
+  getApiKey,
+  formatMetricsMarkdown,
+  printMetrics,
+  pushMetrics,
+  validateReviewOutput,
+  detectPlatform,
+  parsePrUrl,
+  postReviewComment,
+  reviewPr,
+  renderMarkdown
+};
+//# sourceMappingURL=chunk-QGUJENIG.js.map