memorix 1.4.4 → 1.4.5

package/src/cli/commands/setup.ts

@@ -30,6 +30,7 @@ import { OmpMCPAdapter } from '../../workspace/mcp-adapters/omp.js';
 import { KiroMCPAdapter } from '../../workspace/mcp-adapters/kiro.js';
 import { OpenCodeMCPAdapter } from '../../workspace/mcp-adapters/opencode.js';
 import { TraeMCPAdapter } from '../../workspace/mcp-adapters/trae.js';
+import { DshMCPAdapter } from '../../workspace/mcp-adapters/dsh.js';
 import { CodeBuddyMCPAdapter } from '../../workspace/mcp-adapters/codebuddy.js';
 import { getSetupIntegrationRows as readSetupIntegrationRows } from '../../integrations/registry.js';
 import { OFFICIAL_MEMORIX_SKILLS } from '../../hooks/official-skills.js';
@@ -190,6 +191,7 @@ const SUPPORTED_SETUP_AGENTS: AgentName[] = [
   'omp',
   'kiro',
   'trae',
+  'dsh',
   'pi',
 ];
 
@@ -402,6 +404,7 @@ export function getMcpAdapter(agent: McpConfigAgent): MCPConfigAdapter {
     kiro: new KiroMCPAdapter(),
     opencode: new OpenCodeMCPAdapter(),
     trae: new TraeMCPAdapter(),
+    dsh: new DshMCPAdapter(),
   };
   return adapters[agent];
 }
@@ -699,6 +702,55 @@ function mergeYamlMcpConfig(existingContent: string | null, generatedContent: st
   return stringifyYaml(merged, { lineWidth: 0 });
 }
 
+/**
+ * Merge the generated DeepSeek Harness patch rows into an existing
+ * `cordis.patch.yml` without clobbering unrelated user patches.
+ *
+ * DSH patch files are lists of Cordis patch operations. Memorix owns exactly
+ * the `@deepseek-ai/dsh-mcp-client` row whose config.serverName is `memorix`;
+ * every other operation is user-owned and must survive the merge. When the
+ * existing file is not a parseable list, the generated rows are appended to
+ * the raw content instead of overwriting it.
+ */
+function mergeDshPatchConfig(existingContent: string | null, generatedContent: string): string {
+  const generatedTrimmed = generatedContent.trimEnd();
+  if (!existingContent?.trim()) {
+    return generatedTrimmed.endsWith('\n') ? generatedTrimmed : `${generatedTrimmed}\n`;
+  }
+
+  const isMemorixInsertRow = (row: unknown): boolean => {
+    if (!row || typeof row !== 'object' || Array.isArray(row)) return false;
+    const record = row as Record<string, unknown>;
+    if (record.name !== '@deepseek-ai/dsh-mcp-client') return false;
+    const config = record.config;
+    return Boolean(
+      config && typeof config === 'object' && !Array.isArray(config)
+      && (config as Record<string, unknown>).serverName === 'memorix',
+    );
+  };
+
+  const opContainsMemorixRow = (op: unknown): boolean => {
+    if (!op || typeof op !== 'object' || Array.isArray(op)) return false;
+    const insert = (op as Record<string, unknown>).insert;
+    return Array.isArray(insert) && insert.some(isMemorixInsertRow);
+  };
+
+  let existingDocument: unknown;
+  try {
+    existingDocument = parseYaml(existingContent);
+  } catch {
+    return `${existingContent.trimEnd()}\n\n${generatedTrimmed}\n`;
+  }
+  if (!Array.isArray(existingDocument)) {
+    // A scalar or mapping document is not a patch list — never rewrite it.
+    return `${existingContent.trimEnd()}\n\n${generatedTrimmed}\n`;
+  }
+
+  const kept = existingDocument.filter((op) => !opContainsMemorixRow(op));
+  const merged = [...kept, ...(parseYaml(generatedContent) as unknown[])];
+  return stringifyYaml(merged, { lineWidth: 0 }) + '\n';
+}
+
 export async function installMcpConfig(options: {
   agent: McpConfigAgent;
   projectRoot?: string;
@@ -725,7 +777,9 @@ export async function installMcpConfig(options: {
     ? mergeTomlMcpConfig(existingContent, generated)
     : options.agent === 'hermes'
       ? mergeYamlMcpConfig(existingContent, generated)
-    : mergeJsonMcpConfig(existingContent, generated);
+      : options.agent === 'dsh'
+        ? mergeDshPatchConfig(existingContent, generated)
+        : mergeJsonMcpConfig(existingContent, generated);
 
   await mkdir(path.dirname(configPath), { recursive: true });
   await writeFile(configPath, content, 'utf-8');
@@ -1603,7 +1657,7 @@ export default defineCommand({
   args: {
     agent: {
       type: 'string',
-      description: 'Target agent (claude, codex, codebuddy, opencode, cursor, windsurf, copilot, gemini-cli, antigravity, openclaw, hermes, omp, kiro, trae, pi, all)',
+      description: 'Target agent (claude, codex, codebuddy, opencode, cursor, windsurf, copilot, gemini-cli, antigravity, openclaw, hermes, omp, kiro, trae, dsh, pi, all)',
       required: false,
     },
     mcp: {
@@ -1677,6 +1731,7 @@ export default defineCommand({
           { value: 'hermes', label: 'Hermes Agent', hint: 'plugin + hooks + commands + skills + MCP' },
           { value: 'omp', label: 'Oh-my-Pi', hint: 'package + extension + command + MCP' },
           { value: 'pi', label: 'Pi coding agent', hint: 'package + extension + skill' },
+          { value: 'dsh', label: 'DeepSeek Harness', hint: 'MCP patch + AGENTS.md + skills' },
           { value: 'opencode', label: 'OpenCode', hint: 'local plugin + AGENTS.md + MCP' },
           { value: 'windsurf', label: 'Windsurf', hint: 'rules + hooks + MCP' },
           { value: 'all', label: 'All supported agents', hint: 'install detected-compatible files' },

package/src/cli/commands/uninstall.ts

@@ -56,6 +56,15 @@ function checkTOML(p: string): boolean {
   } catch { return false; }
 }
 
+function checkDshPatch(p: string): boolean {
+  if (!exists(p)) return false;
+  try {
+    const content = fs.readFileSync(p, 'utf-8');
+    if (!content.includes('memory-memorix')) return false;
+    return /serverName:\s*['"]?memorix['"]?/.test(content);
+  } catch { return false; }
+}
+
 /** Detects memorix MCP config entries in both global and project-level paths. */
 function getMCPConfigEntries(home: string, cwd: string): MCPConfigEntry[] {
   const entries: MCPConfigEntry[] = [];
@@ -216,6 +225,17 @@ function getMCPConfigEntries(home: string, cwd: string): MCPConfigEntry[] {
     note: 'Remove the "memorix" key from mcpServers in this file.',
   });
 
+  // DeepSeek Harness
+  const dshPatchPath = path.join(process.env.DSH_HOME?.trim() || path.join(home, '.dsh'), 'cordis.patch.yml');
+  entries.push({
+    agent: 'DeepSeek Harness',
+    path: dshPatchPath,
+    kind: 'global',
+    format: 'json',
+    detected: checkDshPatch(dshPatchPath),
+    note: 'Remove the memory-memorix insert row from this patch file.',
+  });
+
   return entries;
 }
 

package/src/hooks/installers/index.ts

@@ -360,6 +360,9 @@ const AGENT_SKILL_DIRS: Partial<Record<AgentName, { project: string; global?: st
   kiro: { project: path.join('.kiro', 'skills'), global: path.join('.kiro', 'skills') },
   opencode: { project: path.join('.opencode', 'skills'), global: path.join('.config', 'opencode', 'skills') },
   trae: { project: path.join('.trae', 'skills'), global: path.join('.trae', 'skills') },
+  // DSH's user skill root is <harness home>/skills; the global root below is
+  // resolved to $DSH_HOME (or ~/.dsh) for dsh by installOfficialSkillsForAgent.
+  dsh: { project: path.join('.dsh', 'skills'), global: 'skills' },
 };
 
 const PACKAGE_OWNED_HOOK_AGENTS = new Set<AgentName>(['openclaw', 'hermes', 'omp']);
@@ -384,7 +387,11 @@ async function installOfficialSkillsForAgent(
   const relativeDir = global ? dirs?.global : dirs?.project;
   if (!relativeDir) return [];
 
-  const root = global ? os.homedir() : projectRoot;
+  const root = global
+    ? (agent === 'dsh'
+      ? (process.env.DSH_HOME?.trim() || path.join(os.homedir(), '.dsh'))
+      : os.homedir())
+    : projectRoot;
   const skillPaths: string[] = [];
   for (const skillEntry of OFFICIAL_MEMORIX_SKILLS) {
     const skillPath = path.join(root, relativeDir, skillEntry.name, 'SKILL.md');
@@ -626,6 +633,9 @@ export function getProjectConfigPath(agent: AgentName, projectRoot: string): str
     case 'trae':
       // Trae has no hooks system — only rules (.trae/rules/project_rules.md)
       return path.join(projectRoot, '.trae', 'rules', 'project_rules.md');
+    case 'dsh':
+      // DeepSeek Harness has no hooks system — only guidance (AGENTS.md)
+      return path.join(projectRoot, 'AGENTS.md');
     case 'opencode':
       // OpenCode uses plugin files for hooks
       return path.join(projectRoot, '.opencode', 'plugins', 'memorix.js');
@@ -684,6 +694,9 @@ export function getGlobalConfigPath(agent: AgentName): string {
       return path.join(home, '.omp', 'agent', 'packages', 'memorix', 'extensions', 'memorix.js');
     case 'trae':
       return path.join(home, '.trae', 'rules', 'project_rules.md');
+    case 'dsh':
+      // DSH reads the user-global AGENTS.md from its harness home.
+      return path.join(process.env.DSH_HOME?.trim() || path.join(home, '.dsh'), 'AGENTS.md');
     default:
       return path.join(home, '.memorix', 'hooks.json');
   }
@@ -709,6 +722,9 @@ export function getAgentRulesPath(agent: AgentName, root: string, global = false
         return path.join(root, '.gemini', 'GEMINI.md');
       case 'trae':
         return path.join(root, '.trae', 'rules', 'project_rules.md');
+      case 'dsh':
+        // The user-global AGENTS.md lives in the harness home DSH reads.
+        return path.join(process.env.DSH_HOME?.trim() || path.join(root, '.dsh'), 'AGENTS.md');
       default:
         return path.join(root, '.agent', 'rules', 'memorix.md');
     }
@@ -734,6 +750,8 @@ export function getAgentRulesPath(agent: AgentName, root: string, global = false
       return path.join(root, 'GEMINI.md');
     case 'trae':
       return path.join(root, '.trae', 'rules', 'project_rules.md');
+    case 'dsh':
+      return path.join(root, 'AGENTS.md');
     default:
       return path.join(root, '.agent', 'rules', 'memorix.md');
   }
@@ -842,6 +860,13 @@ export async function detectInstalledAgents(): Promise<AgentName[]> {
     agents.push('trae');
   } catch { /* not installed */ }
 
+  // Check for DeepSeek Harness (its home dir or an explicit DSH_HOME)
+  const dshDir = process.env.DSH_HOME?.trim() || path.join(home, '.dsh');
+  try {
+    await fs.access(dshDir);
+    agents.push('dsh');
+  } catch { /* not installed */ }
+
   return agents;
 }
 
@@ -947,6 +972,22 @@ export async function installHooks(
           generated: { note: 'Trae has no hooks system, only rules (.trae/rules/project_rules.md) installed' },
         };
       }
+    case 'dsh':
+      // DeepSeek Harness has no hook system — install AGENTS.md guidance and
+      // skills; the MCP row is installed by `memorix setup --agent dsh`.
+      {
+        const rulesPath = await installAgentRules(agent, projectRoot, global);
+        const skillPaths = await installOfficialSkillsForAgent(agent, projectRoot, global);
+        return {
+          agent,
+          configPath: rulesPath,
+          events: [],
+          generated: {
+            note: 'DeepSeek Harness has no hook system — installed AGENTS.md guidance and skills; the MCP row is installed by `memorix setup --agent dsh`.',
+            ...(skillPaths.length > 0 ? { skillPaths, skillPath: skillPaths[0] } : {}),
+          },
+        };
+      }
     case 'opencode': {
       // OpenCode uses JS plugin files for hooks
       const pluginContent = generateOpenCodePlugin();
@@ -1127,7 +1168,7 @@ async function installAgentRules(agent: AgentName, projectRoot: string, global =
   try {
     await fs.mkdir(path.dirname(rulesPath), { recursive: true });
 
-    if (agent === 'claude' || agent === 'codex' || agent === 'opencode' || agent === 'antigravity' || agent === 'gemini-cli') {
+    if (agent === 'claude' || agent === 'codex' || agent === 'opencode' || agent === 'antigravity' || agent === 'gemini-cli' || agent === 'dsh') {
       // For shared context files (CLAUDE.md / AGENTS.md / GEMINI.md), append rather than overwrite.
       try {
         const existing = await fs.readFile(rulesPath, 'utf-8');

package/src/hooks/types.ts

@@ -41,6 +41,7 @@ export type AgentName =
   | 'hermes'
   | 'opencode'
   | 'trae'
+  | 'dsh'
   | 'pi'
   | 'omp';
 
@@ -61,6 +62,7 @@ export const AGENT_SUPPORT_TIER: Record<AgentName, SupportTier> = {
   hermes: 'community',
   opencode: 'community',
   trae: 'community',
+  dsh: 'community',
   pi: 'community',
   omp: 'community',
   antigravity: 'community',

package/src/integrations/registry.ts

@@ -150,6 +150,15 @@ export const MEMORIX_INTEGRATIONS: MemorixIntegration[] = [
     install: 'memorix setup --agent trae',
     surfaces: ['MCP', 'rules'],
   },
+  {
+    agent: 'dsh',
+    name: 'DeepSeek Harness',
+    entry: 'official-config',
+    status: 'ready',
+    install: 'memorix setup --agent dsh',
+    surfaces: ['MCP', 'AGENTS.md', 'skills'],
+    note: 'DeepSeek Harness support writes a @deepseek-ai/dsh-mcp-client row into $DSH_HOME/cordis.patch.yml (default ~/.dsh/cordis.patch.yml), guidance into the harness AGENTS.md, and skills under $DSH_HOME/skills.',
+  },
   {
     agent: 'memcode',
     name: 'memcode',

package/src/types.ts

@@ -654,7 +654,7 @@ export interface MemoryRef {
 /** MCP config format adapter interface */
 export interface MCPConfigAdapter {
   /** Setup-only adapters may support a host that does not participate in workspace sync. */
-  readonly source: AgentTarget | 'codebuddy';
+  readonly source: AgentTarget | 'codebuddy' | 'dsh';
   /** Parse MCP server entries from a config file */
   parse(content: string): MCPServerEntry[];
   /** Generate config file content from MCP server entries */

package/src/workspace/mcp-adapters/dsh.ts

@@ -0,0 +1,147 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import type { MCPConfigAdapter, MCPServerEntry } from '../../types.js';
+
+/**
+ * DeepSeek Harness (DSH) MCP Configuration Adapter.
+ *
+ * DSH composes its runtime from Cordis patch layers. External MCP servers are
+ * registered as rows of the `@deepseek-ai/dsh-mcp-client` plugin inside a
+ * patch list. The user-level layer that applies to every profile lives at:
+ *
+ *   $DSH_HOME/cordis.patch.yml   (default: ~/.dsh/cordis.patch.yml)
+ *
+ * Row shape follows DSH's own shipped Memorix reference
+ * (examples/mcp-memory/memorix.cordis.yml in deepseek-ai/deepseek-harness):
+ *
+ *   - insert:
+ *       - id: memory-memorix
+ *         name: '@deepseek-ai/dsh-mcp-client'
+ *         config:
+ *           serverName: memorix
+ *           transport: stdio
+ *           command: memorix
+ *           args: [serve]
+ *
+ * The `cwd` key is deliberately omitted so the MCP child inherits the DSH
+ * process working directory — the workspace DSH was launched from — which is
+ * what keeps Memorix bound to the current Git project.
+ *
+ * Source: https://github.com/deepseek-ai/deepseek-harness/tree/master/packages/mcp/mcp-client
+ */
+
+const MCP_CLIENT_PLUGIN = '@deepseek-ai/dsh-mcp-client';
+const MEMORIX_ROW_ID = 'memory-memorix';
+
+function resolveDshHome(): string {
+  const configured = process.env.DSH_HOME?.trim();
+  if (configured) return configured;
+  return join(homedir(), '.dsh');
+}
+
+function isMemorixRow(row: unknown): row is Record<string, unknown> {
+  if (!row || typeof row !== 'object' || Array.isArray(row)) return false;
+  const record = row as Record<string, unknown>;
+  if (record.name !== MCP_CLIENT_PLUGIN) return false;
+  const config = record.config;
+  return Boolean(
+    config && typeof config === 'object' && !Array.isArray(config)
+    && (config as Record<string, unknown>).serverName === 'memorix',
+  );
+}
+
+function rowToEntry(row: Record<string, unknown>): MCPServerEntry | null {
+  const config = row.config as Record<string, unknown>;
+  if (!config || typeof config !== 'object') return null;
+  const entry: MCPServerEntry = {
+    name: 'memorix',
+    command: typeof config.command === 'string' ? config.command : '',
+    args: Array.isArray(config.args) ? config.args.filter((arg): arg is string => typeof arg === 'string') : [],
+  };
+  if (typeof config.url === 'string' && config.url) entry.url = config.url;
+  if (config.env && typeof config.env === 'object' && !Array.isArray(config.env)) {
+    const env: Record<string, string> = {};
+    for (const [key, value] of Object.entries(config.env as Record<string, unknown>)) {
+      if (typeof value === 'string') env[key] = value;
+    }
+    if (Object.keys(env).length > 0) entry.env = env;
+  }
+  if (config.disabled === true) entry.disabled = true;
+  return entry;
+}
+
+/** Flatten one parsed patch document into its row list, tolerating both
+ *  `- insert: [...]` operations and bare row lists. */
+function patchRows(document: unknown): Record<string, unknown>[] {
+  const rows: Record<string, unknown>[] = [];
+  if (!Array.isArray(document)) return rows;
+  for (const item of document) {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) continue;
+    const record = item as Record<string, unknown>;
+    if (Array.isArray(record.insert)) {
+      for (const row of record.insert) {
+        if (row && typeof row === 'object' && !Array.isArray(row)) {
+          rows.push(row as Record<string, unknown>);
+        }
+      }
+      continue;
+    }
+    rows.push(record);
+  }
+  return rows;
+}
+
+export class DshMCPAdapter implements MCPConfigAdapter {
+  readonly source = 'dsh' as const;
+
+  parse(content: string): MCPServerEntry[] {
+    if (!content.trim()) return [];
+    let document: unknown;
+    try {
+      document = parseYaml(content);
+    } catch {
+      return [];
+    }
+    return patchRows(document)
+      .filter(isMemorixRow)
+      .map(rowToEntry)
+      .filter((entry): entry is MCPServerEntry => entry !== null);
+  }
+
+  generate(servers: MCPServerEntry[]): string {
+    const rows = servers
+      .filter((server) => server.name === 'memorix')
+      .map((server) => {
+        const config: Record<string, unknown> = {
+          serverName: server.name,
+        };
+        if (server.url) {
+          config.transport = 'streamable-http';
+          config.url = server.url;
+          if (server.headers && Object.keys(server.headers).length > 0) config.headers = server.headers;
+        } else {
+          config.transport = 'stdio';
+          config.command = server.command;
+          if (server.args && server.args.length > 0) config.args = server.args;
+          if (server.env && Object.keys(server.env).length > 0) config.env = server.env;
+        }
+        const row: Record<string, unknown> = {
+          id: MEMORIX_ROW_ID,
+          name: MCP_CLIENT_PLUGIN,
+          config,
+        };
+        if (server.disabled === true) row.disabled = true;
+        return row;
+      });
+
+    if (rows.length === 0) return '';
+    return stringifyYaml([{ insert: rows }], { lineWidth: 0 }) + '\n';
+  }
+
+  getConfigPath(_projectRoot?: string): string {
+    return join(resolveDshHome(), 'cordis.patch.yml');
+  }
+}
+
+export { MEMORIX_ROW_ID };