@hasna/hooks 0.0.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-phonenotify/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "lib": ["ESNext"],
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/hooks/hook-precompact/CLAUDE.md

@@ -0,0 +1,23 @@
+# CLAUDE.md
+
+## hook-precompact
+
+A PreCompact hook that saves session state before context compaction.
+
+### Key Files
+
+| File | Purpose |
+|------|---------|
+| `src/hook.ts` | Main hook logic — captures git state, writes handoff files |
+| `src/cli.ts` | CLI — install/uninstall/status/list/latest |
+
+### Hook Events
+
+- **PreCompact** — fires before context compaction
+
+### Behavior
+
+- Saves handoff files to `.claude-handoffs/` (auto-gitignored)
+- Captures: session ID, git branch/status/recent commits, timestamp
+- Maintains `latest.json` for quick access to most recent handoff
+- Non-blocking — failures are logged but don't interrupt

package/hooks/hook-precompact/README.md

@@ -0,0 +1,36 @@
+# hook-precompact
+
+Claude Code hook that saves session state before context compaction.
+
+## Overview
+
+When Claude Code compacts the context (to free up token space), important state can be lost. This hook saves a handoff file with session context, git state, and metadata before compaction occurs.
+
+## Installation
+
+```bash
+bun install -g @hasnaxyz/hook-precompact
+hook-precompact install
+```
+
+## Commands
+
+```bash
+hook-precompact install     # Install to Claude Code settings
+hook-precompact uninstall   # Remove hook
+hook-precompact status      # Check installation
+hook-precompact list        # Show recent handoffs
+hook-precompact latest      # Show latest handoff data
+```
+
+## What Gets Saved
+
+Each handoff file (`.claude-handoffs/`) contains:
+- Session ID and timestamp
+- Current working directory
+- Git branch, last commit, status, recent commits
+- Transcript summary (when available)
+
+## License
+
+MIT

package/hooks/hook-precompact/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@hasnaxyz/hook-precompact",
+  "version": "0.1.0",
+  "description": "Claude Code hook that saves session state before context compaction",
+  "type": "module",
+  "bin": {
+    "hook-precompact": "./dist/cli.js"
+  },
+  "main": "./dist/hook.js",
+  "exports": {
+    ".": {
+      "import": "./dist/hook.js",
+      "types": "./dist/hook.d.ts"
+    },
+    "./cli": {
+      "import": "./dist/cli.js"
+    }
+  },
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "build": "bun build ./src/cli.ts ./src/hook.ts --outdir ./dist --target node",
+    "prepublishOnly": "bun run build",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": ["claude-code", "claude", "hook", "precompact", "context", "session", "state", "cli"],
+  "author": "Hasna",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hasnaxyz/hook-precompact.git"
+  },
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": { "node": ">=18", "bun": ">=1.0" },
+  "devDependencies": {
+    "@types/bun": "^1.3.8",
+    "@types/node": "^20",
+    "typescript": "^5.0.0"
+  }
+}

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/hooks/hook-precompact/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "lib": ["ESNext"],
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@hasna/hooks",
+  "version": "0.0.1",
+  "description": "Open source Claude Code hooks library - Install hooks with a single command",
+  "type": "module",
+  "bin": {
+    "hooks": "./bin/index.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "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",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "claude-code",
+    "hooks",
+    "cli",
+    "typescript",
+    "bun",
+    "git-safety",
+    "code-quality",
+    "security"
+  ],
+  "author": "Hasna",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/react": "^18.2.0",
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "conf": "^13.0.1",
+    "ink": "^5.0.1",
+    "ink-select-input": "^6.0.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "react": "^18.2.0"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hasna/open-hooks.git"
+  }
+}