memorix 1.6.1 → 1.6.3

package/src/project/launch-root.ts

@@ -0,0 +1,115 @@
+/**
+ * Launch-root guards for HTTP/stdio/background.
+ *
+ * LaunchAgents and Cursor stdio often start with cwd=$HOME. Binding that path
+ * treats the home directory as a project and can create a decoy ~/memorix.db
+ * while the real store lives in ~/.memorix/data/memorix.db.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export const LAST_PROJECT_ROOT_FILENAME = 'last-project-root';
+
+/**
+ * Resolve the home directory used by Memorix boundary guards.
+ *
+ * Node's os.homedir() is intentionally stable on Windows and does not always
+ * follow a process-level HOME/USERPROFILE override. The CLI and test harnesses
+ * use those environment variables as the configured home, so all guards need
+ * one shared resolution rule instead of mixing the two sources.
+ */
+export function effectiveHomeDirectory(): string {
+  const configuredHome = process.platform === 'win32'
+    ? process.env.USERPROFILE?.trim() || process.env.HOME?.trim()
+    : process.env.HOME?.trim() || process.env.USERPROFILE?.trim();
+  return path.resolve(configuredHome || os.homedir());
+}
+
+export function isHomeDirectory(candidate: string, homeDir: string = effectiveHomeDirectory()): boolean {
+  try {
+    return path.resolve(candidate) === path.resolve(homeDir);
+  } catch {
+    return false;
+  }
+}
+
+export function lastProjectRootPath(homeDir: string = effectiveHomeDirectory()): string {
+  return path.join(homeDir, '.memorix', LAST_PROJECT_ROOT_FILENAME);
+}
+
+export function readLastProjectRoot(homeDir: string = effectiveHomeDirectory()): string | null {
+  try {
+    const raw = readFileSync(lastProjectRootPath(homeDir), 'utf8').trim();
+    if (!raw) return null;
+    const resolved = path.resolve(raw);
+    if (isHomeDirectory(resolved, homeDir)) return null;
+    if (!existsSync(resolved)) return null;
+    return resolved;
+  } catch {
+    return null;
+  }
+}
+
+export function writeLastProjectRoot(projectRoot: string, homeDir?: string): void {
+  // Tests pass an explicit homeDir. Default writes are skipped under Vitest so
+  // unit tests do not mutate the developer's ~/.memorix/last-project-root.
+  if (process.env.VITEST && homeDir === undefined) return;
+  const resolvedHome = homeDir ?? effectiveHomeDirectory();
+  const resolved = path.resolve(projectRoot);
+  if (isHomeDirectory(resolved, resolvedHome)) return;
+  if (!existsSync(resolved)) return;
+  const memorixDir = path.join(resolvedHome, '.memorix');
+  mkdirSync(memorixDir, { recursive: true });
+  writeFileSync(lastProjectRootPath(resolvedHome), `${resolved}\n`, 'utf8');
+}
+
+export function homeProjectRootError(candidate: string): string {
+  return (
+    `Refusing to bind $HOME as a project root (${candidate}). ` +
+    'Pass a git project via --cwd, MEMORIX_PROJECT_ROOT, or memorix_session_start({ projectRoot }). ' +
+    'Memorix will not create ~/memorix.db.'
+  );
+}
+
+/**
+ * When the launcher cwd is $HOME, inherit the last git project or an explicit
+ * MEMORIX_PROJECT_ROOT. System directories stay fail-closed (no restore).
+ */
+export function inheritProjectRootFromHome(options: {
+  homeDir: string;
+  envProjectRoot?: string;
+  readLastRoot?: () => string | null;
+}): string | null {
+  const envRoot = options.envProjectRoot?.trim();
+  if (envRoot && !isHomeDirectory(envRoot, options.homeDir) && existsSync(envRoot)) {
+    return path.resolve(envRoot);
+  }
+  const lastRoot = (options.readLastRoot ?? (() => readLastProjectRoot(options.homeDir)))();
+  if (lastRoot && !isHomeDirectory(lastRoot, options.homeDir) && existsSync(lastRoot)) {
+    return lastRoot;
+  }
+  return null;
+}
+
+/**
+ * Shared SQLite must never be opened at $HOME — that creates a decoy ~/memorix.db.
+ */
+export function resolveControlPlaneDataDir(options: {
+  requestedDataDir?: string;
+  homeDir?: string;
+  globalDataDir: string;
+}): string {
+  const homeDir = options.homeDir ?? effectiveHomeDirectory();
+  if (options.requestedDataDir && !isHomeDirectory(options.requestedDataDir, homeDir)) {
+    return options.requestedDataDir;
+  }
+  return options.globalDataDir;
+}
+
+export function assertNotHomeDataDir(dataDir: string, homeDir: string = effectiveHomeDirectory()): void {
+  if (isHomeDirectory(dataDir, homeDir)) {
+    throw new Error(homeProjectRootError(dataDir));
+  }
+}

package/src/rules/adapters/trae.ts

@@ -1,56 +1,56 @@
-/**
- * Trae IDE Rule Format Adapter
- *
- * Parses and generates rules in Trae's format:
- * - .trae/rules/project_rules.md (project-level rules, plain Markdown)
- *
- * Trae also supports user-level rules (user_rules.md) created via the UI,
- * but those are managed by Trae itself and not project-scoped.
- *
- * Rules are plain Markdown — no frontmatter, no special syntax.
- * Project rules override personal rules when there are conflicts.
- *
- * Source: https://docs.trae.ai/ide/rules
- */
-
-import type { RuleFormatAdapter, UnifiedRule, RuleSource } from '../../types.js';
-import { hashContent, generateRuleId } from '../utils.js';
-
-export class TraeAdapter implements RuleFormatAdapter {
-    readonly source: RuleSource = 'trae';
-
-    readonly filePatterns = [
-        '.trae/rules/project_rules.md',
-        '.trae/rules/*.md',
-    ];
-
-    parse(filePath: string, content: string): UnifiedRule[] {
-        const trimmed = content.trim();
-        if (!trimmed) return [];
-
-        const isProjectRules = filePath.includes('project_rules.md');
-
-        return [{
-            id: generateRuleId('trae', filePath),
-            content: trimmed,
-            description: isProjectRules ? 'Trae project rules' : undefined,
-            source: 'trae',
-            scope: 'project',
-            alwaysApply: true,
-            priority: isProjectRules ? 10 : 5,
-            hash: hashContent(trimmed),
-        }];
-    }
-
-    generate(rules: UnifiedRule[]): { filePath: string; content: string }[] {
-        if (rules.length === 0) return [];
-
-        // Trae uses a single project_rules.md file — merge all rules into one
-        const combined = rules.map(r => r.content).join('\n\n---\n\n');
-
-        return [{
-            filePath: '.trae/rules/project_rules.md',
-            content: combined,
-        }];
-    }
-}
+/**
+ * Trae IDE Rule Format Adapter
+ *
+ * Parses and generates rules in Trae's format:
+ * - .trae/rules/project_rules.md (project-level rules, plain Markdown)
+ *
+ * Trae also supports user-level rules (user_rules.md) created via the UI,
+ * but those are managed by Trae itself and not project-scoped.
+ *
+ * Rules are plain Markdown — no frontmatter, no special syntax.
+ * Project rules override personal rules when there are conflicts.
+ *
+ * Source: https://docs.trae.ai/ide/rules
+ */
+
+import type { RuleFormatAdapter, UnifiedRule, RuleSource } from '../../types.js';
+import { hashContent, generateRuleId } from '../utils.js';
+
+export class TraeAdapter implements RuleFormatAdapter {
+    readonly source: RuleSource = 'trae';
+
+    readonly filePatterns = [
+        '.trae/rules/project_rules.md',
+        '.trae/rules/*.md',
+    ];
+
+    parse(filePath: string, content: string): UnifiedRule[] {
+        const trimmed = content.trim();
+        if (!trimmed) return [];
+
+        const isProjectRules = filePath.includes('project_rules.md');
+
+        return [{
+            id: generateRuleId('trae', filePath),
+            content: trimmed,
+            description: isProjectRules ? 'Trae project rules' : undefined,
+            source: 'trae',
+            scope: 'project',
+            alwaysApply: true,
+            priority: isProjectRules ? 10 : 5,
+            hash: hashContent(trimmed),
+        }];
+    }
+
+    generate(rules: UnifiedRule[]): { filePath: string; content: string }[] {
+        if (rules.length === 0) return [];
+
+        // Trae uses a single project_rules.md file — merge all rules into one
+        const combined = rules.map(r => r.content).join('\n\n---\n\n');
+
+        return [{
+            filePath: '.trae/rules/project_rules.md',
+            content: combined,
+        }];
+    }
+}