memorix 0.2.1 → 0.2.3

package/dist/index.js

@@ -372,6 +372,258 @@ var init_orama_store = __esm({
   }
 });
 
+// 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/memory/retention.ts
 var retention_exports = {};
 __export(retention_exports, {
@@ -917,6 +1169,9 @@ async function reindexObservations() {
   return count2;
 }
 
+// src/server.ts
+init_orama_store();
+
 // src/memory/auto-relations.ts
 init_esm_shims();
 function inferRelationType(obs) {
@@ -2215,10 +2470,10 @@ var WorkspaceSyncEngine = class {
     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;
@@ -2385,6 +2640,23 @@ async function createMemorixServer(cwd) {
   }
   console.error(`[memorix] Project: ${project.id} (${project.name})`);
   console.error(`[memorix] Data dir: ${projectDir2}`);
+  try {
+    const { getHookStatus: getHookStatus2, installHooks: installHooks2, detectInstalledAgents: detectInstalledAgents2 } = await Promise.resolve().then(() => (init_installers(), installers_exports));
+    const workDir = cwd ?? process.cwd();
+    const statuses = await getHookStatus2(workDir);
+    const anyInstalled = statuses.some((s) => s.installed);
+    if (!anyInstalled) {
+      const agents = await detectInstalledAgents2();
+      for (const agent of agents) {
+        try {
+          const config = await installHooks2(agent, workDir);
+          console.error(`[memorix] Auto-installed hooks for ${agent} \u2192 ${config.configPath}`);
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
   const observationsFile = projectDir2 + "/observations.json";
   let reloadDebounce = null;
   try {
@@ -2392,6 +2664,7 @@ async function createMemorixServer(cwd) {
       if (reloadDebounce) clearTimeout(reloadDebounce);
       reloadDebounce = setTimeout(async () => {
         try {
+          await resetDb();
           await initObservations(projectDir2);
           const count2 = await reindexObservations();
           if (count2 > 0) {