@hasna/hooks 0.0.1

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

@@ -0,0 +1,148 @@
+#!/usr/bin/env bun
+
+/**
+ * Claude Code Hook: contextrefresh
+ *
+ * UserPromptSubmit hook that re-injects important context every N prompts
+ * to prevent context decay in long sessions.
+ *
+ * Reads context from .claude-context file in project root and injects
+ * it as a system message every N user prompts. Tracks prompt count
+ * in a persistent counter file.
+ */
+
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { tmpdir } from "os";
+
+interface HookInput {
+  session_id: string;
+  cwd: string;
+  hook_event_name: string;
+  user_prompt?: string;
+}
+
+interface HookOutput {
+  continue?: boolean;
+  suppressPrompt?: boolean;
+  updatedPrompt?: string;
+}
+
+interface RefreshConfig {
+  enabled?: boolean;
+  interval?: number;
+  contextFile?: string;
+}
+
+const CONFIG_KEY = "contextRefreshConfig";
+const COUNTER_DIR = join(tmpdir(), "hook-contextrefresh");
+
+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(): RefreshConfig {
+  const settingsPath = join(homedir(), ".claude", "settings.json");
+  try {
+    if (existsSync(settingsPath)) {
+      const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+      return settings[CONFIG_KEY] || { enabled: true, interval: 10 };
+    }
+  } catch {}
+  return { enabled: true, interval: 10 };
+}
+
+function getPromptCount(sessionId: string): number {
+  mkdirSync(COUNTER_DIR, { recursive: true });
+  const counterFile = join(COUNTER_DIR, `${sessionId}.count`);
+  try {
+    if (existsSync(counterFile)) {
+      return parseInt(readFileSync(counterFile, "utf-8").trim(), 10) || 0;
+    }
+  } catch {}
+  return 0;
+}
+
+function setPromptCount(sessionId: string, count: number): void {
+  mkdirSync(COUNTER_DIR, { recursive: true });
+  const counterFile = join(COUNTER_DIR, `${sessionId}.count`);
+  writeFileSync(counterFile, String(count));
+}
+
+function getContextContent(cwd: string, contextFile?: string): string | null {
+  // Try configured context file, then defaults
+  const candidates = [
+    contextFile ? join(cwd, contextFile) : null,
+    join(cwd, ".claude-context"),
+    join(cwd, ".claude-refresh"),
+  ].filter(Boolean) as string[];
+
+  for (const path of candidates) {
+    if (existsSync(path)) {
+      try {
+        return readFileSync(path, "utf-8").trim();
+      } catch {}
+    }
+  }
+
+  return null;
+}
+
+function respond(output: HookOutput): void {
+  console.log(JSON.stringify(output));
+}
+
+export function run(): void {
+  const input = readStdinJson();
+
+  if (!input) {
+    respond({ continue: true });
+    return;
+  }
+
+  const config = getConfig();
+
+  if (!config.enabled) {
+    respond({ continue: true });
+    return;
+  }
+
+  const interval = config.interval || 10;
+  const count = getPromptCount(input.session_id) + 1;
+  setPromptCount(input.session_id, count);
+
+  // Check if it's time to inject context
+  if (count % interval !== 0) {
+    respond({ continue: true });
+    return;
+  }
+
+  const contextContent = getContextContent(input.cwd, config.contextFile);
+
+  if (!contextContent) {
+    respond({ continue: true });
+    return;
+  }
+
+  // Inject context by prepending it to the user's prompt
+  const refreshPrefix = `[Context Refresh - Prompt #${count}]\n${contextContent}\n\n---\n\n`;
+  const updatedPrompt = input.user_prompt
+    ? `${refreshPrefix}${input.user_prompt}`
+    : undefined;
+
+  respond({
+    continue: true,
+    updatedPrompt,
+  });
+}
+
+if (import.meta.main) {
+  run();
+}

package/hooks/hook-contextrefresh/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-gitguard/CLAUDE.md

@@ -0,0 +1,22 @@
+# CLAUDE.md
+
+## hook-gitguard
+
+A PreToolUse hook that blocks destructive git operations.
+
+### Key Files
+
+| File | Purpose |
+|------|---------|
+| `src/hook.ts` | Main hook logic — pattern matching against dangerous git commands |
+| `src/cli.ts` | CLI — install/uninstall/status/test |
+
+### Hook Events
+
+- **PreToolUse** (matcher: `Bash`)
+
+### Behavior
+
+- Checks Bash commands for destructive git patterns
+- Blocks: reset --hard, push --force, checkout ., clean -f, branch -D, stash drop/clear
+- Approves all non-git commands immediately

package/hooks/hook-gitguard/README.md

@@ -0,0 +1,30 @@
+# hook-gitguard
+
+Claude Code hook that blocks destructive git operations.
+
+## Overview
+
+Prevents Claude from running irreversible git commands like `git reset --hard`, `git push --force`, `git checkout .`, `git clean -f`, and more.
+
+## Installation
+
+```bash
+bun install -g @hasnaxyz/hook-gitguard
+hook-gitguard install
+```
+
+## Blocked Operations
+
+- `git reset --hard` — discards all uncommitted changes
+- `git push --force` / `-f` — overwrites remote history
+- `git checkout .` / `git checkout -- .` — discards working directory
+- `git restore .` — discards working directory changes
+- `git clean -f` — removes untracked files permanently
+- `git branch -D` — force deletes branch without merge check
+- `git stash drop` / `clear` — permanently deletes stash entries
+- `git reflog expire` / `delete` — destroys recovery points
+- `git gc --prune=now` — permanently removes unreachable objects
+
+## License
+
+MIT

package/hooks/hook-gitguard/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@hasnaxyz/hook-gitguard",
+  "version": "0.1.0",
+  "description": "Claude Code hook that blocks destructive git operations",
+  "type": "module",
+  "bin": {
+    "hook-gitguard": "./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",
+    "git",
+    "safety",
+    "guard",
+    "destructive",
+    "cli"
+  ],
+  "author": "Hasna",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hasnaxyz/hook-gitguard.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-gitguard/src/cli.ts

@@ -0,0 +1,159 @@
+#!/usr/bin/env bun
+
+/**
+ * CLI for hook-gitguard
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const HOOK_NAME = "hook-gitguard";
+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 block destructive git operations");
+}
+
+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"}`);
+}
+
+function test(command: string): void {
+  const PATTERNS: Array<{ pattern: RegExp; description: string }> = [
+    { pattern: /git\s+reset\s+--hard/, description: "git reset --hard" },
+    { pattern: /git\s+push\s+.*--force(?!-)/, description: "git push --force" },
+    { pattern: /git\s+push\s+.*\s-f\b/, description: "git push -f" },
+    { pattern: /git\s+checkout\s+\.\s*$/, description: "git checkout ." },
+    { pattern: /git\s+checkout\s+--\s+\./, description: "git checkout -- ." },
+    { pattern: /git\s+clean\s+(-[a-zA-Z]*f|--force)/, description: "git clean -f" },
+    { pattern: /git\s+branch\s+-D\s/, description: "git branch -D" },
+    { pattern: /git\s+stash\s+(drop|clear)/, description: "git stash drop/clear" },
+  ];
+
+  for (const { pattern, description } of PATTERNS) {
+    if (pattern.test(command)) {
+      console.log(`BLOCKED: ${description}`);
+      return;
+    }
+  }
+  console.log("ALLOWED");
+}
+
+function help(): void {
+  console.log(`
+${HOOK_NAME} - Block destructive git operations in Claude Code
+
+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
+  test <cmd>  Test if a git command would be blocked
+  help        Show this help message
+
+Blocked operations:
+  git reset --hard          git push --force / -f
+  git checkout .            git checkout -- .
+  git clean -f              git branch -D
+  git stash drop/clear      git reflog expire/delete
+`);
+}
+
+const command = process.argv[2];
+
+switch (command) {
+  case "install": install(); break;
+  case "uninstall": uninstall(); break;
+  case "status": status(); break;
+  case "test":
+    if (process.argv[3]) {
+      test(process.argv.slice(3).join(" "));
+    } else {
+      console.error("Usage: hook-gitguard test <command>");
+      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-gitguard/src/hook.ts

@@ -0,0 +1,129 @@
+#!/usr/bin/env bun
+
+/**
+ * Claude Code Hook: gitguard
+ *
+ * PreToolUse hook that blocks destructive git operations:
+ * - git reset --hard
+ * - git push --force / -f (especially to main/master)
+ * - git checkout . / git checkout -- .
+ * - git clean -f / -fd
+ * - git branch -D (force delete)
+ * - git stash drop / clear
+ * - git rebase without caution
+ */
+
+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 DESTRUCTIVE_PATTERNS: Array<{ pattern: RegExp; description: string }> = [
+  // git reset --hard
+  { pattern: /git\s+reset\s+--hard/, description: "git reset --hard (discards all uncommitted changes)" },
+
+  // git push --force (any variant)
+  { pattern: /git\s+push\s+.*--force-with-lease/, description: "git push --force-with-lease (force push with safety)" },
+  { pattern: /git\s+push\s+.*--force(?!-)/, description: "git push --force (overwrites remote history)" },
+  { pattern: /git\s+push\s+.*\s-f\b/, description: "git push -f (force push)" },
+
+  // Force push to main/master specifically
+  { pattern: /git\s+push\s+.*--force.*\s+(main|master)\b/, description: "force push to main/master" },
+  { pattern: /git\s+push\s+.*-f\s+.*(main|master)\b/, description: "force push to main/master" },
+
+  // git checkout . / git checkout -- . (discard all changes)
+  { pattern: /git\s+checkout\s+\.\s*$/, description: "git checkout . (discards all working directory changes)" },
+  { pattern: /git\s+checkout\s+--\s+\./, description: "git checkout -- . (discards all working directory changes)" },
+
+  // git restore . (discard all changes)
+  { pattern: /git\s+restore\s+\.\s*$/, description: "git restore . (discards all working directory changes)" },
+  { pattern: /git\s+restore\s+--staged\s+--worktree\s+\./, description: "git restore --staged --worktree . (discards everything)" },
+
+  // git clean -f (remove untracked files)
+  { pattern: /git\s+clean\s+(-[a-zA-Z]*f|--force)/, description: "git clean -f (removes untracked files permanently)" },
+
+  // git branch -D (force delete branch)
+  { pattern: /git\s+branch\s+-D\s/, description: "git branch -D (force delete branch without merge check)" },
+
+  // git stash drop/clear
+  { pattern: /git\s+stash\s+drop/, description: "git stash drop (permanently deletes stash entry)" },
+  { pattern: /git\s+stash\s+clear/, description: "git stash clear (deletes all stash entries)" },
+
+  // git reflog expire/delete
+  { pattern: /git\s+reflog\s+(expire|delete)/, description: "git reflog expire/delete (destroys recovery points)" },
+
+  // git gc --prune=now
+  { pattern: /git\s+gc\s+--prune=now/, description: "git gc --prune=now (permanently removes unreachable objects)" },
+];
+
+function readStdinJson(): HookInput | null {
+  try {
+    const input = readFileSync(0, "utf-8").trim();
+    if (!input) return null;
+    return JSON.parse(input);
+  } catch {
+    return null;
+  }
+}
+
+function checkDestructiveGit(command: string): { blocked: boolean; reason?: string } {
+  for (const { pattern, description } of DESTRUCTIVE_PATTERNS) {
+    if (pattern.test(command)) {
+      return { blocked: true, reason: `Blocked: ${description}` };
+    }
+  }
+  return { blocked: false };
+}
+
+function respond(output: HookOutput): void {
+  console.log(JSON.stringify(output));
+}
+
+export function run(): 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;
+  }
+
+  // Only check commands that contain "git"
+  if (!command.includes("git")) {
+    respond({ decision: "approve" });
+    return;
+  }
+
+  const result = checkDestructiveGit(command);
+
+  if (result.blocked) {
+    console.error(`[hook-gitguard] ${result.reason}`);
+    respond({ decision: "block", reason: result.reason });
+    return;
+  }
+
+  respond({ decision: "approve" });
+}
+
+if (import.meta.main) {
+  run();
+}

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

@@ -0,0 +1,23 @@
+# CLAUDE.md
+
+## hook-packageage
+
+A PreToolUse hook that checks package age before npm/bun install commands.
+
+### Key Files
+
+| File | Purpose |
+|------|---------|
+| `src/hook.ts` | Main hook logic — extracts packages from commands, checks npm registry |
+| `src/cli.ts` | CLI — install/uninstall/status/check |
+
+### Hook Events
+
+- **PreToolUse** (matcher: `Bash`)
+
+### Behavior
+
+- Parses npm/bun/yarn/pnpm install commands to extract package names
+- Checks each package against npm registry for last publish date
+- Warns on stale (>1yr), abandoned (>2yr), or deprecated packages
+- Non-blocking — warns but always approves (packages may still be valid)

package/hooks/hook-packageage/README.md

@@ -0,0 +1,33 @@
+# hook-packageage
+
+Claude Code hook that checks package age before install to warn on outdated or abandoned packages.
+
+## Overview
+
+Before `npm install`, `bun add`, `yarn add`, or `pnpm add`, this hook checks each package against the npm registry and warns if packages are stale (>1 year) or potentially abandoned (>2 years).
+
+## Installation
+
+```bash
+bun install -g @hasnaxyz/hook-packageage
+hook-packageage install
+```
+
+## Commands
+
+```bash
+hook-packageage install       # Install to Claude Code settings
+hook-packageage uninstall     # Remove hook
+hook-packageage status        # Check installation
+hook-packageage check <pkg>   # Manually check a package
+```
+
+## Thresholds
+
+- **>1 year** since last publish: STALE warning
+- **>2 years** since last publish: ABANDONED warning
+- **Deprecated** packages: always warned
+
+## License
+
+MIT

package/hooks/hook-packageage/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@hasnaxyz/hook-packageage",
+  "version": "0.1.0",
+  "description": "Claude Code hook that checks package age before install to warn on outdated or abandoned packages",
+  "type": "module",
+  "bin": {
+    "hook-packageage": "./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", "package", "age", "outdated", "abandoned", "npm", "cli"],
+  "author": "Hasna",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hasnaxyz/hook-packageage.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"
+  }
+}