Automatic Code Review

import { execSync } from "child_process";
import {
  existsSync,
  readFileSync,
  writeFileSync,
} from "fs";
import { join } from "path";

function getDiffStat(): string {
  // Prefer diff --stat for a concise summary
  const diff = execSync("git diff --stat HEAD", {
    encoding: "utf-8",
  }).trim();
  if (diff) return diff;

  // Fall back to status for untracked files
  return execSync("git status --porcelain", {
    encoding: "utf-8",
  }).trim();
}

function hash(s: string): string {
  let h = 0;
  for (let i = 0; i < s.length; i++) {
    h = ((h << 5) - h + s.charCodeAt(i)) | 0;
  }
  return h.toString(36);
}

function check(model?: string): void {
  const diffStat = getDiffStat();
  if (!diffStat) {
    process.exit(0);
  }

  // Deduplicate: skip if diff unchanged since last check
  const gitDir = execSync("git rev-parse --git-dir", {
    encoding: "utf-8",
  }).trim();
  const hashFile = join(gitDir, "redline-last-diff");
  const currentHash = hash(diffStat);

  if (existsSync(hashFile)) {
    const lastHash = readFileSync(
      hashFile,
      "utf-8",
    ).trim();
    if (lastHash === currentHash) {
      process.exit(0);
    }
  }

  writeFileSync(hashFile, currentHash);

  const cmd = model
    ? `redline review --model ${model}`
    : "redline review";

  const hookOutput = {
    decision: "block",
    reason: [
      "Redline: Here is a summary of uncommitted",
      "changes since the last review:",
      "",
      diffStat,
      "",
      "If these changes are substantial enough to",
      "warrant a code review (e.g., new logic, bug",
      "fixes, refactors — not just formatting or",
      "comments), run the following command as a",
      "background task:",
      "",
      `  ${cmd}`,
      "",
      "If the changes are trivial, or a review is",
      "already running, skip it. When a review",
      "completes, assess the findings and inform",
      "the user of any issues.",
    ].join("\n"),
  };

  console.log(JSON.stringify(hookOutput));
}

import { spawn } from "child_process";
import { readFileSync, unlinkSync } from "fs";
import { join } from "path";
import { tmpdir } from "os";

async function review(model?: string): Promise<void> {
  const outputFile = join(
    tmpdir(),
    `redline-review-${Date.now()}.txt`,
  );

  const args = [
    "exec",
    "review",
    "-c",
    'model_provider="openrouter"',
    "--uncommitted",
    "-o",
    outputFile,
  ];

  if (model) {
    args.push("-c", `model="${model}"`);
  }

  // Stream output in real-time so background task
  // shows progress
  const exitCode = await new Promise<number>(
    (resolve) => {
      const proc = spawn("codex", args, {
        cwd: process.cwd(),
        env: process.env,
        stdio: ["ignore", "inherit", "inherit"],
      });
      proc.on("close", (code) => resolve(code ?? 1));
    },
  );

  // Read the final review from the -o output file
  let review = "";
  try {
    review = readFileSync(outputFile, "utf-8").trim();
    unlinkSync(outputFile);
  } catch {
    // No output file — output was already streamed
  }

  if (exitCode !== 0 && !review) {
    console.error(`Codex review failed (exit ${exitCode}).`);
    process.exit(1);
  }

  if (review) {
    console.log("\n--- Review Summary ---\n");
    console.log(review);
  }
}

import {
  readFileSync,
  writeFileSync,
  mkdirSync,
} from "fs";
import { join } from "path";

const SETTINGS_PATH = join(
  ".claude",
  "settings.local.json",
);
const HOOK_PREFIX = "redline";

function readSettings(): Record<string, unknown> {
  try {
    return JSON.parse(
      readFileSync(SETTINGS_PATH, "utf-8"),
    );
  } catch {
    return {};
  }
}

function writeSettings(
  settings: Record<string, unknown>,
): void {
  mkdirSync(".claude", { recursive: true });
  writeFileSync(
    SETTINGS_PATH,
    JSON.stringify(settings, null, 2) + "\n",
  );
}

function installHook(model?: string): void {
  const settings = readSettings();
  const command = model
    ? `${HOOK_PREFIX} check --model ${model}`
    : `${HOOK_PREFIX} check`;

  const hookEntry = {
    hooks: [
      {
        type: "command",
        command,
        timeout: 10,
      },
    ],
  };

  const hooks = (settings.hooks ?? {}) as Record<
    string,
    unknown[]
  >;
  const stopHooks = (hooks.Stop ?? []) as Array<{
    hooks: Array<{ command: string }>;
  }>;

  // Check for existing redline hook
  const existing = stopHooks.findIndex((h) =>
    h.hooks?.some((inner) =>
      inner.command?.startsWith(HOOK_PREFIX),
    ),
  );

  if (existing >= 0) {
    stopHooks[existing] = hookEntry;
  } else {
    stopHooks.push(hookEntry);
  }

  hooks.Stop = stopHooks;
  settings.hooks = hooks;
  writeSettings(settings);
}

function removeHook(): void {
  const settings = readSettings();
  const hooks = (settings.hooks ?? {}) as Record<
    string,
    unknown[]
  >;
  const stopHooks = (hooks.Stop ?? []) as Array<{
    hooks: Array<{ command: string }>;
  }>;

  hooks.Stop = stopHooks.filter(
    (h) =>
      !h.hooks?.some((inner) =>
        inner.command?.startsWith(HOOK_PREFIX),
      ),
  );

  if (
    Array.isArray(hooks.Stop) &&
    hooks.Stop.length === 0
  ) {
    delete hooks.Stop;
  }
  if (Object.keys(hooks).length === 0) {
    delete settings.hooks;
  }

  writeSettings(settings);
}

const args = process.argv.slice(2);
const command = args[0];

const modelFlag = args.indexOf("--model");
const model =
  modelFlag >= 0 ? args[modelFlag + 1] : undefined;

switch (command) {
  case "install":
    installHook(model);
    console.log(
      "Hook installed in",
      ".claude/settings.local.json",
    );
    break;

  case "off":
    removeHook();
    console.log("Hook removed.");
    break;

  case "check":
    check(model);
    break;

  case "review":
    review(model);
    break;

  default:
    installHook(model);
    console.log(
      "Hook installed in",
      ".claude/settings.local.json",
    );
    break;
}