memorix 1.4.3 → 1.4.5

package/src/cli/commands/purge-project-memory.ts

@@ -1,83 +1,83 @@
-/**
- * CLI Command: memorix purge project-memory
- *
- * Delete memories for the current project only.
- */
-
-import { defineCommand } from 'citty';
-import * as p from '@clack/prompts';
-
-export default defineCommand({
-  meta: {
-    name: 'project-memory',
-    description: 'Delete memories for current project',
-  },
-  args: {},
-  run: async ({}) => {
-    const os = await import('node:os');
-    let cwd: string;
-    try { cwd = process.cwd(); } catch { cwd = os.homedir(); }
-
-    p.intro('Purge Project Memory');
-
-    // Show what will be deleted
-    console.log('');
-    console.log('Will delete memories for:');
-    console.log(`  Project: ${cwd}`);
-    console.log('');
-    console.log('This will remove all observations, entities, and relations');
-    console.log('associated with this project from the memory database.');
-    console.log('');
-    console.log('Project artifacts (hook files) will be preserved.');
-    console.log('');
-
-    // Confirm
-    const confirmed = await p.confirm({
-      message: 'Continue purge?',
-    });
-
-    if (p.isCancel(confirmed) || !confirmed) {
-      p.outro('Purge cancelled.');
-      return;
-    }
-
-    // Get project ID
-    const projectId = getProjectId(cwd);
-
-    // Delete project memories
-    try {
-      const {
-        getProjectObservations,
-        resolveObservations,
-      } = await import('../../memory/observations.js');
-      const { withFreshIndex } = await import('../../memory/freshness.js');
-      const observations = await withFreshIndex(() => getProjectObservations(projectId));
-      const ids = observations.map((o) => o.id);
-
-      if (ids.length === 0) {
-        console.log('No observations found for this project.');
-        p.outro('No memories to purge.');
-        return;
-      }
-
-      const result = await resolveObservations(ids, 'archived');
-
-      console.log(`[OK] Archived ${result.resolved.length} observations for project`);
-
-      p.outro(`Project memory purged. ${result.resolved.length} observations archived.`);
-    } catch (err) {
-      console.error(`[ERROR] Failed to purge project memory: ${err}`);
-      p.outro('Purge failed.');
-    }
-  },
-});
-
-function getProjectId(projectRoot: string): string {
-  try {
-    const { detectProject } = require('../project/detector.js');
-    const project = detectProject(projectRoot);
-    if (project) return project.id;
-  } catch { /* fallback below */ }
-  const normalized = projectRoot.replace(/\\/g, '/');
-  return `untracked/${normalized}`;
-}
+/**
+ * CLI Command: memorix purge project-memory
+ *
+ * Delete memories for the current project only.
+ */
+
+import { defineCommand } from 'citty';
+import * as p from '@clack/prompts';
+
+export default defineCommand({
+  meta: {
+    name: 'project-memory',
+    description: 'Delete memories for current project',
+  },
+  args: {},
+  run: async ({}) => {
+    const os = await import('node:os');
+    let cwd: string;
+    try { cwd = process.cwd(); } catch { cwd = os.homedir(); }
+
+    p.intro('Purge Project Memory');
+
+    // Show what will be deleted
+    console.log('');
+    console.log('Will delete memories for:');
+    console.log(`  Project: ${cwd}`);
+    console.log('');
+    console.log('This will remove all observations, entities, and relations');
+    console.log('associated with this project from the memory database.');
+    console.log('');
+    console.log('Project artifacts (hook files) will be preserved.');
+    console.log('');
+
+    // Confirm
+    const confirmed = await p.confirm({
+      message: 'Continue purge?',
+    });
+
+    if (p.isCancel(confirmed) || !confirmed) {
+      p.outro('Purge cancelled.');
+      return;
+    }
+
+    // Get project ID
+    const projectId = getProjectId(cwd);
+
+    // Delete project memories
+    try {
+      const {
+        getProjectObservations,
+        resolveObservations,
+      } = await import('../../memory/observations.js');
+      const { withFreshIndex } = await import('../../memory/freshness.js');
+      const observations = await withFreshIndex(() => getProjectObservations(projectId));
+      const ids = observations.map((o) => o.id);
+
+      if (ids.length === 0) {
+        console.log('No observations found for this project.');
+        p.outro('No memories to purge.');
+        return;
+      }
+
+      const result = await resolveObservations(ids, 'archived');
+
+      console.log(`[OK] Archived ${result.resolved.length} observations for project`);
+
+      p.outro(`Project memory purged. ${result.resolved.length} observations archived.`);
+    } catch (err) {
+      console.error(`[ERROR] Failed to purge project memory: ${err}`);
+      p.outro('Purge failed.');
+    }
+  },
+});
+
+function getProjectId(projectRoot: string): string {
+  try {
+    const { detectProject } = require('../project/detector.js');
+    const project = detectProject(projectRoot);
+    if (project) return project.id;
+  } catch { /* fallback below */ }
+  const normalized = projectRoot.replace(/\\/g, '/');
+  return `untracked/${normalized}`;
+}

package/src/cli/commands/reasoning.ts

@@ -1,6 +1,6 @@
-import { defineCommand } from 'citty';
-import { compactSearch } from '../../compact/engine.js';
-import { storeObservation } from '../../memory/observations.js';
+import { defineCommand } from 'citty';
+import { compactSearch } from '../../compact/engine.js';
+import { storeObservation } from '../../memory/observations.js';
 import {
   emitError,
   emitResult,
@@ -9,65 +9,65 @@ import {
   parsePositiveInt,
   resolveCliWriteScope,
 } from './operator-shared.js';
-
-export default defineCommand({
-  meta: {
-    name: 'reasoning',
-    description: 'Store and search decision rationale from the operator CLI',
-  },
-  args: {
-    entity: { type: 'string', description: 'Entity this reasoning applies to' },
-    decision: { type: 'string', description: 'Decision that was made' },
-    rationale: { type: 'string', description: 'Why this approach was chosen' },
-    alternatives: { type: 'string', description: 'Comma-separated alternatives that were considered' },
-    constraints: { type: 'string', description: 'Comma-separated constraints' },
-    expectedOutcome: { type: 'string', description: 'Expected outcome from this decision' },
-    risks: { type: 'string', description: 'Comma-separated risks or downsides' },
-    concepts: { type: 'string', description: 'Comma-separated related concepts' },
-    files: { type: 'string', description: 'Comma-separated file list' },
-    relatedCommits: { type: 'string', description: 'Comma-separated related commit hashes' },
+
+export default defineCommand({
+  meta: {
+    name: 'reasoning',
+    description: 'Store and search decision rationale from the operator CLI',
+  },
+  args: {
+    entity: { type: 'string', description: 'Entity this reasoning applies to' },
+    decision: { type: 'string', description: 'Decision that was made' },
+    rationale: { type: 'string', description: 'Why this approach was chosen' },
+    alternatives: { type: 'string', description: 'Comma-separated alternatives that were considered' },
+    constraints: { type: 'string', description: 'Comma-separated constraints' },
+    expectedOutcome: { type: 'string', description: 'Expected outcome from this decision' },
+    risks: { type: 'string', description: 'Comma-separated risks or downsides' },
+    concepts: { type: 'string', description: 'Comma-separated related concepts' },
+    files: { type: 'string', description: 'Comma-separated file list' },
+    relatedCommits: { type: 'string', description: 'Comma-separated related commit hashes' },
     relatedEntities: { type: 'string', description: 'Comma-separated related entity names' },
     visibility: { type: 'string', description: 'Reasoning visibility: project (default), personal, or team' },
-    query: { type: 'string', description: 'Search query for reasoning traces' },
-    limit: { type: 'string', description: 'Search result limit' },
-    scope: { type: 'string', description: 'project or global scope for search' },
-    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
-  },
-  run: async ({ args }) => {
-    const action = (args._ as string[])?.[0] || '';
-    const asJson = !!args.json;
-
-    try {
+    query: { type: 'string', description: 'Search query for reasoning traces' },
+    limit: { type: 'string', description: 'Search result limit' },
+    scope: { type: 'string', description: 'project or global scope for search' },
+    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
+  },
+  run: async ({ args }) => {
+    const action = (args._ as string[])?.[0] || '';
+    const asJson = !!args.json;
+
+    try {
       const { project, reader, identity } = await getCliProjectContext({ searchIndex: action === 'search' });
-
-      switch (action) {
-        case 'store': {
-          const entityName = (args.entity as string | undefined)?.trim();
-          const decision = (args.decision as string | undefined)?.trim();
-          const rationale = (args.rationale as string | undefined)?.trim();
-          if (!entityName || !decision || !rationale) {
-            emitError('entity, decision, and rationale are required for "memorix reasoning store"', asJson);
-            return;
-          }
-
-          const alternatives = parseCsvList(args.alternatives as string | undefined);
-          const constraints = parseCsvList(args.constraints as string | undefined);
-          const risks = parseCsvList(args.risks as string | undefined);
-          const concepts = parseCsvList(args.concepts as string | undefined);
-          const filesModified = parseCsvList(args.files as string | undefined);
-          const relatedCommits = parseCsvList(args.relatedCommits as string | undefined);
-          const relatedEntities = parseCsvList(args.relatedEntities as string | undefined);
-
-          const narrativeParts: string[] = [rationale];
-          if (alternatives.length > 0) {
-            narrativeParts.push(`Alternatives considered: ${alternatives.join('; ')}`);
-          }
-          if (constraints.length > 0) {
-            narrativeParts.push(`Constraints: ${constraints.join('; ')}`);
-          }
-          if (args.expectedOutcome) {
-            narrativeParts.push(`Expected outcome: ${String(args.expectedOutcome).trim()}`);
-          }
+
+      switch (action) {
+        case 'store': {
+          const entityName = (args.entity as string | undefined)?.trim();
+          const decision = (args.decision as string | undefined)?.trim();
+          const rationale = (args.rationale as string | undefined)?.trim();
+          if (!entityName || !decision || !rationale) {
+            emitError('entity, decision, and rationale are required for "memorix reasoning store"', asJson);
+            return;
+          }
+
+          const alternatives = parseCsvList(args.alternatives as string | undefined);
+          const constraints = parseCsvList(args.constraints as string | undefined);
+          const risks = parseCsvList(args.risks as string | undefined);
+          const concepts = parseCsvList(args.concepts as string | undefined);
+          const filesModified = parseCsvList(args.files as string | undefined);
+          const relatedCommits = parseCsvList(args.relatedCommits as string | undefined);
+          const relatedEntities = parseCsvList(args.relatedEntities as string | undefined);
+
+          const narrativeParts: string[] = [rationale];
+          if (alternatives.length > 0) {
+            narrativeParts.push(`Alternatives considered: ${alternatives.join('; ')}`);
+          }
+          if (constraints.length > 0) {
+            narrativeParts.push(`Constraints: ${constraints.join('; ')}`);
+          }
+          if (args.expectedOutcome) {
+            narrativeParts.push(`Expected outcome: ${String(args.expectedOutcome).trim()}`);
+          }
           if (risks.length > 0) {
             narrativeParts.push(`Risks: ${risks.join('; ')}`);
           }
@@ -77,70 +77,70 @@ export default defineCommand({
           );
 
           const result = await storeObservation({
-            entityName,
-            type: 'reasoning',
-            title: decision,
-            narrative: narrativeParts.join('. '),
-            facts: [
-              `Decision: ${decision}`,
-              ...alternatives.map((item) => `Alternative: ${item}`),
-              ...constraints.map((item) => `Constraint: ${item}`),
-              ...(args.expectedOutcome ? [`Expected outcome: ${String(args.expectedOutcome).trim()}`] : []),
-              ...risks.map((item) => `Risk: ${item}`),
-              ...relatedCommits.map((item) => `Commit: ${item}`),
-              ...relatedEntities.map((item) => `Related entity: ${item}`),
-            ],
-            concepts,
-            filesModified,
-            relatedCommits,
-            relatedEntities,
+            entityName,
+            type: 'reasoning',
+            title: decision,
+            narrative: narrativeParts.join('. '),
+            facts: [
+              `Decision: ${decision}`,
+              ...alternatives.map((item) => `Alternative: ${item}`),
+              ...constraints.map((item) => `Constraint: ${item}`),
+              ...(args.expectedOutcome ? [`Expected outcome: ${String(args.expectedOutcome).trim()}`] : []),
+              ...risks.map((item) => `Risk: ${item}`),
+              ...relatedCommits.map((item) => `Commit: ${item}`),
+              ...relatedEntities.map((item) => `Related entity: ${item}`),
+            ],
+            concepts,
+            filesModified,
+            relatedCommits,
+            relatedEntities,
             projectId: project.id,
             source: 'manual',
             ...writeScope,
-          });
-
-          emitResult(
-            { project, observation: result.observation, upserted: result.upserted },
-            `${result.upserted ? 'Updated' : 'Stored'} reasoning trace #${result.observation.id}: ${decision}`,
-            asJson,
-          );
-          return;
-        }
-
-        case 'search': {
-          const query = (args.query as string | undefined)?.trim();
-          if (!query) {
-            emitError('query is required for "memorix reasoning search"', asJson);
-            return;
-          }
-          const scope = (args.scope as string | undefined) === 'global' ? 'global' : 'project';
-          const limit = parsePositiveInt(args.limit as string | undefined, 10);
-          const result = await compactSearch({
-            query,
-            limit,
+          });
+
+          emitResult(
+            { project, observation: result.observation, upserted: result.upserted },
+            `${result.upserted ? 'Updated' : 'Stored'} reasoning trace #${result.observation.id}: ${decision}`,
+            asJson,
+          );
+          return;
+        }
+
+        case 'search': {
+          const query = (args.query as string | undefined)?.trim();
+          if (!query) {
+            emitError('query is required for "memorix reasoning search"', asJson);
+            return;
+          }
+          const scope = (args.scope as string | undefined) === 'global' ? 'global' : 'project';
+          const limit = parsePositiveInt(args.limit as string | undefined, 10);
+          const result = await compactSearch({
+            query,
+            limit,
             type: 'reasoning',
             projectId: scope === 'global' ? undefined : project.id,
             status: 'active',
             reader: scope === 'global' ? {} : reader,
-          });
-          emitResult(
-            { project, scope, entries: result.entries },
-            result.entries.length === 0 ? 'No reasoning traces found.' : `[REASONING] Reasoning traces\n${result.formatted}`,
-            asJson,
-          );
-          return;
-        }
-
-        default:
-          console.log('Memorix Reasoning Commands');
-          console.log('');
-          console.log('Usage:');
+          });
+          emitResult(
+            { project, scope, entries: result.entries },
+            result.entries.length === 0 ? 'No reasoning traces found.' : `[REASONING] Reasoning traces\n${result.formatted}`,
+            asJson,
+          );
+          return;
+        }
+
+        default:
+          console.log('Memorix Reasoning Commands');
+          console.log('');
+          console.log('Usage:');
           console.log('  memorix reasoning store --entity auth --decision "Use SQLite" --rationale "..." [--visibility project|personal|team]');
-          console.log('  memorix reasoning search --query "why sqlite" [--scope project|global --limit 10]');
-      }
-    } catch (error) {
-      emitError(error instanceof Error ? error.message : String(error), asJson);
-    }
-  },
-});
-
+          console.log('  memorix reasoning search --query "why sqlite" [--scope project|global --limit 10]');
+      }
+    } catch (error) {
+      emitError(error instanceof Error ? error.message : String(error), asJson);
+    }
+  },
+});
+

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' },