@rely-ai/caliber 0.1.1 → 0.2.1

package/README.md

@@ -43,8 +43,10 @@ If you already have these files, Caliber audits them against your actual codebas
 | `caliber recommend` | Discover skills from [skills.sh](https://skills.sh) |
 | `caliber undo` | Revert all changes made by Caliber |
 | `caliber status` | Show current setup status |
-| `caliber hooks install` | Install auto-refresh hook for Claude Code |
-| `caliber hooks remove` | Remove auto-refresh hook |
+| `caliber hooks install` | Install Claude Code auto-refresh hook |
+| `caliber hooks remove` | Remove Claude Code auto-refresh hook |
+| `caliber hooks install-precommit` | Install git pre-commit hook for auto-refresh |
+| `caliber hooks remove-precommit` | Remove git pre-commit hook |
 | `caliber hooks status` | Show installed hooks |
 | `caliber learn install` | Install session learning hooks |
 | `caliber learn status` | Show learned insights from sessions |
@@ -109,11 +111,19 @@ During `caliber init`, a before/after score is displayed so you can see the impr
 
 ### Auto-refresh
 
-After init, Caliber installs a Claude Code hook that automatically updates your docs when code changes:
+During `caliber init`, you'll be prompted to choose how docs auto-refresh:
+
+- **Claude Code hook** — refreshes docs when Claude Code sessions end
+- **Git pre-commit hook** — refreshes docs before each commit
+- **Both** — enables both hooks
+- **Skip** — install later with `caliber hooks install` or `caliber hooks install-precommit`
 
 ```bash
-caliber hooks install    # Install auto-refresh hook
-caliber hooks remove     # Remove it
+caliber hooks install              # Install Claude Code hook
+caliber hooks install-precommit    # Install git pre-commit hook
+caliber hooks remove               # Remove Claude Code hook
+caliber hooks remove-precommit     # Remove pre-commit hook
+caliber hooks status               # Show installed hooks
 ```
 
 ### Session Learning

package/dist/bin.js

@@ -95,98 +95,21 @@ function isGitRepo() {
 import fs from "fs";
 import path from "path";
 import { globSync } from "glob";
-var NODE_FRAMEWORK_DEPS = {
-  react: "React",
-  next: "Next.js",
-  vue: "Vue",
-  nuxt: "Nuxt",
-  svelte: "Svelte",
-  "@sveltejs/kit": "SvelteKit",
-  angular: "Angular",
-  "@angular/core": "Angular",
-  express: "Express",
-  fastify: "Fastify",
-  hono: "Hono",
-  nestjs: "NestJS",
-  "@nestjs/core": "NestJS",
-  tailwindcss: "Tailwind CSS",
-  prisma: "Prisma",
-  drizzle: "Drizzle",
-  "drizzle-orm": "Drizzle",
-  "@supabase/supabase-js": "Supabase",
-  mongoose: "MongoDB",
-  typeorm: "TypeORM",
-  sequelize: "Sequelize",
-  "better-auth": "Better Auth"
-};
-var PYTHON_FRAMEWORK_DEPS = {
-  fastapi: "FastAPI",
-  django: "Django",
-  flask: "Flask",
-  sqlalchemy: "SQLAlchemy",
-  pydantic: "Pydantic",
-  celery: "Celery",
-  pytest: "pytest",
-  uvicorn: "Uvicorn",
-  starlette: "Starlette",
-  httpx: "HTTPX",
-  alembic: "Alembic",
-  tortoise: "Tortoise ORM",
-  "google-cloud-pubsub": "Google Pub/Sub",
-  stripe: "Stripe",
-  redis: "Redis"
-};
 var WORKSPACE_GLOBS = [
   "apps/*/package.json",
   "packages/*/package.json",
   "services/*/package.json",
   "libs/*/package.json"
 ];
-function detectNodeFrameworks(pkgPath) {
-  try {
-    const pkg3 = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-    const allDeps = { ...pkg3.dependencies, ...pkg3.devDependencies };
-    const frameworks = [];
-    for (const [dep, framework] of Object.entries(NODE_FRAMEWORK_DEPS)) {
-      if (allDeps[dep]) frameworks.push(framework);
-    }
-    return frameworks;
-  } catch {
-    return [];
-  }
-}
-function detectPythonFrameworks(dir) {
-  const frameworks = [];
-  const candidates = [
-    path.join(dir, "pyproject.toml"),
-    path.join(dir, "requirements.txt"),
-    ...globSync("apps/*/pyproject.toml", { cwd: dir, absolute: true }),
-    ...globSync("apps/*/requirements.txt", { cwd: dir, absolute: true }),
-    ...globSync("services/*/pyproject.toml", { cwd: dir, absolute: true })
-  ];
-  for (const filePath of candidates) {
-    if (!fs.existsSync(filePath)) continue;
-    try {
-      const content = fs.readFileSync(filePath, "utf-8").toLowerCase();
-      for (const [dep, framework] of Object.entries(PYTHON_FRAMEWORK_DEPS)) {
-        if (content.includes(dep)) frameworks.push(framework);
-      }
-    } catch {
-    }
-  }
-  return frameworks;
-}
 function analyzePackageJson(dir) {
   const rootPkgPath = path.join(dir, "package.json");
   let name;
-  const allFrameworks = [];
   const languages = [];
   if (fs.existsSync(rootPkgPath)) {
     try {
       const pkg3 = JSON.parse(fs.readFileSync(rootPkgPath, "utf-8"));
       name = pkg3.name;
       const allDeps = { ...pkg3.dependencies, ...pkg3.devDependencies };
-      allFrameworks.push(...detectNodeFrameworks(rootPkgPath));
       if (allDeps.typescript || allDeps["@types/node"]) {
         languages.push("TypeScript");
       }
@@ -197,7 +120,6 @@ function analyzePackageJson(dir) {
   for (const glob of WORKSPACE_GLOBS) {
     const matches = globSync(glob, { cwd: dir, absolute: true });
     for (const pkgPath of matches) {
-      allFrameworks.push(...detectNodeFrameworks(pkgPath));
       try {
         const pkg3 = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
         const deps = { ...pkg3.dependencies, ...pkg3.devDependencies };
@@ -208,10 +130,8 @@ function analyzePackageJson(dir) {
       }
     }
   }
-  allFrameworks.push(...detectPythonFrameworks(dir));
   return {
     name,
-    frameworks: [...new Set(allFrameworks)],
     languages: [...new Set(languages)]
   };
 }
@@ -1277,7 +1197,7 @@ function collectFingerprint(dir) {
     gitRemoteUrl,
     packageName: pkgInfo.name,
     languages,
-    frameworks: pkgInfo.frameworks,
+    frameworks: [],
     fileTree,
     existingConfigs,
     codeAnalysis
@@ -1937,6 +1857,7 @@ import { createTwoFilesPatch } from "diff";
 // src/lib/hooks.ts
 import fs14 from "fs";
 import path13 from "path";
+import { execSync as execSync3 } from "child_process";
 var SETTINGS_PATH = path13.join(".claude", "settings.json");
 var HOOK_COMMAND = "caliber refresh --quiet";
 var HOOK_DESCRIPTION = "Caliber: auto-refreshing docs based on code changes";
@@ -1998,6 +1919,70 @@ function removeHook() {
   writeSettings(settings);
   return { removed: true, notFound: false };
 }
+var PRECOMMIT_START = "# caliber:pre-commit:start";
+var PRECOMMIT_END = "# caliber:pre-commit:end";
+var PRECOMMIT_BLOCK = `${PRECOMMIT_START}
+if command -v caliber >/dev/null 2>&1; then
+  caliber refresh --quiet 2>/dev/null || true
+  git diff --name-only -- CLAUDE.md .claude/ .cursor/ AGENTS.md 2>/dev/null | xargs git add 2>/dev/null || true
+fi
+${PRECOMMIT_END}`;
+function getGitHooksDir() {
+  try {
+    const gitDir = execSync3("git rev-parse --git-dir", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return path13.join(gitDir, "hooks");
+  } catch {
+    return null;
+  }
+}
+function getPreCommitPath() {
+  const hooksDir = getGitHooksDir();
+  return hooksDir ? path13.join(hooksDir, "pre-commit") : null;
+}
+function isPreCommitHookInstalled() {
+  const hookPath = getPreCommitPath();
+  if (!hookPath || !fs14.existsSync(hookPath)) return false;
+  const content = fs14.readFileSync(hookPath, "utf-8");
+  return content.includes(PRECOMMIT_START);
+}
+function installPreCommitHook() {
+  if (isPreCommitHookInstalled()) {
+    return { installed: false, alreadyInstalled: true };
+  }
+  const hookPath = getPreCommitPath();
+  if (!hookPath) return { installed: false, alreadyInstalled: false };
+  const hooksDir = path13.dirname(hookPath);
+  if (!fs14.existsSync(hooksDir)) fs14.mkdirSync(hooksDir, { recursive: true });
+  let content = "";
+  if (fs14.existsSync(hookPath)) {
+    content = fs14.readFileSync(hookPath, "utf-8");
+    if (!content.endsWith("\n")) content += "\n";
+    content += "\n" + PRECOMMIT_BLOCK + "\n";
+  } else {
+    content = "#!/bin/sh\n\n" + PRECOMMIT_BLOCK + "\n";
+  }
+  fs14.writeFileSync(hookPath, content);
+  fs14.chmodSync(hookPath, 493);
+  return { installed: true, alreadyInstalled: false };
+}
+function removePreCommitHook() {
+  const hookPath = getPreCommitPath();
+  if (!hookPath || !fs14.existsSync(hookPath)) {
+    return { removed: false, notFound: true };
+  }
+  let content = fs14.readFileSync(hookPath, "utf-8");
+  if (!content.includes(PRECOMMIT_START)) {
+    return { removed: false, notFound: true };
+  }
+  const regex = new RegExp(`\\n?${PRECOMMIT_START}[\\s\\S]*?${PRECOMMIT_END}\\n?`);
+  content = content.replace(regex, "\n");
+  if (content.trim() === "#!/bin/sh" || content.trim() === "") {
+    fs14.unlinkSync(hookPath);
+  } else {
+    fs14.writeFileSync(hookPath, content);
+  }
+  return { removed: true, notFound: false };
+}
 
 // src/lib/learning-hooks.ts
 import fs15 from "fs";
@@ -2090,7 +2075,7 @@ function removeLearningHooks() {
 init_constants();
 import fs16 from "fs";
 import path15 from "path";
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 var STATE_FILE = path15.join(CALIBER_DIR, ".caliber-state.json");
 function readState() {
   try {
@@ -2108,7 +2093,7 @@ function writeState(state) {
 }
 function getCurrentHeadSha() {
   try {
-    return execSync3("git rev-parse HEAD", {
+    return execSync4("git rev-parse HEAD", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -3334,17 +3319,26 @@ function displayScoreDelta(before, after) {
   const deltaColor = delta >= 0 ? chalk2.green : chalk2.red;
   const beforeGc = gradeColor(before.grade);
   const afterGc = gradeColor(after.grade);
+  const BOX_INNER = 51;
+  const scorePart = `Score: ${before.score} > ${after.score}`;
+  const deltaPart = `${deltaStr} pts`;
+  const gradePart = `${before.grade} > ${after.grade}`;
+  const contentLen = 3 + scorePart.length + deltaPart.length + gradePart.length + 8;
+  const totalPad = BOX_INNER - contentLen;
+  const pad1 = Math.max(2, Math.ceil(totalPad / 2));
+  const pad2 = Math.max(1, totalPad - pad1);
+  const scoreLineFormatted = "   Score: " + beforeGc(`${before.score}`) + chalk2.gray(" \u2192 ") + afterGc(`${after.score}`) + " ".repeat(pad1) + deltaColor(deltaPart) + " ".repeat(pad2) + beforeGc(before.grade) + chalk2.gray(" \u2192 ") + afterGc(after.grade);
+  const visibleLen = 3 + scorePart.length + pad1 + deltaPart.length + pad2 + gradePart.length;
+  const trailingPad = Math.max(0, BOX_INNER - visibleLen);
+  const barWidth = Math.floor((BOX_INNER - 12) / 2);
+  const barLine = `   ${progressBar(before.score, before.maxScore, barWidth)}` + chalk2.gray("  \u2192  ") + progressBar(after.score, after.maxScore, barWidth) + "   ";
   console.log("");
-  console.log(chalk2.gray("  \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E"));
-  console.log(chalk2.gray("  \u2502") + "                                                   " + chalk2.gray("\u2502"));
-  console.log(
-    chalk2.gray("  \u2502") + "   Score: " + beforeGc(`${before.score}`) + chalk2.gray(" \u2192 ") + afterGc(`${after.score}`) + "        " + deltaColor(`${deltaStr} pts`) + "        " + beforeGc(before.grade) + chalk2.gray(" \u2192 ") + afterGc(after.grade) + "   " + chalk2.gray("\u2502")
-  );
-  console.log(
-    chalk2.gray("  \u2502") + `   ${progressBar(before.score, before.maxScore, 18)}` + chalk2.gray("  \u2192  ") + `${progressBar(after.score, after.maxScore, 18)}   ` + chalk2.gray("\u2502")
-  );
-  console.log(chalk2.gray("  \u2502") + "                                                   " + chalk2.gray("\u2502"));
-  console.log(chalk2.gray("  \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F"));
+  console.log(chalk2.gray("  \u256D" + "\u2500".repeat(BOX_INNER) + "\u256E"));
+  console.log(chalk2.gray("  \u2502") + " ".repeat(BOX_INNER) + chalk2.gray("\u2502"));
+  console.log(chalk2.gray("  \u2502") + scoreLineFormatted + " ".repeat(trailingPad) + chalk2.gray("\u2502"));
+  console.log(chalk2.gray("  \u2502") + barLine + chalk2.gray("\u2502"));
+  console.log(chalk2.gray("  \u2502") + " ".repeat(BOX_INNER) + chalk2.gray("\u2502"));
+  console.log(chalk2.gray("  \u2570" + "\u2500".repeat(BOX_INNER) + "\u256F"));
   console.log("");
   const improved = after.checks.filter((ac) => {
     const bc = before.checks.find((b) => b.id === ac.id);
@@ -3380,10 +3374,10 @@ async function initCommand(options) {
   console.log(chalk3.dim("  against your actual codebase \u2014 keeping what works, fixing"));
   console.log(chalk3.dim("  what's stale, and adding what's missing.\n"));
   console.log(chalk3.bold("  How it works:\n"));
-  console.log(chalk3.dim("  1. Scan      Analyze your code, dependencies, and file structure"));
-  console.log(chalk3.dim("  2. Generate  AI creates config files tailored to your project"));
-  console.log(chalk3.dim("  3. Review    You accept, refine, or decline the generated setup"));
-  console.log(chalk3.dim("  4. Apply     Config files are written to your project\n"));
+  console.log(chalk3.dim("  1. Scan      Analyze your code, dependencies, and existing configs"));
+  console.log(chalk3.dim("  2. Generate  AI creates or improves config files for your project"));
+  console.log(chalk3.dim("  3. Review    You accept, refine, or decline the proposed changes"));
+  console.log(chalk3.dim("  4. Apply     Config files are written with backups\n"));
   console.log(chalk3.hex("#6366f1").bold("  Step 1/4 \u2014 Check LLM provider\n"));
   const config = loadConfig();
   if (!config) {
@@ -3398,13 +3392,12 @@ async function initCommand(options) {
   console.log(chalk3.dim(`  Provider: ${config.provider} | Model: ${config.model}
 `));
   console.log(chalk3.hex("#6366f1").bold("  Step 2/4 \u2014 Scan project\n"));
-  console.log(chalk3.dim("  Detecting languages, frameworks, file structure, and existing configs.\n"));
+  console.log(chalk3.dim("  Detecting languages, dependencies, file structure, and existing configs.\n"));
   const spinner = ora("Analyzing project...").start();
   const fingerprint = collectFingerprint(process.cwd());
+  await enrichFingerprintWithLLM(fingerprint, process.cwd());
   spinner.succeed("Project analyzed");
-  const enrichmentPromise = enrichFingerprintWithLLM(fingerprint, process.cwd());
   console.log(chalk3.dim(`  Languages: ${fingerprint.languages.join(", ") || "none detected"}`));
-  console.log(chalk3.dim(`  Frameworks: ${fingerprint.frameworks.join(", ") || "none detected"}`));
   console.log(chalk3.dim(`  Files: ${fingerprint.fileTree.length} found
 `));
   const targetAgent = options.agent || await promptAgent();
@@ -3413,12 +3406,16 @@ async function initCommand(options) {
   if (isEmpty) {
     fingerprint.description = await promptInput("What will you build in this project?");
   }
-  await enrichmentPromise;
-  console.log(chalk3.hex("#6366f1").bold("  Step 3/4 \u2014 Auditing your configs\n"));
-  console.log(chalk3.dim("  AI is auditing your CLAUDE.md, skills, and rules against your"));
-  console.log(chalk3.dim("  project's actual codebase and conventions.\n"));
-  console.log(chalk3.dim("  This usually takes 1\u20133 minutes on first run.\n"));
   const hasExistingConfig = !!(fingerprint.existingConfigs.claudeMd || fingerprint.existingConfigs.claudeSettings || fingerprint.existingConfigs.claudeSkills?.length || fingerprint.existingConfigs.cursorrules || fingerprint.existingConfigs.cursorRules?.length);
+  if (hasExistingConfig) {
+    console.log(chalk3.hex("#6366f1").bold("  Step 3/4 \u2014 Auditing your configs\n"));
+    console.log(chalk3.dim("  AI is reviewing your existing configs against your codebase"));
+    console.log(chalk3.dim("  and suggesting improvements.\n"));
+  } else {
+    console.log(chalk3.hex("#6366f1").bold("  Step 3/4 \u2014 Generating configs\n"));
+    console.log(chalk3.dim("  AI is creating agent config files tailored to your project.\n"));
+  }
+  console.log(chalk3.dim("  This usually takes 1\u20133 minutes.\n"));
   const genStartTime = Date.now();
   const genSpinner = ora("Generating setup...").start();
   const genMessages = new SpinnerMessages(genSpinner, GENERATION_MESSAGES, { showElapsedTime: true });
@@ -3543,13 +3540,14 @@ async function initCommand(options) {
     lastRefreshTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
     targetAgent
   });
-  if (targetAgent === "claude" || targetAgent === "both") {
+  const hookChoice = await promptHookType(targetAgent);
+  if (hookChoice === "claude" || hookChoice === "both") {
     const hookResult = installHook();
     if (hookResult.installed) {
-      console.log(`  ${chalk3.green("\u2713")} Auto-refresh hook installed \u2014 docs update on Claude Code session end`);
+      console.log(`  ${chalk3.green("\u2713")} Claude Code hook installed \u2014 docs update on session end`);
       console.log(chalk3.dim("    Run `caliber hooks remove` to disable"));
     } else if (hookResult.alreadyInstalled) {
-      console.log(chalk3.dim("  Auto-refresh hook already installed"));
+      console.log(chalk3.dim("  Claude Code hook already installed"));
     }
     const learnResult = installLearningHooks();
     if (learnResult.installed) {
@@ -3559,6 +3557,20 @@ async function initCommand(options) {
       console.log(chalk3.dim("  Learning hooks already installed"));
     }
   }
+  if (hookChoice === "precommit" || hookChoice === "both") {
+    const precommitResult = installPreCommitHook();
+    if (precommitResult.installed) {
+      console.log(`  ${chalk3.green("\u2713")} Pre-commit hook installed \u2014 docs refresh before each commit`);
+      console.log(chalk3.dim("    Run `caliber hooks remove-precommit` to disable"));
+    } else if (precommitResult.alreadyInstalled) {
+      console.log(chalk3.dim("  Pre-commit hook already installed"));
+    } else {
+      console.log(chalk3.yellow("  Could not install pre-commit hook (not a git repository?)"));
+    }
+  }
+  if (hookChoice === "skip") {
+    console.log(chalk3.dim("  Skipped auto-refresh hooks. Run `caliber hooks install` later to enable."));
+  }
   const afterScore = computeLocalScore(process.cwd(), targetAgent);
   displayScoreDelta(baselineScore, afterScore);
   console.log(chalk3.bold.green("  Setup complete! Your coding agent is now configured."));
@@ -3618,6 +3630,21 @@ async function promptAgent() {
     ]
   });
 }
+async function promptHookType(targetAgent) {
+  const choices = [];
+  if (targetAgent === "claude" || targetAgent === "both") {
+    choices.push({ name: "Claude Code hook (auto-refresh on session end)", value: "claude" });
+  }
+  choices.push({ name: "Git pre-commit hook (refresh before each commit)", value: "precommit" });
+  if (targetAgent === "claude" || targetAgent === "both") {
+    choices.push({ name: "Both (Claude Code + pre-commit)", value: "both" });
+  }
+  choices.push({ name: "Skip for now", value: "skip" });
+  return select({
+    message: "How would you like to auto-refresh your docs?",
+    choices
+  });
+}
 async function promptWantsReview() {
   const answer = await select({
     message: "Would you like to review the diffs before deciding?",
@@ -3909,9 +3936,10 @@ async function regenerateCommand(options) {
   genMessages.start();
   let generatedSetup = null;
   try {
+    const targetAgent = readState()?.targetAgent ?? "both";
     const result2 = await generateSetup(
       fingerprint,
-      "both",
+      targetAgent,
       void 0,
       {
         onStatus: (status) => {
@@ -3961,7 +3989,7 @@ async function regenerateCommand(options) {
 // src/commands/recommend.ts
 import chalk7 from "chalk";
 import ora4 from "ora";
-import { mkdirSync, writeFileSync } from "fs";
+import { mkdirSync, readFileSync as readFileSync7, existsSync as existsSync9, writeFileSync } from "fs";
 import { join as join8, dirname as dirname2 } from "path";
 
 // src/scanner/index.ts
@@ -4123,15 +4151,26 @@ async function searchSkills(technologies) {
   }
   return results;
 }
+function extractTopDeps() {
+  const pkgPath = join8(process.cwd(), "package.json");
+  if (!existsSync9(pkgPath)) return [];
+  try {
+    const pkg3 = JSON.parse(readFileSync7(pkgPath, "utf-8"));
+    return Object.keys(pkg3.dependencies ?? {});
+  } catch {
+    return [];
+  }
+}
 async function recommendCommand(options) {
   const fingerprint = collectFingerprint(process.cwd());
   const platforms = detectLocalPlatforms();
-  const technologies = [
+  const technologies = [...new Set([
     ...fingerprint.languages,
-    ...fingerprint.frameworks
-  ].filter(Boolean);
+    ...fingerprint.frameworks,
+    ...extractTopDeps()
+  ].filter(Boolean))];
   if (technologies.length === 0) {
-    console.log(chalk7.yellow("Could not detect any languages or frameworks. Try running from a project root."));
+    console.log(chalk7.yellow("Could not detect any languages or dependencies. Try running from a project root."));
     throw new Error("__exit__");
   }
   const spinner = ora4("Searching for skills...").start();
@@ -4328,7 +4367,7 @@ import chalk9 from "chalk";
 import ora5 from "ora";
 
 // src/lib/git-diff.ts
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 var MAX_DIFF_BYTES = 1e5;
 var DOC_PATTERNS = [
   "CLAUDE.md",
@@ -4342,7 +4381,7 @@ function excludeArgs() {
 }
 function safeExec(cmd) {
   try {
-    return execSync4(cmd, {
+    return execSync5(cmd, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       maxBuffer: 10 * 1024 * 1024
@@ -4628,7 +4667,7 @@ import chalk10 from "chalk";
 async function hooksInstallCommand() {
   const result = installHook();
   if (result.alreadyInstalled) {
-    console.log(chalk10.dim("Hook already installed."));
+    console.log(chalk10.dim("Claude Code hook already installed."));
     return;
   }
   console.log(chalk10.green("\u2713") + " SessionEnd hook installed in .claude/settings.json");
@@ -4637,18 +4676,47 @@ async function hooksInstallCommand() {
 async function hooksRemoveCommand() {
   const result = removeHook();
   if (result.notFound) {
-    console.log(chalk10.dim("Hook not found."));
+    console.log(chalk10.dim("Claude Code hook not found."));
     return;
   }
   console.log(chalk10.green("\u2713") + " SessionEnd hook removed from .claude/settings.json");
 }
+async function hooksInstallPrecommitCommand() {
+  const result = installPreCommitHook();
+  if (result.alreadyInstalled) {
+    console.log(chalk10.dim("Pre-commit hook already installed."));
+    return;
+  }
+  if (!result.installed) {
+    console.log(chalk10.red("Failed to install pre-commit hook (not a git repository?)."));
+    return;
+  }
+  console.log(chalk10.green("\u2713") + " Pre-commit hook installed in .git/hooks/pre-commit");
+  console.log(chalk10.dim("  Docs will auto-refresh before each commit via LLM."));
+}
+async function hooksRemovePrecommitCommand() {
+  const result = removePreCommitHook();
+  if (result.notFound) {
+    console.log(chalk10.dim("Pre-commit hook not found."));
+    return;
+  }
+  console.log(chalk10.green("\u2713") + " Pre-commit hook removed from .git/hooks/pre-commit");
+}
 async function hooksStatusCommand() {
-  const installed = isHookInstalled();
-  if (installed) {
-    console.log(chalk10.green("\u2713") + " Auto-refresh hook is " + chalk10.green("installed"));
+  const claudeInstalled = isHookInstalled();
+  const precommitInstalled = isPreCommitHookInstalled();
+  if (claudeInstalled) {
+    console.log(chalk10.green("\u2713") + " Claude Code hook is " + chalk10.green("installed"));
+  } else {
+    console.log(chalk10.dim("\u2717") + " Claude Code hook is " + chalk10.yellow("not installed"));
+  }
+  if (precommitInstalled) {
+    console.log(chalk10.green("\u2713") + " Pre-commit hook is " + chalk10.green("installed"));
   } else {
-    console.log(chalk10.dim("\u2717") + " Auto-refresh hook is " + chalk10.yellow("not installed"));
-    console.log(chalk10.dim("  Run `caliber hooks install` to enable auto-refresh on session end."));
+    console.log(chalk10.dim("\u2717") + " Pre-commit hook is " + chalk10.yellow("not installed"));
+  }
+  if (!claudeInstalled && !precommitInstalled) {
+    console.log(chalk10.dim("\n  Run `caliber hooks install` or `caliber hooks install-precommit` to enable auto-refresh."));
   }
 }
 
@@ -5095,10 +5163,12 @@ program.command("config").description("Configure LLM provider, API key, and mode
 program.command("recommend").description("Discover and install skill recommendations").option("--generate", "Force fresh recommendation search").action(recommendCommand);
 program.command("score").description("Score your current agent config setup (deterministic, no network)").option("--json", "Output as JSON").option("--quiet", "One-line output for scripts/hooks").option("--agent <type>", "Target agent: claude, cursor, or both").action(scoreCommand);
 program.command("refresh").description("Update docs based on recent code changes").option("--quiet", "Suppress output (for use in hooks)").option("--dry-run", "Preview changes without writing files").action(refreshCommand);
-var hooks = program.command("hooks").description("Manage Claude Code session hooks");
-hooks.command("install").description("Install auto-refresh SessionEnd hook").action(hooksInstallCommand);
-hooks.command("remove").description("Remove auto-refresh SessionEnd hook").action(hooksRemoveCommand);
-hooks.command("status").description("Check if auto-refresh hook is installed").action(hooksStatusCommand);
+var hooks = program.command("hooks").description("Manage auto-refresh hooks (Claude Code and git pre-commit)");
+hooks.command("install").description("Install Claude Code SessionEnd auto-refresh hook").action(hooksInstallCommand);
+hooks.command("remove").description("Remove Claude Code SessionEnd auto-refresh hook").action(hooksRemoveCommand);
+hooks.command("install-precommit").description("Install git pre-commit hook for auto-refresh").action(hooksInstallPrecommitCommand);
+hooks.command("remove-precommit").description("Remove git pre-commit hook").action(hooksRemovePrecommitCommand);
+hooks.command("status").description("Check installed hooks status").action(hooksStatusCommand);
 var learn = program.command("learn").description("Session learning \u2014 observe tool usage and extract reusable instructions");
 learn.command("observe").description("Record a tool event from stdin (called by hooks)").option("--failure", "Mark event as a tool failure").action(learnObserveCommand);
 learn.command("finalize").description("Analyze session events and update CLAUDE.md (called on SessionEnd)").action(learnFinalizeCommand);
@@ -5110,7 +5180,7 @@ learn.command("status").description("Show learning system status").action(learnS
 import fs25 from "fs";
 import path22 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { execSync as execSync5 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 import chalk13 from "chalk";
 import ora6 from "ora";
 import confirm2 from "@inquirer/confirm";
@@ -5120,7 +5190,7 @@ var pkg2 = JSON.parse(
 );
 function getInstalledVersion() {
   try {
-    const globalRoot = execSync5("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const globalRoot = execSync6("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
     const pkgPath = path22.join(globalRoot, "@rely-ai", "caliber", "package.json");
     return JSON.parse(fs25.readFileSync(pkgPath, "utf-8")).version;
   } catch {
@@ -5165,7 +5235,7 @@ Update available: ${current} -> ${latest}`)
     }
     const spinner = ora6("Updating caliber...").start();
     try {
-      execSync5(`npm install -g @rely-ai/caliber@${latest} --prefer-online`, { stdio: "pipe", timeout: 6e4 });
+      execSync6(`npm install -g @rely-ai/caliber@${latest} --prefer-online`, { stdio: "pipe", timeout: 6e4 });
       const installed = getInstalledVersion();
       if (installed !== latest) {
         spinner.fail(`Update incomplete \u2014 got ${installed ?? "unknown"}, expected ${latest}`);
@@ -5178,7 +5248,7 @@ Update available: ${current} -> ${latest}`)
       console.log(chalk13.dim(`
 Restarting: caliber ${args.join(" ")}
 `));
-      execSync5(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
+      execSync6(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
         stdio: "inherit",
         env: { ...process.env, CALIBER_SKIP_UPDATE_CHECK: "1" }
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rely-ai/caliber",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Open-source CLI for configuring coding agent environments (CLAUDE.md, .cursorrules, skills). Bring your own LLM.",
   "type": "module",
   "bin": {