memorix 1.6.1 → 1.6.3

package/src/rules/syncer.ts

@@ -1,235 +1,235 @@
-/**
- * Rules Syncer
- *
- * Core sync engine for cross-agent rule synchronization.
- * Scans project for rule files from all supported agents,
- * deduplicates by content hash, detects conflicts, and
- * generates output in any target agent format.
- *
- * This is the ~15% original logic in Memorix — dedup and
- * conflict detection are not found in any existing tool.
- */
-
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import type { UnifiedRule, RuleSource, RuleFormatAdapter } from '../types.js';
-import { CursorAdapter } from './adapters/cursor.js';
-import { ClaudeCodeAdapter } from './adapters/claude-code.js';
-import { CodexAdapter } from './adapters/codex.js';
-import { WindsurfAdapter } from './adapters/windsurf.js';
-import { AntigravityAdapter } from './adapters/antigravity.js';
-import { GeminiCLIAdapter } from './adapters/gemini-cli.js';
-import { CopilotAdapter } from './adapters/copilot.js';
-import { KiroAdapter } from './adapters/kiro.js';
-import { TraeAdapter } from './adapters/trae.js';
-
-/** A detected conflict between two rules */
-export interface RuleConflict {
-  ruleA: UnifiedRule;
-  ruleB: UnifiedRule;
-  reason: string;
-}
-
-/** Sync status report */
-export interface SyncStatus {
-  totalRules: number;
-  uniqueRules: number;
-  sources: RuleSource[];
-  conflicts: RuleConflict[];
-}
-
-/** File scan patterns for each adapter */
-interface ScanEntry {
-  adapter: RuleFormatAdapter;
-  paths: string[];
-}
-
-export class RulesSyncer {
-  private readonly projectRoot: string;
-  private readonly adapters: Map<RuleSource, RuleFormatAdapter>;
-
-  constructor(projectRoot: string) {
-    this.projectRoot = projectRoot;
-    this.adapters = new Map();
-
-    const all: RuleFormatAdapter[] = [
-      new CursorAdapter(),
-      new ClaudeCodeAdapter(),
-      new CodexAdapter(),
-      new WindsurfAdapter(),
-      new AntigravityAdapter(),
-      new GeminiCLIAdapter(),
-      new CopilotAdapter(),
-      new KiroAdapter(),
-      new TraeAdapter(),
-    ];
-    for (const a of all) {
-      this.adapters.set(a.source, a);
-    }
-  }
-
-  /** Scan the project root for all known rule files and parse them */
-  async scanRules(): Promise<UnifiedRule[]> {
-    const rules: UnifiedRule[] = [];
-
-    const scanEntries = this.buildScanEntries();
-
-    for (const entry of scanEntries) {
-      for (const scanPath of entry.paths) {
-        const found = await this.findFiles(scanPath);
-        for (const filePath of found) {
-          try {
-            const content = await fs.readFile(filePath, 'utf-8');
-            const relativePath = path.relative(this.projectRoot, filePath).replace(/\\/g, '/');
-            const parsed = entry.adapter.parse(relativePath, content);
-            rules.push(...parsed);
-          } catch {
-            // Skip unreadable files
-          }
-        }
-      }
-    }
-
-    return rules;
-  }
-
-  /** Remove duplicate rules by content hash, keeping highest priority */
-  deduplicateRules(rules: UnifiedRule[]): UnifiedRule[] {
-    const byHash = new Map<string, UnifiedRule>();
-
-    for (const rule of rules) {
-      const existing = byHash.get(rule.hash);
-      if (!existing || rule.priority > existing.priority) {
-        byHash.set(rule.hash, rule);
-      }
-    }
-
-    return Array.from(byHash.values());
-  }
-
-  /** Detect conflicts: rules with overlapping paths but different content */
-  detectConflicts(rules: UnifiedRule[]): RuleConflict[] {
-    const conflicts: RuleConflict[] = [];
-
-    for (let i = 0; i < rules.length; i++) {
-      for (let j = i + 1; j < rules.length; j++) {
-        const a = rules[i];
-        const b = rules[j];
-
-        // Only compare rules from different sources
-        if (a.source === b.source) continue;
-        // Only compare if both have overlapping paths
-        if (a.scope === 'path-specific' && b.scope === 'path-specific') {
-          if (this.pathsOverlap(a.paths || [], b.paths || [])) {
-            conflicts.push({
-              ruleA: a,
-              ruleB: b,
-              reason: `Overlapping paths: ${a.source} vs ${b.source}`,
-            });
-          }
-        }
-      }
-    }
-
-    return conflicts;
-  }
-
-  /** Generate rule files for a target agent format */
-  generateForTarget(
-    rules: UnifiedRule[],
-    target: RuleSource,
-  ): { filePath: string; content: string }[] {
-    const adapter = this.adapters.get(target);
-    if (!adapter) {
-      throw new Error(`No adapter for target: ${target}`);
-    }
-    return adapter.generate(rules);
-  }
-
-  /** Get a full sync status report */
-  async syncStatus(): Promise<SyncStatus> {
-    const rules = await this.scanRules();
-    const deduped = this.deduplicateRules(rules);
-    const conflicts = this.detectConflicts(deduped);
-    const sources = [...new Set(rules.map(r => r.source))];
-
-    return {
-      totalRules: rules.length,
-      uniqueRules: deduped.length,
-      sources,
-      conflicts,
-    };
-  }
-
-  /** Build scan entries mapping adapters to their file search paths */
-  private buildScanEntries(): ScanEntry[] {
-    const entries: ScanEntry[] = [];
-
-    for (const adapter of this.adapters.values()) {
-      const absolutePaths = adapter.filePatterns.map(p =>
-        path.join(this.projectRoot, p),
-      );
-      entries.push({ adapter, paths: absolutePaths });
-    }
-
-    return entries;
-  }
-
-  /** Find files matching a glob-like path (simple implementation) */
-  private async findFiles(pattern: string): Promise<string[]> {
-    const dir = path.dirname(pattern);
-    const fileGlob = path.basename(pattern);
-
-    try {
-      const stat = await fs.stat(dir);
-      if (!stat.isDirectory()) {
-        // It's a direct file path
-        try {
-          await fs.access(pattern);
-          return [pattern];
-        } catch {
-          return [];
-        }
-      }
-    } catch {
-      // If dir doesn't exist, check if pattern itself is a file
-      try {
-        await fs.access(pattern);
-        return [pattern];
-      } catch {
-        return [];
-      }
-    }
-
-    // If it's a glob pattern (contains *), list dir and filter
-    if (fileGlob.includes('*')) {
-      try {
-        const files = await fs.readdir(dir);
-        const ext = fileGlob.replace('*', '');
-        return files
-          .filter(f => ext ? f.endsWith(ext) : true)
-          .map(f => path.join(dir, f));
-      } catch {
-        return [];
-      }
-    }
-
-    // Direct file
-    try {
-      await fs.access(path.join(dir, fileGlob));
-      return [path.join(dir, fileGlob)];
-    } catch {
-      return [];
-    }
-  }
-
-  /** Check if two sets of glob paths overlap (simplified: exact match) */
-  private pathsOverlap(a: string[], b: string[]): boolean {
-    for (const pa of a) {
-      for (const pb of b) {
-        if (pa === pb) return true;
-      }
-    }
-    return false;
-  }
-}
+/**
+ * Rules Syncer
+ *
+ * Core sync engine for cross-agent rule synchronization.
+ * Scans project for rule files from all supported agents,
+ * deduplicates by content hash, detects conflicts, and
+ * generates output in any target agent format.
+ *
+ * This is the ~15% original logic in Memorix — dedup and
+ * conflict detection are not found in any existing tool.
+ */
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import type { UnifiedRule, RuleSource, RuleFormatAdapter } from '../types.js';
+import { CursorAdapter } from './adapters/cursor.js';
+import { ClaudeCodeAdapter } from './adapters/claude-code.js';
+import { CodexAdapter } from './adapters/codex.js';
+import { WindsurfAdapter } from './adapters/windsurf.js';
+import { AntigravityAdapter } from './adapters/antigravity.js';
+import { GeminiCLIAdapter } from './adapters/gemini-cli.js';
+import { CopilotAdapter } from './adapters/copilot.js';
+import { KiroAdapter } from './adapters/kiro.js';
+import { TraeAdapter } from './adapters/trae.js';
+
+/** A detected conflict between two rules */
+export interface RuleConflict {
+  ruleA: UnifiedRule;
+  ruleB: UnifiedRule;
+  reason: string;
+}
+
+/** Sync status report */
+export interface SyncStatus {
+  totalRules: number;
+  uniqueRules: number;
+  sources: RuleSource[];
+  conflicts: RuleConflict[];
+}
+
+/** File scan patterns for each adapter */
+interface ScanEntry {
+  adapter: RuleFormatAdapter;
+  paths: string[];
+}
+
+export class RulesSyncer {
+  private readonly projectRoot: string;
+  private readonly adapters: Map<RuleSource, RuleFormatAdapter>;
+
+  constructor(projectRoot: string) {
+    this.projectRoot = projectRoot;
+    this.adapters = new Map();
+
+    const all: RuleFormatAdapter[] = [
+      new CursorAdapter(),
+      new ClaudeCodeAdapter(),
+      new CodexAdapter(),
+      new WindsurfAdapter(),
+      new AntigravityAdapter(),
+      new GeminiCLIAdapter(),
+      new CopilotAdapter(),
+      new KiroAdapter(),
+      new TraeAdapter(),
+    ];
+    for (const a of all) {
+      this.adapters.set(a.source, a);
+    }
+  }
+
+  /** Scan the project root for all known rule files and parse them */
+  async scanRules(): Promise<UnifiedRule[]> {
+    const rules: UnifiedRule[] = [];
+
+    const scanEntries = this.buildScanEntries();
+
+    for (const entry of scanEntries) {
+      for (const scanPath of entry.paths) {
+        const found = await this.findFiles(scanPath);
+        for (const filePath of found) {
+          try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const relativePath = path.relative(this.projectRoot, filePath).replace(/\\/g, '/');
+            const parsed = entry.adapter.parse(relativePath, content);
+            rules.push(...parsed);
+          } catch {
+            // Skip unreadable files
+          }
+        }
+      }
+    }
+
+    return rules;
+  }
+
+  /** Remove duplicate rules by content hash, keeping highest priority */
+  deduplicateRules(rules: UnifiedRule[]): UnifiedRule[] {
+    const byHash = new Map<string, UnifiedRule>();
+
+    for (const rule of rules) {
+      const existing = byHash.get(rule.hash);
+      if (!existing || rule.priority > existing.priority) {
+        byHash.set(rule.hash, rule);
+      }
+    }
+
+    return Array.from(byHash.values());
+  }
+
+  /** Detect conflicts: rules with overlapping paths but different content */
+  detectConflicts(rules: UnifiedRule[]): RuleConflict[] {
+    const conflicts: RuleConflict[] = [];
+
+    for (let i = 0; i < rules.length; i++) {
+      for (let j = i + 1; j < rules.length; j++) {
+        const a = rules[i];
+        const b = rules[j];
+
+        // Only compare rules from different sources
+        if (a.source === b.source) continue;
+        // Only compare if both have overlapping paths
+        if (a.scope === 'path-specific' && b.scope === 'path-specific') {
+          if (this.pathsOverlap(a.paths || [], b.paths || [])) {
+            conflicts.push({
+              ruleA: a,
+              ruleB: b,
+              reason: `Overlapping paths: ${a.source} vs ${b.source}`,
+            });
+          }
+        }
+      }
+    }
+
+    return conflicts;
+  }
+
+  /** Generate rule files for a target agent format */
+  generateForTarget(
+    rules: UnifiedRule[],
+    target: RuleSource,
+  ): { filePath: string; content: string }[] {
+    const adapter = this.adapters.get(target);
+    if (!adapter) {
+      throw new Error(`No adapter for target: ${target}`);
+    }
+    return adapter.generate(rules);
+  }
+
+  /** Get a full sync status report */
+  async syncStatus(): Promise<SyncStatus> {
+    const rules = await this.scanRules();
+    const deduped = this.deduplicateRules(rules);
+    const conflicts = this.detectConflicts(deduped);
+    const sources = [...new Set(rules.map(r => r.source))];
+
+    return {
+      totalRules: rules.length,
+      uniqueRules: deduped.length,
+      sources,
+      conflicts,
+    };
+  }
+
+  /** Build scan entries mapping adapters to their file search paths */
+  private buildScanEntries(): ScanEntry[] {
+    const entries: ScanEntry[] = [];
+
+    for (const adapter of this.adapters.values()) {
+      const absolutePaths = adapter.filePatterns.map(p =>
+        path.join(this.projectRoot, p),
+      );
+      entries.push({ adapter, paths: absolutePaths });
+    }
+
+    return entries;
+  }
+
+  /** Find files matching a glob-like path (simple implementation) */
+  private async findFiles(pattern: string): Promise<string[]> {
+    const dir = path.dirname(pattern);
+    const fileGlob = path.basename(pattern);
+
+    try {
+      const stat = await fs.stat(dir);
+      if (!stat.isDirectory()) {
+        // It's a direct file path
+        try {
+          await fs.access(pattern);
+          return [pattern];
+        } catch {
+          return [];
+        }
+      }
+    } catch {
+      // If dir doesn't exist, check if pattern itself is a file
+      try {
+        await fs.access(pattern);
+        return [pattern];
+      } catch {
+        return [];
+      }
+    }
+
+    // If it's a glob pattern (contains *), list dir and filter
+    if (fileGlob.includes('*')) {
+      try {
+        const files = await fs.readdir(dir);
+        const ext = fileGlob.replace('*', '');
+        return files
+          .filter(f => ext ? f.endsWith(ext) : true)
+          .map(f => path.join(dir, f));
+      } catch {
+        return [];
+      }
+    }
+
+    // Direct file
+    try {
+      await fs.access(path.join(dir, fileGlob));
+      return [path.join(dir, fileGlob)];
+    } catch {
+      return [];
+    }
+  }
+
+  /** Check if two sets of glob paths overlap (simplified: exact match) */
+  private pathsOverlap(a: string[], b: string[]): boolean {
+    for (const pa of a) {
+      for (const pb of b) {
+        if (pa === pb) return true;
+      }
+    }
+    return false;
+  }
+}

package/src/runtime/isolated-maintenance.ts

@@ -1,5 +1,6 @@
 import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process';
 import { existsSync } from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -52,6 +53,16 @@ function childError(prefix: string, detail: string): Error {
   return new Error(cleaned ? `${prefix}: ${cleaned}` : prefix);
 }
 
+/**
+ * Isolated jobs already receive an absolute projectRoot on stdin. Using that
+ * directory as spawn cwd keeps the folder locked on Windows (EBUSY on rmdir)
+ * for the life of the child. Park the process in a disposable temp dir instead.
+ */
+export function isolatedMaintenanceCwd(): string {
+  const tmp = os.tmpdir();
+  return existsSync(tmp) ? tmp : process.cwd();
+}
+
 /**
  * Resolve the runner beside the compiled package entry. The CLI bundle lives
  * in dist/cli while the library entry lives directly in dist.
@@ -148,7 +159,7 @@ export async function runMaintenanceInChildProcess(
     let child: ChildProcessWithoutNullStreams;
     try {
       child = spawn(process.execPath, [runnerPath], {
-        cwd: request.projectRoot,
+        cwd: isolatedMaintenanceCwd(),
         env,
         stdio: ['pipe', 'pipe', 'pipe'],
         windowsHide: true,

package/src/sdk.ts

@@ -303,6 +303,14 @@ export class MemoryClient {
     } catch {
       // best-effort cleanup
     }
+    // ObservationStore.close() only detaches from the shared handle.
+    // Release this dataDir so Windows can unlink memorix.db after close().
+    try {
+      const { closeDatabase } = await import('./store/sqlite-db.js');
+      closeDatabase(this._dataDir);
+    } catch {
+      // best-effort cleanup
+    }
   }
 }
 
@@ -346,14 +354,10 @@ export async function createMemoryClient(options: MemoryClientOptions): Promise<
     );
   }
 
-  // Resolve data directory
-  const path = await import('node:path');
-  const os = await import('node:os');
-  const dataDir = path.join(os.homedir(), '.memorix', 'data', project.id.replace(/\//g, path.sep));
-
-  // Ensure data directory exists
-  const fs = await import('node:fs');
-  fs.mkdirSync(dataDir, { recursive: true });
+  // SDK, CLI, hooks, and HTTP MCP must share the same flat data directory.
+  // Project identity is stored in each row, not encoded in the directory.
+  const { getProjectDataDir } = await import('./store/persistence.js');
+  const dataDir = await getProjectDataDir(project.id);
 
   const client = new MemoryClient(project.id, projectRoot, dataDir);
   await client._init(silent);

package/src/search/query-expansion.ts

@@ -1,52 +1,52 @@
-import { callLLM, initLLM, isLLMEnabled } from '../llm/provider.js';
-
-const CJK_PATTERN = /[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/g;
-const COMMAND_LIKE_QUERY = /\b(git|npm|npx|pnpm|yarn|node|bash|powershell|curl|memorix)\b/i;
-
-const QUERY_EXPANSION_PROMPT = `You rewrite coding-memory search queries for retrieval.
-
-Rules:
-- Input may be Chinese, Japanese, or Korean
-- Output one short English search phrase only
-- Keep the technical meaning
-- Prefer wording that would match engineering notes or memory titles
-- No bullets, no JSON, no explanation, no quotes
-- 4 to 12 words is ideal`;
-
-function isCjkHeavy(query: string): boolean {
-  const cjkCount = (query.match(CJK_PATTERN) || []).length;
-  return query.length > 0 && cjkCount / query.length > 0.3;
-}
-
-function normalizeExpansion(text: string): string {
-  return text
-    .trim()
-    .replace(/^[-*]\s*/, '')
-    .replace(/^["'`]+|["'`]+$/g, '')
-    .split(/\r?\n/)[0]
-    .trim();
-}
-
-export async function maybeExpandSearchQuery(query: string): Promise<string> {
-  if (!query || !isCjkHeavy(query) || COMMAND_LIKE_QUERY.test(query)) {
-    return query;
-  }
-
-  if (!isLLMEnabled()) {
-    initLLM();
-  }
-
-  if (!isLLMEnabled()) {
-    return query;
-  }
-
-  try {
-    const response = await callLLM(QUERY_EXPANSION_PROMPT, query);
-    const expanded = normalizeExpansion(response.content);
-    if (!expanded) return query;
-    if (expanded.toLowerCase() === query.toLowerCase()) return query;
-    return `${query} ${expanded}`.slice(0, 500);
-  } catch {
-    return query;
-  }
-}
+import { callLLM, initLLM, isLLMEnabled } from '../llm/provider.js';
+
+const CJK_PATTERN = /[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/g;
+const COMMAND_LIKE_QUERY = /\b(git|npm|npx|pnpm|yarn|node|bash|powershell|curl|memorix)\b/i;
+
+const QUERY_EXPANSION_PROMPT = `You rewrite coding-memory search queries for retrieval.
+
+Rules:
+- Input may be Chinese, Japanese, or Korean
+- Output one short English search phrase only
+- Keep the technical meaning
+- Prefer wording that would match engineering notes or memory titles
+- No bullets, no JSON, no explanation, no quotes
+- 4 to 12 words is ideal`;
+
+function isCjkHeavy(query: string): boolean {
+  const cjkCount = (query.match(CJK_PATTERN) || []).length;
+  return query.length > 0 && cjkCount / query.length > 0.3;
+}
+
+function normalizeExpansion(text: string): string {
+  return text
+    .trim()
+    .replace(/^[-*]\s*/, '')
+    .replace(/^["'`]+|["'`]+$/g, '')
+    .split(/\r?\n/)[0]
+    .trim();
+}
+
+export async function maybeExpandSearchQuery(query: string): Promise<string> {
+  if (!query || !isCjkHeavy(query) || COMMAND_LIKE_QUERY.test(query)) {
+    return query;
+  }
+
+  if (!isLLMEnabled()) {
+    initLLM();
+  }
+
+  if (!isLLMEnabled()) {
+    return query;
+  }
+
+  try {
+    const response = await callLLM(QUERY_EXPANSION_PROMPT, query);
+    const expanded = normalizeExpansion(response.content);
+    if (!expanded) return query;
+    if (expanded.toLowerCase() === query.toLowerCase()) return query;
+    return `${query} ${expanded}`.slice(0, 500);
+  } catch {
+    return query;
+  }
+}