@hasna/hooks 0.0.1

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

@@ -0,0 +1,334 @@
+#!/usr/bin/env bun
+
+/**
+ * Claude Code Hook: check-tests
+ *
+ * Runs a headless Claude Code agent to check for missing tests.
+ * Uses service-implementation CLI to dispatch tasks.
+ *
+ * This hook runs ASYNC (non-blocking) on PostToolUse.
+ * Only runs for repos matching [prefix]-[name] pattern.
+ *
+ * Configuration:
+ * - taskListId: task list for dispatching test tasks
+ * - editThreshold: run check after this many edits (default: 3, range: 3-7)
+ * - keywords: keywords that trigger the check (default: ["dev"])
+ * - enabled: enable/disable the hook
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { spawn } from "child_process";
+
+interface CheckTestsConfig {
+  taskListId?: string;
+  editThreshold?: number;
+  keywords?: string[];
+  enabled?: boolean;
+}
+
+interface HookInput {
+  session_id: string;
+  transcript_path: string;
+  cwd: string;
+  tool_name: string;
+  tool_input: Record<string, unknown>;
+  tool_output?: string;
+}
+
+interface SessionState {
+  editCount: number;
+  editedFiles: string[];
+  lastCheckRun: number;
+  checkInProgress: boolean;
+}
+
+const CONFIG_KEY = "checkTestsConfig";
+const STATE_DIR = join(homedir(), ".claude", "hook-state");
+const EDIT_TOOLS = ["Edit", "Write", "NotebookEdit"];
+
+/**
+ * Sanitize ID to prevent path traversal and injection attacks
+ */
+function sanitizeId(id: string): string {
+  if (!id || typeof id !== 'string') return 'default';
+  return id.replace(/[^a-zA-Z0-9_-]/g, '-').slice(0, 100) || 'default';
+}
+
+/**
+ * Sanitize file path for safe display in prompts
+ */
+function sanitizePath(path: string): string {
+  if (!path || typeof path !== 'string') return '';
+  return path.replace(/[`$"'\\;&|<>(){}[\]!#*?~]/g, '_');
+}
+
+const TESTS_PROMPT = `You are a test coverage reviewer. Review the following files that were recently edited and identify missing or incomplete tests:
+
+FILES TO REVIEW:
+{files}
+
+For each test coverage issue found, create a task using the service-implementation CLI:
+service-implementation task dispatch "{taskListId}" -s "TEST: [brief description]" -d "[detailed description of what tests need to be added]"
+
+Focus on:
+- Missing unit tests for new functions/methods
+- Missing integration tests for new features
+- Missing edge case tests
+- Missing error handling tests
+- Untested code paths
+- Missing mock/stub implementations
+- Missing test fixtures or setup
+- Missing API endpoint tests
+- Missing validation tests
+
+If no test coverage issues are found, do not create any tasks.
+Only create tasks for meaningful test gaps, not trivial ones.
+Limit to max 5 most important test tasks.`;
+
+function isValidRepoPattern(cwd: string): boolean {
+  const dirName = cwd.split("/").filter(Boolean).pop() || "";
+  // Match: hook-checklint, skill-installhook, iapp-mail, etc.
+  return /^[a-z]+-[a-z0-9-]+$/i.test(dirName);
+}
+
+function readStdinJson(): HookInput | null {
+  try {
+    const stdin = readFileSync(0, "utf-8");
+    return JSON.parse(stdin);
+  } catch {
+    return null;
+  }
+}
+
+function readSettings(path: string): Record<string, unknown> {
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function getConfig(cwd: string): CheckTestsConfig {
+  // Try project settings first
+  const projectSettings = readSettings(join(cwd, ".claude", "settings.json"));
+  if (projectSettings[CONFIG_KEY]) {
+    return projectSettings[CONFIG_KEY] as CheckTestsConfig;
+  }
+
+  // Fall back to global settings
+  const globalSettings = readSettings(join(homedir(), ".claude", "settings.json"));
+  if (globalSettings[CONFIG_KEY]) {
+    return globalSettings[CONFIG_KEY] as CheckTestsConfig;
+  }
+
+  // Default config
+  return {
+    editThreshold: 3,
+    keywords: ["dev"],
+    enabled: true,
+  };
+}
+
+function getStateFile(sessionId: string): string {
+  mkdirSync(STATE_DIR, { recursive: true });
+  const safeSessionId = sanitizeId(sessionId);
+  return join(STATE_DIR, `checktests-${safeSessionId}.json`);
+}
+
+function getSessionState(sessionId: string): SessionState {
+  const stateFile = getStateFile(sessionId);
+  if (existsSync(stateFile)) {
+    try {
+      return JSON.parse(readFileSync(stateFile, "utf-8"));
+    } catch {
+      // Corrupted state, reset
+    }
+  }
+  return { editCount: 0, editedFiles: [], lastCheckRun: 0, checkInProgress: false };
+}
+
+function saveSessionState(sessionId: string, state: SessionState): void {
+  const stateFile = getStateFile(sessionId);
+  writeFileSync(stateFile, JSON.stringify(state, null, 2));
+}
+
+function getSessionName(transcriptPath: string): string | null {
+  if (!existsSync(transcriptPath)) return null;
+
+  try {
+    const content = readFileSync(transcriptPath, "utf-8");
+    let lastTitle: string | null = null;
+    let searchStart = 0;
+
+    while (true) {
+      const titleIndex = content.indexOf('"custom-title"', searchStart);
+      if (titleIndex === -1) break;
+
+      const lineStart = content.lastIndexOf("\n", titleIndex) + 1;
+      const lineEnd = content.indexOf("\n", titleIndex);
+      const line = content.slice(lineStart, lineEnd === -1 ? undefined : lineEnd);
+
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === "custom-title" && entry.customTitle) {
+          lastTitle = entry.customTitle;
+        }
+      } catch {
+        // Skip malformed lines
+      }
+
+      searchStart = titleIndex + 1;
+    }
+
+    return lastTitle;
+  } catch {
+    return null;
+  }
+}
+
+function getProjectTaskListId(cwd: string): string | null {
+  const dirName = cwd.split("/").filter(Boolean).pop() || "";
+  return `${dirName}-qa`;
+}
+
+function runHeadlessTestsCheck(
+  cwd: string,
+  files: string[],
+  taskListId: string
+): void {
+  // Sanitize file paths to prevent prompt injection
+  const filesFormatted = files.map((f) => `- ${sanitizePath(f)}`).join("\n");
+  // Sanitize taskListId
+  const safeTaskListId = sanitizeId(taskListId);
+
+  const prompt = TESTS_PROMPT
+    .replace("{files}", filesFormatted)
+    .replace("{taskListId}", safeTaskListId);
+
+  // Spawn headless Claude Code agent in background
+  const child = spawn(
+    "claude",
+    [
+      "-p",
+      prompt,
+      "--permission-mode",
+      "acceptEdits",
+      "--allowedTools",
+      "Bash,Read",
+      "--no-session-persistence",
+    ],
+    {
+      cwd,
+      detached: true,
+      stdio: "ignore",
+    }
+  );
+
+  // Detach from parent process
+  child.unref();
+
+  console.error(`[hook-checktests] Started tests check for ${files.length} files`);
+}
+
+function approve() {
+  console.log(JSON.stringify({ decision: "approve" }));
+  process.exit(0);
+}
+
+export function run() {
+  const hookInput = readStdinJson();
+  if (!hookInput) {
+    approve();
+    return;
+  }
+
+  const { session_id, cwd, tool_name, tool_input, transcript_path } = hookInput;
+
+  // Only process edit tools
+  if (!EDIT_TOOLS.includes(tool_name)) {
+    approve();
+    return;
+  }
+
+  // Check repo pattern - only run for [prefix]-[name] folders
+  if (!isValidRepoPattern(cwd)) {
+    approve();
+    return;
+  }
+
+  const config = getConfig(cwd);
+
+  // Check if hook is disabled
+  if (config.enabled === false) {
+    approve();
+    return;
+  }
+
+  // Check keywords match
+  const sessionName = transcript_path ? getSessionName(transcript_path) : null;
+  const nameToCheck = sessionName || config.taskListId || "";
+  const keywords = config.keywords || ["dev"];
+
+  const matchesKeyword = keywords.some((keyword) =>
+    nameToCheck.toLowerCase().includes(keyword.toLowerCase())
+  );
+
+  // If keywords are configured and we have a session name, check for match
+  if (keywords.length > 0 && nameToCheck && !matchesKeyword) {
+    approve();
+    return;
+  }
+
+  // Get edited file path
+  const filePath = (tool_input.file_path || tool_input.notebook_path) as string | undefined;
+  if (!filePath) {
+    approve();
+    return;
+  }
+
+  // Update session state
+  const state = getSessionState(session_id);
+
+  // Skip if check already in progress
+  if (state.checkInProgress) {
+    approve();
+    return;
+  }
+
+  state.editCount++;
+
+  if (!state.editedFiles.includes(filePath)) {
+    state.editedFiles.push(filePath);
+  }
+
+  const threshold = Math.min(7, Math.max(3, config.editThreshold || 3));
+
+  // Check if we should run tests check
+  if (state.editCount >= threshold) {
+    const taskListId = config.taskListId || getProjectTaskListId(cwd) || "default-qa";
+
+    // Mark check in progress
+    state.checkInProgress = true;
+    saveSessionState(session_id, state);
+
+    // Run headless tests check (async, non-blocking)
+    runHeadlessTestsCheck(cwd, state.editedFiles, taskListId);
+
+    // Reset counter after starting check
+    state.editCount = 0;
+    state.editedFiles = [];
+    state.lastCheckRun = Date.now();
+    state.checkInProgress = false;
+  }
+
+  saveSessionState(session_id, state);
+  approve();
+}
+
+// Allow direct execution
+if (import.meta.main) {
+  run();
+}

package/hooks/hook-checktests/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "./dist",
+    "declaration": true,
+    "declarationMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/hooks/hook-contextrefresh/CLAUDE.md

@@ -0,0 +1,23 @@
+# CLAUDE.md
+
+## hook-contextrefresh
+
+A UserPromptSubmit hook that re-injects important context every N prompts.
+
+### Key Files
+
+| File | Purpose |
+|------|---------|
+| `src/hook.ts` | Main hook logic — tracks prompt count, injects context |
+| `src/cli.ts` | CLI — install/uninstall/status |
+
+### Hook Events
+
+- **UserPromptSubmit** — fires before Claude processes each user prompt
+
+### Behavior
+
+- Tracks prompt count per session in temp files
+- Every N prompts, reads `.claude-context` from project root
+- Prepends context to user's prompt as a refresh
+- Configurable interval and context file path

package/hooks/hook-contextrefresh/README.md

@@ -0,0 +1,42 @@
+# hook-contextrefresh
+
+Claude Code hook that re-injects important context every N prompts to prevent context decay.
+
+## Overview
+
+In long Claude Code sessions, important instructions can drift out of the active context window. This hook automatically re-injects content from a `.claude-context` file every N user prompts.
+
+## Installation
+
+```bash
+bun install -g @hasnaxyz/hook-contextrefresh
+hook-contextrefresh install 10  # inject every 10 prompts
+```
+
+Then create `.claude-context` in your project root with the context you want refreshed.
+
+## Commands
+
+```bash
+hook-contextrefresh install [N]  # Install with interval (default: 10)
+hook-contextrefresh uninstall    # Remove hook
+hook-contextrefresh status       # Show config
+```
+
+## Configuration
+
+In `~/.claude/settings.json`:
+
+```json
+{
+  "contextRefreshConfig": {
+    "enabled": true,
+    "interval": 10,
+    "contextFile": ".claude-context"
+  }
+}
+```
+
+## License
+
+MIT

package/hooks/hook-contextrefresh/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@hasnaxyz/hook-contextrefresh",
+  "version": "0.1.0",
+  "description": "Claude Code hook that re-injects important context every N prompts to prevent context decay",
+  "type": "module",
+  "bin": {
+    "hook-contextrefresh": "./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", "context", "refresh", "memory", "cli"],
+  "author": "Hasna",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hasnaxyz/hook-contextrefresh.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-contextrefresh/src/cli.ts

@@ -0,0 +1,152 @@
+#!/usr/bin/env bun
+
+/**
+ * CLI for hook-contextrefresh
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const HOOK_NAME = "hook-contextrefresh";
+const SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
+
+interface ClaudeSettings {
+  hooks?: {
+    UserPromptSubmit?: Array<{
+      matcher?: string;
+      hooks: Array<{ type: "command"; command: string }>;
+    }>;
+  };
+  contextRefreshConfig?: {
+    enabled?: boolean;
+    interval?: number;
+    contextFile?: 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(interval?: string): void {
+  const settings = readSettings();
+  if (!settings.hooks) settings.hooks = {};
+  if (!settings.hooks.UserPromptSubmit) settings.hooks.UserPromptSubmit = [];
+
+  const existing = settings.hooks.UserPromptSubmit.find((h) =>
+    h.hooks.some((hook) => hook.command.includes(HOOK_NAME))
+  );
+
+  if (existing) {
+    console.log(`${HOOK_NAME} is already installed`);
+    return;
+  }
+
+  settings.hooks.UserPromptSubmit.push({
+    hooks: [{ type: "command", command: `bunx @hasnaxyz/${HOOK_NAME}` }],
+  });
+
+  if (!settings.contextRefreshConfig) {
+    settings.contextRefreshConfig = {
+      enabled: true,
+      interval: interval ? parseInt(interval, 10) : 10,
+    };
+  }
+
+  writeSettings(settings);
+  console.log(`${HOOK_NAME} installed successfully`);
+  console.log(`Interval: every ${settings.contextRefreshConfig.interval} prompts`);
+  console.log(`\nCreate a .claude-context file in your project root with the context to inject.`);
+}
+
+function uninstall(): void {
+  const settings = readSettings();
+  if (!settings.hooks?.UserPromptSubmit) {
+    console.log(`${HOOK_NAME} is not installed`);
+    return;
+  }
+
+  const before = settings.hooks.UserPromptSubmit.length;
+  settings.hooks.UserPromptSubmit = settings.hooks.UserPromptSubmit.filter(
+    (h) => !h.hooks.some((hook) => hook.command.includes(HOOK_NAME))
+  );
+
+  if (before === settings.hooks.UserPromptSubmit.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?.UserPromptSubmit?.some((h) =>
+    h.hooks.some((hook) => hook.command.includes(HOOK_NAME))
+  );
+  console.log(`${HOOK_NAME} is ${installed ? "installed" : "not installed"}`);
+
+  if (settings.contextRefreshConfig) {
+    console.log(`\nConfig:`);
+    console.log(`  Enabled: ${settings.contextRefreshConfig.enabled !== false}`);
+    console.log(`  Interval: every ${settings.contextRefreshConfig.interval || 10} prompts`);
+    console.log(`  Context file: ${settings.contextRefreshConfig.contextFile || ".claude-context"}`);
+  }
+
+  // Check if context file exists
+  const contextFile = join(process.cwd(), ".claude-context");
+  console.log(`\nContext file: ${existsSync(contextFile) ? "found" : "not found"} (${contextFile})`);
+}
+
+function help(): void {
+  console.log(`
+${HOOK_NAME} - Re-inject context every N prompts
+
+Usage: ${HOOK_NAME} <command>
+
+Commands:
+  install [N]   Install hook (optional: set interval, default 10)
+  uninstall     Remove hook from Claude Code settings
+  status        Check if hook is installed and show config
+  help          Show this help message
+
+Setup:
+  1. Run: ${HOOK_NAME} install
+  2. Create .claude-context in your project root
+  3. Add important context/rules to that file
+  4. Context is re-injected every N prompts automatically
+`);
+}
+
+const command = process.argv[2];
+
+switch (command) {
+  case "install": install(process.argv[3]); break;
+  case "uninstall": uninstall(); break;
+  case "status": status(); 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);
+    }
+}