@simplexlat/memhub 0.1.3 → 0.1.4

package/dist/cli.js

@@ -1348,9 +1348,9 @@ function getConfig() {
 }
 
 // src/connectors/ide-injector.ts
-import fs5 from "fs";
-import path5 from "path";
-import os3 from "os";
+import fs6 from "fs";
+import path6 from "path";
+import os4 from "os";
 
 // src/connectors/rules-injector.ts
 import fs4 from "fs";
@@ -1438,6 +1438,9 @@ When completing a task or subtask, include a \`## Key Learnings:\` section at th
 If context reset or compaction occurs, immediately call \`mem_session_summary\` to persist the compacted summary, then call \`mem_context\` to recover previous session context.
 
 ${MEMHUB_RULES_END_MARKER}`;
+function getHomeDir() {
+  return process.env.HOME || os2.homedir();
+}
 var RulesInjector = class {
   /**
    * Injects or updates the managed MemHub rules block inside a markdown file.
@@ -1481,7 +1484,7 @@ ${MEMHUB_PROTOCOL_INSTRUCTIONS}
    */
   static injectClaudeCode(cwd = process.cwd()) {
     const local = this.injectIntoFile(path4.join(cwd, "CLAUDE.md"), "Claude Code (Workspace)");
-    const globalPath = path4.join(os2.homedir(), ".claude", "CLAUDE.md");
+    const globalPath = path4.join(getHomeDir(), ".claude", "CLAUDE.md");
     const global = this.injectIntoFile(globalPath, "Claude Code (Global)");
     return [local, global];
   }
@@ -1492,7 +1495,7 @@ ${MEMHUB_PROTOCOL_INSTRUCTIONS}
     const cursorRules = this.injectIntoFile(path4.join(cwd, ".cursorrules"), "Cursor (.cursorrules)");
     const mdcPath = path4.join(cwd, ".cursor", "rules", "memhub.mdc");
     const mdc = this.injectIntoFile(mdcPath, "Cursor MDC (.cursor/rules/memhub.mdc)");
-    const globalCursor = this.injectIntoFile(path4.join(os2.homedir(), ".cursorrules"), "Cursor (Global .cursorrules)");
+    const globalCursor = this.injectIntoFile(path4.join(getHomeDir(), ".cursorrules"), "Cursor (Global .cursorrules)");
     return [cursorRules, mdc, globalCursor];
   }
   /**
@@ -1500,8 +1503,8 @@ ${MEMHUB_PROTOCOL_INSTRUCTIONS}
    */
   static injectAntigravity(cwd = process.cwd()) {
     const localRule = path4.join(cwd, ".gemini", "antigravity-cli", "rules", "memhub.md");
-    const globalRule = path4.join(os2.homedir(), ".gemini", "antigravity-cli", "rules", "memhub.md");
-    const legacyGlobalRule = path4.join(os2.homedir(), ".gemini", "config", "rules", "memhub.md");
+    const globalRule = path4.join(getHomeDir(), ".gemini", "antigravity-cli", "rules", "memhub.md");
+    const legacyGlobalRule = path4.join(getHomeDir(), ".gemini", "config", "rules", "memhub.md");
     return [
       this.injectIntoFile(localRule, "Antigravity (Workspace)"),
       this.injectIntoFile(globalRule, "Antigravity (Global)"),
@@ -1513,7 +1516,7 @@ ${MEMHUB_PROTOCOL_INSTRUCTIONS}
    */
   static injectWindsurf(cwd = process.cwd()) {
     const local = this.injectIntoFile(path4.join(cwd, ".windsurfrules"), "Windsurf (.windsurfrules)");
-    const global = this.injectIntoFile(path4.join(os2.homedir(), ".windsurfrules"), "Windsurf (Global .windsurfrules)");
+    const global = this.injectIntoFile(path4.join(getHomeDir(), ".windsurfrules"), "Windsurf (Global .windsurfrules)");
     return [local, global];
   }
   /**
@@ -1521,7 +1524,7 @@ ${MEMHUB_PROTOCOL_INSTRUCTIONS}
    */
   static injectCline(cwd = process.cwd()) {
     const local = this.injectIntoFile(path4.join(cwd, ".clinerules"), "Cline (.clinerules)");
-    const global = this.injectIntoFile(path4.join(os2.homedir(), ".clinerules"), "Cline (Global .clinerules)");
+    const global = this.injectIntoFile(path4.join(getHomeDir(), ".clinerules"), "Cline (Global .clinerules)");
     return [local, global];
   }
   /**
@@ -1529,9 +1532,38 @@ ${MEMHUB_PROTOCOL_INSTRUCTIONS}
    */
   static injectCodex(cwd = process.cwd()) {
     const localAgents = this.injectIntoFile(path4.join(cwd, "AGENTS.md"), "Agents Specification (AGENTS.md)");
-    const globalCodex = this.injectIntoFile(path4.join(os2.homedir(), ".codex", "instructions.md"), "Codex CLI (Global instructions)");
+    const globalCodex = this.injectIntoFile(path4.join(getHomeDir(), ".codex", "instructions.md"), "Codex CLI (Global instructions)");
     return [localAgents, globalCodex];
   }
+  /**
+   * Injects rules for OpenCode CLI (`OPENCODE.md` and `~/.config/opencode/rules/memhub.md`)
+   */
+  static injectOpenCode(cwd = process.cwd()) {
+    const local = this.injectIntoFile(path4.join(cwd, "OPENCODE.md"), "OpenCode (Workspace OPENCODE.md)");
+    const global1 = this.injectIntoFile(path4.join(getHomeDir(), ".config", "opencode", "rules", "memhub.md"), "OpenCode (Global ~/.config/opencode)");
+    const global2 = this.injectIntoFile(path4.join(getHomeDir(), ".opencode", "rules.md"), "OpenCode (Global ~/.opencode)");
+    return [local, global1, global2];
+  }
+  /**
+   * Injects rules for Alibaba Qwen Code / Qwen Agent (`.qwenrules`, `QWEN.md`, and `~/.qwen/rules.md`)
+   */
+  static injectQwen(cwd = process.cwd()) {
+    const localRules = this.injectIntoFile(path4.join(cwd, ".qwenrules"), "Qwen (.qwenrules)");
+    const localMd = this.injectIntoFile(path4.join(cwd, "QWEN.md"), "Qwen (Workspace QWEN.md)");
+    const globalQwen = this.injectIntoFile(path4.join(getHomeDir(), ".qwen", "rules.md"), "Qwen (Global ~/.qwen/rules.md)");
+    const globalDotRules = this.injectIntoFile(path4.join(getHomeDir(), ".qwenrules"), "Qwen (Global ~/.qwenrules)");
+    return [localRules, localMd, globalQwen, globalDotRules];
+  }
+  /**
+   * Injects rules for DeepSeek Harness / CLI (`.deepseekrules`, `DEEPSEEK.md`, and `~/.deepseek/rules.md`)
+   */
+  static injectDeepSeek(cwd = process.cwd()) {
+    const localRules = this.injectIntoFile(path4.join(cwd, ".deepseekrules"), "DeepSeek (.deepseekrules)");
+    const localMd = this.injectIntoFile(path4.join(cwd, "DEEPSEEK.md"), "DeepSeek (Workspace DEEPSEEK.md)");
+    const globalDeepSeek = this.injectIntoFile(path4.join(getHomeDir(), ".deepseek", "rules.md"), "DeepSeek (Global ~/.deepseek/rules.md)");
+    const globalDotRules = this.injectIntoFile(path4.join(getHomeDir(), ".deepseekrules"), "DeepSeek (Global ~/.deepseekrules)");
+    return [localRules, localMd, globalDeepSeek, globalDotRules];
+  }
   /**
    * Injects rules across all supported AI coding agents globally and locally.
    */
@@ -1542,26 +1574,197 @@ ${MEMHUB_PROTOCOL_INSTRUCTIONS}
       ...this.injectAntigravity(cwd),
       ...this.injectWindsurf(cwd),
       ...this.injectCline(cwd),
-      ...this.injectCodex(cwd)
+      ...this.injectCodex(cwd),
+      ...this.injectOpenCode(cwd),
+      ...this.injectQwen(cwd),
+      ...this.injectDeepSeek(cwd)
+    ];
+  }
+};
+
+// src/connectors/skills-injector.ts
+import fs5 from "fs";
+import path5 from "path";
+import os3 from "os";
+function getHomeDir2() {
+  return process.env.HOME || os3.homedir();
+}
+var MEMHUB_SKILL_MD = `---
+name: memhub
+description: Persistent, synchronized team memory and architecture decision logger for AI coding assistants. Use when saving decisions, searching previous solutions, querying shared project context, or closing sessions.
+---
+
+# MemHub Persistent Memory Skill
+
+MemHub synchronizes architectural decisions, bug fixes, technical patterns, and project knowledge across teammates and AI coding agents.
+
+## Core Capabilities
+
+1. **Autonomous Knowledge Ingestion**: Call \`mem_save\` immediately upon completing bugfixes, making architecture decisions, or establishing conventions.
+2. **Proactive Hybrid Retrieval**: Call \`mem_search\` and \`mem_context\` before beginning unfamiliar tasks to benefit from previous solutions.
+3. **Architecture Invariant Protection**: Call \`mem_pin\` to mark critical constraints into the team's \`/rules\` registry.
+4. **Session Handoff & Compaction Recovery**: Call \`mem_session_summary\` before declaring a milestone completed.
+
+## Slash Commands Quick Reference
+
+- \`/mem-save\`: Saves the latest code changes, bugfixes, or decisions as a structured observation.
+- \`/mem-search <query>\`: Searches team memories and previous solutions with hybrid lexical + vector ranking.
+- \`/mem-summary\`: Generates a structured session summary (Goal, Discoveries, Accomplished, Next Steps).
+- \`/mem-status\`: Displays connection status, device ID, and pending outbox events.
+
+## When to Save (Mandatory)
+
+Call \`mem_save\` immediately after:
+- Resolving a non-trivial bug
+- Deciding on a library, data structure, or design pattern
+- Configuring CI/CD, environment variables, or cloud infrastructure
+- Learning a user constraint or project convention
+`;
+var CLAUDE_COMMAND_SAVE = `Save a persistent memory observation of the latest work done using the \`mem_save\` tool.
+Include:
+- title: Verb + what (e.g. "Configured JWT Auth", "Fixed N+1 query in UserList")
+- type: bugfix | decision | architecture | discovery | pattern | config | preference
+- content:
+  **What**: One sentence summary of what was done.
+  **Why**: The motivation or problem solved.
+  **Where**: Affected files and directories.
+  **Learned**: Surprises, edge cases, or gotchas (if any).
+`;
+var CLAUDE_COMMAND_SEARCH = `Search the MemHub shared knowledge base for relevant past solutions, decisions, and patterns using the \`mem_search\` tool with the user's query: \`$ARGUMENTS\`.
+Provide a clear summary of findings with references.
+`;
+var CLAUDE_COMMAND_SUMMARY = `Generate and persist a structured session summary using the \`mem_session_summary\` tool.
+Structure:
+## Goal
+What we worked on in this session.
+
+## Discoveries
+Technical findings, gotchas, or surprising behaviors discovered.
+
+## Accomplished
+Key items completed.
+
+## Next Steps
+Remaining tasks for subsequent sessions.
+
+## Relevant Files
+Files touched and their purpose.
+`;
+var CLAUDE_COMMAND_STATUS = `Check and display the MemHub synchronization status using the \`memhub_sync_status\` tool.
+Show device ID, active project, outbox pending count, and cloud connection state.
+`;
+var SkillsInjector = class {
+  /**
+   * Injects slash commands for Claude Code in workspace and global ~/.claude/commands
+   */
+  static injectClaudeCommands(cwd = process.cwd()) {
+    const targets = [
+      path5.join(cwd, ".claude", "commands"),
+      path5.join(getHomeDir2(), ".claude", "commands")
+    ];
+    for (const dir of targets) {
+      try {
+        if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+        fs5.writeFileSync(path5.join(dir, "mem-save.md"), CLAUDE_COMMAND_SAVE, "utf8");
+        fs5.writeFileSync(path5.join(dir, "mem-search.md"), CLAUDE_COMMAND_SEARCH, "utf8");
+        fs5.writeFileSync(path5.join(dir, "mem-summary.md"), CLAUDE_COMMAND_SUMMARY, "utf8");
+        fs5.writeFileSync(path5.join(dir, "mem-status.md"), CLAUDE_COMMAND_STATUS, "utf8");
+      } catch {
+      }
+    }
+  }
+  /**
+   * Injects Antigravity / Gemini CLI skill in workspace and global ~/.gemini/antigravity-cli/skills/memhub
+   */
+  static injectAntigravitySkill(cwd = process.cwd()) {
+    const targets = [
+      path5.join(cwd, ".gemini", "antigravity-cli", "skills", "memhub"),
+      path5.join(getHomeDir2(), ".gemini", "antigravity-cli", "skills", "memhub"),
+      path5.join(getHomeDir2(), ".gemini", "config", "skills", "memhub")
     ];
+    for (const dir of targets) {
+      try {
+        if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+        fs5.writeFileSync(path5.join(dir, "SKILL.md"), MEMHUB_SKILL_MD, "utf8");
+      } catch {
+      }
+    }
+  }
+  /**
+   * Injects Codex CLI skill in global ~/.codex/skills/memhub
+   */
+  static injectCodexSkill() {
+    const dir = path5.join(getHomeDir2(), ".codex", "skills", "memhub");
+    try {
+      if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+      fs5.writeFileSync(path5.join(dir, "SKILL.md"), MEMHUB_SKILL_MD, "utf8");
+    } catch {
+    }
+  }
+  /**
+   * Injects OpenCode skill in global ~/.config/opencode/skills/memhub
+   */
+  static injectOpenCodeSkill() {
+    const dir = path5.join(getHomeDir2(), ".config", "opencode", "skills", "memhub");
+    try {
+      if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+      fs5.writeFileSync(path5.join(dir, "SKILL.md"), MEMHUB_SKILL_MD, "utf8");
+    } catch {
+    }
+  }
+  /**
+   * Injects Alibaba Qwen skill in global ~/.qwen/skills/memhub
+   */
+  static injectQwenSkill() {
+    const dir = path5.join(getHomeDir2(), ".qwen", "skills", "memhub");
+    try {
+      if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+      fs5.writeFileSync(path5.join(dir, "SKILL.md"), MEMHUB_SKILL_MD, "utf8");
+    } catch {
+    }
+  }
+  /**
+   * Injects DeepSeek skill in global ~/.deepseek/skills/memhub
+   */
+  static injectDeepSeekSkill() {
+    const dir = path5.join(getHomeDir2(), ".deepseek", "skills", "memhub");
+    try {
+      if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+      fs5.writeFileSync(path5.join(dir, "SKILL.md"), MEMHUB_SKILL_MD, "utf8");
+    } catch {
+    }
+  }
+  /**
+   * Injects all skills and slash commands across all supported AI environments.
+   */
+  static injectAll(cwd = process.cwd()) {
+    this.injectClaudeCommands(cwd);
+    this.injectAntigravitySkill(cwd);
+    this.injectCodexSkill();
+    this.injectOpenCodeSkill();
+    this.injectQwenSkill();
+    this.injectDeepSeekSkill();
   }
 };
 
 // src/connectors/ide-injector.ts
+function getHomeDir3() {
+  return process.env.HOME || os4.homedir();
+}
 var IdeConfigInjector = class {
   static serverConfig() {
     return { command: "memhub", args: ["serve"] };
   }
   static injectJsonMcpConfig(target, configPath, options) {
     try {
-      const parent = path5.dirname(configPath);
-      if (!fs5.existsSync(parent) && !options.dryRun) fs5.mkdirSync(parent, { recursive: true });
+      const parent = path6.dirname(configPath);
+      if (!fs6.existsSync(parent) && !options.dryRun) fs6.mkdirSync(parent, { recursive: true });
       let config = { mcpServers: {} };
-      if (fs5.existsSync(configPath)) config = JSON.parse(fs5.readFileSync(configPath, "utf8"));
+      if (fs6.existsSync(configPath)) config = JSON.parse(fs6.readFileSync(configPath, "utf8"));
       config.mcpServers = config.mcpServers || {};
       config.mcpServers.memhub = this.serverConfig();
-      const existed = fs5.existsSync(configPath);
-      if (!options.dryRun) fs5.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+      const existed = fs6.existsSync(configPath);
+      if (!options.dryRun) fs6.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
       return { target, filePath: configPath, success: true, action: existed ? "updated" : "created" };
     } catch (err) {
       return { target, filePath: configPath, success: false, action: "error", error: err.message };
@@ -1572,23 +1775,24 @@ var IdeConfigInjector = class {
    */
   static injectClaudeCode(options) {
     const cwd = options.cwd || process.cwd();
-    const configPath = path5.join(cwd, "mcp.json");
+    const configPath = path6.join(cwd, "mcp.json");
     try {
       let config = { mcpServers: {} };
-      if (fs5.existsSync(configPath)) {
-        config = JSON.parse(fs5.readFileSync(configPath, "utf8"));
+      if (fs6.existsSync(configPath)) {
+        config = JSON.parse(fs6.readFileSync(configPath, "utf8"));
       }
       config.mcpServers = config.mcpServers || {};
       config.mcpServers.memhub = this.serverConfig();
       if (!options.dryRun) {
-        fs5.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+        fs6.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
         RulesInjector.injectClaudeCode(cwd);
+        SkillsInjector.injectClaudeCommands(cwd);
       }
       return {
         target: "Claude Code",
         filePath: configPath,
         success: true,
-        action: fs5.existsSync(configPath) ? "updated" : "created"
+        action: fs6.existsSync(configPath) ? "updated" : "created"
       };
     } catch (err) {
       return {
@@ -1605,27 +1809,27 @@ var IdeConfigInjector = class {
    */
   static injectCursor(options) {
     const cwd = options.cwd || process.cwd();
-    const cursorDir = path5.join(cwd, ".cursor");
-    const configPath = path5.join(cursorDir, "mcp.json");
+    const cursorDir = path6.join(cwd, ".cursor");
+    const configPath = path6.join(cursorDir, "mcp.json");
     try {
-      if (!fs5.existsSync(cursorDir) && !options.dryRun) {
-        fs5.mkdirSync(cursorDir, { recursive: true });
+      if (!fs6.existsSync(cursorDir) && !options.dryRun) {
+        fs6.mkdirSync(cursorDir, { recursive: true });
       }
       let config = { mcpServers: {} };
-      if (fs5.existsSync(configPath)) {
-        config = JSON.parse(fs5.readFileSync(configPath, "utf8"));
+      if (fs6.existsSync(configPath)) {
+        config = JSON.parse(fs6.readFileSync(configPath, "utf8"));
       }
       config.mcpServers = config.mcpServers || {};
       config.mcpServers.memhub = this.serverConfig();
       if (!options.dryRun) {
-        fs5.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+        fs6.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
         RulesInjector.injectCursor(cwd);
       }
       return {
         target: "Cursor",
         filePath: configPath,
         success: true,
-        action: fs5.existsSync(configPath) ? "updated" : "created"
+        action: fs6.existsSync(configPath) ? "updated" : "created"
       };
     } catch (err) {
       return {
@@ -1641,11 +1845,12 @@ var IdeConfigInjector = class {
   static injectAntigravity(options) {
     const res = this.injectJsonMcpConfig(
       "Google Antigravity",
-      path5.join(os3.homedir(), ".gemini", "config", "mcp_config.json"),
+      path6.join(getHomeDir3(), ".gemini", "config", "mcp_config.json"),
       options
     );
     if (res.success && !options.dryRun) {
       RulesInjector.injectAntigravity(options.cwd || process.cwd());
+      SkillsInjector.injectAntigravitySkill(options.cwd || process.cwd());
     }
     return res;
   }
@@ -1653,7 +1858,7 @@ var IdeConfigInjector = class {
   static injectWindsurf(options) {
     const res = this.injectJsonMcpConfig(
       "Windsurf",
-      path5.join(os3.homedir(), ".codeium", "windsurf", "mcp_config.json"),
+      path6.join(getHomeDir3(), ".codeium", "windsurf", "mcp_config.json"),
       options
     );
     if (res.success && !options.dryRun) {
@@ -1665,7 +1870,7 @@ var IdeConfigInjector = class {
   static injectCline(options) {
     const res = this.injectJsonMcpConfig(
       "Cline",
-      path5.join(os3.homedir(), ".cline", "data", "settings", "cline_mcp_settings.json"),
+      path6.join(getHomeDir3(), ".cline", "data", "settings", "cline_mcp_settings.json"),
       options
     );
     if (res.success && !options.dryRun) {
@@ -1675,17 +1880,17 @@ var IdeConfigInjector = class {
   }
   /** Generic JSON client using the common { mcpServers: {} } format. */
   static injectOther(configPath, options) {
-    return this.injectJsonMcpConfig("Other MCP client", path5.resolve(configPath), options);
+    return this.injectJsonMcpConfig("Other MCP client", path6.resolve(configPath), options);
   }
   /**
    * Injects config and memory rules for Codex CLI (`config.toml` and `AGENTS.md`)
    */
   static injectCodex(options) {
-    const codexDir = path5.join(os3.homedir(), ".codex");
-    const configPath = path5.join(codexDir, "config.toml");
+    const codexDir = path6.join(getHomeDir3(), ".codex");
+    const configPath = path6.join(codexDir, "config.toml");
     try {
-      if (!fs5.existsSync(codexDir) && !options.dryRun) {
-        fs5.mkdirSync(codexDir, { recursive: true });
+      if (!fs6.existsSync(codexDir) && !options.dryRun) {
+        fs6.mkdirSync(codexDir, { recursive: true });
       }
       const entry = `
 # MemHub MCP Connector
@@ -1694,17 +1899,18 @@ command = "memhub"
 args = ["serve"]
 `;
       let content = "";
-      if (fs5.existsSync(configPath)) {
-        content = fs5.readFileSync(configPath, "utf8");
+      if (fs6.existsSync(configPath)) {
+        content = fs6.readFileSync(configPath, "utf8");
       }
       if (!content.includes("[mcp.servers.memhub]")) {
         content += entry;
         if (!options.dryRun) {
-          fs5.writeFileSync(configPath, content, "utf8");
+          fs6.writeFileSync(configPath, content, "utf8");
         }
       }
       if (!options.dryRun) {
         RulesInjector.injectCodex(options.cwd || process.cwd());
+        SkillsInjector.injectCodexSkill();
       }
       return {
         target: "Codex CLI",
@@ -1722,6 +1928,42 @@ args = ["serve"]
       };
     }
   }
+  /** OpenCode CLI global MCP configuration and rules. */
+  static injectOpenCode(options) {
+    const res = this.injectJsonMcpConfig(
+      "OpenCode CLI",
+      path6.join(getHomeDir3(), ".config", "opencode", "mcp.json"),
+      options
+    );
+    if (!options.dryRun) {
+      RulesInjector.injectOpenCode(options.cwd || process.cwd());
+    }
+    return res;
+  }
+  /** Alibaba Qwen Code / Qwen Agent global MCP configuration and rules. */
+  static injectQwen(options) {
+    const res = this.injectJsonMcpConfig(
+      "Qwen Code",
+      path6.join(getHomeDir3(), ".qwen", "mcp.json"),
+      options
+    );
+    if (!options.dryRun) {
+      RulesInjector.injectQwen(options.cwd || process.cwd());
+    }
+    return res;
+  }
+  /** DeepSeek Harness / CLI global MCP configuration and rules. */
+  static injectDeepSeek(options) {
+    const res = this.injectJsonMcpConfig(
+      "DeepSeek CLI",
+      path6.join(getHomeDir3(), ".deepseek", "mcp.json"),
+      options
+    );
+    if (!options.dryRun) {
+      RulesInjector.injectDeepSeek(options.cwd || process.cwd());
+    }
+    return res;
+  }
   /**
    * Injects for all supported IDEs and tools
    */
@@ -1732,7 +1974,10 @@ args = ["serve"]
       this.injectCodex(options),
       this.injectAntigravity(options),
       this.injectWindsurf(options),
-      this.injectCline(options)
+      this.injectCline(options),
+      this.injectOpenCode(options),
+      this.injectQwen(options),
+      this.injectDeepSeek(options)
     ];
   }
 };
@@ -1742,11 +1987,11 @@ import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { hostname } from "node:os";
 import { execSync as execSync2 } from "node:child_process";
-import path7 from "node:path";
+import path8 from "node:path";
 
 // src/update-notifier.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path7 from "path";
 import https from "https";
 var CHECK_INTERVAL_MS = 2 * 60 * 60 * 1e3;
 var PACKAGE_NAME = "@simplexlat/memhub";
@@ -1797,7 +2042,7 @@ async function fetchLatestFromNpm() {
 }
 var UpdateNotifier = class {
   static cacheFile() {
-    return path6.join(resolveStorageDir(), "update-cache.json");
+    return path7.join(resolveStorageDir(), "update-cache.json");
   }
   static async checkForUpdates(currentVersion) {
     if (process.argv.includes("serve") || process.argv.includes("update")) {
@@ -1808,9 +2053,9 @@ var UpdateNotifier = class {
       ensureDirectory(storageDir);
       const cachePath = this.cacheFile();
       let cache = { lastChecked: 0, latestVersion: currentVersion };
-      if (fs6.existsSync(cachePath)) {
+      if (fs7.existsSync(cachePath)) {
         try {
-          cache = JSON.parse(fs6.readFileSync(cachePath, "utf8"));
+          cache = JSON.parse(fs7.readFileSync(cachePath, "utf8"));
         } catch {
         }
       }
@@ -1821,7 +2066,7 @@ var UpdateNotifier = class {
           if (fetched) {
             cache = { lastChecked: Date.now(), latestVersion: fetched };
             try {
-              fs6.writeFileSync(cachePath, JSON.stringify(cache), "utf8");
+              fs7.writeFileSync(cachePath, JSON.stringify(cache), "utf8");
             } catch {
             }
           }
@@ -1940,7 +2185,7 @@ function openInBrowser(url) {
 }
 
 // src/cli.ts
-var CLI_VERSION = "0.1.3";
+var CLI_VERSION = "0.1.4";
 void UpdateNotifier.checkForUpdates(CLI_VERSION);
 var program = new Command();
 var supportedTargets = ["claude", "cursor", "windsurf", "cline", "codex", "antigravity"];
@@ -2000,7 +2245,7 @@ async function installToSelectedClients(options) {
     }
   }
 }
-program.name("memhub").description("Local-first MCP proxy for MemHub & agentmemory").version("0.1.3");
+program.name("memhub").description("Local-first MCP proxy for MemHub & agentmemory").version("0.1.4");
 program.command("serve").description("Start the MemHub MCP stdio proxy server").action(async () => {
   const config = getConfig();
   const server = new MemHubMcpServer(config);
@@ -2223,7 +2468,7 @@ program.command("flush").description("Force an immediate push of all pending out
 });
 program.command("rules").description("Inject or update MemHub persistent memory protocol instructions into all AI client rules").option("--cwd <path>", "Workspace directory to target", process.cwd()).action(async (options) => {
   console.log("\u{1F4DD} Injecting MemHub memory protocol rules into AI client configuration files...");
-  const results = RulesInjector.injectAll(path7.resolve(options.cwd));
+  const results = RulesInjector.injectAll(path8.resolve(options.cwd));
   for (const res of results) {
     if (res.success) {
       console.log(`  \u2713 ${res.target}: ${res.action} at ${res.filePath}`);
@@ -2231,6 +2476,9 @@ program.command("rules").description("Inject or update MemHub persistent memory
       console.log(`  \u2717 ${res.target}: ${res.error}`);
     }
   }
+  SkillsInjector.injectAll(path8.resolve(options.cwd));
+  console.log("  \u2713 Slash Commands (/mem-save, /mem-search, /mem-summary, /mem-status): configured");
+  console.log("  \u2713 Agent Skills: memhub/SKILL.md configured");
   console.log("\n\u2728 AI agents in this workspace and globally will now proactively save and recall team memories.");
 });
 program.command("update").description("Check for updates and upgrade @simplexlat/memhub to the latest version").option("--canary", "Install prerelease canary build").action(async (options) => {