@hasna/hooks 0.0.1 → 0.0.2

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

@@ -1,473 +0,0 @@
-#!/usr/bin/env bun
-
-/**
- * Claude Code Hook: check-lint
- *
- * Runs linting after every N file edits and creates tasks for errors.
- *
- * Configuration priority:
- * 1. settings.json checkLintConfig (project or global)
- * 2. Environment variables (legacy)
- *
- * Config options:
- * - taskListId: task list for creating lint error tasks (default: auto-detect bugfixes list)
- * - lintCommand: lint command to run (default: auto-detect)
- * - editThreshold: run lint 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, readdirSync } from "fs";
-import { join, dirname } from "path";
-import { homedir } from "os";
-import { execSync } from "child_process";
-
-interface CheckLintConfig {
-  taskListId?: string;
-  lintCommand?: string;
-  editThreshold?: number;
-  keywords?: string[];
-  enabled?: boolean;
-  createTasks?: boolean;
-}
-
-interface HookInput {
-  session_id: string;
-  transcript_path: string;
-  cwd: string;
-  tool_name: string;
-  tool_input: Record<string, unknown>;
-  tool_output?: string;
-}
-
-interface LintError {
-  file: string;
-  line: number;
-  column: number;
-  message: string;
-  rule?: string;
-  severity: "error" | "warning";
-}
-
-interface SessionState {
-  editCount: number;
-  editedFiles: string[];
-  lastLintRun: number;
-}
-
-const CONFIG_KEY = "checkLintConfig";
-const STATE_DIR = join(homedir(), ".claude", "hook-state");
-const EDIT_TOOLS = ["Edit", "Write", "NotebookEdit"];
-
-// Allowed lint commands - whitelist approach for security
-const ALLOWED_LINT_COMMANDS = [
-  "bun lint",
-  "bun lint:check",
-  "bun eslint",
-  "bun biome check",
-  "bunx @biomejs/biome check .",
-  "bunx eslint .",
-  "npm run lint",
-  "npm run lint:check",
-  "npx eslint .",
-  "npx @biomejs/biome check .",
-];
-
-/**
- * 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';
-}
-
-/**
- * Validate lint command against whitelist to prevent command injection
- */
-function isValidLintCommand(cmd: string): boolean {
-  if (!cmd || typeof cmd !== 'string') return false;
-  return ALLOWED_LINT_COMMANDS.some(allowed =>
-    cmd === allowed || cmd.startsWith(allowed + " ")
-  );
-}
-
-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): CheckLintConfig {
-  // Try project settings first
-  const projectSettings = readSettings(join(cwd, ".claude", "settings.json"));
-  if (projectSettings[CONFIG_KEY]) {
-    return projectSettings[CONFIG_KEY] as CheckLintConfig;
-  }
-
-  // Fall back to global settings
-  const globalSettings = readSettings(join(homedir(), ".claude", "settings.json"));
-  if (globalSettings[CONFIG_KEY]) {
-    return globalSettings[CONFIG_KEY] as CheckLintConfig;
-  }
-
-  // Default config
-  return {
-    editThreshold: 3,
-    keywords: ["dev"],
-    enabled: true,
-    createTasks: true,
-  };
-}
-
-function getStateFile(sessionId: string): string {
-  mkdirSync(STATE_DIR, { recursive: true });
-  const safeSessionId = sanitizeId(sessionId);
-  return join(STATE_DIR, `checklint-${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: [], lastLintRun: 0 };
-}
-
-function saveSessionState(sessionId: string, state: SessionState): void {
-  const stateFile = getStateFile(sessionId);
-  writeFileSync(stateFile, JSON.stringify(state, null, 2));
-}
-
-function detectLintCommand(cwd: string): string | null {
-  const packageJsonPath = join(cwd, "package.json");
-  if (existsSync(packageJsonPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-      const scripts = pkg.scripts || {};
-
-      // Check for common lint script names
-      if (scripts.lint) return "bun lint";
-      if (scripts["lint:check"]) return "bun lint:check";
-      if (scripts.eslint) return "bun eslint";
-      if (scripts.biome) return "bun biome check";
-    } catch {
-      // Ignore parse errors
-    }
-  }
-
-  // Check for config files
-  if (existsSync(join(cwd, "biome.json")) || existsSync(join(cwd, "biome.jsonc"))) {
-    return "bunx @biomejs/biome check .";
-  }
-  if (existsSync(join(cwd, ".eslintrc.json")) || existsSync(join(cwd, ".eslintrc.js")) || existsSync(join(cwd, "eslint.config.js"))) {
-    return "bunx eslint .";
-  }
-
-  return null;
-}
-
-function runLint(cwd: string, command: string): { success: boolean; output: string } {
-  try {
-    const output = execSync(command, {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 60000, // 60s timeout
-    });
-    return { success: true, output };
-  } catch (error: unknown) {
-    const execError = error as { stdout?: string; stderr?: string };
-    const output = (execError.stdout || "") + (execError.stderr || "");
-    return { success: false, output };
-  }
-}
-
-function parseLintOutput(output: string): LintError[] {
-  const errors: LintError[] = [];
-  const lines = output.split("\n");
-
-  for (const line of lines) {
-    // ESLint format: /path/file.ts:10:5: error Message [rule-name]
-    // Biome format: path/file.ts:10:5 lint/rule ERROR message
-    // Common format: file:line:col: message
-
-    // Try ESLint/common format
-    const eslintMatch = line.match(/^(.+?):(\d+):(\d+):\s*(error|warning)\s+(.+?)(?:\s+\[(.+?)\])?$/i);
-    if (eslintMatch) {
-      errors.push({
-        file: eslintMatch[1],
-        line: parseInt(eslintMatch[2], 10),
-        column: parseInt(eslintMatch[3], 10),
-        severity: eslintMatch[4].toLowerCase() as "error" | "warning",
-        message: eslintMatch[5].trim(),
-        rule: eslintMatch[6],
-      });
-      continue;
-    }
-
-    // Try Biome format
-    const biomeMatch = line.match(/^(.+?):(\d+):(\d+)\s+(\w+\/\w+)\s+(ERROR|WARNING|WARN)\s+(.+)$/i);
-    if (biomeMatch) {
-      errors.push({
-        file: biomeMatch[1],
-        line: parseInt(biomeMatch[2], 10),
-        column: parseInt(biomeMatch[3], 10),
-        rule: biomeMatch[4],
-        severity: biomeMatch[5].toUpperCase().startsWith("ERR") ? "error" : "warning",
-        message: biomeMatch[6].trim(),
-      });
-      continue;
-    }
-
-    // Generic file:line:col format
-    const genericMatch = line.match(/^(.+?):(\d+):(\d+):\s*(.+)$/);
-    if (genericMatch && !genericMatch[1].startsWith(" ")) {
-      errors.push({
-        file: genericMatch[1],
-        line: parseInt(genericMatch[2], 10),
-        column: parseInt(genericMatch[3], 10),
-        severity: line.toLowerCase().includes("error") ? "error" : "warning",
-        message: genericMatch[4].trim(),
-      });
-    }
-  }
-
-  return errors;
-}
-
-function getProjectTaskList(cwd: string): string | null {
-  const tasksDir = join(homedir(), ".claude", "tasks");
-  if (!existsSync(tasksDir)) return null;
-
-  const dirName = cwd.split("/").filter(Boolean).pop() || "";
-
-  try {
-    const lists = readdirSync(tasksDir, { withFileTypes: true })
-      .filter((d) => d.isDirectory())
-      .map((d) => d.name);
-
-    // Look for a bugfixes list for this project
-    const bugfixList = lists.find((list) => {
-      const listLower = list.toLowerCase();
-      const dirLower = dirName.toLowerCase();
-      return listLower.startsWith(dirLower) && listLower.includes("bugfix");
-    });
-
-    if (bugfixList) return bugfixList;
-
-    // Fall back to dev list
-    const devList = lists.find((list) => {
-      const listLower = list.toLowerCase();
-      const dirLower = dirName.toLowerCase();
-      return listLower.startsWith(dirLower) && listLower.includes("dev");
-    });
-
-    return devList || null;
-  } catch {
-    return null;
-  }
-}
-
-function createTask(taskListId: string, error: LintError): void {
-  const tasksDir = join(homedir(), ".claude", "tasks", taskListId);
-  mkdirSync(tasksDir, { recursive: true });
-
-  const taskId = `lint-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const severity = error.severity === "error" ? "MEDIUM" : "LOW";
-  const ruleInfo = error.rule ? ` (${error.rule})` : "";
-
-  const task = {
-    id: taskId,
-    subject: `BUG: ${severity} - Fix lint ${error.severity} in ${error.file}:${error.line}`,
-    description: `Fix lint ${error.severity} at ${error.file}:${error.line}:${error.column}\n\n**Error:** ${error.message}${ruleInfo}\n\n**File:** ${error.file}\n**Line:** ${error.line}\n**Column:** ${error.column}${error.rule ? `\n**Rule:** ${error.rule}` : ""}\n\n**Acceptance criteria:**\n- Lint error is fixed\n- No new lint errors introduced`,
-    status: "pending",
-    createdAt: new Date().toISOString(),
-    metadata: {
-      source: "hook-checklint",
-      file: error.file,
-      line: error.line,
-      column: error.column,
-      rule: error.rule,
-      severity: error.severity,
-    },
-  };
-
-  const taskFile = join(tasksDir, `${taskId}.json`);
-  writeFileSync(taskFile, JSON.stringify(task, 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 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);
-  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 lint
-  if (state.editCount >= threshold) {
-    // Detect or use configured lint command
-    const lintCommand = config.lintCommand || detectLintCommand(cwd);
-
-    // Validate lint command against whitelist to prevent command injection
-    if (lintCommand && isValidLintCommand(lintCommand)) {
-      const { success, output } = runLint(cwd, lintCommand);
-
-      if (!success) {
-        const errors = parseLintOutput(output);
-
-        // Filter to errors in files we edited (optional - could check all)
-        const relevantErrors = errors.filter((e) =>
-          state.editedFiles.some((f) => f.endsWith(e.file) || e.file.endsWith(f.split("/").pop() || ""))
-        );
-
-        // Create tasks for lint errors if enabled
-        if (config.createTasks !== false && relevantErrors.length > 0) {
-          const taskListId = config.taskListId || getProjectTaskList(cwd);
-
-          if (taskListId) {
-            // Limit to first 5 errors to avoid task spam
-            const errorsToReport = relevantErrors.slice(0, 5);
-            for (const error of errorsToReport) {
-              createTask(taskListId, error);
-            }
-
-            // Log summary
-            console.error(
-              `[hook-checklint] Created ${errorsToReport.length} task(s) for lint errors in "${taskListId}"`
-            );
-            if (relevantErrors.length > 5) {
-              console.error(`[hook-checklint] (${relevantErrors.length - 5} more errors not reported)`);
-            }
-          }
-        }
-      }
-    }
-
-    // Reset counter after lint run
-    state.editCount = 0;
-    state.lastLintRun = Date.now();
-  }
-
-  saveSessionState(session_id, state);
-  approve();
-}
-
-// Allow direct execution
-if (import.meta.main) {
-  run();
-}

package/hooks/hook-checklint/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "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-checkpoint/src/cli.ts

@@ -1,191 +0,0 @@
-#!/usr/bin/env bun
-
-/**
- * CLI for hook-checkpoint
- */
-
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
-import { execSync } from "child_process";
-import { join } from "path";
-import { homedir } from "os";
-
-const HOOK_NAME = "hook-checkpoint";
-const SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
-const CHECKPOINT_DIR = ".claude-checkpoints";
-
-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: "Write|Edit|NotebookEdit",
-    hooks: [{ type: "command", command: `bunx @hasnaxyz/${HOOK_NAME}` }],
-  });
-
-  writeSettings(settings);
-  console.log(`${HOOK_NAME} installed successfully`);
-  console.log("Hook will create shadow git snapshots before Write/Edit/NotebookEdit");
-}
-
-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 list(): void {
-  const checkpointDir = join(process.cwd(), CHECKPOINT_DIR);
-  if (!existsSync(checkpointDir)) {
-    console.log("No checkpoints found in current directory");
-    return;
-  }
-
-  try {
-    const log = execSync("git log --oneline -20", {
-      cwd: checkpointDir,
-      encoding: "utf-8",
-    });
-    console.log("Recent checkpoints:");
-    console.log(log);
-  } catch {
-    console.log("No checkpoints found");
-  }
-}
-
-function restore(ref: string): void {
-  const checkpointDir = join(process.cwd(), CHECKPOINT_DIR);
-  if (!existsSync(checkpointDir)) {
-    console.log("No checkpoints found in current directory");
-    return;
-  }
-
-  try {
-    const files = execSync(`git show ${ref} --name-only --pretty=format:""`, {
-      cwd: checkpointDir,
-      encoding: "utf-8",
-    }).trim().split("\n").filter((f) => f.startsWith("files/"));
-
-    for (const file of files) {
-      const relativePath = file.replace("files/", "");
-      try {
-        const content = execSync(`git show ${ref}:${file}`, {
-          cwd: checkpointDir,
-        });
-        const targetPath = join(process.cwd(), relativePath);
-        writeFileSync(targetPath, content);
-        console.log(`Restored: ${relativePath}`);
-      } catch {
-        console.error(`Failed to restore: ${relativePath}`);
-      }
-    }
-  } catch (error) {
-    console.error(`Failed to restore from ${ref}:`, error);
-  }
-}
-
-function help(): void {
-  console.log(`
-${HOOK_NAME} - Shadow git snapshots for Claude Code file modifications
-
-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 checkpoints in current directory
-  restore <ref> Restore files from a checkpoint (git ref)
-  help          Show this help message
-
-How it works:
-  Before any Write/Edit/NotebookEdit, the hook copies the original file
-  into a shadow git repo (.claude-checkpoints/) and commits it. This gives
-  you a full history of every file before Claude modified it.
-`);
-}
-
-const command = process.argv[2];
-
-switch (command) {
-  case "install": install(); break;
-  case "uninstall": uninstall(); break;
-  case "status": status(); break;
-  case "list": list(); break;
-  case "restore":
-    if (process.argv[3]) {
-      restore(process.argv[3]);
-    } else {
-      console.error("Usage: hook-checkpoint restore <git-ref>");
-      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);
-    }
-}