memorix 0.2.2 → 0.3.0

package/dist/index.js

@@ -1,6 +1,12 @@
 #!/usr/bin/env node
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -12,9 +18,13 @@ var __export = (target, all) => {
 // node_modules/tsup/assets/esm_shims.js
 import path from "path";
 import { fileURLToPath } from "url";
+var getFilename, getDirname, __dirname;
 var init_esm_shims = __esm({
   "node_modules/tsup/assets/esm_shims.js"() {
     "use strict";
+    getFilename = () => fileURLToPath(import.meta.url);
+    getDirname = () => path.dirname(getFilename());
+    __dirname = /* @__PURE__ */ getDirname();
   }
 });
 
@@ -372,6 +382,354 @@ 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";
+import { createRequire } from "module";
+function resolveHookCommand() {
+  if (process.platform === "win32") {
+    try {
+      const devPath = path5.resolve(import.meta.dirname ?? __dirname, "../../cli/index.js");
+      try {
+        const fsStat = __require("fs");
+        if (fsStat.existsSync(devPath)) {
+          return `node ${devPath.replace(/\\/g, "/")}`;
+        }
+      } catch {
+      }
+      const require_ = createRequire(import.meta.url);
+      const pkgPath = require_.resolve("memorix/package.json");
+      const cliPath = path5.join(path5.dirname(pkgPath), "dist", "cli", "index.js");
+      return `node ${cliPath.replace(/\\/g, "/")}`;
+    } catch {
+      return "memorix";
+    }
+  }
+  return "memorix";
+}
+function generateClaudeConfig() {
+  const cmd = `${resolveHookCommand()} hook`;
+  const hookEntry = {
+    type: "command",
+    command: cmd,
+    timeout: 10
+  };
+  return {
+    hooks: {
+      SessionStart: [hookEntry],
+      PostToolUse: [hookEntry],
+      UserPromptSubmit: [hookEntry],
+      PreCompact: [hookEntry],
+      Stop: [hookEntry]
+    }
+  };
+}
+function generateWindsurfConfig() {
+  const cmd = `${resolveHookCommand()} hook`;
+  const hookEntry = {
+    command: cmd,
+    show_output: false
+  };
+  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() {
+  const cmd = `${resolveHookCommand()} hook`;
+  return {
+    hooks: {
+      beforeSubmitPrompt: {
+        command: cmd
+      },
+      afterFileEdit: {
+        command: cmd
+      },
+      stop: {
+        command: cmd
+      }
+    }
+  };
+}
+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
+${resolveHookCommand()} 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;
+  }
+  await installAgentRules(agent, projectRoot);
+  return {
+    agent,
+    configPath,
+    events,
+    generated: typeof generated === "string" ? { content: generated } : generated
+  };
+}
+async function installAgentRules(agent, projectRoot) {
+  const rulesContent = getAgentRulesContent();
+  let rulesPath;
+  switch (agent) {
+    case "windsurf":
+      rulesPath = path5.join(projectRoot, ".windsurf", "rules", "memorix.md");
+      break;
+    case "cursor":
+      rulesPath = path5.join(projectRoot, ".cursor", "rules", "memorix.mdc");
+      break;
+    case "claude":
+    case "copilot":
+      rulesPath = path5.join(projectRoot, ".github", "copilot-instructions.md");
+      break;
+    default:
+      return;
+  }
+  try {
+    await fs3.mkdir(path5.dirname(rulesPath), { recursive: true });
+    try {
+      await fs3.access(rulesPath);
+    } catch {
+      await fs3.writeFile(rulesPath, rulesContent, "utf-8");
+    }
+  } catch {
+  }
+}
+function getAgentRulesContent() {
+  return `# Memorix \u2014 Automatic Memory Rules
+
+You have access to Memorix memory tools. Follow these rules to maintain persistent context across sessions.
+
+## Session Start \u2014 Load Context
+
+At the **beginning of every conversation**, before responding to the user:
+
+1. Call \`memorix_search\` with query related to the user's first message or the current project
+2. If results are found, use them to understand the current project state, recent decisions, and pending tasks
+3. Reference relevant memories naturally in your response
+
+This ensures you already know the project context without the user re-explaining.
+
+## During Session \u2014 Capture Important Context
+
+Proactively call \`memorix_store\` when any of the following happen:
+
+- **Architecture decision**: You or the user decide on a technology, pattern, or approach
+- **Bug fix**: A bug is identified and resolved \u2014 store the root cause and fix
+- **Gotcha/pitfall**: Something unexpected or tricky is discovered
+- **Configuration change**: Environment, port, path, or tooling changes
+
+Use appropriate types: \`decision\`, \`problem-solution\`, \`gotcha\`, \`what-changed\`, \`discovery\`.
+
+## Session End \u2014 Store Summary
+
+When the conversation is ending or the user says goodbye:
+
+1. Call \`memorix_store\` with type \`session-request\` to record:
+   - What was accomplished in this session
+   - Current project state
+   - Pending tasks or next steps
+   - Any unresolved issues
+
+This creates a "handoff note" for the next session.
+
+## Guidelines
+
+- **Don't store trivial information** (greetings, acknowledgments, simple file reads)
+- **Do store anything you'd want to know if you lost all context**
+- **Use concise titles** and structured facts
+- **Include file paths** in filesModified when relevant
+`;
+}
+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 init_installers = __esm({
+  "src/hooks/installers/index.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/memory/retention.ts
 var retention_exports = {};
 __export(retention_exports, {
@@ -1667,8 +2025,9 @@ var RulesSyncer = class {
 
 // src/workspace/engine.ts
 init_esm_shims();
-import { readFileSync, readdirSync, existsSync as existsSync3 } from "fs";
+import { readFileSync, readdirSync, existsSync as existsSync3, cpSync, mkdirSync as mkdirSync2 } from "fs";
 import { join as join6 } from "path";
+import { homedir as homedir5 } from "os";
 
 // src/workspace/mcp-adapters/windsurf.ts
 init_esm_shims();
@@ -2190,7 +2549,7 @@ var WorkspaceSyncApplier = class {
 };
 
 // src/workspace/engine.ts
-var WorkspaceSyncEngine = class {
+var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
     this.adapters = /* @__PURE__ */ new Map([
@@ -2218,10 +2577,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;
@@ -2239,7 +2598,8 @@ var WorkspaceSyncEngine = class {
       rulesCount = rules.length;
     } catch {
     }
-    return { mcpConfigs, workflows, rulesCount };
+    const skills = this.scanSkills();
+    return { mcpConfigs, workflows, rulesCount, skills };
   }
   /**
    * Migrate workspace configs to a target agent format.
@@ -2249,7 +2609,8 @@ var WorkspaceSyncEngine = class {
     const result = {
       mcpServers: { scanned: [], generated: [] },
       workflows: { scanned: [], generated: [] },
-      rules: { scanned: 0, generated: 0 }
+      rules: { scanned: 0, generated: 0 },
+      skills: { scanned: [], copied: [] }
     };
     const allServers = /* @__PURE__ */ new Map();
     for (const servers of Object.values(scan.mcpConfigs)) {
@@ -2286,9 +2647,85 @@ var WorkspaceSyncEngine = class {
       }
     } catch {
     }
+    result.skills.scanned = scan.skills;
     return result;
   }
   // ---- Private helpers ----
+  /** Skills directories per agent */
+  static SKILLS_DIRS = {
+    codex: [".codex/skills", ".agents/skills"],
+    cursor: [".cursor/skills", ".cursor/skills-cursor"],
+    windsurf: [".windsurf/skills"],
+    "claude-code": [".claude/skills"]
+  };
+  /** Get the target skills directory for an agent */
+  getTargetSkillsDir(target) {
+    const dirs = _WorkspaceSyncEngine.SKILLS_DIRS[target];
+    return join6(this.projectRoot, dirs[0]);
+  }
+  /**
+   * Scan all agent skills directories and collect unique skills.
+   */
+  scanSkills() {
+    const skills = [];
+    const seen = /* @__PURE__ */ new Set();
+    const home = homedir5();
+    for (const [agent, dirs] of Object.entries(_WorkspaceSyncEngine.SKILLS_DIRS)) {
+      for (const dir of dirs) {
+        const paths = [
+          join6(this.projectRoot, dir),
+          join6(home, dir)
+        ];
+        for (const skillsRoot of paths) {
+          if (!existsSync3(skillsRoot)) continue;
+          try {
+            const entries = readdirSync(skillsRoot, { withFileTypes: true });
+            for (const entry of entries) {
+              if (!entry.isDirectory()) continue;
+              if (seen.has(entry.name)) continue;
+              const skillMd = join6(skillsRoot, entry.name, "SKILL.md");
+              if (!existsSync3(skillMd)) continue;
+              let description = "";
+              try {
+                const content = readFileSync(skillMd, "utf-8");
+                const match = content.match(/^---[\s\S]*?description:\s*["']?(.+?)["']?\s*$/m);
+                if (match) description = match[1];
+              } catch {
+              }
+              seen.add(entry.name);
+              skills.push({
+                name: entry.name,
+                description,
+                sourcePath: join6(skillsRoot, entry.name),
+                sourceAgent: agent
+              });
+            }
+          } catch {
+          }
+        }
+      }
+    }
+    return skills;
+  }
+  /**
+   * Copy skills to a target agent's skills directory.
+   * Returns list of copied skill names.
+   */
+  copySkills(skills, target) {
+    const targetDir = this.getTargetSkillsDir(target);
+    const copied = [];
+    for (const skill of skills) {
+      const dest = join6(targetDir, skill.name);
+      if (existsSync3(dest)) continue;
+      try {
+        mkdirSync2(targetDir, { recursive: true });
+        cpSync(skill.sourcePath, dest, { recursive: true });
+        copied.push(skill.name);
+      } catch {
+      }
+    }
+    return copied;
+  }
   scanWorkflows() {
     const workflows = [];
     const wfDir = join6(this.projectRoot, ".windsurf", "workflows");
@@ -2323,12 +2760,23 @@ var WorkspaceSyncEngine = class {
       ...syncResult.workflows.generated
     ];
     const applyResult = await applier.apply(filesToWrite);
+    let copiedSkills = [];
+    if (syncResult.skills.scanned.length > 0) {
+      copiedSkills = this.copySkills(syncResult.skills.scanned, target);
+    }
     const lines = [];
     if (applyResult.success) {
       lines.push(`\u2705 Applied ${applyResult.filesWritten.length} file(s) for ${target}`);
       for (const f of applyResult.filesWritten) {
         lines.push(`  \u2192 ${f}`);
       }
+      if (copiedSkills.length > 0) {
+        lines.push(`
+\u{1F9E9} Copied ${copiedSkills.length} skill(s):`);
+        for (const sk of copiedSkills) {
+          lines.push(`  \u2192 ${sk}`);
+        }
+      }
       if (applyResult.backups.length > 0) {
         lines.push(`
 \u{1F4E6} Backups created (${applyResult.backups.length}):`);
@@ -2388,6 +2836,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 {
@@ -2828,7 +3293,7 @@ Entity: ${entityName} | Type: ${type} | Project: ${project.id}${enrichment}`
     "memorix_workspace_sync",
     {
       title: "Workspace Sync",
-      description: 'Migrate your entire workspace environment between AI agents. Syncs MCP server configs, workflows, and rules. Action "scan": detect all workspace configs. Action "migrate": generate configs for target agent (preview only). Action "apply": migrate AND write configs to disk with backup/rollback.',
+      description: 'Migrate your entire workspace environment between AI agents. Syncs MCP server configs, workflows, rules, and skills. Action "scan": detect all workspace configs. Action "migrate": generate configs for target agent (preview only). Action "apply": migrate AND write configs to disk with backup/rollback.',
       inputSchema: {
         action: z.enum(["scan", "migrate", "apply"]).describe('Action: "scan" to detect configs, "migrate" to preview, "apply" to write to disk'),
         target: z.enum(AGENT_TARGETS).optional().describe("Target agent for migration (required for migrate)")
@@ -2858,6 +3323,14 @@ Entity: ${entityName} | Type: ${type} | Project: ${project.id}${enrichment}`
         }
         lines2.push("", `### Rules`);
         lines2.push(`- ${scan.rulesCount} rule(s) detected across all agents`);
+        lines2.push("", `### Skills`);
+        if (scan.skills.length > 0) {
+          for (const sk of scan.skills) {
+            lines2.push(`- **${sk.name}** (${sk.sourceAgent}): ${sk.description || "(no description)"}`);
+          }
+        } else {
+          lines2.push("- No skills found");
+        }
         return {
           content: [{ type: "text", text: lines2.join("\n") }]
         };
@@ -2895,6 +3368,12 @@ Entity: ${entityName} | Type: ${type} | Project: ${project.id}${enrichment}`
       if (result.rules.generated > 0) {
         lines.push(`### Rules`, `- ${result.rules.generated} rule file(s) generated`);
       }
+      if (result.skills.scanned.length > 0) {
+        lines.push("### Skills", `- ${result.skills.scanned.length} skill(s) found, ready to copy:`);
+        for (const sk of result.skills.scanned) {
+          lines.push(`  - **${sk.name}** (from ${sk.sourceAgent})`);
+        }
+      }
       lines.push("", '> Review the generated configs above. Use action "apply" to write them to disk.');
       return {
         content: [{ type: "text", text: lines.join("\n") }]