@hasna/hooks 0.0.4 → 0.0.6

package/hooks/hook-phonenotify/src/cli.ts

@@ -0,0 +1,196 @@
+#!/usr/bin/env bun
+
+/**
+ * CLI for hook-phonenotify
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const HOOK_NAME = "hook-phonenotify";
+const SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
+
+interface ClaudeSettings {
+  hooks?: {
+    Stop?: Array<{ matcher?: string; hooks: Array<{ type: "command"; command: string }> }>;
+    Notification?: Array<{ matcher?: string; hooks: Array<{ type: "command"; command: string }> }>;
+  };
+  phoneNotifyConfig?: {
+    enabled?: boolean;
+    topic?: string;
+    server?: string;
+    priority?: number;
+  };
+  [key: string]: unknown;
+}
+
+function readSettings(): ClaudeSettings {
+  try {
+    if (existsSync(SETTINGS_PATH)) {
+      return JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
+    }
+  } catch {}
+  return {};
+}
+
+function writeSettings(settings: ClaudeSettings): void {
+  const dir = join(homedir(), ".claude");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+}
+
+function install(topic?: string): void {
+  const settings = readSettings();
+  if (!settings.hooks) settings.hooks = {};
+  if (!settings.hooks.Stop) settings.hooks.Stop = [];
+  if (!settings.hooks.Notification) settings.hooks.Notification = [];
+
+  const hookCommand = `bunx @hasnaxyz/${HOOK_NAME}`;
+
+  const existing = settings.hooks.Stop.find((h) =>
+    h.hooks.some((hook) => hook.command.includes(HOOK_NAME))
+  );
+
+  if (existing) {
+    console.log(`${HOOK_NAME} is already installed`);
+    return;
+  }
+
+  settings.hooks.Stop.push({
+    hooks: [{ type: "command", command: hookCommand }],
+  });
+  settings.hooks.Notification.push({
+    hooks: [{ type: "command", command: hookCommand }],
+  });
+
+  if (!settings.phoneNotifyConfig) {
+    settings.phoneNotifyConfig = {
+      enabled: true,
+      topic: topic || "claude-code",
+      server: "https://ntfy.sh",
+      priority: 3,
+    };
+  }
+
+  writeSettings(settings);
+  console.log(`${HOOK_NAME} installed successfully`);
+  console.log(`Topic: ${settings.phoneNotifyConfig.topic}`);
+  console.log(`\nTo receive notifications, subscribe to your topic in the ntfy app:`);
+  console.log(`  https://ntfy.sh/${settings.phoneNotifyConfig.topic}`);
+}
+
+function uninstall(): void {
+  const settings = readSettings();
+  let removed = false;
+
+  if (settings.hooks?.Stop) {
+    const before = settings.hooks.Stop.length;
+    settings.hooks.Stop = settings.hooks.Stop.filter(
+      (h) => !h.hooks.some((hook) => hook.command.includes(HOOK_NAME))
+    );
+    if (before !== settings.hooks.Stop.length) removed = true;
+  }
+
+  if (settings.hooks?.Notification) {
+    const before = settings.hooks.Notification.length;
+    settings.hooks.Notification = settings.hooks.Notification.filter(
+      (h) => !h.hooks.some((hook) => hook.command.includes(HOOK_NAME))
+    );
+    if (before !== settings.hooks.Notification.length) removed = true;
+  }
+
+  if (!removed) {
+    console.log(`${HOOK_NAME} is not installed`);
+    return;
+  }
+
+  writeSettings(settings);
+  console.log(`${HOOK_NAME} uninstalled successfully`);
+}
+
+function status(): void {
+  const settings = readSettings();
+  const installed = settings.hooks?.Stop?.some((h) =>
+    h.hooks.some((hook) => hook.command.includes(HOOK_NAME))
+  );
+  console.log(`${HOOK_NAME} is ${installed ? "installed" : "not installed"}`);
+
+  if (settings.phoneNotifyConfig) {
+    console.log(`\nConfig:`);
+    console.log(`  Enabled: ${settings.phoneNotifyConfig.enabled !== false}`);
+    console.log(`  Topic: ${settings.phoneNotifyConfig.topic || "(not set)"}`);
+    console.log(`  Server: ${settings.phoneNotifyConfig.server || "https://ntfy.sh"}`);
+    console.log(`  Priority: ${settings.phoneNotifyConfig.priority || 3}`);
+  }
+}
+
+async function test(): Promise<void> {
+  console.log("Sending test notification...");
+  const settings = readSettings();
+  const config = settings.phoneNotifyConfig;
+
+  if (!config?.topic) {
+    console.error("No topic configured. Run: hook-phonenotify install <topic>");
+    process.exit(1);
+  }
+
+  const server = config.server || "https://ntfy.sh";
+  const url = `${server}/${config.topic}`;
+
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      Title: "Claude Code - Test",
+      Priority: String(config.priority || 3),
+      Tags: "robot,test_tube",
+    },
+    body: "This is a test notification from hook-phonenotify.",
+  });
+
+  if (response.ok) {
+    console.log("Test notification sent!");
+  } else {
+    console.error(`Failed: ${response.status} ${response.statusText}`);
+  }
+}
+
+function help(): void {
+  console.log(`
+${HOOK_NAME} - Push notifications to phone via ntfy.sh
+
+Usage: ${HOOK_NAME} <command>
+
+Commands:
+  install [topic]  Install hook (optional: set ntfy topic)
+  uninstall        Remove hook from Claude Code settings
+  status           Check if hook is installed and show config
+  test             Send a test notification
+  help             Show this help message
+
+Setup:
+  1. Install the ntfy app on your phone (iOS/Android)
+  2. Subscribe to your chosen topic
+  3. Run: ${HOOK_NAME} install my-secret-topic
+`);
+}
+
+const command = process.argv[2];
+
+switch (command) {
+  case "install": install(process.argv[3]); break;
+  case "uninstall": uninstall(); break;
+  case "status": status(); break;
+  case "test": test(); break;
+  case "help":
+  case "--help":
+  case "-h": help(); break;
+  default:
+    if (!command) {
+      import("./hook.ts").then((m) => m.run());
+    } else {
+      console.error(`Unknown command: ${command}`);
+      help();
+      process.exit(1);
+    }
+}

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

@@ -0,0 +1,139 @@
+#!/usr/bin/env bun
+
+/**
+ * Claude Code Hook: phonenotify
+ *
+ * Stop/Notification hook that sends push notifications to your phone
+ * via ntfy.sh when Claude finishes a task or needs your attention.
+ *
+ * Configure via ~/.claude/settings.json:
+ * {
+ *   "phoneNotifyConfig": {
+ *     "enabled": true,
+ *     "topic": "claude-code-YOUR_SECRET",
+ *     "server": "https://ntfy.sh",
+ *     "priority": 3
+ *   }
+ * }
+ */
+
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+interface HookInput {
+  session_id: string;
+  cwd: string;
+  hook_event_name: string;
+  notification_type?: string;
+  message?: string;
+}
+
+interface HookOutput {
+  continue?: boolean;
+}
+
+interface PhoneNotifyConfig {
+  enabled?: boolean;
+  topic?: string;
+  server?: string;
+  priority?: number;
+}
+
+const CONFIG_KEY = "phoneNotifyConfig";
+
+function readStdinJson(): HookInput | null {
+  try {
+    const input = readFileSync(0, "utf-8").trim();
+    if (!input) return null;
+    return JSON.parse(input);
+  } catch {
+    return null;
+  }
+}
+
+function getConfig(): PhoneNotifyConfig {
+  const settingsPath = join(homedir(), ".claude", "settings.json");
+  try {
+    if (existsSync(settingsPath)) {
+      const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+      return settings[CONFIG_KEY] || {};
+    }
+  } catch {}
+  return {};
+}
+
+async function sendNotification(
+  config: PhoneNotifyConfig,
+  title: string,
+  message: string
+): Promise<void> {
+  const server = config.server || "https://ntfy.sh";
+  const topic = config.topic;
+
+  if (!topic) {
+    console.error("[hook-phonenotify] No topic configured. Set phoneNotifyConfig.topic in settings.");
+    return;
+  }
+
+  const url = `${server}/${topic}`;
+
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Title: title,
+        Priority: String(config.priority || 3),
+        Tags: "robot",
+      },
+      body: message,
+    });
+
+    if (!response.ok) {
+      console.error(`[hook-phonenotify] Failed to send: ${response.status}`);
+    }
+  } catch (error) {
+    console.error(`[hook-phonenotify] Send failed: ${error}`);
+  }
+}
+
+function respond(output: HookOutput): void {
+  console.log(JSON.stringify(output));
+}
+
+export async function run(): Promise<void> {
+  const input = readStdinJson();
+
+  if (!input) {
+    respond({ continue: true });
+    return;
+  }
+
+  const config = getConfig();
+
+  if (!config.enabled) {
+    respond({ continue: true });
+    return;
+  }
+
+  let title = "Claude Code";
+  let message = "";
+
+  if (input.hook_event_name === "Stop") {
+    title = "Claude Code - Done";
+    message = "Claude has finished and is waiting for your response.";
+  } else if (input.hook_event_name === "Notification") {
+    title = "Claude Code - Attention";
+    message = input.message || "Claude Code requires your attention.";
+  } else {
+    respond({ continue: true });
+    return;
+  }
+
+  await sendNotification(config, title, message);
+  respond({ continue: true });
+}
+
+if (import.meta.main) {
+  run();
+}

package/hooks/hook-precompact/src/cli.ts

@@ -0,0 +1,168 @@
+#!/usr/bin/env bun
+
+/**
+ * CLI for hook-precompact
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const HOOK_NAME = "hook-precompact";
+const SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
+const HANDOFF_DIR = ".claude-handoffs";
+
+interface ClaudeSettings {
+  hooks?: {
+    PreCompact?: Array<{
+      matcher?: string;
+      hooks: Array<{ type: "command"; command: string }>;
+    }>;
+  };
+  [key: string]: unknown;
+}
+
+function readSettings(): ClaudeSettings {
+  try {
+    if (existsSync(SETTINGS_PATH)) {
+      return JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
+    }
+  } catch {}
+  return {};
+}
+
+function writeSettings(settings: ClaudeSettings): void {
+  const dir = join(homedir(), ".claude");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+}
+
+function install(): void {
+  const settings = readSettings();
+  if (!settings.hooks) settings.hooks = {};
+  if (!settings.hooks.PreCompact) settings.hooks.PreCompact = [];
+
+  const existing = settings.hooks.PreCompact.find((h) =>
+    h.hooks.some((hook) => hook.command.includes(HOOK_NAME))
+  );
+
+  if (existing) {
+    console.log(`${HOOK_NAME} is already installed`);
+    return;
+  }
+
+  settings.hooks.PreCompact.push({
+    hooks: [{ type: "command", command: `bunx @hasnaxyz/${HOOK_NAME}` }],
+  });
+
+  writeSettings(settings);
+  console.log(`${HOOK_NAME} installed successfully`);
+  console.log("Hook will save session state before context compaction");
+}
+
+function uninstall(): void {
+  const settings = readSettings();
+  if (!settings.hooks?.PreCompact) {
+    console.log(`${HOOK_NAME} is not installed`);
+    return;
+  }
+
+  const before = settings.hooks.PreCompact.length;
+  settings.hooks.PreCompact = settings.hooks.PreCompact.filter(
+    (h) => !h.hooks.some((hook) => hook.command.includes(HOOK_NAME))
+  );
+
+  if (before === settings.hooks.PreCompact.length) {
+    console.log(`${HOOK_NAME} is not installed`);
+    return;
+  }
+
+  writeSettings(settings);
+  console.log(`${HOOK_NAME} uninstalled successfully`);
+}
+
+function status(): void {
+  const settings = readSettings();
+  const installed = settings.hooks?.PreCompact?.some((h) =>
+    h.hooks.some((hook) => hook.command.includes(HOOK_NAME))
+  );
+  console.log(`${HOOK_NAME} is ${installed ? "installed" : "not installed"}`);
+}
+
+function list(): void {
+  const handoffDir = join(process.cwd(), HANDOFF_DIR);
+  if (!existsSync(handoffDir)) {
+    console.log("No handoffs found in current directory");
+    return;
+  }
+
+  const files = readdirSync(handoffDir)
+    .filter((f) => f.startsWith("handoff-") && f.endsWith(".json"))
+    .sort()
+    .reverse();
+
+  if (files.length === 0) {
+    console.log("No handoffs found");
+    return;
+  }
+
+  console.log(`Recent handoffs (${files.length} total):\n`);
+  for (const file of files.slice(0, 10)) {
+    try {
+      const data = JSON.parse(readFileSync(join(handoffDir, file), "utf-8"));
+      console.log(`  ${data.timestamp} | session: ${data.session_id} | branch: ${data.git?.branch || "?"}`);
+    } catch {
+      console.log(`  ${file} (unreadable)`);
+    }
+  }
+}
+
+function latest(): void {
+  const latestPath = join(process.cwd(), HANDOFF_DIR, "latest.json");
+  if (!existsSync(latestPath)) {
+    console.log("No handoffs found");
+    return;
+  }
+
+  const data = JSON.parse(readFileSync(latestPath, "utf-8"));
+  console.log(JSON.stringify(data, null, 2));
+}
+
+function help(): void {
+  console.log(`
+${HOOK_NAME} - Save session state before context compaction
+
+Usage: ${HOOK_NAME} <command>
+
+Commands:
+  install     Install hook to Claude Code settings
+  uninstall   Remove hook from Claude Code settings
+  status      Check if hook is installed
+  list        Show recent handoffs in current directory
+  latest      Show the latest handoff data
+  help        Show this help message
+
+Handoff files are saved in .claude-handoffs/ (gitignored).
+`);
+}
+
+const command = process.argv[2];
+
+switch (command) {
+  case "install": install(); break;
+  case "uninstall": uninstall(); break;
+  case "status": status(); break;
+  case "list": list(); break;
+  case "latest": latest(); break;
+  case "help":
+  case "--help":
+  case "-h": help(); break;
+  default:
+    if (!command) {
+      import("./hook.ts").then((m) => m.run());
+    } else {
+      console.error(`Unknown command: ${command}`);
+      help();
+      process.exit(1);
+    }
+}

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

@@ -0,0 +1,122 @@
+#!/usr/bin/env bun
+
+/**
+ * Claude Code Hook: precompact
+ *
+ * PreCompact hook that saves session state/handoff data before
+ * context compaction to prevent information loss in long sessions.
+ *
+ * Creates timestamped handoff files in .claude-handoffs/ with:
+ * - Session ID and timestamp
+ * - Current working directory
+ * - Git branch and recent changes
+ * - Task list state (if any)
+ * - Environment context
+ */
+
+import { readFileSync, existsSync, mkdirSync, writeFileSync, appendFileSync } from "fs";
+import { execSync } from "child_process";
+import { join } from "path";
+
+interface HookInput {
+  session_id: string;
+  cwd: string;
+  hook_event_name: string;
+  transcript_summary?: string;
+}
+
+interface HookOutput {
+  continue?: boolean;
+}
+
+const HANDOFF_DIR = ".claude-handoffs";
+
+function readStdinJson(): HookInput | null {
+  try {
+    const input = readFileSync(0, "utf-8").trim();
+    if (!input) return null;
+    return JSON.parse(input);
+  } catch {
+    return null;
+  }
+}
+
+function safeExec(cmd: string, cwd: string): string {
+  try {
+    return execSync(cmd, { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+  } catch {
+    return "";
+  }
+}
+
+function getGitContext(cwd: string): Record<string, string> {
+  const branch = safeExec("git rev-parse --abbrev-ref HEAD", cwd);
+  const lastCommit = safeExec("git log -1 --oneline", cwd);
+  const status = safeExec("git status --short", cwd);
+  const recentCommits = safeExec("git log -5 --oneline", cwd);
+
+  return { branch, lastCommit, status, recentCommits };
+}
+
+function createHandoff(input: HookInput): void {
+  const handoffDir = join(input.cwd, HANDOFF_DIR);
+  mkdirSync(handoffDir, { recursive: true });
+
+  // Ensure it's gitignored
+  const gitignorePath = join(input.cwd, ".gitignore");
+  if (existsSync(gitignorePath)) {
+    const content = readFileSync(gitignorePath, "utf-8");
+    if (!content.includes(HANDOFF_DIR)) {
+      appendFileSync(gitignorePath, `\n${HANDOFF_DIR}/\n`);
+    }
+  }
+
+  const timestamp = new Date().toISOString();
+  const gitContext = getGitContext(input.cwd);
+
+  const handoff = {
+    session_id: input.session_id,
+    timestamp,
+    cwd: input.cwd,
+    event: "PreCompact",
+    git: gitContext,
+    summary: input.transcript_summary || null,
+  };
+
+  // Write timestamped handoff file
+  const filename = `handoff-${timestamp.replace(/[:.]/g, "-")}.json`;
+  writeFileSync(join(handoffDir, filename), JSON.stringify(handoff, null, 2));
+
+  // Also write a "latest" file for easy access
+  writeFileSync(join(handoffDir, "latest.json"), JSON.stringify(handoff, null, 2));
+
+  // Append to log
+  const logEntry = `[${timestamp}] PreCompact handoff saved (session: ${input.session_id})\n`;
+  appendFileSync(join(handoffDir, "handoff.log"), logEntry);
+}
+
+function respond(output: HookOutput): void {
+  console.log(JSON.stringify(output));
+}
+
+export function run(): void {
+  const input = readStdinJson();
+
+  if (!input) {
+    respond({ continue: true });
+    return;
+  }
+
+  try {
+    createHandoff(input);
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    console.error(`[hook-precompact] Warning: handoff save failed: ${errMsg}`);
+  }
+
+  respond({ continue: true });
+}
+
+if (import.meta.main) {
+  run();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/hooks",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Open source Claude Code hooks library - Install hooks with a single command",
   "type": "module",
   "bin": {
@@ -17,6 +17,7 @@
   "scripts": {
     "build": "bun build ./src/cli/index.tsx --outdir ./bin --target bun --external ink --external react --external chalk --external conf && bun build ./src/index.ts --outdir ./dist --target bun",
     "dev": "bun run ./src/cli/index.tsx",
+    "test": "bun test",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "bun run build"
   },

package/.hooks/index.ts

@@ -1,6 +0,0 @@
-/**
- * Auto-generated index of installed hooks
- * Do not edit manually - run 'hooks install' to update
- */
-
-