@zuvia-software-solutions/code-mapper 1.4.0

package/dist/storage/git.d.ts

@@ -0,0 +1,6 @@
+/** @file git.ts
+ *  @description Git utilities for repository detection, commit tracking, and root discovery */
+export declare const isGitRepo: (repoPath: string) => boolean;
+export declare const getCurrentCommit: (repoPath: string) => string;
+/** Find the git repository root from any path inside the repo */
+export declare const getGitRoot: (fromPath: string) => string | null;

package/dist/storage/git.js

@@ -0,0 +1,35 @@
+// code-mapper/src/storage/git.ts
+/** @file git.ts
+ *  @description Git utilities for repository detection, commit tracking, and root discovery */
+import { execSync } from 'child_process';
+import path from 'path';
+export const isGitRepo = (repoPath) => {
+    try {
+        execSync('git rev-parse --is-inside-work-tree', { cwd: repoPath, stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const getCurrentCommit = (repoPath) => {
+    try {
+        return execSync('git rev-parse HEAD', { cwd: repoPath }).toString().trim();
+    }
+    catch {
+        return '';
+    }
+};
+/** Find the git repository root from any path inside the repo */
+export const getGitRoot = (fromPath) => {
+    try {
+        const raw = execSync('git rev-parse --show-toplevel', { cwd: fromPath })
+            .toString()
+            .trim();
+        // On Windows, git returns /d/Projects/Foo — path.resolve normalizes to D:\Projects\Foo
+        return path.resolve(raw);
+    }
+    catch {
+        return null;
+    }
+};

package/dist/storage/repo-manager.d.ts

@@ -0,0 +1,87 @@
+/** @file repo-manager.ts
+ *  @description Manages Code Mapper index storage in .code-mapper/ at repo root
+ *  Maintains a global registry at ~/.code-mapper/registry.json for MCP repo discovery */
+export interface RepoMeta {
+    repoPath: string;
+    lastCommit: string;
+    indexedAt: string;
+    stats?: {
+        files?: number;
+        nodes?: number;
+        edges?: number;
+        communities?: number;
+        processes?: number;
+        embeddings?: number;
+    };
+}
+export interface IndexedRepo {
+    repoPath: string;
+    storagePath: string;
+    lbugPath: string;
+    metaPath: string;
+    meta: RepoMeta;
+}
+/** Shape of an entry in the global registry (~/.code-mapper/registry.json) */
+export interface RegistryEntry {
+    name: string;
+    path: string;
+    storagePath: string;
+    indexedAt: string;
+    lastCommit: string;
+    stats?: RepoMeta['stats'];
+}
+/** Get the .code-mapper storage path for a repository */
+export declare const getStoragePath: (repoPath: string) => string;
+/** Get paths to key storage files */
+export declare const getStoragePaths: (repoPath: string) => {
+    storagePath: string;
+    lbugPath: string;
+    metaPath: string;
+};
+/** Check whether a KuzuDB index exists (non-destructive, safe for status commands) */
+export declare const hasKuzuIndex: (storagePath: string) => Promise<boolean>;
+/**
+ * Clean up stale KuzuDB files after migration to LadybugDB
+ * @returns found (kuzu existed and was deleted), needsReindex (kuzu existed but lbug does not)
+ */
+export declare const cleanupOldKuzuFiles: (storagePath: string) => Promise<{
+    found: boolean;
+    needsReindex: boolean;
+}>;
+/** Load metadata from an indexed repo */
+export declare const loadMeta: (storagePath: string) => Promise<RepoMeta | null>;
+/** Save metadata to storage */
+export declare const saveMeta: (storagePath: string, meta: RepoMeta) => Promise<void>;
+/** Check if a path has a Code Mapper index */
+export declare const hasIndex: (repoPath: string) => Promise<boolean>;
+/** Load an indexed repo from a path */
+export declare const loadRepo: (repoPath: string) => Promise<IndexedRepo | null>;
+/** Find .code-mapper by walking up from a starting path */
+export declare const findRepo: (startPath: string) => Promise<IndexedRepo | null>;
+/** Add .code-mapper to .gitignore if not already present */
+export declare const addToGitignore: (repoPath: string) => Promise<void>;
+/** Get the path to the global Code Mapper directory */
+export declare const getGlobalDir: () => string;
+/** Get the path to the global registry file */
+export declare const getGlobalRegistryPath: () => string;
+/** Read the global registry, returns empty array if not found */
+export declare const readRegistry: () => Promise<RegistryEntry[]>;
+/** Register (add or update) a repo in the global registry after analyze */
+export declare const registerRepo: (repoPath: string, meta: RepoMeta) => Promise<void>;
+/** Remove a repo from the global registry after clean */
+export declare const unregisterRepo: (repoPath: string) => Promise<void>;
+/** List all registered repos, optionally validating each .code-mapper/ still exists */
+export declare const listRegisteredRepos: (opts?: {
+    validate?: boolean;
+}) => Promise<RegistryEntry[]>;
+export interface CLIConfig {
+    apiKey?: string;
+    model?: string;
+    baseUrl?: string;
+}
+/** Get the path to the global CLI config file */
+export declare const getGlobalConfigPath: () => string;
+/** Load CLI config from ~/.code-mapper/config.json */
+export declare const loadCLIConfig: () => Promise<CLIConfig>;
+/** Save CLI config to ~/.code-mapper/config.json */
+export declare const saveCLIConfig: (config: CLIConfig) => Promise<void>;

package/dist/storage/repo-manager.js

@@ -0,0 +1,249 @@
+// code-mapper/src/storage/repo-manager.ts
+/** @file repo-manager.ts
+ *  @description Manages Code Mapper index storage in .code-mapper/ at repo root
+ *  Maintains a global registry at ~/.code-mapper/registry.json for MCP repo discovery */
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+const CODE_MAPPER_DIR = '.code-mapper';
+// Local Storage Helpers
+/** Get the .code-mapper storage path for a repository */
+export const getStoragePath = (repoPath) => {
+    return path.join(path.resolve(repoPath), CODE_MAPPER_DIR);
+};
+/** Get paths to key storage files */
+export const getStoragePaths = (repoPath) => {
+    const storagePath = getStoragePath(repoPath);
+    return {
+        storagePath,
+        lbugPath: path.join(storagePath, 'lbug'),
+        metaPath: path.join(storagePath, 'meta.json'),
+    };
+};
+/** Check whether a KuzuDB index exists (non-destructive, safe for status commands) */
+export const hasKuzuIndex = async (storagePath) => {
+    try {
+        await fs.stat(path.join(storagePath, 'kuzu'));
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Clean up stale KuzuDB files after migration to LadybugDB
+ * @returns found (kuzu existed and was deleted), needsReindex (kuzu existed but lbug does not)
+ */
+export const cleanupOldKuzuFiles = async (storagePath) => {
+    const oldPath = path.join(storagePath, 'kuzu');
+    const newPath = path.join(storagePath, 'lbug');
+    try {
+        await fs.stat(oldPath);
+        // Old kuzu file/dir exists — determine if lbug is already present
+        let needsReindex = false;
+        try {
+            await fs.stat(newPath);
+        }
+        catch {
+            needsReindex = true;
+        }
+        // Delete kuzu database file and its sidecars (.wal, .lock)
+        for (const suffix of ['', '.wal', '.lock']) {
+            try {
+                await fs.unlink(oldPath + suffix);
+            }
+            catch { }
+        }
+        // Also handle the case where kuzu was stored as a directory
+        try {
+            await fs.rm(oldPath, { recursive: true, force: true });
+        }
+        catch { }
+        return { found: true, needsReindex };
+    }
+    catch {
+        // Old path doesn't exist — nothing to do
+        return { found: false, needsReindex: false };
+    }
+};
+/** Load metadata from an indexed repo */
+export const loadMeta = async (storagePath) => {
+    try {
+        const metaPath = path.join(storagePath, 'meta.json');
+        const raw = await fs.readFile(metaPath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+};
+/** Save metadata to storage */
+export const saveMeta = async (storagePath, meta) => {
+    await fs.mkdir(storagePath, { recursive: true });
+    const metaPath = path.join(storagePath, 'meta.json');
+    await fs.writeFile(metaPath, JSON.stringify(meta, null, 2), 'utf-8');
+};
+/** Check if a path has a Code Mapper index */
+export const hasIndex = async (repoPath) => {
+    const { metaPath } = getStoragePaths(repoPath);
+    try {
+        await fs.access(metaPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+/** Load an indexed repo from a path */
+export const loadRepo = async (repoPath) => {
+    const paths = getStoragePaths(repoPath);
+    const meta = await loadMeta(paths.storagePath);
+    if (!meta)
+        return null;
+    return {
+        repoPath: path.resolve(repoPath),
+        ...paths,
+        meta,
+    };
+};
+/** Find .code-mapper by walking up from a starting path */
+export const findRepo = async (startPath) => {
+    let current = path.resolve(startPath);
+    const root = path.parse(current).root;
+    while (current !== root) {
+        const repo = await loadRepo(current);
+        if (repo)
+            return repo;
+        current = path.dirname(current);
+    }
+    return null;
+};
+/** Add .code-mapper to .gitignore if not already present */
+export const addToGitignore = async (repoPath) => {
+    const gitignorePath = path.join(repoPath, '.gitignore');
+    try {
+        const content = await fs.readFile(gitignorePath, 'utf-8');
+        if (content.includes(CODE_MAPPER_DIR))
+            return;
+        const newContent = content.endsWith('\n')
+            ? `${content}${CODE_MAPPER_DIR}\n`
+            : `${content}\n${CODE_MAPPER_DIR}\n`;
+        await fs.writeFile(gitignorePath, newContent, 'utf-8');
+    }
+    catch {
+        // .gitignore doesn't exist, create it
+        await fs.writeFile(gitignorePath, `${CODE_MAPPER_DIR}\n`, 'utf-8');
+    }
+};
+// Global Registry (~/.code-mapper/registry.json)
+/** Get the path to the global Code Mapper directory */
+export const getGlobalDir = () => {
+    return path.join(os.homedir(), '.code-mapper');
+};
+/** Get the path to the global registry file */
+export const getGlobalRegistryPath = () => {
+    return path.join(getGlobalDir(), 'registry.json');
+};
+/** Read the global registry, returns empty array if not found */
+export const readRegistry = async () => {
+    try {
+        const raw = await fs.readFile(getGlobalRegistryPath(), 'utf-8');
+        const data = JSON.parse(raw);
+        return Array.isArray(data) ? data : [];
+    }
+    catch {
+        return [];
+    }
+};
+/** Write the global registry to disk */
+const writeRegistry = async (entries) => {
+    const dir = getGlobalDir();
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(getGlobalRegistryPath(), JSON.stringify(entries, null, 2), 'utf-8');
+};
+/** Register (add or update) a repo in the global registry after analyze */
+export const registerRepo = async (repoPath, meta) => {
+    const resolved = path.resolve(repoPath);
+    const name = path.basename(resolved);
+    const { storagePath } = getStoragePaths(resolved);
+    const entries = await readRegistry();
+    const existing = entries.findIndex((e) => {
+        const a = path.resolve(e.path);
+        const b = resolved;
+        return process.platform === 'win32'
+            ? a.toLowerCase() === b.toLowerCase()
+            : a === b;
+    });
+    const entry = {
+        name,
+        path: resolved,
+        storagePath,
+        indexedAt: meta.indexedAt,
+        lastCommit: meta.lastCommit,
+        stats: meta.stats,
+    };
+    if (existing >= 0) {
+        entries[existing] = entry;
+    }
+    else {
+        entries.push(entry);
+    }
+    await writeRegistry(entries);
+};
+/** Remove a repo from the global registry after clean */
+export const unregisterRepo = async (repoPath) => {
+    const resolved = path.resolve(repoPath);
+    const entries = await readRegistry();
+    const filtered = entries.filter((e) => path.resolve(e.path) !== resolved);
+    await writeRegistry(filtered);
+};
+/** List all registered repos, optionally validating each .code-mapper/ still exists */
+export const listRegisteredRepos = async (opts) => {
+    const entries = await readRegistry();
+    if (!opts?.validate)
+        return entries;
+    // Validate each entry still has a .code-mapper/ directory
+    const valid = [];
+    for (const entry of entries) {
+        try {
+            await fs.access(path.join(entry.storagePath, 'meta.json'));
+            valid.push(entry);
+        }
+        catch {
+            // Index no longer exists — skip
+        }
+    }
+    // If we pruned any entries, save the cleaned registry
+    if (valid.length !== entries.length) {
+        await writeRegistry(valid);
+    }
+    return valid;
+};
+/** Get the path to the global CLI config file */
+export const getGlobalConfigPath = () => {
+    return path.join(getGlobalDir(), 'config.json');
+};
+/** Load CLI config from ~/.code-mapper/config.json */
+export const loadCLIConfig = async () => {
+    try {
+        const raw = await fs.readFile(getGlobalConfigPath(), 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+};
+/** Save CLI config to ~/.code-mapper/config.json */
+export const saveCLIConfig = async (config) => {
+    const dir = getGlobalDir();
+    await fs.mkdir(dir, { recursive: true });
+    const configPath = getGlobalConfigPath();
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+    // Restrict file permissions on Unix (config may contain API keys)
+    if (process.platform !== 'win32') {
+        try {
+            await fs.chmod(configPath, 0o600);
+        }
+        catch { /* best-effort */ }
+    }
+};

package/dist/types/pipeline.d.ts

@@ -0,0 +1,35 @@
+/** @file pipeline.ts @description Types for the ingestion pipeline: phases, progress, results, and serialization helpers */
+import { GraphNode, GraphRelationship, KnowledgeGraph } from '../core/graph/types.js';
+import { CommunityDetectionResult } from '../core/ingestion/community-processor.js';
+import { ProcessDetectionResult } from '../core/ingestion/process-processor.js';
+export type PipelinePhase = 'idle' | 'extracting' | 'structure' | 'parsing' | 'imports' | 'calls' | 'heritage' | 'communities' | 'processes' | 'enriching' | 'complete' | 'error';
+export interface PipelineProgress {
+    phase: PipelinePhase;
+    percent: number;
+    message: string;
+    detail?: string;
+    stats?: {
+        filesProcessed: number;
+        totalFiles: number;
+        nodesCreated: number;
+    };
+}
+export interface PipelineResult {
+    graph: KnowledgeGraph;
+    /** Absolute path to the repo root, used for lazy file reads during LadybugDB loading */
+    repoPath: string;
+    /** Total files scanned */
+    totalFileCount: number;
+    communityResult?: CommunityDetectionResult;
+    processResult?: ProcessDetectionResult;
+}
+export interface SerializablePipelineResult {
+    nodes: GraphNode[];
+    relationships: GraphRelationship[];
+    repoPath: string;
+    totalFileCount: number;
+}
+/** Convert PipelineResult to a serializable format for postMessage */
+export declare const serializePipelineResult: (result: PipelineResult) => SerializablePipelineResult;
+/** Reconstruct a PipelineResult from serialized format (used in main thread) */
+export declare const deserializePipelineResult: (serialized: SerializablePipelineResult, createGraph: () => KnowledgeGraph) => PipelineResult;

package/dist/types/pipeline.js

@@ -0,0 +1,20 @@
+// code-mapper/src/types/pipeline.ts
+/** @file pipeline.ts @description Types for the ingestion pipeline: phases, progress, results, and serialization helpers */
+/** Convert PipelineResult to a serializable format for postMessage */
+export const serializePipelineResult = (result) => ({
+    nodes: [...result.graph.iterNodes()],
+    relationships: [...result.graph.iterRelationships()],
+    repoPath: result.repoPath,
+    totalFileCount: result.totalFileCount,
+});
+/** Reconstruct a PipelineResult from serialized format (used in main thread) */
+export const deserializePipelineResult = (serialized, createGraph) => {
+    const graph = createGraph();
+    serialized.nodes.forEach(node => graph.addNode(node));
+    serialized.relationships.forEach(rel => graph.addRelationship(rel));
+    return {
+        graph,
+        repoPath: serialized.repoPath,
+        totalFileCount: serialized.totalFileCount,
+    };
+};

package/hooks/claude/code-mapper-hook.cjs

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+/**
+ * Code Mapper Claude Code Hook
+ *
+ * PreToolUse  — intercepts Grep/Glob/Bash searches and augments
+ *               with graph context from the Code Mapper index.
+ * PostToolUse — detects stale index after git mutations and notifies
+ *               the agent to reindex.
+ *
+ * NOTE: SessionStart hooks are broken on Windows (Claude Code bug).
+ * Session context is injected via CLAUDE.md / skills instead.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+/**
+ * Read JSON input from stdin synchronously.
+ */
+function readInput() {
+  try {
+    const data = fs.readFileSync(0, 'utf-8');
+    return JSON.parse(data);
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Find the .code-mapper directory by walking up from startDir.
+ * Returns the path to .code-mapper/ or null if not found.
+ */
+function findCodeMapperDir(startDir) {
+  let dir = startDir || process.cwd();
+  for (let i = 0; i < 5; i++) {
+    const candidate = path.join(dir, '.code-mapper');
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+/**
+ * Extract search pattern from tool input.
+ */
+function extractPattern(toolName, toolInput) {
+  if (toolName === 'Grep') {
+    return toolInput.pattern || null;
+  }
+
+  if (toolName === 'Glob') {
+    const raw = toolInput.pattern || '';
+    const match = raw.match(/[*\/]([a-zA-Z][a-zA-Z0-9_-]{2,})/);
+    return match ? match[1] : null;
+  }
+
+  if (toolName === 'Bash') {
+    const cmd = toolInput.command || '';
+    if (!/\brg\b|\bgrep\b/.test(cmd)) return null;
+
+    const tokens = cmd.split(/\s+/);
+    let foundCmd = false;
+    let skipNext = false;
+    const flagsWithValues = new Set(['-e', '-f', '-m', '-A', '-B', '-C', '-g', '--glob', '-t', '--type', '--include', '--exclude']);
+
+    for (const token of tokens) {
+      if (skipNext) { skipNext = false; continue; }
+      if (!foundCmd) {
+        if (/\brg$|\bgrep$/.test(token)) foundCmd = true;
+        continue;
+      }
+      if (token.startsWith('-')) {
+        if (flagsWithValues.has(token)) skipNext = true;
+        continue;
+      }
+      const cleaned = token.replace(/['"]/g, '');
+      return cleaned.length >= 3 ? cleaned : null;
+    }
+    return null;
+  }
+
+  return null;
+}
+
+/**
+ * Resolve the code-mapper CLI path.
+ * 1. Relative path (works when script is inside npm package)
+ * 2. require.resolve (works when code-mapper is globally installed)
+ * 3. Fall back to npx (returns empty string)
+ */
+function resolveCliPath() {
+  let cliPath = path.resolve(__dirname, '..', '..', 'dist', 'cli', 'index.js');
+  if (!fs.existsSync(cliPath)) {
+    try {
+      cliPath = require.resolve('code-mapper/dist/cli/index.js');
+    } catch {
+      cliPath = '';
+    }
+  }
+  return cliPath;
+}
+
+/**
+ * Spawn a code-mapper CLI command synchronously.
+ * Returns the stderr output (KuzuDB captures stdout at OS level).
+ */
+function runCodeMapperCli(cliPath, args, cwd, timeout) {
+  const isWin = process.platform === 'win32';
+  if (cliPath) {
+    return spawnSync(
+      process.execPath,
+      [cliPath, ...args],
+      { encoding: 'utf-8', timeout, cwd, stdio: ['pipe', 'pipe', 'pipe'] }
+    );
+  }
+  // On Windows, invoke npx.cmd directly (no shell needed)
+  return spawnSync(
+    isWin ? 'npx.cmd' : 'npx',
+    ['-y', 'code-mapper', ...args],
+    { encoding: 'utf-8', timeout: timeout + 5000, cwd, stdio: ['pipe', 'pipe', 'pipe'] }
+  );
+}
+
+/**
+ * PreToolUse handler — augment searches with graph context.
+ */
+function handlePreToolUse(input) {
+  const cwd = input.cwd || process.cwd();
+  if (!path.isAbsolute(cwd)) return;
+  if (!findCodeMapperDir(cwd)) return;
+
+  const toolName = input.tool_name || '';
+  const toolInput = input.tool_input || {};
+
+  if (toolName !== 'Grep' && toolName !== 'Glob' && toolName !== 'Bash') return;
+
+  const pattern = extractPattern(toolName, toolInput);
+  if (!pattern || pattern.length < 3) return;
+
+  const cliPath = resolveCliPath();
+  let result = '';
+  try {
+    const child = runCodeMapperCli(cliPath, ['augment', '--', pattern], cwd, 7000);
+    if (!child.error && child.status === 0) {
+      result = child.stderr || '';
+    }
+  } catch { /* graceful failure */ }
+
+  if (result && result.trim()) {
+    sendHookResponse('PreToolUse', result.trim());
+  }
+}
+
+/**
+ * Emit a PostToolUse hook response with additional context for the agent.
+ */
+function sendHookResponse(hookEventName, message) {
+  console.log(JSON.stringify({
+    hookSpecificOutput: { hookEventName, additionalContext: message }
+  }));
+}
+
+/**
+ * PostToolUse handler — detect index staleness after git mutations.
+ *
+ * Instead of spawning a full `code-mapper analyze` synchronously (which blocks
+ * the agent for up to 120s and risks KuzuDB corruption on timeout), we do a
+ * lightweight staleness check: compare `git rev-parse HEAD` against the
+ * lastCommit stored in `.code-mapper/meta.json`. If they differ, notify the
+ * agent so it can decide when to reindex.
+ */
+function handlePostToolUse(input) {
+  const toolName = input.tool_name || '';
+  if (toolName !== 'Bash') return;
+
+  const command = (input.tool_input || {}).command || '';
+  if (!/\bgit\s+(commit|merge|rebase|cherry-pick|pull)(\s|$)/.test(command)) return;
+
+  // Only proceed if the command succeeded
+  const toolOutput = input.tool_output || {};
+  if (toolOutput.exit_code !== undefined && toolOutput.exit_code !== 0) return;
+
+  const cwd = input.cwd || process.cwd();
+  if (!path.isAbsolute(cwd)) return;
+  const codeMapperDir = findCodeMapperDir(cwd);
+  if (!codeMapperDir) return;
+
+  // Compare HEAD against last indexed commit — skip if unchanged
+  let currentHead = '';
+  try {
+    const headResult = spawnSync('git', ['rev-parse', 'HEAD'], {
+      encoding: 'utf-8', timeout: 3000, cwd, stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    currentHead = (headResult.stdout || '').trim();
+  } catch { return; }
+
+  if (!currentHead) return;
+
+  let lastCommit = '';
+  let hadEmbeddings = false;
+  try {
+    const meta = JSON.parse(fs.readFileSync(path.join(codeMapperDir, 'meta.json'), 'utf-8'));
+    lastCommit = meta.lastCommit || '';
+    hadEmbeddings = (meta.stats && meta.stats.embeddings > 0);
+  } catch { /* no meta — treat as stale */ }
+
+  // If HEAD matches last indexed commit, no reindex needed
+  if (currentHead && currentHead === lastCommit) return;
+
+  const analyzeCmd = `npx code-mapper analyze${hadEmbeddings ? ' --embeddings' : ''}`;
+  sendHookResponse('PostToolUse',
+    `Code Mapper index is stale (last indexed: ${lastCommit ? lastCommit.slice(0, 7) : 'never'}). ` +
+    `Run \`${analyzeCmd}\` to update the knowledge graph.`
+  );
+}
+
+// Dispatch map for hook events
+const handlers = {
+  PreToolUse: handlePreToolUse,
+  PostToolUse: handlePostToolUse,
+};
+
+function main() {
+  try {
+    const input = readInput();
+    const handler = handlers[input.hook_event_name || ''];
+    if (handler) handler(input);
+  } catch (err) {
+    if (process.env.CODE_MAPPER_DEBUG) {
+      console.error('Code Mapper hook error:', (err.message || '').slice(0, 200));
+    }
+  }
+}
+
+main();