memorix 0.1.5 → 0.2.1

package/dist/cli/index.js

@@ -722,6 +722,15 @@ var init_entity_extractor = __esm({
 });
 
 // src/memory/observations.ts
+var observations_exports = {};
+__export(observations_exports, {
+  getObservation: () => getObservation,
+  getObservationCount: () => getObservationCount2,
+  getProjectObservations: () => getProjectObservations,
+  initObservations: () => initObservations,
+  reindexObservations: () => reindexObservations,
+  storeObservation: () => storeObservation
+});
 async function initObservations(dir) {
   projectDir = dir;
   const loaded = await loadObservationsJson(dir);
@@ -793,6 +802,12 @@ async function storeObservation(input) {
 function getObservation(id) {
   return observations.find((o) => o.id === id);
 }
+function getProjectObservations(projectId) {
+  return observations.filter((o) => o.projectId === projectId);
+}
+function getObservationCount2() {
+  return observations.length;
+}
 async function reindexObservations() {
   let count2 = 0;
   for (const obs of observations) {
@@ -2264,10 +2279,10 @@ var init_engine2 = __esm({
         for (const [target, adapter] of this.adapters) {
           const configPath = adapter.getConfigPath(this.projectRoot);
           const globalPath = adapter.getConfigPath();
-          for (const path5 of [configPath, globalPath]) {
-            if (existsSync3(path5)) {
+          for (const path6 of [configPath, globalPath]) {
+            if (existsSync3(path6)) {
               try {
-                const content = readFileSync(path5, "utf-8");
+                const content = readFileSync(path6, "utf-8");
                 const servers = adapter.parse(content);
                 if (servers.length > 0) {
                   mcpConfigs[target] = servers;
@@ -2532,6 +2547,7 @@ var server_exports = {};
 __export(server_exports, {
   createMemorixServer: () => createMemorixServer
 });
+import { watch } from "fs";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 async function createMemorixServer(cwd) {
@@ -2546,6 +2562,26 @@ async function createMemorixServer(cwd) {
   }
   console.error(`[memorix] Project: ${project.id} (${project.name})`);
   console.error(`[memorix] Data dir: ${projectDir2}`);
+  const observationsFile = projectDir2 + "/observations.json";
+  let reloadDebounce = null;
+  try {
+    watch(observationsFile, () => {
+      if (reloadDebounce) clearTimeout(reloadDebounce);
+      reloadDebounce = setTimeout(async () => {
+        try {
+          await initObservations(projectDir2);
+          const count2 = await reindexObservations();
+          if (count2 > 0) {
+            console.error(`[memorix] Hot-reloaded ${count2} observations (external write detected)`);
+          }
+        } catch {
+        }
+      }, 500);
+    });
+    console.error(`[memorix] Watching for external writes (hooks hot-reload enabled)`);
+  } catch {
+    console.error(`[memorix] Warning: could not watch observations file for hot-reload`);
+  }
   const server = new McpServer({
     name: "memorix",
     version: "0.1.0"
@@ -3204,8 +3240,8 @@ var init_sync = __esm({
       run: async ({ args }) => {
         const { detectProject: detectProject2 } = await Promise.resolve().then(() => (init_detector(), detector_exports));
         const { RulesSyncer: RulesSyncer2 } = await Promise.resolve().then(() => (init_syncer(), syncer_exports));
-        const { promises: fs3 } = await import("fs");
-        const path5 = await import("path");
+        const { promises: fs4 } = await import("fs");
+        const path6 = await import("path");
         p2.intro("memorix sync");
         const project = detectProject2();
         p2.log.info(`Project: ${project.name} (${project.id})`);
@@ -3273,9 +3309,9 @@ var init_sync = __esm({
           process.exit(0);
         }
         for (const file of files) {
-          const fullPath = path5.join(project.rootPath, file.filePath);
-          await fs3.mkdir(path5.dirname(fullPath), { recursive: true });
-          await fs3.writeFile(fullPath, file.content, "utf-8");
+          const fullPath = path6.join(project.rootPath, file.filePath);
+          await fs4.mkdir(path6.dirname(fullPath), { recursive: true });
+          await fs4.writeFile(fullPath, file.content, "utf-8");
           p2.log.success(`Written: ${file.filePath}`);
         }
         p2.outro(`Synced ${files.length} rule(s) to ${target} format`);
@@ -3284,10 +3320,918 @@ var init_sync = __esm({
   }
 });
 
+// src/hooks/normalizer.ts
+function detectAgent(payload) {
+  if ("agent_action_name" in payload) return "windsurf";
+  if ("hook_event_name" in payload && "conversation_id" in payload) return "cursor";
+  if ("hookEventName" in payload) {
+    return "copilot";
+  }
+  if ("event_type" in payload) return "kiro";
+  if ("hook_type" in payload) return "codex";
+  return "claude";
+}
+function extractEventName(payload, agent) {
+  switch (agent) {
+    case "windsurf":
+      return payload.agent_action_name ?? "";
+    case "cursor":
+      return payload.hook_event_name ?? "";
+    case "copilot":
+    case "claude":
+      return payload.hookEventName ?? "";
+    case "kiro":
+      return payload.event_type ?? "";
+    case "codex":
+      return payload.hook_type ?? "";
+    default:
+      return "";
+  }
+}
+function normalizeClaude(payload, event) {
+  const result = {
+    sessionId: payload.sessionId ?? "",
+    cwd: payload.cwd ?? "",
+    transcriptPath: payload.transcript_path
+  };
+  const toolName = payload.tool_name ?? "";
+  if (toolName) {
+    result.toolName = toolName;
+    result.toolInput = payload.tool_input;
+    result.toolResult = payload.tool_result;
+    if (toolName === "write" || toolName === "edit" || toolName === "multi_edit") {
+      const input = payload.tool_input;
+      result.filePath = input?.file_path ?? input?.filePath;
+    }
+  }
+  if (event === "user_prompt") {
+    result.userPrompt = payload.prompt ?? "";
+  }
+  return result;
+}
+function normalizeWindsurf(payload, event) {
+  const toolInfo = payload.tool_info ?? {};
+  const result = {
+    sessionId: payload.trajectory_id ?? "",
+    cwd: ""
+  };
+  switch (event) {
+    case "post_edit":
+      result.filePath = toolInfo.file_path;
+      if (Array.isArray(toolInfo.edits)) {
+        result.edits = toolInfo.edits.map((e) => ({
+          oldString: e.old_string ?? "",
+          newString: e.new_string ?? ""
+        }));
+      }
+      break;
+    case "post_command":
+      result.command = toolInfo.command_line;
+      result.cwd = toolInfo.cwd ?? "";
+      break;
+    case "post_tool":
+      result.toolName = toolInfo.mcp_tool_name;
+      result.toolInput = toolInfo.mcp_tool_arguments;
+      result.toolResult = toolInfo.mcp_result;
+      break;
+    case "user_prompt":
+      result.userPrompt = toolInfo.user_prompt;
+      break;
+    case "post_response":
+      result.aiResponse = toolInfo.response;
+      break;
+  }
+  return result;
+}
+function normalizeCursor(payload, event) {
+  const result = {
+    sessionId: payload.conversation_id ?? "",
+    cwd: payload.cwd ?? ""
+  };
+  const roots = payload.workspace_roots;
+  if (roots?.length && !result.cwd) {
+    result.cwd = roots[0];
+  }
+  switch (event) {
+    case "user_prompt":
+      result.userPrompt = payload.prompt ?? "";
+      break;
+    case "post_command":
+      result.command = payload.command ?? "";
+      break;
+    case "post_edit":
+      result.filePath = payload.file_path ?? "";
+      break;
+  }
+  return result;
+}
+function normalizeHookInput(payload) {
+  const agent = detectAgent(payload);
+  const rawEventName = extractEventName(payload, agent);
+  const event = EVENT_MAP[rawEventName] ?? "post_tool";
+  const timestamp = payload.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+  let agentSpecific = {};
+  switch (agent) {
+    case "claude":
+    case "copilot":
+      agentSpecific = normalizeClaude(payload, event);
+      break;
+    case "windsurf":
+      agentSpecific = normalizeWindsurf(payload, event);
+      break;
+    case "cursor":
+      agentSpecific = normalizeCursor(payload, event);
+      break;
+    default:
+      agentSpecific = { sessionId: "", cwd: "" };
+  }
+  return {
+    event,
+    agent,
+    timestamp,
+    sessionId: agentSpecific.sessionId ?? "",
+    cwd: agentSpecific.cwd ?? "",
+    raw: payload,
+    ...agentSpecific
+  };
+}
+var EVENT_MAP;
+var init_normalizer = __esm({
+  "src/hooks/normalizer.ts"() {
+    "use strict";
+    init_esm_shims();
+    EVENT_MAP = {
+      // Claude Code / VS Code Copilot
+      SessionStart: "session_start",
+      UserPromptSubmit: "user_prompt",
+      PreToolUse: "post_tool",
+      // we handle pre as post for memory purposes
+      PostToolUse: "post_tool",
+      PreCompact: "pre_compact",
+      Stop: "session_end",
+      // Windsurf
+      pre_user_prompt: "user_prompt",
+      post_write_code: "post_edit",
+      post_read_code: "post_tool",
+      post_run_command: "post_command",
+      pre_mcp_tool_use: "post_tool",
+      post_mcp_tool_use: "post_tool",
+      post_cascade_response: "post_response",
+      // Cursor
+      beforeSubmitPrompt: "user_prompt",
+      beforeShellExecution: "post_command",
+      beforeMCPExecution: "post_tool",
+      afterFileEdit: "post_edit",
+      stop: "session_end"
+    };
+  }
+});
+
+// src/hooks/pattern-detector.ts
+function detectPatterns(content) {
+  if (!content || content.length < MIN_CONTENT_LENGTH) {
+    return [];
+  }
+  const results = [];
+  for (const pattern of PATTERNS) {
+    if (content.length < pattern.minLength) continue;
+    const matchedKeywords = [];
+    let matchCount = 0;
+    for (const regex of pattern.keywords) {
+      const matches = content.match(new RegExp(regex.source, regex.flags + "g"));
+      if (matches) {
+        matchCount += matches.length;
+        matchedKeywords.push(...matches.map((m) => m.trim()));
+      }
+    }
+    if (matchCount > 0) {
+      const confidence = Math.min(1, pattern.baseConfidence + matchCount * 0.05);
+      results.push({
+        type: pattern.type,
+        confidence,
+        matchedKeywords: [...new Set(matchedKeywords)].slice(0, 5)
+      });
+    }
+  }
+  results.sort((a, b) => b.confidence - a.confidence);
+  return results;
+}
+function detectBestPattern(content, minConfidence = 0.5) {
+  const patterns = detectPatterns(content);
+  if (patterns.length === 0) return null;
+  if (patterns[0].confidence < minConfidence) return null;
+  return patterns[0];
+}
+function patternToObservationType(pattern) {
+  const map = {
+    decision: "decision",
+    error: "problem-solution",
+    gotcha: "gotcha",
+    configuration: "what-changed",
+    learning: "discovery",
+    implementation: "what-changed"
+  };
+  return map[pattern] ?? "discovery";
+}
+var MIN_CONTENT_LENGTH, PATTERNS;
+var init_pattern_detector = __esm({
+  "src/hooks/pattern-detector.ts"() {
+    "use strict";
+    init_esm_shims();
+    MIN_CONTENT_LENGTH = 100;
+    PATTERNS = [
+      {
+        type: "decision",
+        keywords: [
+          /\b(decided|chose|will use|settled on|going with|picked|selected)\b/i,
+          /(决定|选择了|采用|确定用|最终选了)/,
+          /\b(architecture|approach|strategy|pattern|framework)\b/i
+        ],
+        minLength: 100,
+        baseConfidence: 0.8
+      },
+      {
+        type: "error",
+        keywords: [
+          /\b(error|bug|fix(ed)?|resolv(ed|ing)|crash|fail(ed|ure)?|broken)\b/i,
+          /(错误|修复|报错|崩溃|失败|异常|解决了)/,
+          /\b(workaround|hotfix|patch|regression|stack\s*trace)\b/i
+        ],
+        minLength: 100,
+        baseConfidence: 0.75
+      },
+      {
+        type: "gotcha",
+        keywords: [
+          /\b(gotcha|pitfall|trap|caveat|watch out|careful|beware|warning)\b/i,
+          /(坑|注意|陷阱|小心|踩坑|坑点)/,
+          /\b(don'?t|never|avoid|must not|不要|千万别|切记)\b/i
+        ],
+        minLength: 80,
+        baseConfidence: 0.85
+      },
+      {
+        type: "configuration",
+        keywords: [
+          /\b(config(ured?|uration)?|setting|environment|env\b|\.env|path|port)\b/i,
+          /(配置|环境|路径|端口|设置|安装)/,
+          /\b(gradle|webpack|vite|tsconfig|package\.json|docker)\b/i
+        ],
+        minLength: 80,
+        baseConfidence: 0.7
+      },
+      {
+        type: "learning",
+        keywords: [
+          /\b(learn(ed)?|discover(ed)?|realiz(ed)?|turns?\s*out|found\s*out|TIL)\b/i,
+          /(学到|发现|原来|才知道|了解到)/,
+          /\b(insight|understanding|clarif(ied|ication))\b/i
+        ],
+        minLength: 150,
+        baseConfidence: 0.65
+      },
+      {
+        type: "implementation",
+        keywords: [
+          /\b(implement(ed)?|creat(ed|ing)|built|added|integrat(ed|ing))\b/i,
+          /(实现了|创建了|添加了|集成了|完成了)/,
+          /\b(refactor(ed)?|migrat(ed|ing)|upgrad(ed|ing))\b/i
+        ],
+        minLength: 200,
+        baseConfidence: 0.5
+      }
+    ];
+  }
+});
+
+// src/hooks/handler.ts
+var handler_exports = {};
+__export(handler_exports, {
+  handleHookEvent: () => handleHookEvent,
+  runHook: () => runHook
+});
+function isInCooldown(eventKey) {
+  const last = cooldowns.get(eventKey);
+  if (!last) return false;
+  return Date.now() - last < COOLDOWN_MS;
+}
+function markTriggered(eventKey) {
+  cooldowns.set(eventKey, Date.now());
+}
+function extractContent(input) {
+  const parts = [];
+  if (input.userPrompt) parts.push(input.userPrompt);
+  if (input.aiResponse) parts.push(input.aiResponse);
+  if (input.toolResult) parts.push(input.toolResult);
+  if (input.commandOutput) parts.push(input.commandOutput);
+  if (input.command) parts.push(`Command: ${input.command}`);
+  if (input.filePath) parts.push(`File: ${input.filePath}`);
+  if (input.edits) {
+    for (const edit of input.edits) {
+      parts.push(`Edit: ${edit.oldString} \u2192 ${edit.newString}`);
+    }
+  }
+  return parts.join("\n").slice(0, MAX_CONTENT_LENGTH);
+}
+function deriveEntityName(input) {
+  if (input.filePath) {
+    const parts = input.filePath.replace(/\\/g, "/").split("/");
+    const filename = parts[parts.length - 1];
+    return filename.replace(/\.[^.]+$/, "");
+  }
+  if (input.toolName) return input.toolName;
+  if (input.command) {
+    const firstWord = input.command.split(/\s+/)[0];
+    return firstWord.replace(/[^a-zA-Z0-9-_]/g, "");
+  }
+  return "session";
+}
+function generateTitle(input, patternType) {
+  const maxLen = 60;
+  if (input.filePath) {
+    const filename = input.filePath.replace(/\\/g, "/").split("/").pop() ?? "";
+    const verb = patternType === "problem-solution" ? "Fixed issue in" : patternType === "what-changed" ? "Changed" : "Updated";
+    return `${verb} ${filename}`.slice(0, maxLen);
+  }
+  if (input.command) {
+    return `Ran: ${input.command}`.slice(0, maxLen);
+  }
+  if (input.userPrompt) {
+    return input.userPrompt.slice(0, maxLen);
+  }
+  return `Session activity (${patternType})`;
+}
+function buildObservation(input, content) {
+  const pattern = detectBestPattern(content);
+  const obsType = pattern ? patternToObservationType(pattern.type) : "discovery";
+  return {
+    entityName: deriveEntityName(input),
+    type: obsType,
+    title: generateTitle(input, obsType),
+    narrative: content.slice(0, 2e3),
+    facts: [
+      `Agent: ${input.agent}`,
+      `Session: ${input.sessionId}`,
+      ...input.filePath ? [`File: ${input.filePath}`] : [],
+      ...input.command ? [`Command: ${input.command}`] : []
+    ],
+    concepts: pattern?.matchedKeywords ?? [],
+    filesModified: input.filePath ? [input.filePath] : []
+  };
+}
+async function handleHookEvent(input) {
+  const defaultOutput = { continue: true };
+  if (input.toolName === "memorix_store" || input.toolName === "memorix_search") {
+    return { observation: null, output: defaultOutput };
+  }
+  switch (input.event) {
+    case "session_start":
+      return {
+        observation: null,
+        output: {
+          continue: true,
+          systemMessage: "Memorix is active. Your memories from previous sessions are available via memorix_search."
+        }
+      };
+    case "pre_compact":
+      return {
+        observation: buildObservation(input, extractContent(input)),
+        output: defaultOutput
+      };
+    case "session_end":
+      return {
+        observation: buildObservation(input, extractContent(input)),
+        output: defaultOutput
+      };
+    case "post_edit":
+    case "post_command":
+    case "post_tool":
+    case "post_response":
+    case "user_prompt": {
+      const cooldownKey = `${input.event}:${input.filePath ?? input.command ?? "general"}`;
+      if (isInCooldown(cooldownKey)) {
+        return { observation: null, output: defaultOutput };
+      }
+      const content = extractContent(input);
+      if (content.length < MIN_STORE_LENGTH) {
+        return { observation: null, output: defaultOutput };
+      }
+      const pattern = detectBestPattern(content);
+      if (!pattern) {
+        return { observation: null, output: defaultOutput };
+      }
+      markTriggered(cooldownKey);
+      return {
+        observation: buildObservation(input, content),
+        output: defaultOutput
+      };
+    }
+    default:
+      return { observation: null, output: defaultOutput };
+  }
+}
+async function runHook() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  const rawInput = Buffer.concat(chunks).toString("utf-8").trim();
+  if (!rawInput) {
+    process.stdout.write(JSON.stringify({ continue: true }));
+    return;
+  }
+  let payload;
+  try {
+    payload = JSON.parse(rawInput);
+  } catch {
+    process.stdout.write(JSON.stringify({ continue: true }));
+    return;
+  }
+  const input = normalizeHookInput(payload);
+  const { observation, output } = await handleHookEvent(input);
+  if (observation) {
+    try {
+      const { storeObservation: storeObservation2, initObservations: initObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
+      const { detectProject: detectProject2 } = await Promise.resolve().then(() => (init_detector(), detector_exports));
+      const { getProjectDataDir: getProjectDataDir2 } = await Promise.resolve().then(() => (init_persistence(), persistence_exports));
+      const project = await detectProject2(input.cwd || process.cwd());
+      const dataDir = await getProjectDataDir2(project.id);
+      await initObservations2(dataDir);
+      await storeObservation2({ ...observation, projectId: project.id });
+    } catch {
+    }
+  }
+  process.stdout.write(JSON.stringify(output));
+}
+var cooldowns, COOLDOWN_MS, MIN_STORE_LENGTH, MAX_CONTENT_LENGTH;
+var init_handler = __esm({
+  "src/hooks/handler.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_normalizer();
+    init_pattern_detector();
+    cooldowns = /* @__PURE__ */ new Map();
+    COOLDOWN_MS = 3e4;
+    MIN_STORE_LENGTH = 100;
+    MAX_CONTENT_LENGTH = 4e3;
+  }
+});
+
+// src/cli/commands/hook.ts
+var hook_exports = {};
+__export(hook_exports, {
+  default: () => hook_default
+});
+import { defineCommand as defineCommand4 } from "citty";
+var hook_default;
+var init_hook = __esm({
+  "src/cli/commands/hook.ts"() {
+    "use strict";
+    init_esm_shims();
+    hook_default = defineCommand4({
+      meta: {
+        name: "hook",
+        description: "Handle agent hook event (called by agent hook configs)"
+      },
+      run: async () => {
+        const { runHook: runHook2 } = await Promise.resolve().then(() => (init_handler(), handler_exports));
+        await runHook2();
+      }
+    });
+  }
+});
+
+// src/hooks/installers/index.ts
+var installers_exports = {};
+__export(installers_exports, {
+  detectInstalledAgents: () => detectInstalledAgents,
+  getHookStatus: () => getHookStatus,
+  installHooks: () => installHooks,
+  uninstallHooks: () => uninstallHooks
+});
+import * as fs3 from "fs/promises";
+import * as path5 from "path";
+import * as os2 from "os";
+function generateClaudeConfig() {
+  const hookEntry = {
+    type: "command",
+    command: `${HOOK_COMMAND} ${HOOK_ARGS.join(" ")}`,
+    timeout: 10
+  };
+  return {
+    hooks: {
+      SessionStart: [hookEntry],
+      PostToolUse: [hookEntry],
+      UserPromptSubmit: [hookEntry],
+      PreCompact: [hookEntry],
+      Stop: [hookEntry]
+    }
+  };
+}
+function generateWindsurfConfig() {
+  const hookEntry = {
+    command: `${HOOK_COMMAND} ${HOOK_ARGS.join(" ")}`,
+    timeout: 10
+  };
+  return {
+    hooks: {
+      post_write_code: [hookEntry],
+      post_run_command: [hookEntry],
+      post_mcp_tool_use: [hookEntry],
+      pre_user_prompt: [hookEntry],
+      post_cascade_response: [hookEntry]
+    }
+  };
+}
+function generateCursorConfig() {
+  return {
+    hooks: {
+      beforeSubmitPrompt: {
+        command: `${HOOK_COMMAND} ${HOOK_ARGS.join(" ")}`
+      },
+      afterFileEdit: {
+        command: `${HOOK_COMMAND} ${HOOK_ARGS.join(" ")}`
+      },
+      stop: {
+        command: `${HOOK_COMMAND} ${HOOK_ARGS.join(" ")}`
+      }
+    }
+  };
+}
+function generateKiroHookFile() {
+  return `---
+title: Memorix Auto-Memory
+description: Automatically record development context for cross-agent memory sharing
+event: file_saved
+filePattern: "**/*"
+---
+
+Run the memorix hook command to analyze changes and store relevant memories:
+
+\`\`\`bash
+memorix hook
+\`\`\`
+`;
+}
+function getProjectConfigPath(agent, projectRoot) {
+  switch (agent) {
+    case "claude":
+    case "copilot":
+      return path5.join(projectRoot, ".github", "hooks", "memorix.json");
+    case "windsurf":
+      return path5.join(projectRoot, ".windsurf", "hooks.json");
+    case "cursor":
+      return path5.join(projectRoot, ".cursor", "hooks.json");
+    case "kiro":
+      return path5.join(projectRoot, ".kiro", "hooks", "memorix.hook.md");
+    case "codex":
+      return path5.join(projectRoot, ".codex", "hooks.json");
+    default:
+      return path5.join(projectRoot, ".memorix", "hooks.json");
+  }
+}
+function getGlobalConfigPath(agent) {
+  const home = os2.homedir();
+  switch (agent) {
+    case "claude":
+    case "copilot":
+      return path5.join(home, ".claude", "settings.json");
+    case "windsurf":
+      return path5.join(home, ".codeium", "windsurf", "hooks.json");
+    case "cursor":
+      return path5.join(home, ".cursor", "hooks.json");
+    default:
+      return path5.join(home, ".memorix", "hooks.json");
+  }
+}
+async function detectInstalledAgents() {
+  const agents = [];
+  const home = os2.homedir();
+  const claudeDir = path5.join(home, ".claude");
+  try {
+    await fs3.access(claudeDir);
+    agents.push("claude");
+  } catch {
+  }
+  const windsurfDir = path5.join(home, ".codeium", "windsurf");
+  try {
+    await fs3.access(windsurfDir);
+    agents.push("windsurf");
+  } catch {
+  }
+  const cursorDir = path5.join(home, ".cursor");
+  try {
+    await fs3.access(cursorDir);
+    agents.push("cursor");
+  } catch {
+  }
+  if (!agents.includes("claude")) {
+    const vscodeDir = path5.join(home, ".vscode");
+    try {
+      await fs3.access(vscodeDir);
+      agents.push("copilot");
+    } catch {
+    }
+  }
+  const kiroConfig = path5.join(home, ".kiro");
+  try {
+    await fs3.access(kiroConfig);
+    agents.push("kiro");
+  } catch {
+  }
+  return agents;
+}
+async function installHooks(agent, projectRoot, global = false) {
+  const configPath = global ? getGlobalConfigPath(agent) : getProjectConfigPath(agent, projectRoot);
+  let generated;
+  switch (agent) {
+    case "claude":
+    case "copilot":
+      generated = generateClaudeConfig();
+      break;
+    case "windsurf":
+      generated = generateWindsurfConfig();
+      break;
+    case "cursor":
+      generated = generateCursorConfig();
+      break;
+    case "kiro":
+      generated = generateKiroHookFile();
+      break;
+    default:
+      generated = generateClaudeConfig();
+  }
+  await fs3.mkdir(path5.dirname(configPath), { recursive: true });
+  if (agent === "kiro") {
+    await fs3.writeFile(configPath, generated, "utf-8");
+  } else {
+    let existing = {};
+    try {
+      const content = await fs3.readFile(configPath, "utf-8");
+      existing = JSON.parse(content);
+    } catch {
+    }
+    const merged = {
+      ...existing,
+      ...generated
+    };
+    await fs3.writeFile(configPath, JSON.stringify(merged, null, 2), "utf-8");
+  }
+  const events = [];
+  switch (agent) {
+    case "claude":
+    case "copilot":
+      events.push("session_start", "post_tool", "user_prompt", "pre_compact", "session_end");
+      break;
+    case "windsurf":
+      events.push("post_edit", "post_command", "post_tool", "user_prompt", "post_response");
+      break;
+    case "cursor":
+      events.push("user_prompt", "post_edit", "session_end");
+      break;
+    case "kiro":
+      events.push("post_edit");
+      break;
+  }
+  return {
+    agent,
+    configPath,
+    events,
+    generated: typeof generated === "string" ? { content: generated } : generated
+  };
+}
+async function uninstallHooks(agent, projectRoot, global = false) {
+  const configPath = global ? getGlobalConfigPath(agent) : getProjectConfigPath(agent, projectRoot);
+  try {
+    if (agent === "kiro") {
+      await fs3.unlink(configPath);
+    } else {
+      const content = await fs3.readFile(configPath, "utf-8");
+      const config = JSON.parse(content);
+      delete config.hooks;
+      if (Object.keys(config).length === 0) {
+        await fs3.unlink(configPath);
+      } else {
+        await fs3.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getHookStatus(projectRoot) {
+  const results = [];
+  const agents = ["claude", "copilot", "windsurf", "cursor", "kiro", "codex"];
+  for (const agent of agents) {
+    const projectPath = getProjectConfigPath(agent, projectRoot);
+    const globalPath = getGlobalConfigPath(agent);
+    let installed = false;
+    let usedPath = projectPath;
+    try {
+      await fs3.access(projectPath);
+      installed = true;
+    } catch {
+      try {
+        await fs3.access(globalPath);
+        installed = true;
+        usedPath = globalPath;
+      } catch {
+      }
+    }
+    results.push({ agent, installed, configPath: usedPath });
+  }
+  return results;
+}
+var HOOK_COMMAND, HOOK_ARGS;
+var init_installers = __esm({
+  "src/hooks/installers/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    HOOK_COMMAND = "memorix";
+    HOOK_ARGS = ["hook"];
+  }
+});
+
+// src/cli/commands/hooks-install.ts
+var hooks_install_exports = {};
+__export(hooks_install_exports, {
+  default: () => hooks_install_default
+});
+import { defineCommand as defineCommand5 } from "citty";
+var hooks_install_default;
+var init_hooks_install = __esm({
+  "src/cli/commands/hooks-install.ts"() {
+    "use strict";
+    init_esm_shims();
+    hooks_install_default = defineCommand5({
+      meta: {
+        name: "install",
+        description: "Install automatic memory hooks for agents"
+      },
+      args: {
+        agent: {
+          type: "string",
+          description: "Target agent (claude|copilot|windsurf|cursor|kiro|codex). Auto-detects if omitted.",
+          required: false
+        },
+        global: {
+          type: "boolean",
+          description: "Install globally instead of per-project",
+          required: false
+        }
+      },
+      run: async ({ args }) => {
+        const { detectInstalledAgents: detectInstalledAgents2, installHooks: installHooks2 } = await Promise.resolve().then(() => (init_installers(), installers_exports));
+        const cwd = process.cwd();
+        let agents;
+        if (args.agent) {
+          agents = [args.agent];
+        } else {
+          agents = await detectInstalledAgents2();
+          if (agents.length === 0) {
+            console.log("No supported agents detected. Use --agent to specify one.");
+            return;
+          }
+          console.log(`Detected agents: ${agents.join(", ")}`);
+        }
+        for (const agent of agents) {
+          try {
+            const config = await installHooks2(
+              agent,
+              cwd,
+              args.global ?? false
+            );
+            console.log(`\u2705 ${agent}: hooks installed \u2192 ${config.configPath}`);
+            console.log(`   Events: ${config.events.join(", ")}`);
+          } catch (err) {
+            console.error(`\u274C ${agent}: failed \u2014 ${err}`);
+          }
+        }
+        console.log("\nMemory hooks are now active. Restart your agent to apply.");
+      }
+    });
+  }
+});
+
+// src/cli/commands/hooks-uninstall.ts
+var hooks_uninstall_exports = {};
+__export(hooks_uninstall_exports, {
+  default: () => hooks_uninstall_default
+});
+import { defineCommand as defineCommand6 } from "citty";
+var hooks_uninstall_default;
+var init_hooks_uninstall = __esm({
+  "src/cli/commands/hooks-uninstall.ts"() {
+    "use strict";
+    init_esm_shims();
+    hooks_uninstall_default = defineCommand6({
+      meta: {
+        name: "uninstall",
+        description: "Remove automatic memory hooks for agents"
+      },
+      args: {
+        agent: {
+          type: "string",
+          description: "Target agent (claude|copilot|windsurf|cursor|kiro|codex)",
+          required: false
+        },
+        global: {
+          type: "boolean",
+          description: "Uninstall global hooks",
+          required: false
+        }
+      },
+      run: async ({ args }) => {
+        const { detectInstalledAgents: detectInstalledAgents2, uninstallHooks: uninstallHooks2 } = await Promise.resolve().then(() => (init_installers(), installers_exports));
+        const cwd = process.cwd();
+        let agents;
+        if (args.agent) {
+          agents = [args.agent];
+        } else {
+          agents = await detectInstalledAgents2();
+        }
+        for (const agent of agents) {
+          const ok = await uninstallHooks2(
+            agent,
+            cwd,
+            args.global ?? false
+          );
+          if (ok) {
+            console.log(`\u2705 ${agent}: hooks removed`);
+          } else {
+            console.log(`\u26A0\uFE0F  ${agent}: no hooks found`);
+          }
+        }
+      }
+    });
+  }
+});
+
+// src/cli/commands/hooks-status.ts
+var hooks_status_exports = {};
+__export(hooks_status_exports, {
+  default: () => hooks_status_default
+});
+import { defineCommand as defineCommand7 } from "citty";
+var hooks_status_default;
+var init_hooks_status = __esm({
+  "src/cli/commands/hooks-status.ts"() {
+    "use strict";
+    init_esm_shims();
+    hooks_status_default = defineCommand7({
+      meta: {
+        name: "status",
+        description: "Show hook installation status for all agents"
+      },
+      run: async () => {
+        const { getHookStatus: getHookStatus2 } = await Promise.resolve().then(() => (init_installers(), installers_exports));
+        const cwd = process.cwd();
+        const statuses = await getHookStatus2(cwd);
+        console.log("\nMemorix Hooks Status");
+        console.log("\u2550".repeat(50));
+        for (const { agent, installed, configPath } of statuses) {
+          const icon = installed ? "\u2705" : "\u2B1A";
+          const label = agent.charAt(0).toUpperCase() + agent.slice(1);
+          console.log(`${icon} ${label.padEnd(12)} ${installed ? configPath : "(not installed)"}`);
+        }
+        console.log("\nRun `memorix hooks install` to set up hooks for detected agents.");
+      }
+    });
+  }
+});
+
+// src/cli/commands/hooks.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  default: () => hooks_default
+});
+import { defineCommand as defineCommand8 } from "citty";
+var hooks_default;
+var init_hooks = __esm({
+  "src/cli/commands/hooks.ts"() {
+    "use strict";
+    init_esm_shims();
+    hooks_default = defineCommand8({
+      meta: {
+        name: "hooks",
+        description: "Manage automatic memory hooks for agents"
+      },
+      subCommands: {
+        install: () => Promise.resolve().then(() => (init_hooks_install(), hooks_install_exports)).then((m) => m.default),
+        uninstall: () => Promise.resolve().then(() => (init_hooks_uninstall(), hooks_uninstall_exports)).then((m) => m.default),
+        status: () => Promise.resolve().then(() => (init_hooks_status(), hooks_status_exports)).then((m) => m.default)
+      },
+      run() {
+      }
+    });
+  }
+});
+
 // src/cli/index.ts
 init_esm_shims();
-import { defineCommand as defineCommand4, runMain } from "citty";
-var main = defineCommand4({
+import { defineCommand as defineCommand9, runMain } from "citty";
+var main = defineCommand9({
   meta: {
     name: "memorix",
     version: "0.1.0",
@@ -3296,7 +4240,9 @@ var main = defineCommand4({
   subCommands: {
     serve: () => Promise.resolve().then(() => (init_serve(), serve_exports)).then((m) => m.default),
     status: () => Promise.resolve().then(() => (init_status(), status_exports)).then((m) => m.default),
-    sync: () => Promise.resolve().then(() => (init_sync(), sync_exports)).then((m) => m.default)
+    sync: () => Promise.resolve().then(() => (init_sync(), sync_exports)).then((m) => m.default),
+    hook: () => Promise.resolve().then(() => (init_hook(), hook_exports)).then((m) => m.default),
+    hooks: () => Promise.resolve().then(() => (init_hooks(), hooks_exports)).then((m) => m.default)
   },
   run() {
   }