@hasna/hooks 0.2.19 → 0.2.20

package/dist/cli/components/App.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+interface AppProps {
+    initialHooks?: string[];
+    overwrite?: boolean;
+}
+export declare function App({ initialHooks, overwrite }: AppProps): React.JSX.Element;
+export {};

package/dist/cli/components/CategorySelect.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+interface CategorySelectProps {
+    onSelect: (category: string) => void;
+    onBack?: () => void;
+}
+export declare function CategorySelect({ onSelect, onBack }: CategorySelectProps): React.JSX.Element;
+export {};

package/dist/cli/components/DataTable.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import { HookMeta } from "../../lib/registry.js";
+interface DataTableProps {
+    hooks: HookMeta[];
+    selected: Set<string>;
+    onToggle: (name: string) => void;
+    onConfirm: () => void;
+    onBack: () => void;
+}
+export declare function DataTable({ hooks, selected, onToggle, onConfirm, onBack, }: DataTableProps): React.JSX.Element;
+export {};

package/dist/cli/components/Header.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+interface HeaderProps {
+    title?: string;
+    subtitle?: string;
+}
+export declare function Header({ title, subtitle }: HeaderProps): React.JSX.Element;
+export {};

package/dist/cli/components/HookSelect.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import { HookMeta } from "../../lib/registry.js";
+interface HookSelectProps {
+    hooks: HookMeta[];
+    selected: Set<string>;
+    onToggle: (name: string) => void;
+    onConfirm: () => void;
+    onBack: () => void;
+}
+export declare function HookSelect({ hooks, selected, onToggle, onConfirm, onBack, }: HookSelectProps): React.JSX.Element;
+export {};

package/dist/cli/components/InstallProgress.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { InstallResult } from "../../lib/installer.js";
+interface InstallProgressProps {
+    hooks: string[];
+    overwrite?: boolean;
+    onComplete: (results: InstallResult[]) => void;
+}
+export declare function InstallProgress({ hooks, overwrite, onComplete, }: InstallProgressProps): React.JSX.Element;
+export {};

package/dist/cli/components/SearchView.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+interface SearchViewProps {
+    selected: Set<string>;
+    onToggle: (name: string) => void;
+    onConfirm: () => void;
+    onBack: () => void;
+}
+export declare function SearchView({ selected, onToggle, onConfirm, onBack, }: SearchViewProps): React.JSX.Element;
+export {};

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/db/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * SQLite DB module for hooks — persistent storage at ~/.hasna/hooks/hooks.db
+ *
+ * Uses bun:sqlite with WAL mode for concurrent reads.
+ * Supports HASNA_HOOKS_DATA_DIR / HOOKS_DATA_DIR and HASNA_HOOKS_DB_PATH / HOOKS_DB_PATH env overrides.
+ */
+import { Database } from "bun:sqlite";
+export declare function getDbPath(): string;
+export declare function getDb(): Database;
+export declare function closeDb(): void;
+export declare function createTestDb(): Database;

package/dist/db/legacy-import.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Legacy flat-file import — runs once on first DB creation.
+ *
+ * Scans for old .claude/session-log-*.jsonl and .claude/errors.log files
+ * in the user's home projects directory and imports their entries into hook_events.
+ *
+ * Non-blocking: any failure is logged to stderr and skipped.
+ * Tracks completion via a `_meta` table row keyed "legacy_import_done".
+ */
+import type { Database } from "bun:sqlite";
+export declare function runLegacyImport(db: Database): void;

package/dist/db/migrations/001_initial.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Migration 001 — initial schema
+ * Creates hook_events table and indexes.
+ */
+import type { Database } from "bun:sqlite";
+export declare function up(db: Database): void;

package/dist/db/migrations/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Migration runner — applies pending migrations in order.
+ * Tracks applied migrations in a `schema_migrations` table.
+ * Migrations are additive-only, never destructive.
+ */
+import type { Database } from "bun:sqlite";
+export declare function runMigrations(db: Database): void;

package/dist/db/pg-migrations.d.ts

@@ -0,0 +1,7 @@
+/**
+ * PostgreSQL migrations for open-hooks storage sync.
+ *
+ * Equivalent to the SQLite schema in schema.ts, migrations/, and index.ts,
+ * translated for PostgreSQL.
+ */
+export declare const PG_MIGRATIONS: string[];

package/dist/db/retention.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Retention/cleanup — auto-prune hook_events older than N days.
+ *
+ * Configurable via HOOKS_RETENTION_DAYS env var (default: 30).
+ * Called on DB open after migrations.
+ */
+import type { Database } from "bun:sqlite";
+export declare function runRetention(db: Database, days?: number): number;

package/dist/db/schema.d.ts

@@ -0,0 +1,21 @@
+/**
+ * hook_events table schema and DDL
+ */
+import type { Database } from "bun:sqlite";
+export declare const CREATE_HOOK_EVENTS_TABLE = "\n  CREATE TABLE IF NOT EXISTS hook_events (\n    id           TEXT PRIMARY KEY,\n    timestamp    TEXT NOT NULL,\n    session_id   TEXT NOT NULL,\n    hook_name    TEXT NOT NULL,\n    event_type   TEXT NOT NULL CHECK (event_type IN ('PreToolUse', 'PostToolUse', 'Stop', 'Notification')),\n    tool_name    TEXT,\n    tool_input   TEXT,\n    result       TEXT CHECK (result IN ('continue', 'block', NULL)),\n    error        TEXT,\n    duration_ms  INTEGER,\n    project_dir  TEXT,\n    metadata     TEXT\n  )\n";
+export declare const CREATE_INDEXES: string[];
+export interface HookEventRow {
+    id: string;
+    timestamp: string;
+    session_id: string;
+    hook_name: string;
+    event_type: "PreToolUse" | "PostToolUse" | "Stop" | "Notification";
+    tool_name: string | null;
+    tool_input: string | null;
+    result: "continue" | "block" | null;
+    error: string | null;
+    duration_ms: number | null;
+    project_dir: string | null;
+    metadata: string | null;
+}
+export declare function applySchema(db: Database): void;

package/dist/index.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @hasna/hooks - Open source Claude Code hooks library
+ *
+ * Install hooks with a single command:
+ *   npx @hasna/hooks install gitguard branchprotect
+ *
+ * Or use the interactive CLI:
+ *   npx @hasna/hooks
+ */
+export { HOOKS, CATEGORIES, getHook, getHooksByCategory, searchHooks, type HookMeta, type Category, } from "./lib/registry.js";
+export { installHook, installHooks, getInstalledHooks, getRegisteredHooks, getRegisteredHooksForTarget, removeHook, hookExists, getHookPath, getSettingsPath, type InstallResult, type InstallOptions, type Scope, type Target, } from "./lib/installer.js";
+export interface HookAgentInfo {
+    agent_id: string;
+    agent_type: "claude" | "gemini" | "custom";
+    name?: string;
+    preferences?: Record<string, unknown>;
+}
+/** The JSON object passed to a hook via stdin */
+export interface HookInput {
+    session_id?: string;
+    cwd?: string;
+    tool_name?: string;
+    tool_input?: Record<string, unknown>;
+    agent?: HookAgentInfo;
+    [key: string]: unknown;
+}
+/** The JSON object a PreToolUse hook returns via stdout */
+export interface HookOutput {
+    decision?: "approve" | "block";
+    reason?: string;
+    [key: string]: unknown;
+}
+import type { InstallOptions, InstallResult } from "./lib/installer.js";
+/** Install a hook scoped to the current project (.claude/settings.json) */
+export declare function installHookForProject(name: string, options?: Omit<InstallOptions, "scope">): InstallResult;
+/** Install multiple hooks scoped to the current project */
+export declare function installHooksForProject(names: string[], options?: Omit<InstallOptions, "scope">): InstallResult[];
+/** List all hooks registered for the current project */
+export declare function listProjectHooks(): string[];
+/** Remove a hook from the current project */
+export declare function removeProjectHook(name: string): boolean;
+export interface RunHookOptions {
+    /** Agent profile ID to inject into hook input */
+    profile?: string;
+    /** Timeout in milliseconds (default: 10000) */
+    timeout?: number;
+}
+export interface RunHookResult {
+    output: HookOutput;
+    stderr: string;
+    exitCode: number;
+}
+/**
+ * Programmatically execute a hook with the given input.
+ * Spawns the hook's src/hook.ts via bun, passes input as stdin JSON,
+ * and returns the parsed stdout JSON.
+ */
+export declare function runHook(name: string, input: HookInput, options?: RunHookOptions): Promise<RunHookResult>;
+export { createProfile, getProfile, listProfiles, updateProfile, deleteProfile, touchProfile, getProfilesDir, exportProfiles, importProfiles, type AgentProfile, type CreateProfileInput, } from "./lib/profiles.js";

package/dist/lib/db-writer.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shared hook DB writer — single write path for all observability hooks.
+ * Never throws: errors are written to stderr only.
+ */
+import type { HookEventRow } from "../db/schema";
+export type HookEventInput = Omit<HookEventRow, "id" | "timestamp"> & {
+    timestamp?: string;
+};
+export declare function writeHookEvent(event: HookEventInput): void;

package/dist/lib/installer.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Hook installer - registers hooks in AI coding agent settings
+ *
+ * Supports:
+ * - Claude Code: ~/.claude/settings.json (PreToolUse, PostToolUse, Stop, Notification)
+ * - Gemini CLI: ~/.gemini/settings.json (BeforeTool, AfterTool, AfterAgent, Notification)
+ *
+ * Hooks run directly from the globally installed @hasna/hooks package.
+ * No files are copied. The settings entry points to `hooks run <name>`.
+ */
+export type Scope = "global" | "project";
+export type Target = "claude" | "gemini" | "all";
+export interface InstallResult {
+    hook: string;
+    success: boolean;
+    error?: string;
+    scope?: Scope;
+    target?: Target;
+    conflict?: string;
+}
+export interface InstallOptions {
+    scope?: Scope;
+    overwrite?: boolean;
+    target?: Target;
+    profile?: string;
+}
+export declare function getSettingsPath(scope?: Scope, target?: "claude" | "gemini"): string;
+export declare function getHookPath(name: string): string;
+export declare function hookExists(name: string): boolean;
+export declare function installHook(name: string, options?: InstallOptions): InstallResult;
+export declare function installHooks(names: string[], options?: InstallOptions): InstallResult[];
+export declare function getRegisteredHooksForTarget(scope?: Scope, target?: "claude" | "gemini"): string[];
+export declare function getRegisteredHooks(scope?: Scope): string[];
+/** @deprecated Use getRegisteredHooks instead */
+export declare const getInstalledHooks: typeof getRegisteredHooks;
+export declare function removeHook(name: string, scope?: Scope, target?: Target): boolean;

package/dist/lib/profiles.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Agent profile management — identity system for hooks
+ *
+ * Each agent instance gets a unique 8-char UUID stored at ~/.hasna/hooks/profiles/<id>.json.
+ * Profiles are injected into HookInput when hooks are run with --profile <id>,
+ * allowing hooks to identify which agent is calling them.
+ */
+export interface AgentProfile {
+    agent_id: string;
+    agent_type: "claude" | "gemini" | "custom";
+    name?: string;
+    created_at: string;
+    last_seen_at: string;
+    preferences: Record<string, unknown>;
+}
+export interface CreateProfileInput {
+    agent_type: "claude" | "gemini" | "custom";
+    name?: string;
+}
+export declare function getProfilesDir(): string;
+export declare function createProfile(input: CreateProfileInput): AgentProfile;
+export declare function getProfile(id: string): AgentProfile | null;
+export declare function listProfiles(): AgentProfile[];
+export declare function updateProfile(id: string, data: Partial<Pick<AgentProfile, "name" | "preferences">>): AgentProfile | null;
+export declare function deleteProfile(id: string): boolean;
+export declare function touchProfile(id: string): void;
+/** Export all profiles as a JSON bundle for cross-machine backup */
+export declare function exportProfiles(): AgentProfile[];
+/** Import profiles from a JSON bundle, skipping duplicates by agent_id */
+export declare function importProfiles(profiles: AgentProfile[]): {
+    imported: number;
+    skipped: number;
+};

package/dist/lib/registry.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Hook registry - metadata about all available hooks
+ */
+export interface HookMeta {
+    name: string;
+    displayName: string;
+    description: string;
+    version: string;
+    category: string;
+    event: "PreToolUse" | "PostToolUse" | "Stop" | "Notification";
+    matcher: string;
+    tags: string[];
+}
+export declare const CATEGORIES: readonly ["Git Safety", "Code Quality", "Security", "Notifications", "Context Management", "Workflow Automation", "Environment", "Permissions", "Observability", "Agent Teams"];
+export type Category = (typeof CATEGORIES)[number];
+export declare const HOOKS: HookMeta[];
+export declare function getHooksByCategory(category: Category): HookMeta[];
+export declare function searchHooks(query: string): HookMeta[];
+export declare function getHook(name: string): HookMeta | undefined;

package/dist/mcp/http.d.ts

@@ -0,0 +1,16 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const DEFAULT_MCP_HTTP_PORT = 8847;
+export declare const MCP_HTTP_HOST = "127.0.0.1";
+export declare const MCP_SERVICE_NAME = "hooks";
+export declare function isHttpMode(args: string[]): boolean;
+export declare function resolveMcpHttpPort(args: string[]): number;
+export declare function healthPayload(name?: string): {
+    status: string;
+    name: string;
+};
+export declare function handleMcpRequest(req: Request, buildServer: () => McpServer): Promise<Response>;
+export declare function startMcpHttpServer(options: {
+    name: string;
+    port: number;
+    buildServer: () => McpServer;
+}): ReturnType<typeof Bun.serve>;

package/dist/mcp/server.d.ts

@@ -0,0 +1,17 @@
+/**
+ * MCP server for @hasna/hooks
+ *
+ * Exposes hook management as MCP tools for AI agents.
+ * Runs on port 39427 (SSE) or stdio transport.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const MCP_PORT = 39427;
+export declare function createHooksServer(): McpServer;
+/**
+ * Start the MCP server with SSE transport on the configured port
+ */
+export declare function startSSEServer(port?: number): Promise<void>;
+/**
+ * Start the MCP server with stdio transport
+ */
+export declare function startStdioServer(): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/hooks",
-  "version": "0.2.19",
+  "version": "0.2.20",
   "description": "Open source hooks library for AI coding agents - Install safety, quality, and automation hooks with a single command",
   "type": "module",
   "bin": {
@@ -15,7 +15,7 @@
   "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 --external @modelcontextprotocol/sdk --external zod && bun build ./src/index.ts --outdir ./dist --target bun",
+    "build": "rm -rf ./bin ./dist && bun build ./src/cli/index.tsx --outdir ./bin --target bun --external ink --external react --external chalk --external conf --external @modelcontextprotocol/sdk --external zod && bun build ./src/index.ts --outdir ./dist --target bun && bunx tsc -p tsconfig.build.json --emitDeclarationOnly",
     "dev": "bun run ./src/cli/index.tsx",
     "test": "bun test",
     "typecheck": "bunx tsc --noEmit",
@@ -43,7 +43,6 @@
     "typescript": "^5"
   },
   "dependencies": {
-    "@hasna/cloud": "0.1.24",
     "@hasna/events": "^0.1.6",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "chalk": "^5.3.0",

package/hooks/hook-affected-tests/dist/hook.js

@@ -1,106 +0,0 @@
-#!/usr/bin/env bun
-// @bun
-
-// src/hook.ts
-import { readFileSync, existsSync } from "fs";
-import { join, dirname, basename, extname } from "path";
-import { execSync } from "child_process";
-function readStdinJson() {
-  try {
-    const input = readFileSync(0, "utf-8").trim();
-    if (!input)
-      return null;
-    return JSON.parse(input);
-  } catch {
-    return null;
-  }
-}
-function respond(output) {
-  console.log(JSON.stringify(output));
-}
-function isTestFile(filePath) {
-  return /\.(test|spec)\.[jt]sx?$/.test(filePath) || /_test\.(py|go|rs)$/.test(filePath) || /test_.*\.py$/.test(filePath);
-}
-function findTestFiles(filePath, cwd) {
-  if (isTestFile(filePath))
-    return [];
-  const ext = extname(filePath);
-  const base = basename(filePath, ext);
-  const dir = dirname(filePath);
-  const candidates = [];
-  const testExts = [`.test${ext}`, `.spec${ext}`, `.test.ts`, `.spec.ts`, `.test.tsx`, `.spec.tsx`];
-  for (const testExt of testExts) {
-    candidates.push(join(dir, `${base}${testExt}`));
-  }
-  candidates.push(join(dir, "__tests__", `${base}.test${ext}`));
-  candidates.push(join(dir, "__tests__", `${base}.spec${ext}`));
-  for (const testDir of ["test", "tests", "__tests__"]) {
-    const relPath = filePath.replace(/^.*?\/(src|lib|app)\//, "");
-    candidates.push(join(cwd, testDir, relPath.replace(ext, `.test${ext}`)));
-    candidates.push(join(cwd, testDir, relPath.replace(ext, `.spec${ext}`)));
-  }
-  return candidates.filter((p) => existsSync(p));
-}
-function detectTestCommand(cwd) {
-  const pkgPath = join(cwd, "package.json");
-  if (existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-      const scripts = pkg.scripts || {};
-      if (scripts.test)
-        return "bun test";
-    } catch {}
-  }
-  return "bun test";
-}
-function runTests(cwd, testFiles) {
-  const cmd = detectTestCommand(cwd);
-  const fileArgs = testFiles.map((f) => `"${f}"`).join(" ");
-  const fullCmd = `${cmd} ${fileArgs}`;
-  console.error(`[hook-affected-tests] Running: ${fullCmd}`);
-  try {
-    const output = execSync(fullCmd, {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 60000
-    });
-    const lines = output.trim().split(`
-`);
-    const summary = lines[lines.length - 1] || "Tests passed";
-    console.error(`[hook-affected-tests] ${summary}`);
-  } catch (error) {
-    const execError = error;
-    const output = (execError.stdout || "") + (execError.stderr || "");
-    const lines = output.trim().split(`
-`).filter((l) => l.trim());
-    const summary = lines.slice(-3).join(" | ");
-    console.error(`[hook-affected-tests] Tests failed: ${summary}`);
-  }
-}
-function run() {
-  const input = readStdinJson();
-  if (!input) {
-    respond({ continue: true });
-    return;
-  }
-  const filePath = input.tool_input.file_path || input.tool_input.notebook_path;
-  if (!filePath) {
-    respond({ continue: true });
-    return;
-  }
-  const testFiles = findTestFiles(filePath, input.cwd);
-  if (testFiles.length === 0) {
-    respond({ continue: true });
-    return;
-  }
-  console.error(`[hook-affected-tests] Found ${testFiles.length} test file(s) for ${basename(filePath)}`);
-  runTests(input.cwd, testFiles);
-  respond({ continue: true });
-}
-if (__require.main == __require.module) {
-  run();
-}
-export {
-  run
-};

package/hooks/hook-announce-start/dist/hook.js

@@ -1,98 +0,0 @@
-#!/usr/bin/env bun
-// @bun
-
-// src/hook.ts
-import { readFileSync, existsSync, mkdirSync, writeFileSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-import { execSync } from "child_process";
-var STATE_DIR = join(tmpdir(), "hook-announce-start");
-function readStdinJson() {
-  try {
-    const input = readFileSync(0, "utf-8").trim();
-    if (!input)
-      return null;
-    return JSON.parse(input);
-  } catch {
-    return null;
-  }
-}
-function respond(output) {
-  console.log(JSON.stringify(output));
-}
-function sanitizeId(id) {
-  return id.replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 64);
-}
-function hasAlreadyAnnounced(sessionId) {
-  const safe = sanitizeId(sessionId);
-  return existsSync(join(STATE_DIR, `${safe}.announced`));
-}
-function markAnnounced(sessionId) {
-  mkdirSync(STATE_DIR, { recursive: true });
-  const safe = sanitizeId(sessionId);
-  writeFileSync(join(STATE_DIR, `${safe}.announced`), new Date().toISOString());
-}
-function registerAgentProfile() {
-  try {
-    execSync("hooks init", {
-      encoding: "utf-8",
-      timeout: 5000,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-  } catch {}
-}
-function fetchContext() {
-  try {
-    const output = execSync("conversations context", {
-      encoding: "utf-8",
-      timeout: 1e4,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return output.trim() || null;
-  } catch {
-    return null;
-  }
-}
-function announceToSpace(cwd, sessionId) {
-  const project = cwd.split("/").filter(Boolean).pop() || "project";
-  const agent = process.env.HOOKS_AGENT_NAME || `session:${sessionId.slice(0, 8)}`;
-  const space = process.env.HOOKS_SPACE || "general";
-  const message = `Agent **${agent}** started a session on **${project}**`;
-  try {
-    execSync(`conversations send "${message}" --space "${space}"`, {
-      encoding: "utf-8",
-      timeout: 1e4,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    console.error(`[hook-announce-start] Announced to space '${space}'`);
-  } catch {
-    console.error(`[hook-announce-start] Could not post to space`);
-  }
-}
-function run() {
-  const input = readStdinJson();
-  if (!input) {
-    respond({ continue: true });
-    return;
-  }
-  if (hasAlreadyAnnounced(input.session_id)) {
-    respond({ continue: true });
-    return;
-  }
-  markAnnounced(input.session_id);
-  registerAgentProfile();
-  const context = fetchContext();
-  if (context) {
-    process.stderr.write(`[hook-announce-start] Session context:
-${context}
-`);
-  }
-  announceToSpace(input.cwd, input.session_id);
-  respond({ continue: true });
-}
-if (__require.main == __require.module) {
-  run();
-}
-export {
-  run
-};