@hasna/hooks 0.0.1

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

@@ -0,0 +1,165 @@
+#!/usr/bin/env bun
+
+/**
+ * CLI for hook-packageage
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const HOOK_NAME = "hook-packageage";
+const SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
+
+interface ClaudeSettings {
+  hooks?: {
+    PreToolUse?: 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.PreToolUse) settings.hooks.PreToolUse = [];
+
+  const existing = settings.hooks.PreToolUse.find((h) =>
+    h.hooks.some((hook) => hook.command.includes(HOOK_NAME))
+  );
+
+  if (existing) {
+    console.log(`${HOOK_NAME} is already installed`);
+    return;
+  }
+
+  settings.hooks.PreToolUse.push({
+    matcher: "Bash",
+    hooks: [{ type: "command", command: `bunx @hasnaxyz/${HOOK_NAME}` }],
+  });
+
+  writeSettings(settings);
+  console.log(`${HOOK_NAME} installed successfully`);
+  console.log("Hook will check package age before npm/bun install commands");
+}
+
+function uninstall(): void {
+  const settings = readSettings();
+  if (!settings.hooks?.PreToolUse) {
+    console.log(`${HOOK_NAME} is not installed`);
+    return;
+  }
+
+  const before = settings.hooks.PreToolUse.length;
+  settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(
+    (h) => !h.hooks.some((hook) => hook.command.includes(HOOK_NAME))
+  );
+
+  if (before === settings.hooks.PreToolUse.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?.PreToolUse?.some((h) =>
+    h.hooks.some((hook) => hook.command.includes(HOOK_NAME))
+  );
+  console.log(`${HOOK_NAME} is ${installed ? "installed" : "not installed"}`);
+}
+
+async function check(packageName: string): Promise<void> {
+  console.log(`Checking ${packageName}...`);
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}`);
+    if (!response.ok) {
+      console.error(`Package not found: ${packageName}`);
+      return;
+    }
+    const data = await response.json() as Record<string, unknown>;
+    const time = data.time as Record<string, string> | undefined;
+    const modified = time?.modified;
+    if (modified) {
+      const days = Math.floor((Date.now() - new Date(modified).getTime()) / (1000 * 60 * 60 * 24));
+      const status = days > 730 ? "ABANDONED" : days > 365 ? "STALE" : "ACTIVE";
+      console.log(`  Last updated: ${modified} (${days} days ago) — ${status}`);
+    }
+
+    const distTags = data["dist-tags"] as Record<string, string> | undefined;
+    const latestVersion = distTags?.latest;
+    const versions = data.versions as Record<string, Record<string, unknown>> | undefined;
+    if (latestVersion && versions?.[latestVersion]?.deprecated) {
+      console.log(`  DEPRECATED: ${versions[latestVersion].deprecated}`);
+    }
+  } catch (error) {
+    console.error(`Error checking ${packageName}:`, error);
+  }
+}
+
+function help(): void {
+  console.log(`
+${HOOK_NAME} - Check package age before install
+
+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
+  check <pkg>     Manually check a package's age
+  help            Show this help message
+
+Thresholds:
+  > 1 year since last publish: STALE warning
+  > 2 years since last publish: ABANDONED warning
+  Deprecated packages: always warned
+`);
+}
+
+const command = process.argv[2];
+
+switch (command) {
+  case "install": install(); break;
+  case "uninstall": uninstall(); break;
+  case "status": status(); break;
+  case "check":
+    if (process.argv[3]) {
+      check(process.argv[3]);
+    } else {
+      console.error("Usage: hook-packageage check <package-name>");
+      process.exit(1);
+    }
+    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-packageage/src/hook.ts

@@ -0,0 +1,177 @@
+#!/usr/bin/env bun
+
+/**
+ * Claude Code Hook: packageage
+ *
+ * PreToolUse hook that checks package age before npm/bun install commands.
+ * Warns on packages that haven't been updated in over a year (potentially
+ * abandoned) or have known deprecation markers.
+ *
+ * Checks the npm registry for last publish date and warns accordingly.
+ */
+
+import { readFileSync } from "fs";
+
+interface HookInput {
+  session_id: string;
+  cwd: string;
+  tool_name: string;
+  tool_input: Record<string, unknown>;
+}
+
+interface HookOutput {
+  decision?: "approve" | "block";
+  reason?: string;
+}
+
+const INSTALL_PATTERNS = [
+  /(?:npm|bun|yarn|pnpm)\s+(?:install|add|i)\s+/,
+];
+
+const STALE_THRESHOLD_DAYS = 365; // 1 year
+const ABANDONED_THRESHOLD_DAYS = 730; // 2 years
+
+function readStdinJson(): HookInput | null {
+  try {
+    const input = readFileSync(0, "utf-8").trim();
+    if (!input) return null;
+    return JSON.parse(input);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract package names from an install command
+ */
+function extractPackageNames(command: string): string[] {
+  // Match: npm install pkg1 pkg2 / bun add pkg1 / etc.
+  const match = command.match(/(?:npm|bun|yarn|pnpm)\s+(?:install|add|i)\s+(.*)/);
+  if (!match) return [];
+
+  return match[1]
+    .split(/\s+/)
+    .filter((arg) => !arg.startsWith("-") && !arg.startsWith("--"))
+    .map((pkg) => pkg.replace(/@[\^~><=\d].*$/, "")) // strip version specifier
+    .filter((pkg) => pkg.length > 0 && !pkg.startsWith(".")); // filter paths
+}
+
+/**
+ * Check package age via npm registry
+ */
+async function checkPackageAge(packageName: string): Promise<{
+  name: string;
+  lastPublish: Date | null;
+  daysSincePublish: number;
+  deprecated: boolean;
+  error?: string;
+}> {
+  try {
+    const response = await fetch(
+      `https://registry.npmjs.org/${encodeURIComponent(packageName)}`,
+      { signal: AbortSignal.timeout(5000) }
+    );
+
+    if (!response.ok) {
+      return { name: packageName, lastPublish: null, daysSincePublish: 0, deprecated: false, error: `HTTP ${response.status}` };
+    }
+
+    const data = await response.json() as Record<string, unknown>;
+
+    // Check deprecation
+    const distTags = data["dist-tags"] as Record<string, string> | undefined;
+    const latestVersion = distTags?.latest;
+    const versions = data.versions as Record<string, Record<string, unknown>> | undefined;
+    const deprecated = latestVersion && versions?.[latestVersion]?.deprecated ? true : false;
+
+    // Get last publish date
+    const time = data.time as Record<string, string> | undefined;
+    const modified = time?.modified;
+
+    if (!modified) {
+      return { name: packageName, lastPublish: null, daysSincePublish: 0, deprecated };
+    }
+
+    const lastPublish = new Date(modified);
+    const daysSincePublish = Math.floor(
+      (Date.now() - lastPublish.getTime()) / (1000 * 60 * 60 * 24)
+    );
+
+    return { name: packageName, lastPublish, daysSincePublish, deprecated };
+  } catch (error) {
+    return {
+      name: packageName,
+      lastPublish: null,
+      daysSincePublish: 0,
+      deprecated: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+function respond(output: HookOutput): void {
+  console.log(JSON.stringify(output));
+}
+
+export async function run(): Promise<void> {
+  const input = readStdinJson();
+
+  if (!input) {
+    respond({ decision: "approve" });
+    return;
+  }
+
+  if (input.tool_name !== "Bash") {
+    respond({ decision: "approve" });
+    return;
+  }
+
+  const command = input.tool_input?.command as string;
+  if (!command || typeof command !== "string") {
+    respond({ decision: "approve" });
+    return;
+  }
+
+  // Check if this is a package install command
+  const isInstall = INSTALL_PATTERNS.some((p) => p.test(command));
+  if (!isInstall) {
+    respond({ decision: "approve" });
+    return;
+  }
+
+  const packages = extractPackageNames(command);
+  if (packages.length === 0) {
+    respond({ decision: "approve" });
+    return;
+  }
+
+  const warnings: string[] = [];
+
+  // Check each package (in parallel, with timeout)
+  const results = await Promise.all(packages.map(checkPackageAge));
+
+  for (const result of results) {
+    if (result.deprecated) {
+      warnings.push(`${result.name}: DEPRECATED`);
+    }
+    if (result.daysSincePublish > ABANDONED_THRESHOLD_DAYS) {
+      warnings.push(`${result.name}: possibly abandoned (last updated ${result.daysSincePublish} days ago)`);
+    } else if (result.daysSincePublish > STALE_THRESHOLD_DAYS) {
+      warnings.push(`${result.name}: stale (last updated ${result.daysSincePublish} days ago)`);
+    }
+  }
+
+  if (warnings.length > 0) {
+    const reason = `Package age warnings:\n${warnings.map((w) => `  - ${w}`).join("\n")}\n\nConsider using more actively maintained alternatives.`;
+    console.error(`[hook-packageage] ${reason}`);
+    // Warn but don't block — just inject the warning
+    respond({ decision: "approve", reason });
+    return;
+  }
+
+  respond({ decision: "approve" });
+}
+
+if (import.meta.main) {
+  run();
+}

package/hooks/hook-packageage/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-phonenotify/CLAUDE.md

@@ -0,0 +1,25 @@
+# CLAUDE.md
+
+## hook-phonenotify
+
+A Stop/Notification hook that sends push notifications to phone via ntfy.sh.
+
+### Key Files
+
+| File | Purpose |
+|------|---------|
+| `src/hook.ts` | Main hook logic — reads stdin, sends ntfy.sh notification |
+| `src/cli.ts` | CLI — install/uninstall/status/test |
+
+### Hook Events
+
+- **Stop** — notifies when Claude finishes
+- **Notification** — notifies when Claude needs attention
+
+### Configuration
+
+Reads `phoneNotifyConfig` from `~/.claude/settings.json`:
+- `topic` — ntfy.sh topic name (required)
+- `server` — ntfy server URL (default: https://ntfy.sh)
+- `priority` — notification priority 1-5 (default: 3)
+- `enabled` — toggle on/off

package/hooks/hook-phonenotify/README.md

@@ -0,0 +1,44 @@
+# hook-phonenotify
+
+Claude Code hook that sends push notifications to your phone via ntfy.sh.
+
+## Overview
+
+Get notified on your phone when Claude finishes a task or needs your attention. Uses [ntfy.sh](https://ntfy.sh) for free, no-account-required push notifications.
+
+## Installation
+
+```bash
+bun install -g @hasnaxyz/hook-phonenotify
+hook-phonenotify install my-secret-topic
+```
+
+Then subscribe to `my-secret-topic` in the ntfy app on your phone.
+
+## Commands
+
+```bash
+hook-phonenotify install [topic]  # Install with ntfy topic
+hook-phonenotify uninstall        # Remove hook
+hook-phonenotify status           # Show config
+hook-phonenotify test             # Send test notification
+```
+
+## Configuration
+
+In `~/.claude/settings.json`:
+
+```json
+{
+  "phoneNotifyConfig": {
+    "enabled": true,
+    "topic": "your-secret-topic",
+    "server": "https://ntfy.sh",
+    "priority": 3
+  }
+}
+```
+
+## License
+
+MIT

package/hooks/hook-phonenotify/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@hasnaxyz/hook-phonenotify",
+  "version": "0.1.0",
+  "description": "Claude Code hook that sends push notifications to phone via ntfy.sh",
+  "type": "module",
+  "bin": {
+    "hook-phonenotify": "./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", "notifications", "phone", "ntfy", "push", "cli"],
+  "author": "Hasna",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hasnaxyz/hook-phonenotify.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-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);
+    }
+}