@phuc1403/musketeer 0.9.0 → 0.10.0

package/template/.claude/hooks/lib/git-info-cache.cjs

@@ -1,191 +1,191 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * Git Info Cache - Cross-platform git information batching
- *
- * Problem: 5-6 git process spawns per statusline render are slow on Windows (CreateProcess overhead)
- * Solution: Cache git query results for 3 seconds — subsequent renders read cache (zero processes)
- *
- * Performance: 5 spawns per render → event-driven refresh + 30s TTL fallback
- * Cross-platform: No bash-only syntax (no 2>/dev/null), windowsHide on all exec calls
- */
-
-const { execSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-// Cache TTL — long fallback for external changes (git checkout outside Claude)
-// Active invalidation happens via PostToolUse hooks after Edit/Write/Bash
-const CACHE_TTL = 30000;
-const CACHE_MISS = Symbol('cache_miss');
-const CACHE_SKIP = Symbol('cache_skip');
-
-function isTimeoutError(error) {
-  if (!error) return false;
-  if (error.killed) return true;
-  if (error.signal === 'SIGTERM') return true;
-  return /timed out|etimedout/i.test(String(error.message || ''));
-}
-
-function getExecTimeoutMs() {
-  const parsed = Number.parseInt(process.env.CK_GIT_TIMEOUT_MS || '', 10);
-  if (Number.isFinite(parsed) && parsed > 0) return parsed;
-  return 3000;
-}
-
-/**
- * Safe command execution wrapper with optional cwd
- * Timeout prevents hangs on slow/network-mounted repos
- */
-function execIn(cmd, cwd) {
-  try {
-    return {
-      output: execSync(cmd, {
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'ignore'],
-        windowsHide: true,
-        cwd: cwd || undefined,
-        timeout: getExecTimeoutMs()
-      }).trim(),
-      timedOut: false
-    };
-  } catch (error) {
-    return {
-      output: '',
-      timedOut: isTimeoutError(error)
-    };
-  }
-}
-
-/**
- * Get cache file path for current working directory
- */
-function getCachePath(cwd) {
-  const hash = require('crypto')
-    .createHash('md5')
-    .update(cwd)
-    .digest('hex')
-    .slice(0, 8);
-  return path.join(os.tmpdir(), `ck-git-cache-${hash}.json`);
-}
-
-/**
- * Read cache if valid (not expired). Returns CACHE_MISS on miss.
- * No existsSync check (TOCTOU race) — just try read and catch.
- */
-function readCache(cachePath, options = {}) {
-  const { allowStale = false } = options;
-  try {
-    const cache = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
-    if (Date.now() - cache.timestamp < CACHE_TTL || allowStale) {
-      return cache.data; // Can be null (non-git dir) or object (git info)
-    }
-  } catch {
-    // File missing, corrupted, or expired — all treated as cache miss
-  }
-  return CACHE_MISS;
-}
-
-/**
- * Write cache atomically (temp file + rename to avoid partial reads on Windows)
- */
-function writeCache(cachePath, data) {
-  const tmpPath = cachePath + '.tmp';
-  try {
-    fs.writeFileSync(tmpPath, JSON.stringify({ timestamp: Date.now(), data }));
-    fs.renameSync(tmpPath, cachePath);
-  } catch {
-    try { fs.unlinkSync(tmpPath); } catch {}
-  }
-}
-
-/**
- * Count non-empty lines in a newline-delimited string
- */
-function countLines(str) {
-  if (!str) return 0;
-  return str.split('\n').filter(l => l.trim()).length;
-}
-
-/**
- * Fetch git info directly in-process
- * The cache is what eliminates redundant spawns — not subprocess wrapping
- * @param {string} cwd - Directory to run git commands in
- * Returns: { branch, unstaged, staged, ahead, behind } or null if not git repo
- */
-function fetchGitInfo(cwd) {
-  // Check if git repo (fast check) — run in target cwd, not process.cwd()
-  const repoCheck = execIn('git rev-parse --git-dir', cwd);
-  if (repoCheck.timedOut) return CACHE_SKIP;
-  if (!repoCheck.output) {
-    return null;
-  }
-
-  const branchPrimary = execIn('git branch --show-current', cwd);
-  const branchFallback = execIn('git rev-parse --short HEAD', cwd);
-  const unstagedResult = execIn('git diff --name-only', cwd);
-  const stagedResult = execIn('git diff --cached --name-only', cwd);
-  const aheadBehindResult = execIn('git rev-list --left-right --count @{u}...HEAD', cwd);
-
-  if (
-    branchPrimary.timedOut ||
-    branchFallback.timedOut ||
-    unstagedResult.timedOut ||
-    stagedResult.timedOut ||
-    aheadBehindResult.timedOut
-  ) {
-    return CACHE_SKIP;
-  }
-
-  const branch = branchPrimary.output || branchFallback.output;
-  const unstaged = countLines(unstagedResult.output);
-  const staged = countLines(stagedResult.output);
-
-  // Ahead/behind — no 2>/dev/null (invalid on Windows cmd.exe)
-  let ahead = 0;
-  let behind = 0;
-  if (aheadBehindResult.output) {
-    const parts = aheadBehindResult.output.split(/\s+/);
-    behind = parseInt(parts[0], 10) || 0;
-    ahead = parseInt(parts[1], 10) || 0;
-  }
-
-  return { branch, unstaged, staged, ahead, behind };
-}
-
-/**
- * Get git info with caching
- * Main export function used by statusline
- */
-function getGitInfo(cwd = process.cwd()) {
-  const cachePath = getCachePath(cwd);
-
-  // Try cache first (includes cached null for non-git dirs)
-  const cached = readCache(cachePath);
-  if (cached !== CACHE_MISS) return cached;
-
-  // Cache miss or expired, fetch fresh data in target cwd
-  const data = fetchGitInfo(cwd);
-  if (data === CACHE_SKIP) {
-    // Timeout/transient failures should not poison cache as non-git.
-    // Prefer last known value (even stale) if available.
-    const stale = readCache(cachePath, { allowStale: true });
-    return stale === CACHE_MISS ? null : stale;
-  }
-
-  // Cache both positive and null results (avoids re-spawning git in non-git dirs)
-  writeCache(cachePath, data);
-
-  return data;
-}
-
-/**
- * Invalidate cache for a directory (call after file changes to trigger fresh git query)
- */
-function invalidateCache(cwd = process.cwd()) {
-  try { fs.unlinkSync(getCachePath(cwd)); } catch {}
-}
-
-module.exports = { getGitInfo, invalidateCache };
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Git Info Cache - Cross-platform git information batching
+ *
+ * Problem: 5-6 git process spawns per statusline render are slow on Windows (CreateProcess overhead)
+ * Solution: Cache git query results for 3 seconds — subsequent renders read cache (zero processes)
+ *
+ * Performance: 5 spawns per render → event-driven refresh + 30s TTL fallback
+ * Cross-platform: No bash-only syntax (no 2>/dev/null), windowsHide on all exec calls
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Cache TTL — long fallback for external changes (git checkout outside Claude)
+// Active invalidation happens via PostToolUse hooks after Edit/Write/Bash
+const CACHE_TTL = 30000;
+const CACHE_MISS = Symbol('cache_miss');
+const CACHE_SKIP = Symbol('cache_skip');
+
+function isTimeoutError(error) {
+  if (!error) return false;
+  if (error.killed) return true;
+  if (error.signal === 'SIGTERM') return true;
+  return /timed out|etimedout/i.test(String(error.message || ''));
+}
+
+function getExecTimeoutMs() {
+  const parsed = Number.parseInt(process.env.CK_GIT_TIMEOUT_MS || '', 10);
+  if (Number.isFinite(parsed) && parsed > 0) return parsed;
+  return 3000;
+}
+
+/**
+ * Safe command execution wrapper with optional cwd
+ * Timeout prevents hangs on slow/network-mounted repos
+ */
+function execIn(cmd, cwd) {
+  try {
+    return {
+      output: execSync(cmd, {
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'ignore'],
+        windowsHide: true,
+        cwd: cwd || undefined,
+        timeout: getExecTimeoutMs()
+      }).trim(),
+      timedOut: false
+    };
+  } catch (error) {
+    return {
+      output: '',
+      timedOut: isTimeoutError(error)
+    };
+  }
+}
+
+/**
+ * Get cache file path for current working directory
+ */
+function getCachePath(cwd) {
+  const hash = require('crypto')
+    .createHash('md5')
+    .update(cwd)
+    .digest('hex')
+    .slice(0, 8);
+  return path.join(os.tmpdir(), `ck-git-cache-${hash}.json`);
+}
+
+/**
+ * Read cache if valid (not expired). Returns CACHE_MISS on miss.
+ * No existsSync check (TOCTOU race) — just try read and catch.
+ */
+function readCache(cachePath, options = {}) {
+  const { allowStale = false } = options;
+  try {
+    const cache = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+    if (Date.now() - cache.timestamp < CACHE_TTL || allowStale) {
+      return cache.data; // Can be null (non-git dir) or object (git info)
+    }
+  } catch {
+    // File missing, corrupted, or expired — all treated as cache miss
+  }
+  return CACHE_MISS;
+}
+
+/**
+ * Write cache atomically (temp file + rename to avoid partial reads on Windows)
+ */
+function writeCache(cachePath, data) {
+  const tmpPath = cachePath + '.tmp';
+  try {
+    fs.writeFileSync(tmpPath, JSON.stringify({ timestamp: Date.now(), data }));
+    fs.renameSync(tmpPath, cachePath);
+  } catch {
+    try { fs.unlinkSync(tmpPath); } catch {}
+  }
+}
+
+/**
+ * Count non-empty lines in a newline-delimited string
+ */
+function countLines(str) {
+  if (!str) return 0;
+  return str.split('\n').filter(l => l.trim()).length;
+}
+
+/**
+ * Fetch git info directly in-process
+ * The cache is what eliminates redundant spawns — not subprocess wrapping
+ * @param {string} cwd - Directory to run git commands in
+ * Returns: { branch, unstaged, staged, ahead, behind } or null if not git repo
+ */
+function fetchGitInfo(cwd) {
+  // Check if git repo (fast check) — run in target cwd, not process.cwd()
+  const repoCheck = execIn('git rev-parse --git-dir', cwd);
+  if (repoCheck.timedOut) return CACHE_SKIP;
+  if (!repoCheck.output) {
+    return null;
+  }
+
+  const branchPrimary = execIn('git branch --show-current', cwd);
+  const branchFallback = execIn('git rev-parse --short HEAD', cwd);
+  const unstagedResult = execIn('git diff --name-only', cwd);
+  const stagedResult = execIn('git diff --cached --name-only', cwd);
+  const aheadBehindResult = execIn('git rev-list --left-right --count @{u}...HEAD', cwd);
+
+  if (
+    branchPrimary.timedOut ||
+    branchFallback.timedOut ||
+    unstagedResult.timedOut ||
+    stagedResult.timedOut ||
+    aheadBehindResult.timedOut
+  ) {
+    return CACHE_SKIP;
+  }
+
+  const branch = branchPrimary.output || branchFallback.output;
+  const unstaged = countLines(unstagedResult.output);
+  const staged = countLines(stagedResult.output);
+
+  // Ahead/behind — no 2>/dev/null (invalid on Windows cmd.exe)
+  let ahead = 0;
+  let behind = 0;
+  if (aheadBehindResult.output) {
+    const parts = aheadBehindResult.output.split(/\s+/);
+    behind = parseInt(parts[0], 10) || 0;
+    ahead = parseInt(parts[1], 10) || 0;
+  }
+
+  return { branch, unstaged, staged, ahead, behind };
+}
+
+/**
+ * Get git info with caching
+ * Main export function used by statusline
+ */
+function getGitInfo(cwd = process.cwd()) {
+  const cachePath = getCachePath(cwd);
+
+  // Try cache first (includes cached null for non-git dirs)
+  const cached = readCache(cachePath);
+  if (cached !== CACHE_MISS) return cached;
+
+  // Cache miss or expired, fetch fresh data in target cwd
+  const data = fetchGitInfo(cwd);
+  if (data === CACHE_SKIP) {
+    // Timeout/transient failures should not poison cache as non-git.
+    // Prefer last known value (even stale) if available.
+    const stale = readCache(cachePath, { allowStale: true });
+    return stale === CACHE_MISS ? null : stale;
+  }
+
+  // Cache both positive and null results (avoids re-spawning git in non-git dirs)
+  writeCache(cachePath, data);
+
+  return data;
+}
+
+/**
+ * Invalidate cache for a directory (call after file changes to trigger fresh git query)
+ */
+function invalidateCache(cwd = process.cwd()) {
+  try { fs.unlinkSync(getCachePath(cwd)); } catch {}
+}
+
+module.exports = { getGitInfo, invalidateCache };

package/template/.claude/hooks/sync-adr-toc.cjs

@@ -1,146 +1,146 @@
-#!/usr/bin/env node
-// PostToolUse hook: after any `adr` command, rebuild docs/adr/README.md from the
-// ADR files themselves — one row per ADR with its title and current status.
-//
-// The index is fully derived, so it can never drift: every run re-reads the
-// source. That is why there is no need to be clever about which adr subcommand
-// ran, or to protect the file from being rewritten.
-//
-// Also deletes the tool's own `decisions.md`. Every `adr new` regenerates that
-// file unconditionally (not just on `adr generate toc`), which would leave two
-// competing indexes side by side in the same directory. README.md is the richer
-// one — it carries a status column — so it is the one kept.
-//
-// Also runnable directly:  node sync-adr-toc.cjs --write
-//
-// Fails open at exit 0 on any problem — a hook must never block a session.
-
-const fs = require('fs');
-const path = require('path');
-
-const root = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-const ADR_FILE = /^\d+-.*\.md$/;
-
-// The tool reads its directory from a committed `.adr-dir` (default `doc/adr`).
-function adrDir() {
-  try {
-    return fs.readFileSync(path.join(root, '.adr-dir'), 'utf8').trim() || 'doc/adr';
-  } catch {
-    return 'doc/adr';
-  }
-}
-
-// Was this Bash call an adr command? (`adr new -q …` counts; a hyphenated name
-// such as `adr-new` does not, hence the required whitespace.)
-function isAdrCommand() {
-  try {
-    const payload = JSON.parse(fs.readFileSync(0, 'utf8'));
-    return /\badr\s/.test(payload?.tool_input?.command || '');
-  } catch {
-    return false;
-  }
-}
-
-// First line, minus the leading "# " and the tool's own number prefix — the
-// template renders "# 12: Use X over Y" for 0012-….md. Dropping the unpadded 12
-// keeps the padded
-// stem in the ADR column the only number in the file, so nothing here can be
-// mistaken for the stem `adr new -s` expects.
-function title(body, fallback) {
-  const first = body.split(/\r?\n/)[0] || '';
-  return first.replace(/^#\s*(\d+\s*[:.]\s*)?/, '').trim() || fallback;
-}
-
-// First non-empty line of the `## Status` section. The tool maintains this:
-// "Accepted", or "Superseded by [4: …](0004-….md)" after `adr new -s`.
-function status(body) {
-  const lines = body.split(/\r?\n/);
-  const start = lines.findIndex((l) => /^##\s+Status\s*$/i.test(l));
-  if (start === -1) return 'Unknown';
-  for (const line of lines.slice(start + 1)) {
-    if (/^##\s/.test(line)) break;
-    if (line.trim()) return line.trim();
-  }
-  return 'Unknown';
-}
-
-function render(dir, files) {
-  const rows = files.map((name) => {
-    const body = fs.readFileSync(path.join(root, dir, name), 'utf8');
-    const stem = name.replace(/\.md$/, ''); // padded — what `adr new -s` needs
-    const cell = (s) => s.replace(/\|/g, '\\|'); // never break the table
-    return `| [${stem}](./${name}) | ${cell(title(body, stem))} | ${cell(status(body))} |`;
-  });
-
-  return [
-    '# Architecture Decision Records',
-    '',
-    'Generated from the ADR files by the `sync-adr-toc` hook — do not hand-edit.',
-    '',
-    '| ADR | Title | Status |',
-    '|-----|-------|--------|',
-    ...rows,
-    '',
-  ].join('\n');
-}
-
-// The tool writes its own table of contents to `<adr-dir>/decisions.md` on every
-// `adr new`. README.md supersedes it, so drop it rather than commit two indexes
-// that have to agree with each other.
-//
-// Only ever deletes a file that is recognisably that generated index: the exact
-// heading it writes, followed by nothing but link lines. `decisions.md` is an
-// ordinary name for a hand-written decision log, and deleting one of those on
-// the next `adr new` would destroy work no backup covers.
-const GENERATED_TOC = /^# Table of Contents\r?\n\r?\n(?:- \[[^\]]*\]\([^)]*\)\r?\n?)*$/;
-
-function removeRedundantToc(dir) {
-  const stale = path.join(root, dir, 'decisions.md');
-  try {
-    if (!fs.existsSync(stale)) return;
-    if (!GENERATED_TOC.test(fs.readFileSync(stale, 'utf8'))) {
-      process.stdout.write(
-        `Left ${dir}/decisions.md alone — it is not the generated index. ` +
-          'README.md is the one this hook maintains.\n'
-      );
-      return;
-    }
-    fs.unlinkSync(stale);
-    process.stdout.write(`Removed ${dir}/decisions.md (README.md is the index).\n`);
-  } catch {
-    /* not worth failing the hook over */
-  }
-}
-
-function main() {
-  if (!process.argv.includes('--write') && !isAdrCommand()) return;
-
-  const dir = adrDir();
-  removeRedundantToc(dir);
-  const files = fs
-    .readdirSync(path.join(root, dir))
-    .filter((f) => ADR_FILE.test(f))
-    .sort();
-  if (files.length === 0) return;
-
-  const target = path.join(root, dir, 'README.md');
-  const next = render(dir, files);
-
-  let current = null;
-  try {
-    current = fs.readFileSync(target, 'utf8');
-  } catch {
-    /* no index yet */
-  }
-  if (current === next) return; // already in sync
-
-  fs.writeFileSync(target, next);
-  process.stdout.write(`Regenerated ${dir}/README.md (${files.length} ADRs).\n`);
-}
-
-try {
-  main();
-} catch {
-  /* fail open */
-}
-process.exit(0);
+#!/usr/bin/env node
+// PostToolUse hook: after any `adr` command, rebuild docs/adr/README.md from the
+// ADR files themselves — one row per ADR with its title and current status.
+//
+// The index is fully derived, so it can never drift: every run re-reads the
+// source. That is why there is no need to be clever about which adr subcommand
+// ran, or to protect the file from being rewritten.
+//
+// Also deletes the tool's own `decisions.md`. Every `adr new` regenerates that
+// file unconditionally (not just on `adr generate toc`), which would leave two
+// competing indexes side by side in the same directory. README.md is the richer
+// one — it carries a status column — so it is the one kept.
+//
+// Also runnable directly:  node sync-adr-toc.cjs --write
+//
+// Fails open at exit 0 on any problem — a hook must never block a session.
+
+const fs = require('fs');
+const path = require('path');
+
+const root = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const ADR_FILE = /^\d+-.*\.md$/;
+
+// The tool reads its directory from a committed `.adr-dir` (default `doc/adr`).
+function adrDir() {
+  try {
+    return fs.readFileSync(path.join(root, '.adr-dir'), 'utf8').trim() || 'doc/adr';
+  } catch {
+    return 'doc/adr';
+  }
+}
+
+// Was this Bash call an adr command? (`adr new -q …` counts; a hyphenated name
+// such as `adr-new` does not, hence the required whitespace.)
+function isAdrCommand() {
+  try {
+    const payload = JSON.parse(fs.readFileSync(0, 'utf8'));
+    return /\badr\s/.test(payload?.tool_input?.command || '');
+  } catch {
+    return false;
+  }
+}
+
+// First line, minus the leading "# " and the tool's own number prefix — the
+// template renders "# 12: Use X over Y" for 0012-….md. Dropping the unpadded 12
+// keeps the padded
+// stem in the ADR column the only number in the file, so nothing here can be
+// mistaken for the stem `adr new -s` expects.
+function title(body, fallback) {
+  const first = body.split(/\r?\n/)[0] || '';
+  return first.replace(/^#\s*(\d+\s*[:.]\s*)?/, '').trim() || fallback;
+}
+
+// First non-empty line of the `## Status` section. The tool maintains this:
+// "Accepted", or "Superseded by [4: …](0004-….md)" after `adr new -s`.
+function status(body) {
+  const lines = body.split(/\r?\n/);
+  const start = lines.findIndex((l) => /^##\s+Status\s*$/i.test(l));
+  if (start === -1) return 'Unknown';
+  for (const line of lines.slice(start + 1)) {
+    if (/^##\s/.test(line)) break;
+    if (line.trim()) return line.trim();
+  }
+  return 'Unknown';
+}
+
+function render(dir, files) {
+  const rows = files.map((name) => {
+    const body = fs.readFileSync(path.join(root, dir, name), 'utf8');
+    const stem = name.replace(/\.md$/, ''); // padded — what `adr new -s` needs
+    const cell = (s) => s.replace(/\|/g, '\\|'); // never break the table
+    return `| [${stem}](./${name}) | ${cell(title(body, stem))} | ${cell(status(body))} |`;
+  });
+
+  return [
+    '# Architecture Decision Records',
+    '',
+    'Generated from the ADR files by the `sync-adr-toc` hook — do not hand-edit.',
+    '',
+    '| ADR | Title | Status |',
+    '|-----|-------|--------|',
+    ...rows,
+    '',
+  ].join('\n');
+}
+
+// The tool writes its own table of contents to `<adr-dir>/decisions.md` on every
+// `adr new`. README.md supersedes it, so drop it rather than commit two indexes
+// that have to agree with each other.
+//
+// Only ever deletes a file that is recognisably that generated index: the exact
+// heading it writes, followed by nothing but link lines. `decisions.md` is an
+// ordinary name for a hand-written decision log, and deleting one of those on
+// the next `adr new` would destroy work no backup covers.
+const GENERATED_TOC = /^# Table of Contents\r?\n\r?\n(?:- \[[^\]]*\]\([^)]*\)\r?\n?)*$/;
+
+function removeRedundantToc(dir) {
+  const stale = path.join(root, dir, 'decisions.md');
+  try {
+    if (!fs.existsSync(stale)) return;
+    if (!GENERATED_TOC.test(fs.readFileSync(stale, 'utf8'))) {
+      process.stdout.write(
+        `Left ${dir}/decisions.md alone — it is not the generated index. ` +
+          'README.md is the one this hook maintains.\n'
+      );
+      return;
+    }
+    fs.unlinkSync(stale);
+    process.stdout.write(`Removed ${dir}/decisions.md (README.md is the index).\n`);
+  } catch {
+    /* not worth failing the hook over */
+  }
+}
+
+function main() {
+  if (!process.argv.includes('--write') && !isAdrCommand()) return;
+
+  const dir = adrDir();
+  removeRedundantToc(dir);
+  const files = fs
+    .readdirSync(path.join(root, dir))
+    .filter((f) => ADR_FILE.test(f))
+    .sort();
+  if (files.length === 0) return;
+
+  const target = path.join(root, dir, 'README.md');
+  const next = render(dir, files);
+
+  let current = null;
+  try {
+    current = fs.readFileSync(target, 'utf8');
+  } catch {
+    /* no index yet */
+  }
+  if (current === next) return; // already in sync
+
+  fs.writeFileSync(target, next);
+  process.stdout.write(`Regenerated ${dir}/README.md (${files.length} ADRs).\n`);
+}
+
+try {
+  main();
+} catch {
+  /* fail open */
+}
+process.exit(0);