@weavelogic/knowledge-graph-agent 0.9.0 → 0.10.1

package/dist/claude/hook-capture.js

@@ -0,0 +1,792 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from "fs";
+import { join, dirname } from "path";
+import { createSessionId, createConversationId, createMessageId, createToolCallId, createSubAgentId, createSwarmId } from "./types.js";
+const DEFAULT_CAPTURE_CONFIG = {
+  storageDir: ".kg/claude",
+  useKnowledgeGraph: true,
+  createMarkdown: true,
+  separateToolOutputs: true,
+  maxContentLength: 5e4,
+  captureSubAgents: true,
+  captureSwarms: true,
+  captureWorkflows: true,
+  defaultTags: ["claude", "interaction"]
+};
+class HookCaptureSystem {
+  config;
+  state;
+  projectRoot;
+  constructor(projectRoot, config = {}) {
+    this.projectRoot = projectRoot;
+    this.config = { ...DEFAULT_CAPTURE_CONFIG, ...config };
+    this.state = {
+      currentSessionId: null,
+      currentConversationId: null,
+      pendingToolCalls: /* @__PURE__ */ new Map(),
+      subAgentStack: [],
+      activeSwarmId: null,
+      storage: null
+    };
+    this.ensureStorageDir();
+  }
+  /**
+   * Ensure storage directory exists
+   */
+  ensureStorageDir() {
+    const fullPath = join(this.projectRoot, this.config.storageDir);
+    if (!existsSync(fullPath)) {
+      mkdirSync(fullPath, { recursive: true });
+    }
+  }
+  /**
+   * Create empty token usage
+   */
+  createEmptyTokenUsage() {
+    return {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0
+    };
+  }
+  /**
+   * Create empty aggregated token usage
+   */
+  createEmptyAggregatedTokenUsage() {
+    return {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      operationCount: 0
+    };
+  }
+  /**
+   * Create base metadata
+   */
+  createBaseMetadata(tags = []) {
+    const now = /* @__PURE__ */ new Date();
+    return {
+      createdAt: now,
+      updatedAt: now,
+      tags: [...this.config.defaultTags, ...tags]
+    };
+  }
+  /**
+   * Get current git branch
+   */
+  getGitBranch() {
+    try {
+      const headPath = join(this.projectRoot, ".git", "HEAD");
+      if (existsSync(headPath)) {
+        const content = readFileSync(headPath, "utf-8").trim();
+        if (content.startsWith("ref: refs/heads/")) {
+          return content.replace("ref: refs/heads/", "");
+        }
+      }
+    } catch {
+    }
+    return void 0;
+  }
+  /**
+   * Start a new session
+   */
+  startSession(name, purpose) {
+    const sessionId = createSessionId();
+    const now = /* @__PURE__ */ new Date();
+    const environment = {
+      workingDirectory: this.projectRoot,
+      gitBranch: this.getGitBranch(),
+      platform: process.platform
+    };
+    const session = {
+      id: sessionId,
+      name: name || `Session ${now.toISOString().slice(0, 16)}`,
+      purpose: purpose || "General interaction",
+      startedAt: now,
+      status: "running",
+      conversationIds: [],
+      swarmIds: [],
+      workflowIds: [],
+      environment,
+      tokenUsage: this.createEmptyAggregatedTokenUsage(),
+      metadata: this.createBaseMetadata(["session"])
+    };
+    this.state.storage = {
+      session,
+      conversations: /* @__PURE__ */ new Map(),
+      messages: /* @__PURE__ */ new Map(),
+      toolCalls: /* @__PURE__ */ new Map(),
+      subAgents: /* @__PURE__ */ new Map(),
+      swarms: /* @__PURE__ */ new Map()
+    };
+    this.state.currentSessionId = sessionId;
+    this.saveSession(session);
+    return session;
+  }
+  /**
+   * End the current session
+   */
+  endSession() {
+    if (!this.state.storage) return null;
+    const session = this.state.storage.session;
+    session.endedAt = /* @__PURE__ */ new Date();
+    session.status = "completed";
+    session.metadata.updatedAt = /* @__PURE__ */ new Date();
+    this.aggregateSessionTokens();
+    this.saveSession(session);
+    const result = { ...session };
+    this.state.currentSessionId = null;
+    this.state.currentConversationId = null;
+    this.state.storage = null;
+    return result;
+  }
+  /**
+   * Start a new conversation
+   */
+  startConversation(model, systemPrompt) {
+    if (!this.state.storage) {
+      this.startSession();
+    }
+    const conversationId = createConversationId();
+    const now = /* @__PURE__ */ new Date();
+    const conversation = {
+      id: conversationId,
+      sessionId: this.state.storage.session.id,
+      model: model || "claude-opus-4-5-20251101",
+      systemPrompt,
+      messageIds: [],
+      subAgentIds: [],
+      status: "running",
+      startedAt: now,
+      tokenUsage: this.createEmptyTokenUsage(),
+      metadata: this.createBaseMetadata(["conversation"])
+    };
+    this.state.storage.conversations.set(conversationId, conversation);
+    this.state.storage.session.conversationIds.push(conversationId);
+    this.state.currentConversationId = conversationId;
+    return conversation;
+  }
+  /**
+   * Handle hook events
+   */
+  handleHookEvent(event) {
+    switch (event.event) {
+      case "UserPromptSubmit":
+        this.handleUserPrompt(event);
+        break;
+      case "PreToolUse":
+        this.handlePreToolUse(event);
+        break;
+      case "PostToolUse":
+        this.handlePostToolUse(event);
+        break;
+      case "Stop":
+        this.handleSessionStop(event);
+        break;
+      case "PreCompact":
+        this.handlePreCompact(event);
+        break;
+    }
+  }
+  /**
+   * Handle user prompt submission
+   */
+  handleUserPrompt(event) {
+    if (!this.state.currentConversationId || !this.state.storage) {
+      this.startConversation();
+    }
+    const messageId = createMessageId();
+    const now = /* @__PURE__ */ new Date();
+    const conversationId = this.state.currentConversationId;
+    const textBlock = {
+      type: "text",
+      text: this.truncateContent(event.userPrompt || "")
+    };
+    const message = {
+      id: messageId,
+      conversationId,
+      role: "user",
+      content: textBlock.text,
+      contentBlocks: [textBlock],
+      toolCallIds: [],
+      timestamp: now,
+      tokenUsage: this.createEmptyTokenUsage(),
+      metadata: this.createBaseMetadata(["prompt", "user"])
+    };
+    this.state.storage.messages.set(messageId, message);
+    const conversation = this.state.storage.conversations.get(conversationId);
+    if (conversation) {
+      conversation.messageIds.push(messageId);
+    }
+    this.saveMessage(message);
+  }
+  /**
+   * Handle pre-tool use event
+   */
+  handlePreToolUse(event) {
+    if (!this.state.currentConversationId || !this.state.storage) {
+      this.startConversation();
+    }
+    const toolCallId = createToolCallId();
+    const now = /* @__PURE__ */ new Date();
+    const conversationId = this.state.currentConversationId;
+    let lastMessageId;
+    const conversation = this.state.storage.conversations.get(conversationId);
+    if (conversation && conversation.messageIds.length > 0) {
+      lastMessageId = conversation.messageIds[conversation.messageIds.length - 1];
+      const lastMessage = this.state.storage.messages.get(lastMessageId);
+      if (!lastMessage || lastMessage.role === "user") {
+        const assistantMsgId = createMessageId();
+        const assistantMessage = {
+          id: assistantMsgId,
+          conversationId,
+          role: "assistant",
+          content: "",
+          contentBlocks: [],
+          toolCallIds: [],
+          timestamp: now,
+          tokenUsage: this.createEmptyTokenUsage(),
+          metadata: this.createBaseMetadata(["response", "assistant"])
+        };
+        this.state.storage.messages.set(assistantMsgId, assistantMessage);
+        conversation.messageIds.push(assistantMsgId);
+        lastMessageId = assistantMsgId;
+      }
+    } else {
+      const assistantMsgId = createMessageId();
+      const assistantMessage = {
+        id: assistantMsgId,
+        conversationId,
+        role: "assistant",
+        content: "",
+        contentBlocks: [],
+        toolCallIds: [],
+        timestamp: now,
+        tokenUsage: this.createEmptyTokenUsage(),
+        metadata: this.createBaseMetadata(["response", "assistant"])
+      };
+      this.state.storage.messages.set(assistantMsgId, assistantMessage);
+      if (conversation) {
+        conversation.messageIds.push(assistantMsgId);
+      }
+      lastMessageId = assistantMsgId;
+    }
+    const toolCall = {
+      id: toolCallId,
+      messageId: lastMessageId,
+      toolName: event.toolName || "unknown",
+      toolCategory: this.categorizeToolCall(event.toolName || ""),
+      input: event.toolInput || {},
+      status: "running",
+      startedAt: now,
+      metadata: this.createBaseMetadata(["tool-call", event.toolName || "unknown"])
+    };
+    this.state.storage.toolCalls.set(toolCallId, toolCall);
+    const message = this.state.storage.messages.get(lastMessageId);
+    if (message) {
+      message.toolCallIds = message.toolCallIds || [];
+      message.toolCallIds.push(toolCallId);
+    }
+    this.state.pendingToolCalls.set(event.toolName || "unknown", toolCallId);
+    if (event.toolName === "Task" && this.config.captureSubAgents) {
+      this.handleSubAgentSpawn(event, toolCall);
+    }
+    if (event.toolName?.includes("swarm") && this.config.captureSwarms) {
+      this.handleSwarmOperation(event, toolCall);
+    }
+  }
+  /**
+   * Handle post-tool use event
+   */
+  handlePostToolUse(event) {
+    if (!this.state.storage) return;
+    const now = /* @__PURE__ */ new Date();
+    const toolCallId = this.state.pendingToolCalls.get(event.toolName || "unknown");
+    if (!toolCallId) return;
+    this.state.pendingToolCalls.delete(event.toolName || "unknown");
+    const toolCall = this.state.storage.toolCalls.get(toolCallId);
+    if (!toolCall) return;
+    toolCall.output = this.truncateContent(event.toolOutput || "");
+    toolCall.completedAt = now;
+    toolCall.status = event.error ? "failed" : "completed";
+    toolCall.executionTimeMs = event.duration;
+    if (event.error) {
+      toolCall.error = {
+        type: "execution_error",
+        message: event.error
+      };
+    }
+    toolCall.metadata.updatedAt = now;
+    if (toolCall.toolCategory === "file") {
+      const input = toolCall.input;
+      const filePath = input.file_path || input.path;
+      if (filePath) {
+        toolCall.affectedFiles = [String(filePath)];
+      }
+    }
+    if (event.toolName === "Task" && this.state.subAgentStack.length > 0) {
+      this.handleSubAgentComplete(event);
+    }
+    this.saveToolCall(toolCall);
+  }
+  /**
+   * Handle session stop event
+   */
+  handleSessionStop(_event) {
+    this.endSession();
+  }
+  /**
+   * Handle pre-compact event
+   */
+  handlePreCompact(_event) {
+    if (this.state.storage) {
+      this.state.storage.session.metadata.custom = {
+        ...this.state.storage.session.metadata.custom,
+        lastCompaction: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.saveSession(this.state.storage.session);
+    }
+  }
+  /**
+   * Handle sub-agent spawn
+   */
+  handleSubAgentSpawn(event, toolCall) {
+    if (!this.state.storage || !this.state.currentConversationId) return;
+    const subAgentId = createSubAgentId();
+    const now = /* @__PURE__ */ new Date();
+    const input = event.toolInput;
+    const parentConversationId = this.state.currentConversationId;
+    const parentMessageId = toolCall.messageId;
+    const subAgent = {
+      id: subAgentId,
+      parentConversationId,
+      parentMessageId,
+      toolCallId: toolCall.id,
+      agentType: input.subagent_type || "custom",
+      name: String(input.description || "Sub-agent"),
+      task: this.truncateContent(String(input.prompt || input.description || "Unknown task")),
+      model: input.model || "claude-sonnet-4-20250514",
+      status: "running",
+      startedAt: now,
+      tokenUsage: this.createEmptyTokenUsage(),
+      metadata: this.createBaseMetadata(["sub-agent", String(input.subagent_type || "custom")])
+    };
+    this.state.storage.subAgents.set(subAgentId, subAgent);
+    this.state.subAgentStack.push(subAgentId);
+    const conversation = this.state.storage.conversations.get(parentConversationId);
+    if (conversation) {
+      conversation.subAgentIds = conversation.subAgentIds || [];
+      conversation.subAgentIds.push(subAgentId);
+    }
+  }
+  /**
+   * Handle sub-agent completion
+   */
+  handleSubAgentComplete(event) {
+    if (!this.state.storage) return;
+    const subAgentId = this.state.subAgentStack.pop();
+    if (!subAgentId) return;
+    const subAgent = this.state.storage.subAgents.get(subAgentId);
+    if (!subAgent) return;
+    const now = /* @__PURE__ */ new Date();
+    subAgent.completedAt = now;
+    subAgent.status = event.error ? "failed" : "completed";
+    subAgent.result = {
+      success: !event.error,
+      summary: this.truncateContent(event.toolOutput || "").slice(0, 500),
+      error: event.error
+    };
+    subAgent.metadata.updatedAt = now;
+    this.saveSubAgent(subAgent);
+  }
+  /**
+   * Handle swarm operation
+   */
+  handleSwarmOperation(event, _toolCall) {
+    if (!this.state.storage) return;
+    const input = event.toolInput;
+    if (event.toolName?.includes("swarm_init")) {
+      const swarmId = createSwarmId();
+      const now = /* @__PURE__ */ new Date();
+      const swarm = {
+        id: swarmId,
+        sessionId: this.state.storage.session.id,
+        name: String(input.name || "Swarm"),
+        topology: input.topology || "mesh",
+        strategy: input.strategy || "adaptive",
+        maxAgents: input.maxAgents || 8,
+        agentIds: [],
+        task: String(input.task || "Swarm task"),
+        status: "running",
+        startedAt: now,
+        tokenUsage: this.createEmptyAggregatedTokenUsage(),
+        metadata: this.createBaseMetadata(["swarm"])
+      };
+      this.state.storage.swarms.set(swarmId, swarm);
+      this.state.storage.session.swarmIds = this.state.storage.session.swarmIds || [];
+      this.state.storage.session.swarmIds.push(swarmId);
+      this.state.activeSwarmId = swarmId;
+    }
+  }
+  /**
+   * Categorize tool calls
+   */
+  categorizeToolCall(toolName) {
+    const categories = {
+      Read: "file",
+      Write: "file",
+      Edit: "file",
+      MultiEdit: "file",
+      Glob: "file",
+      Grep: "file",
+      Bash: "bash",
+      Task: "task",
+      WebFetch: "search",
+      WebSearch: "search",
+      TodoWrite: "todo",
+      NotebookEdit: "notebook",
+      Skill: "skill"
+    };
+    if (toolName.startsWith("mcp__")) {
+      return "mcp";
+    }
+    return categories[toolName] || "other";
+  }
+  /**
+   * Aggregate session tokens
+   */
+  aggregateSessionTokens() {
+    if (!this.state.storage) return;
+    let totalInput = 0;
+    let totalOutput = 0;
+    let operationCount = 0;
+    for (const conversation of this.state.storage.conversations.values()) {
+      totalInput += conversation.tokenUsage.inputTokens;
+      totalOutput += conversation.tokenUsage.outputTokens;
+      operationCount++;
+    }
+    this.state.storage.session.tokenUsage = {
+      inputTokens: totalInput,
+      outputTokens: totalOutput,
+      totalTokens: totalInput + totalOutput,
+      operationCount
+    };
+  }
+  /**
+   * Truncate content to max length
+   */
+  truncateContent(content) {
+    if (content.length <= this.config.maxContentLength) {
+      return content;
+    }
+    return content.slice(0, this.config.maxContentLength) + "\n\n[... truncated ...]";
+  }
+  /**
+   * Get storage path for an entity
+   */
+  getStoragePath(type, id) {
+    const dir = join(this.projectRoot, this.config.storageDir, type);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    return join(dir, `${id}.json`);
+  }
+  /**
+   * Get markdown path for an entity
+   */
+  getMarkdownPath(type, id) {
+    const dir = join(this.projectRoot, this.config.storageDir, "docs", type);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    return join(dir, `${id}.md`);
+  }
+  /**
+   * Save session to storage
+   */
+  saveSession(session) {
+    const path = this.getStoragePath("sessions", session.id);
+    writeFileSync(path, JSON.stringify(session, null, 2));
+    if (this.config.createMarkdown) {
+      this.saveSessionMarkdown(session);
+    }
+  }
+  /**
+   * Save session as markdown
+   */
+  saveSessionMarkdown(session) {
+    const path = this.getMarkdownPath("sessions", session.id);
+    const content = `---
+title: "${session.name}"
+type: claude-session
+status: ${session.status}
+created: ${session.startedAt.toISOString()}
+updated: ${session.metadata.updatedAt.toISOString()}
+tags: [${session.metadata.tags.join(", ")}]
+session_id: "${session.id}"
+---
+
+# ${session.name}
+
+**Purpose:** ${session.purpose || "General interaction"}
+
+**Started:** ${session.startedAt.toISOString()}
+${session.endedAt ? `**Ended:** ${session.endedAt.toISOString()}` : "**Status:** In Progress"}
+
+## Environment
+
+- **Working Directory:** ${session.environment?.workingDirectory || "Unknown"}
+${session.environment?.gitBranch ? `- **Git Branch:** ${session.environment.gitBranch}` : ""}
+
+## Conversations
+
+${session.conversationIds.map((id) => `- [[${id}]]`).join("\n") || "No conversations yet"}
+
+## Token Usage
+
+| Metric | Count |
+|--------|-------|
+| Input Tokens | ${session.tokenUsage.inputTokens} |
+| Output Tokens | ${session.tokenUsage.outputTokens} |
+| Total Tokens | ${session.tokenUsage.totalTokens} |
+| Operations | ${session.tokenUsage.operationCount} |
+
+---
+> Captured by kg-agent hook system
+`;
+    writeFileSync(path, content);
+  }
+  /**
+   * Save message to storage
+   */
+  saveMessage(message) {
+    if (this.config.createMarkdown) {
+      this.appendToConversationLog(message);
+    }
+  }
+  /**
+   * Append message to conversation log
+   */
+  appendToConversationLog(message) {
+    const path = this.getMarkdownPath("conversations", message.conversationId);
+    const dir = dirname(path);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    if (!existsSync(path)) {
+      const header = `---
+title: "Conversation ${message.conversationId}"
+type: claude-conversation
+created: ${message.timestamp.toISOString()}
+tags: [${this.config.defaultTags.join(", ")}]
+---
+
+# Conversation Log
+
+`;
+      writeFileSync(path, header);
+    }
+    const roleIcon = message.role === "user" ? "👤" : "🤖";
+    const entry = `
+## ${roleIcon} ${message.role.charAt(0).toUpperCase() + message.role.slice(1)} - ${message.timestamp.toISOString()}
+
+${message.content}
+
+${message.toolCallIds && message.toolCallIds.length > 0 ? `**Tool Calls:** ${message.toolCallIds.join(", ")}` : ""}
+
+---
+`;
+    appendFileSync(path, entry);
+  }
+  /**
+   * Save tool call to storage
+   */
+  saveToolCall(toolCall) {
+    if (this.config.separateToolOutputs && toolCall.output) {
+      const path = this.getStoragePath("tool-outputs", toolCall.id);
+      writeFileSync(
+        path,
+        JSON.stringify(
+          {
+            id: toolCall.id,
+            name: toolCall.toolName,
+            category: toolCall.toolCategory,
+            input: toolCall.input,
+            output: toolCall.output,
+            status: toolCall.status,
+            executionTimeMs: toolCall.executionTimeMs,
+            affectedFiles: toolCall.affectedFiles,
+            timestamp: toolCall.completedAt?.toISOString()
+          },
+          null,
+          2
+        )
+      );
+    }
+  }
+  /**
+   * Save sub-agent to storage
+   */
+  saveSubAgent(subAgent) {
+    const path = this.getStoragePath("agents", subAgent.id);
+    writeFileSync(path, JSON.stringify(subAgent, null, 2));
+    if (this.config.createMarkdown) {
+      this.saveSubAgentMarkdown(subAgent);
+    }
+  }
+  /**
+   * Save sub-agent as markdown
+   */
+  saveSubAgentMarkdown(subAgent) {
+    const path = this.getMarkdownPath("agents", subAgent.id);
+    const content = `---
+title: "Sub-Agent: ${subAgent.name.slice(0, 50)}"
+type: claude-agent
+status: ${subAgent.status}
+agent_type: ${subAgent.agentType}
+created: ${subAgent.startedAt.toISOString()}
+tags: [${subAgent.metadata.tags.join(", ")}]
+---
+
+# Sub-Agent: ${subAgent.agentType}
+
+**Name:** ${subAgent.name}
+**Task:** ${subAgent.task.slice(0, 200)}${subAgent.task.length > 200 ? "..." : ""}
+
+**Status:** ${subAgent.status}
+**Model:** ${subAgent.model}
+**Spawned:** ${subAgent.startedAt.toISOString()}
+${subAgent.completedAt ? `**Completed:** ${subAgent.completedAt.toISOString()}` : ""}
+
+## Task Description
+
+\`\`\`
+${subAgent.task}
+\`\`\`
+
+${subAgent.result ? `
+## Result
+
+**Success:** ${subAgent.result.success}
+
+${subAgent.result.summary ? `### Summary
+${subAgent.result.summary}` : ""}
+
+${subAgent.result.error ? `### Error
+\`\`\`
+${subAgent.result.error}
+\`\`\`` : ""}
+` : ""}
+
+---
+> Captured by kg-agent hook system
+`;
+    writeFileSync(path, content);
+  }
+  /**
+   * Get current session
+   */
+  getCurrentSession() {
+    return this.state.storage?.session || null;
+  }
+  /**
+   * Get current conversation
+   */
+  getCurrentConversation() {
+    if (!this.state.storage || !this.state.currentConversationId) return null;
+    return this.state.storage.conversations.get(this.state.currentConversationId) || null;
+  }
+  /**
+   * Load session from storage
+   */
+  loadSession(sessionId) {
+    const path = this.getStoragePath("sessions", sessionId);
+    if (!existsSync(path)) return null;
+    try {
+      const data = readFileSync(path, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * List all stored sessions
+   */
+  listSessions() {
+    const sessionsDir = join(this.projectRoot, this.config.storageDir, "sessions");
+    if (!existsSync(sessionsDir)) return [];
+    try {
+      const { readdirSync } = require("fs");
+      const files = readdirSync(sessionsDir);
+      return files.filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
+    } catch {
+      return [];
+    }
+  }
+}
+async function processHookEvent(projectRoot, eventType, config) {
+  const capture = new HookCaptureSystem(projectRoot, config);
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  const inputData = Buffer.concat(chunks).toString("utf-8");
+  let eventData;
+  try {
+    const parsed = JSON.parse(inputData);
+    eventData = {
+      event: eventType,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      toolName: parsed.tool_name || process.env.TOOL_NAME,
+      toolInput: parsed.tool_input,
+      toolOutput: parsed.tool_output,
+      userPrompt: parsed.user_prompt || inputData,
+      metadata: parsed
+    };
+  } catch {
+    eventData = {
+      event: eventType,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      userPrompt: inputData
+    };
+  }
+  capture.handleHookEvent(eventData);
+}
+function generateHookConfig(projectRoot) {
+  const kgBinPath = "npx @weavelogic/knowledge-graph-agent";
+  return {
+    hooks: {
+      UserPromptSubmit: [
+        {
+          type: "command",
+          command: `${kgBinPath} hooks capture --event UserPromptSubmit --path "${projectRoot}"`
+        }
+      ],
+      PreToolUse: [
+        {
+          type: "command",
+          command: `${kgBinPath} hooks capture --event PreToolUse --path "${projectRoot}"`
+        }
+      ],
+      PostToolUse: [
+        {
+          type: "command",
+          command: `${kgBinPath} hooks capture --event PostToolUse --path "${projectRoot}"`
+        }
+      ],
+      Stop: [
+        {
+          type: "command",
+          command: `${kgBinPath} hooks capture --event Stop --path "${projectRoot}"`
+        }
+      ]
+    }
+  };
+}
+export {
+  DEFAULT_CAPTURE_CONFIG,
+  HookCaptureSystem,
+  HookCaptureSystem as default,
+  generateHookConfig,
+  processHookEvent
+};
+//# sourceMappingURL=hook-capture.js.map