@hasna/hooks 0.2.5 → 0.2.7

package/dist/index.js

@@ -412,7 +412,7 @@ var HOOKS = [
   {
     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",
@@ -422,7 +422,7 @@ var HOOKS = [
   {
     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",
@@ -432,7 +432,7 @@ var HOOKS = [
   {
     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",
@@ -442,7 +442,7 @@ var HOOKS = [
   {
     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",

package/hooks/hook-agentmessages/bin/cli.ts

@@ -0,0 +1,125 @@
+#!/usr/bin/env bun
+/**
+ * CLI for hook-agentmessages
+ *
+ * Usage:
+ *   hook-agentmessages install    - Install hooks into Claude Code
+ *   hook-agentmessages uninstall  - Remove hooks from Claude Code
+ *   hook-agentmessages status     - Show hook status
+ */
+
+import { homedir } from 'os';
+import { join } from 'path';
+
+const CLAUDE_SETTINGS_FILE = join(homedir(), '.claude', 'settings.json');
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+async function showStatus() {
+  console.log('hook-agentmessages status\n');
+
+  // Check if hooks are installed
+  try {
+    const file = Bun.file(CLAUDE_SETTINGS_FILE);
+    if (await file.exists()) {
+      const settings = await file.json();
+
+      if (settings.hooks) {
+        let installed = false;
+
+        if (settings.hooks.SessionStart) {
+          const hasHook = settings.hooks.SessionStart.some((h: any) =>
+            h.hooks?.some((hook: any) => hook.command?.includes('hook-agentmessages'))
+          );
+          if (hasHook) {
+            console.log('  SessionStart hook: installed');
+            installed = true;
+          }
+        }
+
+        if (settings.hooks.Stop) {
+          const hasHook = settings.hooks.Stop.some((h: any) =>
+            h.hooks?.some((hook: any) => hook.command?.includes('hook-agentmessages'))
+          );
+          if (hasHook) {
+            console.log('  Stop hook: installed');
+            installed = true;
+          }
+        }
+
+        if (!installed) {
+          console.log('  No hook-agentmessages hooks installed');
+        }
+      } else {
+        console.log('  No hooks configured in Claude Code');
+      }
+    } else {
+      console.log('  Claude Code settings not found');
+    }
+  } catch (err) {
+    console.log('  Error reading settings:', (err as Error).message);
+  }
+
+  // Check service-message status
+  const serviceDir = join(homedir(), '.service', 'service-message');
+  const configFile = Bun.file(join(serviceDir, 'config.json'));
+
+  console.log('\nservice-message integration:');
+  if (await configFile.exists()) {
+    const config = await configFile.json();
+    console.log(`  Agent ID: ${config.agentId || 'not set'}`);
+    console.log(`  Data dir: ${serviceDir}`);
+  } else {
+    console.log('  Not configured');
+  }
+}
+
+function showHelp() {
+  console.log(`
+hook-agentmessages - Claude Code hook for service-message integration
+
+Usage:
+  hook-agentmessages <command>
+
+Commands:
+  install     Install hooks into Claude Code settings
+  uninstall   Remove hooks from Claude Code settings
+  status      Show current hook status
+
+Examples:
+  hook-agentmessages install
+  hook-agentmessages status
+`);
+}
+
+async function main() {
+  if (!command || command === '--help' || command === '-h') {
+    showHelp();
+    return;
+  }
+
+  switch (command) {
+    case 'install':
+      await import('../src/install.ts');
+      break;
+
+    case 'uninstall':
+      await import('../src/uninstall.ts');
+      break;
+
+    case 'status':
+      await showStatus();
+      break;
+
+    default:
+      console.error(`Unknown command: ${command}`);
+      showHelp();
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/hooks/hook-checkdocs/bun.lock

@@ -0,0 +1,25 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "@hasnaxyz/hook-checkfiles",
+      "devDependencies": {
+        "@types/bun": "^1.3.8",
+        "@types/node": "^20",
+        "typescript": "^5.0.0",
+      },
+    },
+  },
+  "packages": {
+    "@types/bun": ["@types/bun@1.3.8", "", { "dependencies": { "bun-types": "1.3.8" } }, "sha512-3LvWJ2q5GerAXYxO2mffLTqOzEu5qnhEAlh48Vnu8WQfnmSwbgagjGZV6BoHKJztENYEDn6QmVd949W4uESRJA=="],
+
+    "@types/node": ["@types/node@20.19.30", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-WJtwWJu7UdlvzEAUm484QNg5eAoq5QR08KDNx7g45Usrs2NtOPiX8ugDqmKdXkyL03rBqU5dYNYVQetEpBHq2g=="],
+
+    "bun-types": ["bun-types@1.3.8", "", { "dependencies": { "@types/node": "*" } }, "sha512-fL99nxdOWvV4LqjmC+8Q9kW3M4QTtTR1eePs94v5ctGqU8OeceWrSUaRw3JYb7tU3FkMIAjkueehrHPPPGKi5Q=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],
+  }
+}

package/hooks/hook-commandlog/src/hook.ts

@@ -3,15 +3,11 @@
 /**
  * Claude Code Hook: commandlog
  *
- * PostToolUse hook that logs every bash command Claude runs to
- * .claude/commands.log in the project directory.
- *
- * Format: [ISO timestamp] <exit_code> <command>
- * One command per line.
+ * PostToolUse hook that logs every Bash command to SQLite (~/.hooks/hooks.db).
  */
 
-import { readFileSync, existsSync, mkdirSync, appendFileSync } from "fs";
-import { join } from "path";
+import { readFileSync } from "fs";
+import { writeHookEvent } from "../../../src/lib/db-writer";
 
 interface HookInput {
   session_id: string;
@@ -38,31 +34,6 @@ function respond(output: HookOutput): void {
   console.log(JSON.stringify(output));
 }
 
-function logCommand(input: HookInput): void {
-  const claudeDir = join(input.cwd, ".claude");
-
-  // Create .claude/ directory if it doesn't exist
-  if (!existsSync(claudeDir)) {
-    mkdirSync(claudeDir, { recursive: true });
-  }
-
-  const logFile = join(claudeDir, "commands.log");
-  const timestamp = new Date().toISOString();
-  const command = (input.tool_input.command as string) || "(unknown command)";
-  const exitCode = input.tool_input.exit_code;
-
-  // Format: [timestamp] exit_code command
-  // If exit_code is available, include it; otherwise just log the command
-  let logLine: string;
-  if (exitCode !== undefined && exitCode !== null) {
-    logLine = `[${timestamp}] exit=${exitCode} ${command}\n`;
-  } else {
-    logLine = `[${timestamp}] ${command}\n`;
-  }
-
-  appendFileSync(logFile, logLine);
-}
-
 export function run(): void {
   const input = readStdinJson();
 
@@ -77,12 +48,18 @@ export function run(): void {
     return;
   }
 
-  try {
-    logCommand(input);
-  } catch (error) {
-    const errMsg = error instanceof Error ? error.message : String(error);
-    console.error(`[hook-commandlog] Warning: failed to log command: ${errMsg}`);
-  }
+  const command = (input.tool_input.command as string) || "(unknown command)";
+  const exitCode = input.tool_input.exit_code;
+
+  writeHookEvent({
+    session_id: input.session_id,
+    hook_name: "commandlog",
+    event_type: "PostToolUse",
+    tool_name: "Bash",
+    tool_input: command,
+    project_dir: input.cwd,
+    metadata: exitCode !== undefined && exitCode !== null ? JSON.stringify({ exit_code: exitCode }) : null,
+  });
 
   respond({ continue: true });
 }

package/hooks/hook-costwatch/src/hook.ts

@@ -3,24 +3,19 @@
 /**
  * Claude Code Hook: costwatch
  *
- * Stop hook that estimates session token usage and warns if a budget
- * threshold is exceeded.
+ * Stop hook that estimates session token usage and persists cost data to
+ * SQLite (~/.hooks/hooks.db) for cross-session history queries.
  *
  * Configuration:
  * - Environment variable: COST_WATCH_BUDGET (max $ per session, e.g. "5.00")
  * - If not set, no budget enforcement (just logs a reminder)
  *
- * Token estimation is rough:
- * - ~4 characters per token (English text average)
- * - Claude Opus pricing: ~$15/M input tokens, ~$75/M output tokens
- * - We estimate a blended rate of ~$30/M tokens for simplicity
- *
- * Since the Stop event provides limited session info, this hook
- * primarily serves as a reminder to check actual usage.
+ * Token estimation: ~4 chars/token, blended rate ~$30/M tokens.
  */
 
 import { readFileSync, existsSync, readdirSync, statSync } from "fs";
 import { join } from "path";
+import { writeHookEvent } from "../../../src/lib/db-writer";
 
 interface HookInput {
   session_id: string;
@@ -33,10 +28,7 @@ interface HookOutput {
   continue: boolean;
 }
 
-/** Approximate cost per million tokens (blended input/output estimate) */
 const BLENDED_COST_PER_MILLION_TOKENS = 30;
-
-/** Average characters per token */
 const CHARS_PER_TOKEN = 4;
 
 function readStdinJson(): HookInput | null {
@@ -59,8 +51,8 @@ function getBudget(): number | null {
 
   const budget = parseFloat(budgetStr);
   if (isNaN(budget) || budget <= 0) {
-    console.error(
-      `[hook-costwatch] Invalid COST_WATCH_BUDGET value: "${budgetStr}". Must be a positive number.`
+    process.stderr.write(
+      `[hook-costwatch] Invalid COST_WATCH_BUDGET value: "${budgetStr}". Must be a positive number.\n`
     );
     return null;
   }
@@ -74,12 +66,10 @@ function estimateTranscriptCost(transcriptPath: string): {
 } | null {
   try {
     if (!existsSync(transcriptPath)) return null;
-
     const stat = statSync(transcriptPath);
     const charCount = stat.size;
     const estimatedTokens = Math.ceil(charCount / CHARS_PER_TOKEN);
     const estimatedCost = (estimatedTokens / 1_000_000) * BLENDED_COST_PER_MILLION_TOKENS;
-
     return { charCount, estimatedTokens, estimatedCost };
   } catch {
     return null;
@@ -87,7 +77,6 @@ function estimateTranscriptCost(transcriptPath: string): {
 }
 
 function findSessionTranscript(cwd: string, sessionId: string): string | null {
-  // Check common transcript locations
   const possibleDirs = [
     join(cwd, ".claude"),
     join(process.env.HOME || "", ".claude", "projects"),
@@ -98,9 +87,8 @@ function findSessionTranscript(cwd: string, sessionId: string): string | null {
     try {
       const files = readdirSync(dir, { recursive: true }) as string[];
       for (const file of files) {
-        const filePath = join(dir, file);
         if (typeof file === "string" && file.includes(sessionId)) {
-          return filePath;
+          return join(dir, file);
         }
       }
     } catch {
@@ -121,19 +109,13 @@ export function run(): void {
 
   const budget = getBudget();
 
-  // Try to estimate cost from transcript
-  let estimate: {
-    charCount: number;
-    estimatedTokens: number;
-    estimatedCost: number;
-  } | null = null;
+  let estimate: { charCount: number; estimatedTokens: number; estimatedCost: number } | null = null;
 
   if (input.transcript_path) {
     estimate = estimateTranscriptCost(input.transcript_path);
   }
 
   if (!estimate) {
-    // Try to find transcript by session ID
     const transcriptPath = findSessionTranscript(input.cwd, input.session_id);
     if (transcriptPath) {
       estimate = estimateTranscriptCost(transcriptPath);
@@ -143,31 +125,46 @@ export function run(): void {
   if (estimate) {
     const costStr = estimate.estimatedCost.toFixed(2);
     const tokensStr = (estimate.estimatedTokens / 1000).toFixed(1);
+    const budgetExceeded = budget !== null && estimate.estimatedCost > budget;
 
-    console.error(`[hook-costwatch] Session estimate: ~${tokensStr}K tokens, ~$${costStr}`);
+    process.stderr.write(`[hook-costwatch] Session estimate: ~${tokensStr}K tokens, ~$${costStr}\n`);
 
-    if (budget !== null && estimate.estimatedCost > budget) {
-      console.error(
-        `[hook-costwatch] WARNING: Estimated cost ($${costStr}) exceeds budget ($${budget.toFixed(2)})!`
-      );
-      console.error(
-        `[hook-costwatch] Check your actual usage at https://console.anthropic.com/`
+    if (budgetExceeded) {
+      process.stderr.write(
+        `[hook-costwatch] WARNING: Estimated cost ($${costStr}) exceeds budget ($${budget!.toFixed(2)})!\n`
       );
+      process.stderr.write(`[hook-costwatch] Check your actual usage at https://console.anthropic.com/\n`);
     }
+
+    writeHookEvent({
+      session_id: input.session_id,
+      hook_name: "costwatch",
+      event_type: "Stop",
+      project_dir: input.cwd,
+      metadata: JSON.stringify({
+        char_count: estimate.charCount,
+        estimated_tokens: estimate.estimatedTokens,
+        estimated_cost_usd: estimate.estimatedCost,
+        budget_usd: budget,
+        budget_exceeded: budgetExceeded,
+      }),
+    });
   } else {
-    console.error(
-      `[hook-costwatch] Could not estimate session cost (no transcript found).`
-    );
+    process.stderr.write(`[hook-costwatch] Could not estimate session cost (no transcript found).\n`);
+
+    writeHookEvent({
+      session_id: input.session_id,
+      hook_name: "costwatch",
+      event_type: "Stop",
+      project_dir: input.cwd,
+      metadata: JSON.stringify({ error: "no_transcript", budget_usd: budget }),
+    });
   }
 
   if (budget !== null) {
-    console.error(
-      `[hook-costwatch] Budget: $${budget.toFixed(2)}/session. Remember to check actual usage.`
-    );
+    process.stderr.write(`[hook-costwatch] Budget: $${budget.toFixed(2)}/session. Remember to check actual usage.\n`);
   } else {
-    console.error(
-      `[hook-costwatch] No budget set. Set COST_WATCH_BUDGET env var to enable budget warnings.`
-    );
+    process.stderr.write(`[hook-costwatch] No budget set. Set COST_WATCH_BUDGET env var to enable budget warnings.\n`);
   }
 
   respond({ continue: true });

package/hooks/hook-errornotify/src/hook.ts

@@ -3,16 +3,13 @@
 /**
  * Claude Code Hook: errornotify
  *
- * PostToolUse hook that detects tool failures and logs errors.
- * Checks tool output for error indicators (non-zero exit codes,
- * error messages) and logs warnings to stderr. Optionally writes
- * to a .claude/errors.log file for persistent error tracking.
- *
+ * PostToolUse hook that detects tool failures and logs errors to SQLite (~/.hooks/hooks.db).
+ * Also writes warnings to stderr for immediate terminal visibility.
  * Never blocks — always outputs { continue: true }.
  */
 
-import { readFileSync, appendFileSync, mkdirSync, existsSync } from "fs";
-import { join } from "path";
+import { readFileSync } from "fs";
+import { writeHookEvent } from "../../../src/lib/db-writer";
 
 interface HookInput {
   session_id: string;
@@ -26,9 +23,6 @@ interface HookOutput {
   continue: true;
 }
 
-/**
- * Read and parse JSON from stdin
- */
 function readStdinJson(): HookInput | null {
   try {
     const input = readFileSync(0, "utf-8").trim();
@@ -39,31 +33,19 @@ function readStdinJson(): HookInput | null {
   }
 }
 
-/**
- * Check if the tool output indicates a failure
- */
 function detectError(input: HookInput): { isError: boolean; message: string } {
   const output = input.tool_output || {};
 
-  // Check for explicit exit code
   const exitCode = output.exit_code ?? output.exitCode ?? output.code;
   if (exitCode !== undefined && exitCode !== null && exitCode !== 0) {
     const stderr = (output.stderr as string) || (output.output as string) || "unknown error";
-    return {
-      isError: true,
-      message: `Exit code ${exitCode}: ${truncate(stderr, 200)}`,
-    };
+    return { isError: true, message: `Exit code ${exitCode}: ${truncate(stderr, 200)}` };
   }
 
-  // Check for error field
   if (output.error && typeof output.error === "string") {
-    return {
-      isError: true,
-      message: `Error: ${truncate(output.error, 200)}`,
-    };
+    return { isError: true, message: `Error: ${truncate(output.error, 200)}` };
   }
 
-  // Check output text for common error indicators
   const outputText =
     (output.stderr as string) ||
     (output.output as string) ||
@@ -72,7 +54,6 @@ function detectError(input: HookInput): { isError: boolean; message: string } {
     "";
 
   if (typeof outputText === "string" && outputText.length > 0) {
-    // Check for common error patterns in output
     const errorPatterns = [
       /^error:/im,
       /^fatal:/im,
@@ -98,13 +79,9 @@ function detectError(input: HookInput): { isError: boolean; message: string } {
 
     for (const pattern of errorPatterns) {
       if (pattern.test(outputText)) {
-        // Extract the first relevant line
         const lines = outputText.split("\n").filter((l: string) => l.trim());
         const errorLine = lines.find((l: string) => pattern.test(l)) || lines[0] || "";
-        return {
-          isError: true,
-          message: truncate(errorLine.trim(), 200),
-        };
+        return { isError: true, message: truncate(errorLine.trim(), 200) };
       }
     }
   }
@@ -112,17 +89,11 @@ function detectError(input: HookInput): { isError: boolean; message: string } {
   return { isError: false, message: "" };
 }
 
-/**
- * Truncate a string to a maximum length
- */
 function truncate(str: string, maxLen: number): string {
   if (str.length <= maxLen) return str;
   return str.slice(0, maxLen) + "...";
 }
 
-/**
- * Get a human-readable description of what was being executed
- */
 function getToolContext(input: HookInput): string {
   const toolName = input.tool_name;
   const toolInput = input.tool_input || {};
@@ -140,36 +111,11 @@ function getToolContext(input: HookInput): string {
   }
 }
 
-/**
- * Write error to .claude/errors.log
- */
-function writeErrorLog(cwd: string, toolContext: string, errorMessage: string, sessionId: string): void {
-  try {
-    const claudeDir = join(cwd, ".claude");
-    if (!existsSync(claudeDir)) {
-      mkdirSync(claudeDir, { recursive: true });
-    }
-
-    const logFile = join(claudeDir, "errors.log");
-    const timestamp = new Date().toISOString();
-    const entry = `[${timestamp}] [session:${sessionId.slice(0, 8)}] ${toolContext} — ${errorMessage}\n`;
-    appendFileSync(logFile, entry);
-  } catch {
-    // Silently fail — logging should never cause issues
-  }
-}
-
-/**
- * Output hook response
- */
 function respond(): void {
   const output: HookOutput = { continue: true };
   console.log(JSON.stringify(output));
 }
 
-/**
- * Main hook execution
- */
 export function run(): void {
   const input = readStdinJson();
 
@@ -182,11 +128,20 @@ export function run(): void {
 
   if (isError) {
     const toolContext = getToolContext(input);
-    console.error(`[hook-errornotify] FAILURE in ${toolContext}`);
-    console.error(`[hook-errornotify] ${message}`);
 
-    // Write to persistent error log
-    writeErrorLog(input.cwd, toolContext, message, input.session_id);
+    // Keep stderr warnings for immediate terminal visibility
+    process.stderr.write(`[hook-errornotify] FAILURE in ${toolContext}\n`);
+    process.stderr.write(`[hook-errornotify] ${message}\n`);
+
+    writeHookEvent({
+      session_id: input.session_id,
+      hook_name: "errornotify",
+      event_type: "PostToolUse",
+      tool_name: input.tool_name,
+      tool_input: JSON.stringify(input.tool_input),
+      error: message,
+      project_dir: input.cwd,
+    });
   }
 
   respond();

package/hooks/hook-sessionlog/src/hook.ts

@@ -3,18 +3,11 @@
 /**
  * Claude Code Hook: sessionlog
  *
- * PostToolUse hook that logs every tool call to a session log file.
- * Creates .claude/session-log-<date>.jsonl in the project directory.
- *
- * Each line is a JSON object with:
- * - timestamp: ISO string
- * - tool_name: name of the tool that was called
- * - tool_input: first 500 characters of the stringified tool input
- * - session_id: current session ID
+ * PostToolUse hook that logs every tool call to SQLite (~/.hooks/hooks.db).
  */
 
-import { readFileSync, existsSync, mkdirSync, appendFileSync } from "fs";
-import { join } from "path";
+import { readFileSync } from "fs";
+import { writeHookEvent } from "../../../src/lib/db-writer";
 
 interface HookInput {
   session_id: string;
@@ -41,42 +34,6 @@ function respond(output: HookOutput): void {
   console.log(JSON.stringify(output));
 }
 
-function getDateString(): string {
-  const now = new Date();
-  const year = now.getFullYear();
-  const month = String(now.getMonth() + 1).padStart(2, "0");
-  const day = String(now.getDate()).padStart(2, "0");
-  return `${year}-${month}-${day}`;
-}
-
-function truncate(str: string, maxLength: number): string {
-  if (str.length <= maxLength) return str;
-  return str.slice(0, maxLength) + "...";
-}
-
-function logToolCall(input: HookInput): void {
-  const claudeDir = join(input.cwd, ".claude");
-
-  // Create .claude/ directory if it doesn't exist
-  if (!existsSync(claudeDir)) {
-    mkdirSync(claudeDir, { recursive: true });
-  }
-
-  const dateStr = getDateString();
-  const logFile = join(claudeDir, `session-log-${dateStr}.jsonl`);
-
-  const toolInputStr = truncate(JSON.stringify(input.tool_input), 500);
-
-  const logEntry = {
-    timestamp: new Date().toISOString(),
-    tool_name: input.tool_name,
-    tool_input: toolInputStr,
-    session_id: input.session_id,
-  };
-
-  appendFileSync(logFile, JSON.stringify(logEntry) + "\n");
-}
-
 export function run(): void {
   const input = readStdinJson();
 
@@ -85,12 +42,14 @@ export function run(): void {
     return;
   }
 
-  try {
-    logToolCall(input);
-  } catch (error) {
-    const errMsg = error instanceof Error ? error.message : String(error);
-    console.error(`[hook-sessionlog] Warning: failed to log tool call: ${errMsg}`);
-  }
+  writeHookEvent({
+    session_id: input.session_id,
+    hook_name: "sessionlog",
+    event_type: "PostToolUse",
+    tool_name: input.tool_name,
+    tool_input: JSON.stringify(input.tool_input),
+    project_dir: input.cwd,
+  });
 
   respond({ continue: true });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/hooks",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "Open source hooks library for AI coding agents - Install safety, quality, and automation hooks with a single command",
   "type": "module",
   "bin": {