memorix 0.2.3 → 0.3.0

package/README.md

@@ -44,8 +44,26 @@ Memorix stores and indexes project knowledge (architecture decisions, bug fixes,
 - **Rules Parser**: 4 format adapters (Cursor `.mdc`, Claude Code `CLAUDE.md`, Codex `SKILL.md`, Windsurf `.windsurfrules`)
 - **Rules Syncer**: Scan → Deduplicate → Conflict detection → Cross-format generation
 - **Workspace Sync**: MCP config migration + workflow sync across agents
+- **Skills Sync**: Scan `.codex/skills/`, `.cursor/skills/`, `.windsurf/skills/`, `.claude/skills/` → copy entire skill folders across agents (no format conversion needed — SKILL.md is a universal standard)
 - **Apply with Safety**: Backup → Atomic write → Auto-rollback on failure
 
+### P3 — Auto-Memory Hooks
+
+- **Hook Events**: `user_prompt`, `post_response`, `post_edit`, `post_command`, `post_tool`, `session_end`
+- **Agent Normalizer**: Maps Windsurf/Cursor/Claude/Codex native events to unified hook events
+- **Pattern Detection**: Auto-detects decisions, errors, gotchas, configurations, learnings, implementations
+- **Cooldown Filtering**: Prevents duplicate storage within configurable time windows
+- **Noise Filtering**: Skips trivial commands (`ls`, `cat`, `pwd`, etc.)
+- **Agent Rules**: Auto-installs `.windsurf/rules/memorix.md` (or equivalent) to guide agents in proactive memory management
+- **One-Command Install**: `memorix hooks install` sets up hooks + rules for your agent
+
+### Context Continuity
+
+- **Session Start**: Agent rules instruct AI to search memories before responding
+- **During Session**: Auto-capture decisions, bugs, gotchas via hooks + agent-driven `memorix_store`
+- **Session End**: Agent stores a "handoff note" summarizing progress and next steps
+- **Result**: Start a new session and your AI already knows everything — no re-explaining needed
+
 ### P5 — Intelligence (Competitor-Inspired)
 
 - **Access Tracking**: `accessCount` + `lastAccessedAt` on every search hit (from mcp-memory-service)
@@ -115,7 +133,7 @@ npm install memorix
 | `memorix_detail` | L3 | Full observation details | ~500-1000/result |
 | `memorix_retention` | Analytics | Memory decay & retention status | — |
 | `memorix_rules_sync` | Rules | Scan, dedup, convert rules across agents | — |
-| `memorix_workspace_sync` | Workspace | Scan/migrate MCP configs across agents | — |
+| `memorix_workspace_sync` | Workspace | Scan/migrate MCP configs, workflows, and skills across agents | — |
 
 #### MCP Official Compatible
 
@@ -158,9 +176,16 @@ npm install memorix
 │  └─────────────────────────────────────┘    │
 │                                              │
 │  ┌────────────────────────────────────┐     │
-│  │         Rules Syncer               │     │
+│  │      Rules & Skills Syncer        │     │
 │  │  Cursor│Claude│Codex│Windsurf     │     │
-│  │  scan → dedup → conflict → gen    │     │
+│  │  rules: scan→dedup→conflict→gen   │     │
+│  │  skills: scan→copy (no convert)   │     │
+│  └────────────────────────────────────┘     │
+│                                              │
+│  ┌────────────────────────────────────┐     │
+│  │       Auto-Memory Hooks           │     │
+│  │  normalize→detect→filter→store    │     │
+│  │  + agent rules (context cont.)    │     │
 │  └────────────────────────────────────┘     │
 └──────────────────────────────────────────────┘
 ```
@@ -179,7 +204,7 @@ npm install memorix
 | Entity extraction | Regex patterns | MemCP |
 | Rule parsing | `gray-matter` | — |
 | Build | `tsup` | — |
-| Test | `vitest` | 195 tests |
+| Test | `vitest` | 219 tests |
 
 ## Optional: Enable Vector Search
 
@@ -200,7 +225,7 @@ npm install
 # Build
 npm run build
 
-# Run tests (195 tests)
+# Run tests (219 tests)
 npm test
 
 # Type check

package/dist/cli/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();
   }
 });
 
@@ -2236,8 +2246,9 @@ var init_applier = __esm({
 });
 
 // src/workspace/engine.ts
-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";
 var WorkspaceSyncEngine;
 var init_engine2 = __esm({
   "src/workspace/engine.ts"() {
@@ -2251,7 +2262,7 @@ var init_engine2 = __esm({
     init_syncer();
     init_sanitizer();
     init_applier();
-    WorkspaceSyncEngine = class {
+    WorkspaceSyncEngine = class _WorkspaceSyncEngine {
       constructor(projectRoot) {
         this.projectRoot = projectRoot;
         this.adapters = /* @__PURE__ */ new Map([
@@ -2300,7 +2311,8 @@ var init_engine2 = __esm({
           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.
@@ -2310,7 +2322,8 @@ var init_engine2 = __esm({
         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)) {
@@ -2347,9 +2360,85 @@ var init_engine2 = __esm({
           }
         } 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");
@@ -2384,12 +2473,23 @@ var init_engine2 = __esm({
           ...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}):`);
@@ -2438,10 +2538,33 @@ __export(installers_exports, {
 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: `${HOOK_COMMAND} ${HOOK_ARGS.join(" ")}`,
+    command: cmd,
     timeout: 10
   };
   return {
@@ -2455,9 +2578,10 @@ function generateClaudeConfig() {
   };
 }
 function generateWindsurfConfig() {
+  const cmd = `${resolveHookCommand()} hook`;
   const hookEntry = {
-    command: `${HOOK_COMMAND} ${HOOK_ARGS.join(" ")}`,
-    timeout: 10
+    command: cmd,
+    show_output: false
   };
   return {
     hooks: {
@@ -2470,16 +2594,17 @@ function generateWindsurfConfig() {
   };
 }
 function generateCursorConfig() {
+  const cmd = `${resolveHookCommand()} hook`;
   return {
     hooks: {
       beforeSubmitPrompt: {
-        command: `${HOOK_COMMAND} ${HOOK_ARGS.join(" ")}`
+        command: cmd
       },
       afterFileEdit: {
-        command: `${HOOK_COMMAND} ${HOOK_ARGS.join(" ")}`
+        command: cmd
       },
       stop: {
-        command: `${HOOK_COMMAND} ${HOOK_ARGS.join(" ")}`
+        command: cmd
       }
     }
   };
@@ -2495,7 +2620,7 @@ filePattern: "**/*"
 Run the memorix hook command to analyze changes and store relevant memories:
 
 \`\`\`bash
-memorix hook
+${resolveHookCommand()} hook
 \`\`\`
 `;
 }
@@ -2619,6 +2744,7 @@ async function installHooks(agent, projectRoot, global = false) {
       events.push("post_edit");
       break;
   }
+  await installAgentRules(agent, projectRoot);
   return {
     agent,
     configPath,
@@ -2626,6 +2752,79 @@ async function installHooks(agent, projectRoot, global = false) {
     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 {
@@ -2669,13 +2868,10 @@ async function getHookStatus(projectRoot) {
   }
   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"];
   }
 });
 
@@ -3271,7 +3467,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)")
@@ -3301,6 +3497,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") }]
         };
@@ -3338,6 +3542,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") }]
@@ -3844,9 +4054,10 @@ var init_pattern_detector = __esm({
       {
         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
+          /\b(config(ured?|uration)?|setting|environment|\.env)\b/i,
+          /(配置|环境变量|端口配置|设置项|安装配置)/,
+          /\b(gradle|webpack|vite|tsconfig|package\.json|docker|nginx)\b/i,
+          /\b(port\s*[:=]|listen\s+\d|bind\s+\d|DATABASE_URL|API_KEY)\b/i
         ],
         minLength: 80,
         baseConfidence: 0.7
@@ -3974,24 +4185,75 @@ async function handleHookEvent(input) {
         observation: buildObservation(input, extractContent(input)),
         output: defaultOutput
       };
-    case "post_edit":
-    case "post_command":
-    case "post_tool":
+    case "post_edit": {
+      const editKey = `post_edit:${input.filePath ?? "general"}`;
+      if (isInCooldown(editKey)) {
+        return { observation: null, output: defaultOutput };
+      }
+      const editContent = extractContent(input);
+      if (editContent.length < MIN_EDIT_LENGTH) {
+        return { observation: null, output: defaultOutput };
+      }
+      const editPattern = detectBestPattern(editContent, 0.6);
+      if (!editPattern) {
+        return { observation: null, output: defaultOutput };
+      }
+      markTriggered(editKey);
+      return {
+        observation: buildObservation(input, editContent),
+        output: defaultOutput
+      };
+    }
+    case "post_command": {
+      if (input.command && NOISE_COMMANDS.some((r) => r.test(input.command))) {
+        return { observation: null, output: defaultOutput };
+      }
+      const cmdKey = `post_command:${input.command ?? "general"}`;
+      if (isInCooldown(cmdKey)) {
+        return { observation: null, output: defaultOutput };
+      }
+      const cmdContent = input.commandOutput || extractContent(input);
+      if (cmdContent.length < MIN_STORE_LENGTH) {
+        return { observation: null, output: defaultOutput };
+      }
+      detectBestPattern(cmdContent);
+      markTriggered(cmdKey);
+      return {
+        observation: buildObservation(input, cmdContent),
+        output: defaultOutput
+      };
+    }
+    case "post_tool": {
+      const toolKey = `post_tool:${input.toolName ?? "general"}`;
+      if (isInCooldown(toolKey)) {
+        return { observation: null, output: defaultOutput };
+      }
+      const toolContent = extractContent(input);
+      if (toolContent.length < MIN_STORE_LENGTH) {
+        return { observation: null, output: defaultOutput };
+      }
+      const toolPattern = detectBestPattern(toolContent);
+      if (!toolPattern) {
+        return { observation: null, output: defaultOutput };
+      }
+      markTriggered(toolKey);
+      return {
+        observation: buildObservation(input, toolContent),
+        output: defaultOutput
+      };
+    }
     case "post_response":
     case "user_prompt": {
-      const cooldownKey = `${input.event}:${input.filePath ?? input.command ?? "general"}`;
-      if (isInCooldown(cooldownKey)) {
+      const promptKey = `${input.event}:${input.sessionId ?? "general"}`;
+      if (isInCooldown(promptKey)) {
         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);
+      detectBestPattern(content);
+      markTriggered(promptKey);
       return {
         observation: buildObservation(input, content),
         output: defaultOutput
@@ -4034,7 +4296,7 @@ async function runHook() {
   }
   process.stdout.write(JSON.stringify(output));
 }
-var cooldowns, COOLDOWN_MS, MIN_STORE_LENGTH, MAX_CONTENT_LENGTH;
+var cooldowns, COOLDOWN_MS, MIN_STORE_LENGTH, MIN_EDIT_LENGTH, NOISE_COMMANDS, MAX_CONTENT_LENGTH;
 var init_handler = __esm({
   "src/hooks/handler.ts"() {
     "use strict";
@@ -4044,6 +4306,14 @@ var init_handler = __esm({
     cooldowns = /* @__PURE__ */ new Map();
     COOLDOWN_MS = 3e4;
     MIN_STORE_LENGTH = 100;
+    MIN_EDIT_LENGTH = 30;
+    NOISE_COMMANDS = [
+      /^(ls|dir|cd|pwd|echo|cat|type|head|tail|wc|find|which|where|whoami)\b/i,
+      /^(Get-Content|Test-Path|Get-Item|Get-ChildItem|Set-Location|Write-Host)\b/i,
+      /^(Start-Sleep|Select-String|Select-Object|Format-Table|Measure-Object)\b/i,
+      /^(mkdir|rm|cp|mv|touch|chmod|chown)\b/i,
+      /^(node -[ep]|python -c)\b/i
+    ];
     MAX_CONTENT_LENGTH = 4e3;
   }
 });