@phuc1403/musketeer 0.9.0 → 0.10.0

package/template/.claude/hooks/usage-quota-cache-refresh.cjs

@@ -1,166 +1,166 @@
-#!/usr/bin/env node
-/**
- * Usage Cache Writer - UserPromptSubmit & PostToolUse Hook
- *
- * Fetches Claude Code usage limits from Anthropic OAuth API and writes to cache.
- * The cache is read by statusline.cjs to show the 5-hour rate-limit budget.
- *
- * Self-contained port (no .ck.json / hook-logger deps). Fails open: any error
- * just emits {continue:true} so it can never block a prompt or tool call.
- *
- * Features:
- * - Cross-platform credential retrieval (macOS Keychain, file-based)
- * - API response caching (60s TTL)
- * - Throttled API calls (1 min for prompts, 5 mins for tool use)
- */
-
-try {
-  const fs = require("fs");
-  const path = require("path");
-  const os = require("os");
-  const { execSync } = require("child_process");
-
-  // Cache configuration
-  const USAGE_CACHE_FILE = path.join(os.tmpdir(), "ck-usage-limits-cache.json");
-  const FETCH_INTERVAL_MS = 300000; // 5 minutes for PostToolUse
-  const FETCH_INTERVAL_PROMPT_MS = 60000; // 1 minute for UserPromptSubmit
-
-  /**
-   * Get Claude OAuth credentials (cross-platform)
-   */
-  function getClaudeCredentials() {
-    // macOS: Try Keychain first
-    if (os.platform() === "darwin") {
-      try {
-        const result = execSync('security find-generic-password -s "Claude Code-credentials" -w', {
-          timeout: 5000,
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "ignore"],
-        }).trim();
-        const parsed = JSON.parse(result);
-        if (parsed.claudeAiOauth?.accessToken) {
-          return parsed.claudeAiOauth.accessToken;
-        }
-      } catch {
-        // Fallback to file-based
-      }
-    }
-
-    // File-based credentials (Linux/Windows, or macOS fallback)
-    const credPath = path.join(os.homedir(), ".claude", ".credentials.json");
-    try {
-      const content = fs.readFileSync(credPath, "utf-8");
-      const parsed = JSON.parse(content);
-      return parsed.claudeAiOauth?.accessToken || null;
-    } catch {
-      return null;
-    }
-  }
-
-  /**
-   * Check if we should fetch (throttled)
-   */
-  function shouldFetch(isUserPrompt = false) {
-    const interval = isUserPrompt ? FETCH_INTERVAL_PROMPT_MS : FETCH_INTERVAL_MS;
-
-    try {
-      if (fs.existsSync(USAGE_CACHE_FILE)) {
-        const cache = JSON.parse(fs.readFileSync(USAGE_CACHE_FILE, "utf-8"));
-        if (Date.now() - cache.timestamp < interval) {
-          return false;
-        }
-      }
-    } catch {}
-    return true;
-  }
-
-  /**
-   * Write cache atomically (temp+rename prevents partial reads by statusline)
-   */
-  function writeCache(status, data = null) {
-    const tmpFile = `${USAGE_CACHE_FILE}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
-    try {
-      fs.writeFileSync(
-        tmpFile,
-        JSON.stringify({
-          timestamp: Date.now(),
-          status,
-          data,
-        })
-      );
-      fs.renameSync(tmpFile, USAGE_CACHE_FILE);
-    } catch {
-      try { fs.unlinkSync(tmpFile); } catch {}
-    }
-  }
-
-  /**
-   * Fetch usage limits from Anthropic OAuth API and write to cache
-   * Always writes status to cache (available or unavailable) for statusline fallback
-   */
-  async function fetchAndCacheUsageLimits() {
-    const token = getClaudeCredentials();
-    if (!token) {
-      writeCache("unavailable");
-      return;
-    }
-
-    try {
-      const response = await fetch("https://api.anthropic.com/api/oauth/usage", {
-        method: "GET",
-        headers: {
-          Accept: "application/json",
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${token}`,
-          "anthropic-beta": "oauth-2025-04-20",
-          "User-Agent": "claudekit-engineer/1.0",
-        },
-      });
-
-      if (!response.ok) {
-        writeCache("unavailable");
-        return;
-      }
-
-      const data = await response.json();
-      writeCache("available", data);
-    } catch {
-      writeCache("unavailable");
-    }
-  }
-
-  /**
-   * Main hook execution - just fetch and cache, no injection
-   */
-  async function main() {
-    const result = { continue: true };
-
-    try {
-      // Read hook input
-      let inputStr = "";
-      try {
-        inputStr = fs.readFileSync(0, "utf-8");
-      } catch {}
-
-      const input = JSON.parse(inputStr || "{}");
-
-      // Detect hook type (UserPromptSubmit vs PostToolUse) for throttle interval
-      const isUserPrompt = typeof input.prompt === "string";
-
-      // Check if we should fetch (throttled)
-      if (shouldFetch(isUserPrompt)) {
-        await fetchAndCacheUsageLimits();
-      }
-    } catch {}
-
-    // Output result (no injection, just continue)
-    console.log(JSON.stringify(result));
-  }
-
-  main().catch(() => {
-    console.log(JSON.stringify({ continue: true }));
-    process.exit(0);
-  });
-} catch (e) {
-  process.exit(0); // fail-open
-}
+#!/usr/bin/env node
+/**
+ * Usage Cache Writer - UserPromptSubmit & PostToolUse Hook
+ *
+ * Fetches Claude Code usage limits from Anthropic OAuth API and writes to cache.
+ * The cache is read by statusline.cjs to show the 5-hour rate-limit budget.
+ *
+ * Self-contained port (no .ck.json / hook-logger deps). Fails open: any error
+ * just emits {continue:true} so it can never block a prompt or tool call.
+ *
+ * Features:
+ * - Cross-platform credential retrieval (macOS Keychain, file-based)
+ * - API response caching (60s TTL)
+ * - Throttled API calls (1 min for prompts, 5 mins for tool use)
+ */
+
+try {
+  const fs = require("fs");
+  const path = require("path");
+  const os = require("os");
+  const { execSync } = require("child_process");
+
+  // Cache configuration
+  const USAGE_CACHE_FILE = path.join(os.tmpdir(), "ck-usage-limits-cache.json");
+  const FETCH_INTERVAL_MS = 300000; // 5 minutes for PostToolUse
+  const FETCH_INTERVAL_PROMPT_MS = 60000; // 1 minute for UserPromptSubmit
+
+  /**
+   * Get Claude OAuth credentials (cross-platform)
+   */
+  function getClaudeCredentials() {
+    // macOS: Try Keychain first
+    if (os.platform() === "darwin") {
+      try {
+        const result = execSync('security find-generic-password -s "Claude Code-credentials" -w', {
+          timeout: 5000,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "ignore"],
+        }).trim();
+        const parsed = JSON.parse(result);
+        if (parsed.claudeAiOauth?.accessToken) {
+          return parsed.claudeAiOauth.accessToken;
+        }
+      } catch {
+        // Fallback to file-based
+      }
+    }
+
+    // File-based credentials (Linux/Windows, or macOS fallback)
+    const credPath = path.join(os.homedir(), ".claude", ".credentials.json");
+    try {
+      const content = fs.readFileSync(credPath, "utf-8");
+      const parsed = JSON.parse(content);
+      return parsed.claudeAiOauth?.accessToken || null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Check if we should fetch (throttled)
+   */
+  function shouldFetch(isUserPrompt = false) {
+    const interval = isUserPrompt ? FETCH_INTERVAL_PROMPT_MS : FETCH_INTERVAL_MS;
+
+    try {
+      if (fs.existsSync(USAGE_CACHE_FILE)) {
+        const cache = JSON.parse(fs.readFileSync(USAGE_CACHE_FILE, "utf-8"));
+        if (Date.now() - cache.timestamp < interval) {
+          return false;
+        }
+      }
+    } catch {}
+    return true;
+  }
+
+  /**
+   * Write cache atomically (temp+rename prevents partial reads by statusline)
+   */
+  function writeCache(status, data = null) {
+    const tmpFile = `${USAGE_CACHE_FILE}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
+    try {
+      fs.writeFileSync(
+        tmpFile,
+        JSON.stringify({
+          timestamp: Date.now(),
+          status,
+          data,
+        })
+      );
+      fs.renameSync(tmpFile, USAGE_CACHE_FILE);
+    } catch {
+      try { fs.unlinkSync(tmpFile); } catch {}
+    }
+  }
+
+  /**
+   * Fetch usage limits from Anthropic OAuth API and write to cache
+   * Always writes status to cache (available or unavailable) for statusline fallback
+   */
+  async function fetchAndCacheUsageLimits() {
+    const token = getClaudeCredentials();
+    if (!token) {
+      writeCache("unavailable");
+      return;
+    }
+
+    try {
+      const response = await fetch("https://api.anthropic.com/api/oauth/usage", {
+        method: "GET",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`,
+          "anthropic-beta": "oauth-2025-04-20",
+          "User-Agent": "claudekit-engineer/1.0",
+        },
+      });
+
+      if (!response.ok) {
+        writeCache("unavailable");
+        return;
+      }
+
+      const data = await response.json();
+      writeCache("available", data);
+    } catch {
+      writeCache("unavailable");
+    }
+  }
+
+  /**
+   * Main hook execution - just fetch and cache, no injection
+   */
+  async function main() {
+    const result = { continue: true };
+
+    try {
+      // Read hook input
+      let inputStr = "";
+      try {
+        inputStr = fs.readFileSync(0, "utf-8");
+      } catch {}
+
+      const input = JSON.parse(inputStr || "{}");
+
+      // Detect hook type (UserPromptSubmit vs PostToolUse) for throttle interval
+      const isUserPrompt = typeof input.prompt === "string";
+
+      // Check if we should fetch (throttled)
+      if (shouldFetch(isUserPrompt)) {
+        await fetchAndCacheUsageLimits();
+      }
+    } catch {}
+
+    // Output result (no injection, just continue)
+    console.log(JSON.stringify(result));
+  }
+
+  main().catch(() => {
+    console.log(JSON.stringify({ continue: true }));
+    process.exit(0);
+  });
+} catch (e) {
+  process.exit(0); // fail-open
+}

package/template/.claude/hooks/validate-characteristics-hook.cjs

@@ -1,66 +1,66 @@
-#!/usr/bin/env node
-// PostToolUse validation hook for the two architecture-characteristic documents.
-//
-// .claude/settings.json calls this after every Write/Edit/MultiEdit. If the
-// edited file is the ranking or the worksheet, both are checked together — the
-// worksheet is a derivation of the ranking, so neither can be judged alone.
-//
-// Hook exit-code contract:
-//   exit 0 -> ok (stdout shown in transcript)
-//   exit 2 -> blocking error (stderr fed back to Claude to fix)
-// An unrelated edit, a missing file, or an unparseable payload all exit 0.
-//
-// Only structure is checked. The ranking ORDER is the architect's call and is
-// never second-guessed here.
-
-const fs = require('fs');
-const path = require('path');
-
-const RANKING = 'docs/architecture-characteristics-ranking.md';
-const WORKSHEET = 'docs/architecture-characteristics.md';
-
-function read(root, rel) {
-  try {
-    return fs.readFileSync(path.join(root, rel), 'utf8');
-  } catch {
-    return null;
-  }
-}
-
-try {
-  const root = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-  const payload = JSON.parse(fs.readFileSync(0, 'utf8'));
-  const edited = payload?.tool_input?.file_path;
-
-  if (!edited) process.exit(0);
-
-  // Windows resolves paths case-insensitively, so the same document can arrive
-  // spelled several ways. Comparing case-sensitively there would let an edit
-  // slip past the gate unchecked, which is worse than checking one file twice.
-  const fold = (p) => (process.platform === 'win32' ? p.toLowerCase() : p);
-  const rel = path.relative(root, path.resolve(root, edited)).split(path.sep).join('/');
-  if (fold(rel) !== fold(RANKING) && fold(rel) !== fold(WORKSHEET)) process.exit(0);
-
-  const { check } = require('./lib/characteristics/checker.cjs');
-  const ranking = read(root, RANKING);
-
-  // Editing the ranking alone, before any worksheet exists, is the normal path
-  // through Phase A: `read` returns null and the worksheet rules stay quiet.
-  const worksheet = read(root, WORKSHEET);
-
-  const errors = check({ ranking, worksheet });
-
-  if (errors.length) {
-    process.stderr.write(
-      `Architecture characteristics: ${errors.length} structural problem(s) in ${rel}\n\n` +
-        errors.map((e) => `  - ${e}`).join('\n') +
-        '\n\nFix the file. These are mechanical rules, not judgement calls: the ranking must ' +
-        'cover the catalog exactly once each, every Reason must name the row directly below it, ' +
-        'and the worksheet must derive from the top 7.\n'
-    );
-    process.exit(2);
-  }
-} catch {
-  /* fail open — a structure checker must never be the thing that breaks a session */
-}
-process.exit(0);
+#!/usr/bin/env node
+// PostToolUse validation hook for the two architecture-characteristic documents.
+//
+// .claude/settings.json calls this after every Write/Edit/MultiEdit. If the
+// edited file is the ranking or the worksheet, both are checked together — the
+// worksheet is a derivation of the ranking, so neither can be judged alone.
+//
+// Hook exit-code contract:
+//   exit 0 -> ok (stdout shown in transcript)
+//   exit 2 -> blocking error (stderr fed back to Claude to fix)
+// An unrelated edit, a missing file, or an unparseable payload all exit 0.
+//
+// Only structure is checked. The ranking ORDER is the architect's call and is
+// never second-guessed here.
+
+const fs = require('fs');
+const path = require('path');
+
+const RANKING = 'docs/architecture-characteristics-ranking.md';
+const WORKSHEET = 'docs/architecture-characteristics.md';
+
+function read(root, rel) {
+  try {
+    return fs.readFileSync(path.join(root, rel), 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+try {
+  const root = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  const payload = JSON.parse(fs.readFileSync(0, 'utf8'));
+  const edited = payload?.tool_input?.file_path;
+
+  if (!edited) process.exit(0);
+
+  // Windows resolves paths case-insensitively, so the same document can arrive
+  // spelled several ways. Comparing case-sensitively there would let an edit
+  // slip past the gate unchecked, which is worse than checking one file twice.
+  const fold = (p) => (process.platform === 'win32' ? p.toLowerCase() : p);
+  const rel = path.relative(root, path.resolve(root, edited)).split(path.sep).join('/');
+  if (fold(rel) !== fold(RANKING) && fold(rel) !== fold(WORKSHEET)) process.exit(0);
+
+  const { check } = require('./lib/characteristics/checker.cjs');
+  const ranking = read(root, RANKING);
+
+  // Editing the ranking alone, before any worksheet exists, is the normal path
+  // through Phase A: `read` returns null and the worksheet rules stay quiet.
+  const worksheet = read(root, WORKSHEET);
+
+  const errors = check({ ranking, worksheet });
+
+  if (errors.length) {
+    process.stderr.write(
+      `Architecture characteristics: ${errors.length} structural problem(s) in ${rel}\n\n` +
+        errors.map((e) => `  - ${e}`).join('\n') +
+        '\n\nFix the file. These are mechanical rules, not judgement calls: the ranking must ' +
+        'cover the catalog exactly once each, every Reason must name the row directly below it, ' +
+        'and the worksheet must derive from the top 7.\n'
+    );
+    process.exit(2);
+  }
+} catch {
+  /* fail open — a structure checker must never be the thing that breaks a session */
+}
+process.exit(0);