Tự động Review Code

Claude Code Stop event
  → redline check              (fast, <1s)
  → git diff --stat HEAD       (any uncommitted changes?)
  → hash diff stat, compare to .git/redline-last-diff
  → if changes exist AND diff has changed since last check:
      save hash to .git/redline-last-diff
      output { "decision": "block", "reason": "..." }
        reason includes diff stat summary
        Claude decides if changes warrant a review
      Claude spawns `redline review` as background task
      → codex exec review streams output in real-time
      → user can monitor, kill, or keep working
      → when done, Claude reads output, presents findings
  → if no changes OR same diff as last check:
      exit 0 silently → Claude proceeds normally

$
export ANTHROPIC_BASE_URL="https://api.staging.tram.ai.vn"
$
export ANTHROPIC_AUTH_TOKEN="tram_sk-..."
$
export ANTHROPIC_API_KEY=""

1
[model_providers.tram]
2
name = "Tram AI"
3
base_url = "https://api.staging.tram.ai.vn/v1"
4
env_key = "TRAM_AI_API_KEY"

$
export TRAM_AI_API_KEY="tram_sk-..."

1
{
2
  "hooks": {
3
    "Stop": [
4
      {
5
        "hooks": [
6
          {
7
            "type": "command",
8
            "command": "redline check",
9
            "timeout": 10
10
          }
11
        ]
12
      }
13
    ]
14
  }
15
}

1
import { execSync } from "child_process";
2
import {
3
  existsSync,
4
  readFileSync,
5
  writeFileSync,
6
} from "fs";
7
import { join } from "path";
8
9
function getDiffStat(): string {
10
  // Prefer diff --stat for a concise summary
11
  const diff = execSync("git diff --stat HEAD", {
12
    encoding: "utf-8",
13
  }).trim();
14
  if (diff) return diff;
15
16
  // Fall back to status for untracked files
17
  return execSync("git status --porcelain", {
18
    encoding: "utf-8",
19
  }).trim();
20
}
21
22
function hash(s: string): string {
23
  let h = 0;
24
  for (let i = 0; i < s.length; i++) {
25
    h = ((h << 5) - h + s.charCodeAt(i)) | 0;
26
  }
27
  return h.toString(36);
28
}
29
30
function check(model?: string): void {
31
  const diffStat = getDiffStat();
32
  if (!diffStat) {
33
    process.exit(0);
34
  }
35
36
  // Deduplicate: skip if diff unchanged since last check
37
  const gitDir = execSync("git rev-parse --git-dir", {
38
    encoding: "utf-8",
39
  }).trim();
40
  const hashFile = join(gitDir, "redline-last-diff");
41
  const currentHash = hash(diffStat);
42
43
  if (existsSync(hashFile)) {
44
    const lastHash = readFileSync(
45
      hashFile,
46
      "utf-8",
47
    ).trim();
48
    if (lastHash === currentHash) {
49
      process.exit(0);
50
    }
51
  }
52
53
  writeFileSync(hashFile, currentHash);
54
55
  const cmd = model
56
    ? `redline review --model ${model}`
57
    : "redline review";
58
59
  const hookOutput = {
60
    decision: "block",
61
    reason: [
62
      "Redline: Here is a summary of uncommitted",
63
      "changes since the last review:",
64
      "",
65
      diffStat,
66
      "",
67
      "If these changes are substantial enough to",
68
      "warrant a code review (e.g., new logic, bug",
69
      "fixes, refactors — not just formatting or",
70
      "comments), run the following command as a",
71
      "background task:",
72
      "",
73
      `  ${cmd}`,
74
      "",
75
      "If the changes are trivial, or a review is",
76
      "already running, skip it. When a review",
77
      "completes, assess the findings and inform",
78
      "the user of any issues.",
79
    ].join("\n"),
80
  };
81
82
  console.log(JSON.stringify(hookOutput));
83
}

1
import { spawn } from "child_process";
2
import { readFileSync, unlinkSync } from "fs";
3
import { join } from "path";
4
import { tmpdir } from "os";
5
6
async function review(model?: string): Promise<void> {
7
  const outputFile = join(
8
    tmpdir(),
9
    `redline-review-${Date.now()}.txt`,
10
  );
11
12
  const args = [
13
    "exec",
14
    "review",
15
    "-c",
16
    'model_provider="tram"',
17
    "--uncommitted",
18
    "-o",
19
    outputFile,
20
  ];
21
22
  if (model) {
23
    args.push("-c", `model="${model}"`);
24
  }
25
26
  // Stream output in real-time so background task
27
  // shows progress
28
  const exitCode = await new Promise<number>(
29
    (resolve) => {
30
      const proc = spawn("codex", args, {
31
        cwd: process.cwd(),
32
        env: process.env,
33
        stdio: ["ignore", "inherit", "inherit"],
34
      });
35
      proc.on("close", (code) => resolve(code ?? 1));
36
    },
37
  );
38
39
  // Read the final review from the -o output file
40
  let review = "";
41
  try {
42
    review = readFileSync(outputFile, "utf-8").trim();
43
    unlinkSync(outputFile);
44
  } catch {
45
    // No output file — output was already streamed
46
  }
47
48
  if (exitCode !== 0 && !review) {
49
    console.error(`Codex review failed (exit ${exitCode}).`);
50
    process.exit(1);
51
  }
52
53
  if (review) {
54
    console.log("\n--- Review Summary ---\n");
55
    console.log(review);
56
  }
57
}

Redline: Here is a summary of uncommitted changes
since the last review:
 src/commands/check.ts | 25 +++++++++++++++------
 src/commands/review.ts | 12 +++++-----
 2 files changed, 22 insertions(+), 15 deletions(-)
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:
  redline review
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.

$
redline install

1
{
2
  "hooks": {
3
    "Stop": [
4
      {
5
        "hooks": [
6
          {
7
            "type": "command",
8
            "command": "redline check",
9
            "timeout": 10
10
          }
11
        ]
12
      }
13
    ]
14
  }
15
}

$
redline off

1
import {
2
  readFileSync,
3
  writeFileSync,
4
  mkdirSync,
5
} from "fs";
6
import { join } from "path";
7
8
const SETTINGS_PATH = join(
9
  ".claude",
10
  "settings.local.json",
11
);
12
const HOOK_PREFIX = "redline";
13
14
function readSettings(): Record<string, unknown> {
15
  try {
16
    return JSON.parse(
17
      readFileSync(SETTINGS_PATH, "utf-8"),
18
    );
19
  } catch {
20
    return {};
21
  }
22
}
23
24
function writeSettings(
25
  settings: Record<string, unknown>,
26
): void {
27
  mkdirSync(".claude", { recursive: true });
28
  writeFileSync(
29
    SETTINGS_PATH,
30
    JSON.stringify(settings, null, 2) + "\n",
31
  );
32
}
33
34
function installHook(model?: string): void {
35
  const settings = readSettings();
36
  const command = model
37
    ? `${HOOK_PREFIX} check --model ${model}`
38
    : `${HOOK_PREFIX} check`;
39
40
  const hookEntry = {
41
    hooks: [
42
      {
43
        type: "command",
44
        command,
45
        timeout: 10,
46
      },
47
    ],
48
  };
49
50
  const hooks = (settings.hooks ?? {}) as Record<
51
    string,
52
    unknown[]
53
  >;
54
  const stopHooks = (hooks.Stop ?? []) as Array<{
55
    hooks: Array<{ command: string }>;
56
  }>;
57
58
  // Check for existing redline hook
59
  const existing = stopHooks.findIndex((h) =>
60
    h.hooks?.some((inner) =>
61
      inner.command?.startsWith(HOOK_PREFIX),
62
    ),
63
  );
64
65
  if (existing >= 0) {
66
    stopHooks[existing] = hookEntry;
67
  } else {
68
    stopHooks.push(hookEntry);
69
  }
70
71
  hooks.Stop = stopHooks;
72
  settings.hooks = hooks;
73
  writeSettings(settings);
74
}
75
76
function removeHook(): void {
77
  const settings = readSettings();
78
  const hooks = (settings.hooks ?? {}) as Record<
79
    string,
80
    unknown[]
81
  >;
82
  const stopHooks = (hooks.Stop ?? []) as Array<{
83
    hooks: Array<{ command: string }>;
84
  }>;
85
86
  hooks.Stop = stopHooks.filter(
87
    (h) =>
88
      !h.hooks?.some((inner) =>
89
        inner.command?.startsWith(HOOK_PREFIX),
90
      ),
91
  );
92
93
  if (
94
    Array.isArray(hooks.Stop) &&
95
    hooks.Stop.length === 0
96
  ) {
97
    delete hooks.Stop;
98
  }
99
  if (Object.keys(hooks).length === 0) {
100
    delete settings.hooks;
101
  }
102
103
  writeSettings(settings);
104
}

$
# Install the hook
$
redline install
$
$
# Install with a specific review model
$
redline install --model ~openai/gpt-latest
$
$
# Remove the hook
$
redline off
$
$
# Run a review manually (prints to stdout)
$
redline review
$
$
# Fast gate check (called by the Stop hook)
$
redline check

1
const args = process.argv.slice(2);
2
const command = args[0];
3
4
const modelFlag = args.indexOf("--model");
5
const model =
6
  modelFlag >= 0 ? args[modelFlag + 1] : undefined;
7
8
switch (command) {
9
  case "install":
10
    installHook(model);
11
    console.log(
12
      "Hook installed in",
13
      ".claude/settings.local.json",
14
    );
15
    break;
16
17
  case "off":
18
    removeHook();
19
    console.log("Hook removed.");
20
    break;
21
22
  case "check":
23
    check(model);
24
    break;
25
26
  case "review":
27
    review(model);
28
    break;
29
30
  default:
31
    installHook(model);
32
    console.log(
33
      "Hook installed in",
34
      ".claude/settings.local.json",
35
    );
36
    break;
37
}

$
redline install
$
cat .claude/settings.local.json

$
redline check

$
redline check

$
redline review