@hasna/hooks 0.2.6 → 0.2.8

package/bin/index.js

@@ -5,25 +5,43 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -2147,7 +2165,7 @@ var init_registry = __esm(() => {
     {
       name: "sessionlog",
       displayName: "Session Log",
-      description: "Logs every tool call to .claude/session-log-<date>.jsonl",
+      description: "Logs every tool call to SQLite (~/.hooks/hooks.db)",
       version: "0.1.0",
       category: "Observability",
       event: "PostToolUse",
@@ -2157,7 +2175,7 @@ var init_registry = __esm(() => {
     {
       name: "commandlog",
       displayName: "Command Log",
-      description: "Logs every bash command Claude runs to .claude/commands.log",
+      description: "Logs every Bash command to SQLite (~/.hooks/hooks.db)",
       version: "0.1.0",
       category: "Observability",
       event: "PostToolUse",
@@ -2167,7 +2185,7 @@ var init_registry = __esm(() => {
     {
       name: "costwatch",
       displayName: "Cost Watch",
-      description: "Estimates session token usage and warns when budget threshold is exceeded",
+      description: "Estimates session token usage, persists cost history to SQLite, and warns on budget overrun",
       version: "0.1.0",
       category: "Observability",
       event: "Stop",
@@ -2177,7 +2195,7 @@ var init_registry = __esm(() => {
     {
       name: "errornotify",
       displayName: "Error Notify",
-      description: "Detects tool failures and logs errors to .claude/errors.log",
+      description: "Detects tool failures and logs errors to SQLite (~/.hooks/hooks.db)",
       version: "0.1.0",
       category: "Observability",
       event: "PostToolUse",
@@ -2203,6 +2221,86 @@ var init_registry = __esm(() => {
       event: "PostToolUse",
       matcher: "",
       tags: ["tasks", "completion", "gate", "quality", "agent-teams"]
+    },
+    {
+      name: "typecheck-gate",
+      displayName: "Typecheck Gate",
+      description: "Runs TypeScript type checking on Stop and blocks if type errors are found",
+      version: "0.1.0",
+      category: "Code Quality",
+      event: "Stop",
+      matcher: "",
+      tags: ["typescript", "typecheck", "types", "quality", "gate"]
+    },
+    {
+      name: "affected-tests",
+      displayName: "Affected Tests",
+      description: "Maps edited files to their test files and runs them automatically after edits",
+      version: "0.1.0",
+      category: "Code Quality",
+      event: "PostToolUse",
+      matcher: "Edit|Write|NotebookEdit",
+      tags: ["tests", "test-runner", "affected", "quality"]
+    },
+    {
+      name: "conflict-detect",
+      displayName: "Conflict Detect",
+      description: "Blocks edits on files with unresolved git merge conflict markers",
+      version: "0.1.0",
+      category: "Git Safety",
+      event: "PreToolUse",
+      matcher: "Edit|Write",
+      tags: ["git", "conflicts", "merge", "safety"]
+    },
+    {
+      name: "failure-to-task",
+      displayName: "Failure to Task",
+      description: "Creates a todo task automatically when test or build commands fail",
+      version: "0.1.0",
+      category: "Workflow Automation",
+      event: "PostToolUse",
+      matcher: "Bash",
+      tags: ["failures", "tasks", "tests", "build", "automation"]
+    },
+    {
+      name: "filelock",
+      displayName: "File Lock",
+      description: "Auto-checks file locks before edits to prevent multi-agent conflicts",
+      version: "0.1.0",
+      category: "Agent Teams",
+      event: "PreToolUse",
+      matcher: "Edit|Write|NotebookEdit",
+      tags: ["locking", "coordination", "multi-agent", "conflict"]
+    },
+    {
+      name: "announce-start",
+      displayName: "Announce Start",
+      description: "On session start, auto-registers agent, reads messages, and announces to space",
+      version: "0.1.0",
+      category: "Agent Teams",
+      event: "Notification",
+      matcher: "",
+      tags: ["announcement", "start", "register", "messages", "agent-teams"]
+    },
+    {
+      name: "announce-stop",
+      displayName: "Announce Stop",
+      description: "On Stop, releases file locks, posts session summary, and updates task statuses",
+      version: "0.1.0",
+      category: "Agent Teams",
+      event: "Stop",
+      matcher: "",
+      tags: ["announcement", "stop", "locks", "summary", "agent-teams"]
+    },
+    {
+      name: "dm-inject",
+      displayName: "DM Inject",
+      description: "Injects unread direct messages into agent context on Notification events",
+      version: "0.1.0",
+      category: "Agent Teams",
+      event: "Notification",
+      matcher: "",
+      tags: ["messages", "dm", "context", "inject", "agent-teams"]
     }
   ];
 });
@@ -4152,6 +4250,264 @@ var init_profiles = __esm(() => {
   PROFILES_DIR = join2(homedir2(), ".hooks", "profiles");
 });
 
+// src/db/schema.ts
+var CREATE_HOOK_EVENTS_TABLE = `
+  CREATE TABLE IF NOT EXISTS hook_events (
+    id           TEXT PRIMARY KEY,
+    timestamp    TEXT NOT NULL,
+    session_id   TEXT NOT NULL,
+    hook_name    TEXT NOT NULL,
+    event_type   TEXT NOT NULL CHECK (event_type IN ('PreToolUse', 'PostToolUse', 'Stop', 'Notification')),
+    tool_name    TEXT,
+    tool_input   TEXT,
+    result       TEXT CHECK (result IN ('continue', 'block', NULL)),
+    error        TEXT,
+    duration_ms  INTEGER,
+    project_dir  TEXT,
+    metadata     TEXT
+  )
+`, CREATE_INDEXES;
+var init_schema = __esm(() => {
+  CREATE_INDEXES = [
+    `CREATE INDEX IF NOT EXISTS idx_hook_events_timestamp  ON hook_events (timestamp)`,
+    `CREATE INDEX IF NOT EXISTS idx_hook_events_session_id ON hook_events (session_id)`,
+    `CREATE INDEX IF NOT EXISTS idx_hook_events_hook_name  ON hook_events (hook_name)`,
+    `CREATE INDEX IF NOT EXISTS idx_hook_events_event_type ON hook_events (event_type)`,
+    `CREATE INDEX IF NOT EXISTS idx_hook_events_errors     ON hook_events (timestamp) WHERE error IS NOT NULL`
+  ];
+});
+
+// src/db/migrations/001_initial.ts
+function up(db) {
+  db.exec(CREATE_HOOK_EVENTS_TABLE);
+  for (const idx of CREATE_INDEXES) {
+    db.exec(idx);
+  }
+}
+var init_001_initial = __esm(() => {
+  init_schema();
+});
+
+// src/db/migrations/index.ts
+function ensureMigrationsTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      version    TEXT PRIMARY KEY,
+      applied_at TEXT NOT NULL
+    )
+  `);
+}
+function getApplied(db) {
+  const rows = db.query("SELECT version FROM schema_migrations").all();
+  return new Set(rows.map((r) => r.version));
+}
+function runMigrations(db) {
+  ensureMigrationsTable(db);
+  const applied = getApplied(db);
+  for (const migration of MIGRATIONS) {
+    if (applied.has(migration.version))
+      continue;
+    migration.up(db);
+    db.run("INSERT INTO schema_migrations (version, applied_at) VALUES (?, ?)", [
+      migration.version,
+      new Date().toISOString()
+    ]);
+  }
+}
+var MIGRATIONS;
+var init_migrations = __esm(() => {
+  init_001_initial();
+  MIGRATIONS = [{ version: "001_initial", up }];
+});
+
+// src/db/legacy-import.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+function ensureMetaTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS _meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    )
+  `);
+}
+function isAlreadyDone(db) {
+  ensureMetaTable(db);
+  const row = db.query("SELECT value FROM _meta WHERE key = ?").get(META_KEY);
+  return row?.value === "1";
+}
+function markDone(db) {
+  db.run("INSERT OR REPLACE INTO _meta (key, value) VALUES (?, ?)", [META_KEY, "1"]);
+}
+function nanoid() {
+  return crypto.randomUUID().replace(/-/g, "").slice(0, 21);
+}
+function importJsonlFile(db, filePath) {
+  let count = 0;
+  try {
+    const lines = readFileSync3(filePath, "utf-8").split(`
+`).filter(Boolean);
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        db.run(`INSERT OR IGNORE INTO hook_events
+            (id, timestamp, session_id, hook_name, event_type, tool_name, tool_input, project_dir)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+          nanoid(),
+          entry.timestamp ?? new Date().toISOString(),
+          entry.session_id ?? "legacy",
+          "sessionlog",
+          "PostToolUse",
+          entry.tool_name ?? null,
+          entry.tool_input ? String(entry.tool_input).slice(0, 500) : null,
+          null
+        ]);
+        count++;
+      } catch {}
+    }
+  } catch {}
+  return count;
+}
+function importErrorsLog(db, filePath) {
+  let count = 0;
+  try {
+    const lines = readFileSync3(filePath, "utf-8").split(`
+`).filter(Boolean);
+    const linePattern = /^\[(.+?)\]\s+(?:\[session:(\S+)\]\s+)?(.+?)\s+\u2014\s+(.+)$/;
+    for (const line of lines) {
+      try {
+        const m = line.match(linePattern);
+        if (!m)
+          continue;
+        const [, timestamp, sessionPrefix, , errorMsg] = m;
+        db.run(`INSERT OR IGNORE INTO hook_events
+            (id, timestamp, session_id, hook_name, event_type, error)
+           VALUES (?, ?, ?, ?, ?, ?)`, [
+          nanoid(),
+          timestamp,
+          sessionPrefix ? `legacy-${sessionPrefix}` : "legacy",
+          "errornotify",
+          "PostToolUse",
+          errorMsg.slice(0, 500)
+        ]);
+        count++;
+      } catch {}
+    }
+  } catch {}
+  return count;
+}
+function runLegacyImport(db) {
+  try {
+    if (isAlreadyDone(db))
+      return;
+    let total = 0;
+    const claudeProjectsDir = join3(homedir3(), ".claude", "projects");
+    if (existsSync3(claudeProjectsDir)) {
+      try {
+        const projectDirs = readdirSync2(claudeProjectsDir);
+        for (const dir of projectDirs) {
+          const projectDir = join3(claudeProjectsDir, dir);
+          try {
+            const files = readdirSync2(projectDir);
+            for (const file of files) {
+              if (file.match(/^session-log-\d{4}-\d{2}-\d{2}\.jsonl$/)) {
+                total += importJsonlFile(db, join3(projectDir, file));
+              }
+              if (file === "errors.log") {
+                total += importErrorsLog(db, join3(projectDir, file));
+              }
+            }
+          } catch {}
+        }
+      } catch {}
+    }
+    markDone(db);
+    if (total > 0) {
+      process.stderr.write(`[hooks] Imported ${total} legacy log entries into SQLite.
+`);
+    }
+  } catch (err) {
+    process.stderr.write(`[hooks] Legacy import failed (non-fatal): ${err}
+`);
+  }
+}
+var META_KEY = "legacy_import_done";
+var init_legacy_import = () => {};
+
+// src/db/retention.ts
+function runRetention(db, days) {
+  const envDays = parseInt(process.env.HOOKS_RETENTION_DAYS ?? "30");
+  const retentionDays = days ?? (isNaN(envDays) || envDays <= 0 ? 30 : envDays);
+  const cutoff = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1000).toISOString();
+  try {
+    db.run("DELETE FROM hook_events WHERE timestamp < ?", [cutoff]);
+    const changes = db.query("SELECT changes() as changes").get()?.changes ?? 0;
+    return changes;
+  } catch {
+    return 0;
+  }
+}
+
+// src/db/index.ts
+var exports_db = {};
+__export(exports_db, {
+  getDbPath: () => getDbPath,
+  getDb: () => getDb,
+  createTestDb: () => createTestDb,
+  closeDb: () => closeDb
+});
+import { Database } from "bun:sqlite";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+function getDbPath() {
+  if (process.env.HOOKS_DB_PATH) {
+    return process.env.HOOKS_DB_PATH;
+  }
+  const dataDir = process.env.HOOKS_DATA_DIR ?? join4(homedir4(), ".hooks");
+  return join4(dataDir, "hooks.db");
+}
+function ensureDir(dbPath) {
+  const dir = dbPath.substring(0, dbPath.lastIndexOf("/"));
+  if (dir && !existsSync4(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+}
+function getDb() {
+  if (instance)
+    return instance;
+  const dbPath = getDbPath();
+  const isNew = dbPath === ":memory:" || !existsSync4(dbPath);
+  ensureDir(dbPath);
+  instance = new Database(dbPath);
+  instance.exec("PRAGMA journal_mode=WAL");
+  instance.exec("PRAGMA foreign_keys=ON");
+  runMigrations(instance);
+  runRetention(instance);
+  if (isNew) {
+    runLegacyImport(instance);
+  }
+  return instance;
+}
+function closeDb() {
+  if (instance) {
+    instance.close();
+    instance = null;
+  }
+}
+function createTestDb() {
+  const db = new Database(":memory:");
+  db.exec("PRAGMA journal_mode=WAL");
+  db.exec("PRAGMA foreign_keys=ON");
+  return db;
+}
+var instance = null;
+var init_db = __esm(() => {
+  init_migrations();
+  init_legacy_import();
+});
+
 // src/mcp/server.ts
 var exports_server = {};
 __export(exports_server, {
@@ -4165,8 +4521,8 @@ import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { createServer } from "http";
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join3, dirname as dirname2 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { join as join5, dirname as dirname2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function formatInstallResults(results, extra) {
   const installed = results.filter((r) => r.success).map((r) => r.hook);
@@ -4263,7 +4619,7 @@ function createHooksServer() {
     const settingsPath = getSettingsPath(scope);
     const issues = [];
     const healthy = [];
-    const settingsExist = existsSync3(settingsPath);
+    const settingsExist = existsSync5(settingsPath);
     if (!settingsExist) {
       issues.push({ hook: "(settings)", issue: `${settingsPath} not found`, severity: "warning" });
     }
@@ -4276,13 +4632,13 @@ function createHooksServer() {
         continue;
       }
       const hookDir = getHookPath(name);
-      if (!existsSync3(join3(hookDir, "src", "hook.ts"))) {
+      if (!existsSync5(join5(hookDir, "src", "hook.ts"))) {
         issues.push({ hook: name, issue: "Missing src/hook.ts in package", severity: "error" });
         hookHealthy = false;
       }
       if (meta && settingsExist) {
         try {
-          const settings = JSON.parse(readFileSync3(settingsPath, "utf-8"));
+          const settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
           const eventHooks = settings.hooks?.[meta.event] || [];
           const found = eventHooks.some((entry) => entry.hooks?.some((h) => {
             const match = h.command?.match(/^hooks run (\w+)/);
@@ -4313,10 +4669,10 @@ function createHooksServer() {
         return { content: [{ type: "text", text: JSON.stringify({ error: `Hook '${name}' not found` }) }] };
       }
       const hookPath = getHookPath(name);
-      const readmePath = join3(hookPath, "README.md");
+      const readmePath = join5(hookPath, "README.md");
       let readme = "";
-      if (existsSync3(readmePath)) {
-        readme = readFileSync3(readmePath, "utf-8");
+      if (existsSync5(readmePath)) {
+        readme = readFileSync4(readmePath, "utf-8");
       }
       return { content: [{ type: "text", text: JSON.stringify({ ...meta, readme }) }] };
     }
@@ -4365,8 +4721,8 @@ function createHooksServer() {
       return { content: [{ type: "text", text: JSON.stringify({ error: `Hook '${name}' not found` }) }] };
     }
     const hookDir = getHookPath(name);
-    const hookScript = join3(hookDir, "src", "hook.ts");
-    if (!existsSync3(hookScript)) {
+    const hookScript = join5(hookDir, "src", "hook.ts");
+    if (!existsSync5(hookScript)) {
       return { content: [{ type: "text", text: JSON.stringify({ error: `Hook script not found: ${hookScript}` }) }] };
     }
     let hookInput = { ...input };
@@ -4457,7 +4813,7 @@ function createHooksServer() {
     const ctx = {
       scope,
       settings_path: settingsPath,
-      settings_exists: existsSync3(settingsPath),
+      settings_exists: existsSync5(settingsPath),
       registered_hooks: hooks,
       hook_count: hooks.length,
       healthy,
@@ -4495,8 +4851,8 @@ function createHooksServer() {
     const input = { tool_name, tool_input };
     const results = await Promise.all(matchingHooks.map(async (name) => {
       const hookDir = getHookPath(name);
-      const hookScript = join3(hookDir, "src", "hook.ts");
-      if (!existsSync3(hookScript))
+      const hookScript = join5(hookDir, "src", "hook.ts");
+      if (!existsSync5(hookScript))
         return { name, decision: "approve", error: "script not found" };
       const proc = Bun.spawn(["bun", "run", hookScript], {
         stdin: new Response(JSON.stringify(input)),
@@ -4564,8 +4920,8 @@ function createHooksServer() {
       const meta = getHook(name);
       if (!meta)
         return { name, error: `Hook '${name}' not found` };
-      const hookScript = join3(getHookPath(name), "src", "hook.ts");
-      if (!existsSync3(hookScript))
+      const hookScript = join5(getHookPath(name), "src", "hook.ts");
+      if (!existsSync5(hookScript))
         return { name, error: "script not found" };
       const proc = Bun.spawn(["bun", "run", hookScript], {
         stdin: new Response(JSON.stringify(input)),
@@ -4598,8 +4954,8 @@ function createHooksServer() {
     const settingsPath = getSettingsPath(scope);
     let settings = {};
     try {
-      if (existsSync3(settingsPath))
-        settings = JSON.parse(readFileSync3(settingsPath, "utf-8"));
+      if (existsSync5(settingsPath))
+        settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
     } catch {}
     if (!settings.hooks)
       settings.hooks = {};
@@ -4607,9 +4963,9 @@ function createHooksServer() {
     if (!disabled.includes(name))
       disabled.push(name);
     settings.hooks.__disabled = disabled;
-    const { writeFileSync: writeFileSync3, mkdirSync: mkdirSync3 } = await import("fs");
+    const { writeFileSync: writeFileSync3, mkdirSync: mkdirSync4 } = await import("fs");
     const { dirname: dirname3 } = await import("path");
-    mkdirSync3(dirname3(settingsPath), { recursive: true });
+    mkdirSync4(dirname3(settingsPath), { recursive: true });
     writeFileSync3(settingsPath, JSON.stringify(settings, null, 2) + `
 `);
     return { content: [{ type: "text", text: JSON.stringify({ hook: name, disabled: true, scope }) }] };
@@ -4621,8 +4977,8 @@ function createHooksServer() {
     const settingsPath = getSettingsPath(scope);
     let settings = {};
     try {
-      if (existsSync3(settingsPath))
-        settings = JSON.parse(readFileSync3(settingsPath, "utf-8"));
+      if (existsSync5(settingsPath))
+        settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
     } catch {}
     if (settings.hooks?.__disabled) {
       settings.hooks.__disabled = settings.hooks.__disabled.filter((n) => n !== name);
@@ -4645,6 +5001,104 @@ function createHooksServer() {
     const profiles = listProfiles();
     return { content: [{ type: "text", text: JSON.stringify(profiles) }] };
   });
+  server.tool("hooks_log_list", "List hook events from SQLite (~/.hooks/hooks.db). Filter by hook name, session ID, or time range.", {
+    hook_name: z.string().optional().describe("Filter by hook name (e.g. 'sessionlog', 'costwatch')"),
+    session_id: z.string().optional().describe("Filter by session ID prefix"),
+    limit: z.number().default(50).describe("Max number of events to return"),
+    since: z.string().optional().describe("ISO timestamp or duration string (e.g. '1h', '30m', '7d') to filter from")
+  }, async ({ hook_name, session_id, limit, since }) => {
+    const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
+    const db = getDb2();
+    function parseDuration(s) {
+      const m = s.match(/^(\d+)(s|m|h|d)$/);
+      if (!m)
+        return null;
+      const n = parseInt(m[1]);
+      const ms = { s: 1000, m: 60000, h: 3600000, d: 86400000 }[m[2]];
+      return new Date(Date.now() - n * ms).toISOString();
+    }
+    let sql = "SELECT * FROM hook_events WHERE 1=1";
+    const params = [];
+    if (hook_name) {
+      sql += " AND hook_name = ?";
+      params.push(hook_name);
+    }
+    if (session_id) {
+      sql += " AND session_id LIKE ?";
+      params.push(`${session_id}%`);
+    }
+    if (since) {
+      const ts = since.match(/^\d{4}/) ? since : parseDuration(since);
+      if (ts) {
+        sql += " AND timestamp >= ?";
+        params.push(ts);
+      }
+    }
+    sql += " ORDER BY timestamp DESC LIMIT ?";
+    params.push(limit);
+    const rows = db.query(sql).all(...params);
+    return { content: [{ type: "text", text: JSON.stringify({ events: rows, count: rows.length }) }] };
+  });
+  server.tool("hooks_log_tail", "Show the most recent hook events from SQLite.", {
+    n: z.number().default(20).describe("Number of most recent events to return")
+  }, async ({ n }) => {
+    const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
+    const db = getDb2();
+    const rows = db.query("SELECT * FROM hook_events ORDER BY timestamp DESC LIMIT ?").all(n);
+    return { content: [{ type: "text", text: JSON.stringify({ events: rows, count: rows.length }) }] };
+  });
+  server.tool("hooks_log_errors", "Show hook events that contain errors, optionally filtered by time range.", {
+    since: z.string().default("24h").describe("Duration string (e.g. '1h', '30m', '7d') or ISO timestamp"),
+    limit: z.number().default(50).describe("Max number of error events to return")
+  }, async ({ since, limit }) => {
+    const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
+    const db = getDb2();
+    function parseDuration(s) {
+      const m = s.match(/^(\d+)(s|m|h|d)$/);
+      if (!m)
+        return s;
+      const n = parseInt(m[1]);
+      const ms = { s: 1000, m: 60000, h: 3600000, d: 86400000 }[m[2]];
+      return new Date(Date.now() - n * ms).toISOString();
+    }
+    const ts = since.match(/^\d{4}/) ? since : parseDuration(since);
+    const rows = db.query("SELECT * FROM hook_events WHERE error IS NOT NULL AND timestamp >= ? ORDER BY timestamp DESC LIMIT ?").all(ts, limit);
+    return { content: [{ type: "text", text: JSON.stringify({ events: rows, count: rows.length }) }] };
+  });
+  server.tool("hooks_log_summary", "Summarize hook execution: counts per hook, error rates, and recent activity.", {
+    since: z.string().default("24h").describe("Duration string (e.g. '1h', '24h', '7d') or ISO timestamp")
+  }, async ({ since }) => {
+    const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
+    const db = getDb2();
+    function parseDuration(s) {
+      const m = s.match(/^(\d+)(s|m|h|d)$/);
+      if (!m)
+        return s;
+      const n = parseInt(m[1]);
+      const ms = { s: 1000, m: 60000, h: 3600000, d: 86400000 }[m[2]];
+      return new Date(Date.now() - n * ms).toISOString();
+    }
+    const ts = since.match(/^\d{4}/) ? since : parseDuration(since);
+    const totals = db.query("SELECT hook_name, COUNT(*) as total, SUM(CASE WHEN error IS NOT NULL THEN 1 ELSE 0 END) as errors FROM hook_events WHERE timestamp >= ? GROUP BY hook_name ORDER BY total DESC").all(ts);
+    const summary = totals.map((r) => ({
+      hook_name: r.hook_name,
+      total: r.total,
+      errors: r.errors,
+      error_rate: r.total > 0 ? (r.errors / r.total * 100).toFixed(1) + "%" : "0%"
+    }));
+    const grandTotal = totals.reduce((s, r) => s + r.total, 0);
+    const grandErrors = totals.reduce((s, r) => s + r.errors, 0);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          since: ts,
+          hooks: summary,
+          totals: { events: grandTotal, errors: grandErrors, hooks_active: totals.length }
+        })
+      }]
+    };
+  });
   return server;
 }
 async function startSSEServer(port = MCP_PORT) {
@@ -4690,7 +5144,7 @@ var init_server = __esm(() => {
   init_installer();
   init_profiles();
   __dirname3 = dirname2(fileURLToPath2(import.meta.url));
-  pkg = JSON.parse(readFileSync3(join3(__dirname3, "..", "..", "package.json"), "utf-8"));
+  pkg = JSON.parse(readFileSync4(join5(__dirname3, "..", "..", "package.json"), "utf-8"));
 });
 
 // src/cli/index.tsx
@@ -4714,8 +5168,8 @@ var {
 
 // src/cli/index.tsx
 import chalk2 from "chalk";
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import { join as join4, dirname as dirname3 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { join as join6, dirname as dirname3 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/cli/components/App.tsx
@@ -5893,8 +6347,8 @@ init_installer();
 init_profiles();
 import { jsxDEV as jsxDEV8 } from "react/jsx-dev-runtime";
 var __dirname4 = dirname3(fileURLToPath3(import.meta.url));
-var pkgPath = existsSync4(join4(__dirname4, "..", "package.json")) ? join4(__dirname4, "..", "package.json") : join4(__dirname4, "..", "..", "package.json");
-var pkg2 = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+var pkgPath = existsSync6(join6(__dirname4, "..", "package.json")) ? join6(__dirname4, "..", "package.json") : join6(__dirname4, "..", "..", "package.json");
+var pkg2 = JSON.parse(readFileSync5(pkgPath, "utf-8"));
 var program2 = new Command;
 function resolveScope(options) {
   if (options.project)
@@ -5964,8 +6418,8 @@ program2.command("run").argument("<hook>", "Hook to run").option("--profile <id>
     process.exit(1);
   }
   const hookDir = getHookPath(hook);
-  const hookScript = join4(hookDir, "src", "hook.ts");
-  if (!existsSync4(hookScript)) {
+  const hookScript = join6(hookDir, "src", "hook.ts");
+  if (!existsSync6(hookScript)) {
     console.error(JSON.stringify({ error: `Hook script not found: ${hookScript}` }));
     process.exit(1);
   }
@@ -6265,7 +6719,7 @@ program2.command("doctor").option("-g, --global", "Check global settings", false
   const settingsPath = getSettingsPath(scope);
   const issues = [];
   const healthy = [];
-  const settingsExist = existsSync4(settingsPath);
+  const settingsExist = existsSync6(settingsPath);
   if (!settingsExist) {
     issues.push({ hook: "(settings)", issue: `${settingsPath} not found`, severity: "warning" });
   }
@@ -6279,14 +6733,14 @@ program2.command("doctor").option("-g, --global", "Check global settings", false
       continue;
     }
     const hookDir = getHookPath(name);
-    const hookScript = join4(hookDir, "src", "hook.ts");
-    if (!existsSync4(hookScript)) {
+    const hookScript = join6(hookDir, "src", "hook.ts");
+    if (!existsSync6(hookScript)) {
       issues.push({ hook: name, issue: "Missing src/hook.ts in package", severity: "error" });
       hookHealthy = false;
     }
     if (meta && settingsExist) {
       try {
-        const settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+        const settings = JSON.parse(readFileSync5(settingsPath, "utf-8"));
         const eventHooks = settings.hooks?.[meta.event] || [];
         const found = eventHooks.some((entry) => entry.hooks?.some((h) => {
           const match = h.command?.match(/^hooks run (\w+)/);
@@ -6384,10 +6838,10 @@ program2.command("docs").argument("[hook]", "Hook name (shows general docs if om
       return;
     }
     const hookPath = getHookPath(hook);
-    const readmePath = join4(hookPath, "README.md");
+    const readmePath = join6(hookPath, "README.md");
     let readme = "";
-    if (existsSync4(readmePath)) {
-      readme = readFileSync4(readmePath, "utf-8");
+    if (existsSync6(readmePath)) {
+      readme = readFileSync5(readmePath, "utf-8");
     }
     if (options.json) {
       console.log(JSON.stringify({ ...meta, readme }));
@@ -6569,9 +7023,9 @@ program2.command("profile-import").argument("<file>", "JSON file to import profi
   if (file === "-") {
     raw = await new Response(Bun.stdin.stream()).text();
   } else {
-    const { readFileSync: readFileSync5 } = await import("fs");
+    const { readFileSync: readFileSync6 } = await import("fs");
     try {
-      raw = readFileSync5(file, "utf-8");
+      raw = readFileSync6(file, "utf-8");
     } catch {
       if (options.json) {
         console.log(JSON.stringify({ error: `Cannot read file: ${file}` }));
@@ -6602,6 +7056,154 @@ program2.command("profile-import").argument("<file>", "JSON file to import profi
       console.log(chalk2.dim(`  Skipped ${result.skipped} (already exist or invalid)`));
   }
 });
+var logCmd = program2.command("log").description("Query hook event logs from SQLite (~/.hooks/hooks.db)");
+logCmd.command("list").description("List hook events").option("--hook <name>", "Filter by hook name").option("--session <id>", "Filter by session ID").option("-n, --limit <n>", "Number of rows to show", "50").option("-j, --json", "Output as JSON", false).action(async (options) => {
+  const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
+  const db = getDb2();
+  const limit = parseInt(options.limit) || 50;
+  let sql = "SELECT * FROM hook_events WHERE 1=1";
+  const params = [];
+  if (options.hook) {
+    sql += " AND hook_name = ?";
+    params.push(options.hook);
+  }
+  if (options.session) {
+    sql += " AND session_id LIKE ?";
+    params.push(`${options.session}%`);
+  }
+  sql += " ORDER BY timestamp DESC LIMIT ?";
+  params.push(String(limit));
+  const rows = db.query(sql).all(...params);
+  if (options.json) {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  if (rows.length === 0) {
+    console.log(chalk2.dim("No events found."));
+    return;
+  }
+  console.log(chalk2.bold(`
+  Hook Events (${rows.length})
+`));
+  for (const row of rows) {
+    const ts = row.timestamp.slice(0, 19).replace("T", " ");
+    const err = row.error ? chalk2.red(` ERR: ${row.error.slice(0, 60)}`) : "";
+    const tool = row.tool_name ? chalk2.dim(` [${row.tool_name}]`) : "";
+    console.log(`  ${chalk2.dim(ts)}  ${chalk2.cyan(row.hook_name.padEnd(14))}${tool}${err}`);
+  }
+  console.log();
+});
+logCmd.command("search <text>").description("Search hook events by tool_input or error text").option("-n, --limit <n>", "Number of rows to show", "50").option("-j, --json", "Output as JSON", false).action(async (text, options) => {
+  const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
+  const db = getDb2();
+  const limit = parseInt(options.limit) || 50;
+  const q = `%${text}%`;
+  const rows = db.query("SELECT * FROM hook_events WHERE tool_input LIKE ? OR error LIKE ? ORDER BY timestamp DESC LIMIT ?").all(q, q, limit);
+  if (options.json) {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  if (rows.length === 0) {
+    console.log(chalk2.dim(`No events matching "${text}".`));
+    return;
+  }
+  console.log(chalk2.bold(`
+  Search results for "${text}" (${rows.length})
+`));
+  for (const row of rows) {
+    const ts = row.timestamp.slice(0, 19).replace("T", " ");
+    const snippet = (row.tool_input || row.error || "").slice(0, 80);
+    console.log(`  ${chalk2.dim(ts)}  ${chalk2.cyan(row.hook_name.padEnd(14))}  ${chalk2.dim(snippet)}`);
+  }
+  console.log();
+});
+logCmd.command("tail").description("Show most recent hook events").option("-n <n>", "Number of rows", "20").option("-j, --json", "Output as JSON", false).action(async (options) => {
+  const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
+  const db = getDb2();
+  const limit = parseInt(options.n) || 20;
+  const rows = db.query("SELECT * FROM hook_events ORDER BY timestamp DESC LIMIT ?").all(limit);
+  if (options.json) {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  if (rows.length === 0) {
+    console.log(chalk2.dim("No events yet."));
+    return;
+  }
+  console.log(chalk2.bold(`
+  Last ${rows.length} events
+`));
+  for (const row of rows) {
+    const ts = row.timestamp.slice(0, 19).replace("T", " ");
+    const err = row.error ? chalk2.red(` \u2717 ${row.error.slice(0, 60)}`) : "";
+    const tool = row.tool_name ? chalk2.dim(` [${row.tool_name}]`) : "";
+    console.log(`  ${chalk2.dim(ts)}  ${chalk2.cyan(row.hook_name.padEnd(14))}${tool}${err}`);
+  }
+  console.log();
+});
+logCmd.command("errors").description("Show hook events that contain errors").option("--since <duration>", "Only show errors since this duration (e.g. 1h, 30m, 7d)", "24h").option("-n, --limit <n>", "Number of rows to show", "50").option("-j, --json", "Output as JSON", false).action(async (options) => {
+  const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
+  const db = getDb2();
+  const limit = parseInt(options.limit) || 50;
+  function parseDuration(s) {
+    const m = s.match(/^(\d+)(s|m|h|d)$/);
+    if (!m)
+      return 86400000;
+    const n = parseInt(m[1]);
+    switch (m[2]) {
+      case "s":
+        return n * 1000;
+      case "m":
+        return n * 60 * 1000;
+      case "h":
+        return n * 60 * 60 * 1000;
+      case "d":
+        return n * 24 * 60 * 60 * 1000;
+      default:
+        return 86400000;
+    }
+  }
+  const since = new Date(Date.now() - parseDuration(options.since)).toISOString();
+  const rows = db.query("SELECT * FROM hook_events WHERE error IS NOT NULL AND timestamp >= ? ORDER BY timestamp DESC LIMIT ?").all(since, limit);
+  if (options.json) {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  if (rows.length === 0) {
+    console.log(chalk2.dim(`No errors in the last ${options.since}.`));
+    return;
+  }
+  console.log(chalk2.bold(`
+  Errors (last ${options.since}, ${rows.length} found)
+`));
+  for (const row of rows) {
+    const ts = row.timestamp.slice(0, 19).replace("T", " ");
+    console.log(`  ${chalk2.dim(ts)}  ${chalk2.cyan(row.hook_name.padEnd(14))}  ${chalk2.red(row.error.slice(0, 100))}`);
+  }
+  console.log();
+});
+logCmd.command("clear").description("Delete hook event logs").option("--hook <name>", "Only delete events for this hook").option("-y, --yes", "Skip confirmation prompt", false).action(async (options) => {
+  const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
+  const db = getDb2();
+  const countRow = options.hook ? db.query("SELECT COUNT(*) as n FROM hook_events WHERE hook_name = ?").get(options.hook) : db.query("SELECT COUNT(*) as n FROM hook_events").get();
+  const count = countRow?.n ?? 0;
+  if (count === 0) {
+    console.log(chalk2.dim("Nothing to clear."));
+    return;
+  }
+  if (!options.yes) {
+    const scope = options.hook ? `hook "${options.hook}"` : "all hooks";
+    console.log(chalk2.yellow(`About to delete ${count} event(s) for ${scope}.`));
+    console.log(chalk2.dim("Re-run with --yes to confirm."));
+    return;
+  }
+  if (options.hook) {
+    db.run("DELETE FROM hook_events WHERE hook_name = ?", [options.hook]);
+  } else {
+    db.run("DELETE FROM hook_events");
+  }
+  console.log(chalk2.green(`\u2713 Cleared ${count} event(s).`));
+});
 program2.command("mcp").option("-s, --stdio", "Use stdio transport (for agent MCP integration)", false).option("-p, --port <port>", "Port for SSE transport", "39427").description("Start MCP server for AI agent integration").action(async (options) => {
   if (options.stdio) {
     const { startStdioServer: startStdioServer2 } = await Promise.resolve().then(() => (init_server(), exports_server));