memorix 0.9.4 → 0.9.6

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.9.6] — 2026-02-25
+
+### Fixed
+- **Cross-IDE project identity fragmentation** — Data was stored in per-project subdirectories (`~/.memorix/data/<projectId>/`), but different IDEs often detected different projectIds for the same repo (e.g. `placeholder/repo` vs `local/repo` vs `local/Kiro`). This caused observations to silently split across directories, making cross-IDE relay unreliable. Now **all data is stored in a single flat directory** (`~/.memorix/data/`). projectId is metadata only, not used for directory partitioning. Existing per-project subdirectories are automatically merged on first startup (IDs remapped, graphs deduplicated, subdirs backed up to `.migrated-subdirs/`).
+- **`scope: 'project'` parameter now works** — Previously accepted but ignored. Now properly filters search results by the current project's ID via Orama where-clause.
+
+## [0.9.5] — 2026-02-25
+
+### Fixed
+- **Claude Code hooks `matcher` format** — `matcher` must be a **string** (tool name pattern like `"Bash"`, `"Edit|Write"`), not an object. For hooks that should fire on ALL events, `matcher` is now omitted entirely instead of using `{}`. Fixes `matcher: Expected string, but received object` validation error on Claude Code startup.
+
 ## [0.9.4] — 2026-02-25
 
 ### Fixed

package/dist/cli/index.js

@@ -112,7 +112,7 @@ __export(persistence_exports, {
   loadIdCounter: () => loadIdCounter,
   loadObservationsJson: () => loadObservationsJson,
   loadSessionsJson: () => loadSessionsJson,
-  migrateGlobalData: () => migrateGlobalData,
+  migrateSubdirsToFlat: () => migrateSubdirsToFlat,
   saveGraphJsonl: () => saveGraphJsonl,
   saveIdCounter: () => saveIdCounter,
   saveObservationsJson: () => saveObservationsJson,
@@ -121,18 +121,13 @@ __export(persistence_exports, {
 import { promises as fs2 } from "fs";
 import path3 from "path";
 import os from "os";
-function sanitizeProjectId(projectId) {
-  return projectId.replace(/\//g, "--").replace(/[<>:"|?*\\]/g, "_");
-}
-async function getProjectDataDir(projectId, baseDir) {
-  if (projectId === "__invalid__") {
+async function getProjectDataDir(_projectId, baseDir) {
+  if (_projectId === "__invalid__") {
     throw new Error("Cannot create data directory for invalid project");
   }
   const base = baseDir ?? DEFAULT_DATA_DIR;
-  const dirName = sanitizeProjectId(projectId);
-  const dataDir = path3.join(base, dirName);
-  await fs2.mkdir(dataDir, { recursive: true });
-  return dataDir;
+  await fs2.mkdir(base, { recursive: true });
+  return base;
 }
 function getBaseDataDir(baseDir) {
   return baseDir ?? DEFAULT_DATA_DIR;
@@ -146,78 +141,141 @@ async function listProjectDirs(baseDir) {
     return [];
   }
 }
-async function migrateGlobalData(projectId, baseDir) {
+async function migrateSubdirsToFlat(baseDir) {
   const base = baseDir ?? DEFAULT_DATA_DIR;
-  const globalObsPath = path3.join(base, "observations.json");
-  const migratedObsPath = path3.join(base, "observations.json.migrated");
-  let sourceObsPath = null;
+  await fs2.mkdir(base, { recursive: true });
+  let entries;
   try {
-    await fs2.access(globalObsPath);
-    sourceObsPath = globalObsPath;
+    entries = await fs2.readdir(base, { withFileTypes: true });
   } catch {
+    return false;
+  }
+  const dataDirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => path3.join(base, e.name));
+  if (dataDirs.length === 0) return false;
+  const subdirData = [];
+  for (const dir of dataDirs) {
+    const obsPath = path3.join(dir, "observations.json");
     try {
-      await fs2.access(migratedObsPath);
-      sourceObsPath = migratedObsPath;
+      const data = await fs2.readFile(obsPath, "utf-8");
+      const obs = JSON.parse(data);
+      if (Array.isArray(obs) && obs.length > 0) {
+        let graph = { entities: [], relations: [] };
+        try {
+          const graphData = await fs2.readFile(path3.join(dir, "graph.jsonl"), "utf-8");
+          const lines = graphData.split("\n").filter((l) => l.trim());
+          for (const line of lines) {
+            const item = JSON.parse(line);
+            if (item.type === "entity") graph.entities.push(item);
+            if (item.type === "relation") graph.relations.push(item);
+          }
+        } catch {
+        }
+        subdirData.push({ dir, obs, graph });
+      }
     } catch {
-      return false;
     }
   }
-  let globalObs = [];
+  if (subdirData.length === 0) return false;
+  let baseObs = [];
   try {
-    const data = await fs2.readFile(sourceObsPath, "utf-8");
-    globalObs = JSON.parse(data);
-    if (!Array.isArray(globalObs) || globalObs.length === 0) return false;
+    const data = await fs2.readFile(path3.join(base, "observations.json"), "utf-8");
+    baseObs = JSON.parse(data);
+    if (!Array.isArray(baseObs)) baseObs = [];
   } catch {
-    return false;
   }
-  const projectDir2 = await getProjectDataDir(projectId, baseDir);
-  const projectObsPath = path3.join(projectDir2, "observations.json");
-  let projectObs = [];
+  let baseGraph = { entities: [], relations: [] };
   try {
-    const data = await fs2.readFile(projectObsPath, "utf-8");
-    projectObs = JSON.parse(data);
-    if (!Array.isArray(projectObs)) projectObs = [];
+    const graphData = await fs2.readFile(path3.join(base, "graph.jsonl"), "utf-8");
+    const lines = graphData.split("\n").filter((l) => l.trim());
+    for (const line of lines) {
+      const item = JSON.parse(line);
+      if (item.type === "entity") baseGraph.entities.push(item);
+      if (item.type === "relation") baseGraph.relations.push(item);
+    }
   } catch {
   }
-  if (projectObs.length >= globalObs.length) {
-    return false;
-  }
-  const existingIds = new Set(projectObs.map((o) => o.id));
-  const merged = [...projectObs];
-  for (const obs of globalObs) {
-    if (!existingIds.has(obs.id)) {
-      merged.push(obs);
+  const allObs = [...baseObs];
+  for (const { obs } of subdirData) {
+    for (const o of obs) {
+      const isDuplicate = allObs.some(
+        (existing) => existing.title === o.title && existing.createdAt === o.createdAt
+      );
+      if (!isDuplicate) {
+        allObs.push(o);
+      }
     }
   }
-  merged.sort((a, b) => (a.id ?? 0) - (b.id ?? 0));
-  for (const obs of merged) {
-    obs.projectId = projectId;
+  allObs.sort((a, b) => (a.createdAt || "").localeCompare(b.createdAt || ""));
+  for (let i = 0; i < allObs.length; i++) {
+    allObs[i].id = i + 1;
   }
-  await fs2.writeFile(projectObsPath, JSON.stringify(merged, null, 2), "utf-8");
-  for (const file of ["graph.jsonl", "counter.json"]) {
-    const src = path3.join(base, file);
-    const srcMigrated = path3.join(base, file + ".migrated");
-    const dst = path3.join(projectDir2, file);
-    for (const source of [src, srcMigrated]) {
-      try {
-        await fs2.access(source);
-        await fs2.copyFile(source, dst);
-        break;
-      } catch {
+  const entityMap = /* @__PURE__ */ new Map();
+  for (const e of baseGraph.entities) entityMap.set(e.name, e);
+  for (const { graph } of subdirData) {
+    for (const e of graph.entities) {
+      if (!entityMap.has(e.name)) {
+        entityMap.set(e.name, e);
+      } else {
+        const existing = entityMap.get(e.name);
+        const obsSet = /* @__PURE__ */ new Set([...existing.observations || [], ...e.observations || []]);
+        existing.observations = [...obsSet];
       }
     }
   }
-  const maxId = merged.reduce((max, o) => Math.max(max, o.id ?? 0), 0);
+  const relationSet = /* @__PURE__ */ new Set();
+  const mergedRelations = [];
+  for (const rel of [...baseGraph.relations, ...subdirData.flatMap((d) => d.graph.relations)]) {
+    const key = `${rel.from}|${rel.to}|${rel.relationType}`;
+    if (!relationSet.has(key)) {
+      relationSet.add(key);
+      mergedRelations.push(rel);
+    }
+  }
+  await fs2.writeFile(path3.join(base, "observations.json"), JSON.stringify(allObs, null, 2), "utf-8");
   await fs2.writeFile(
-    path3.join(projectDir2, "counter.json"),
-    JSON.stringify({ nextId: maxId + 1 }),
+    path3.join(base, "counter.json"),
+    JSON.stringify({ nextId: allObs.length + 1 }),
     "utf-8"
   );
-  for (const file of ["observations.json", "graph.jsonl", "counter.json"]) {
-    const src = path3.join(base, file);
+  const graphLines = [
+    ...[...entityMap.values()].map((e) => JSON.stringify({ type: "entity", name: e.name, entityType: e.entityType, observations: e.observations })),
+    ...mergedRelations.map((r) => JSON.stringify({ type: "relation", from: r.from, to: r.to, relationType: r.relationType }))
+  ];
+  if (graphLines.length > 0) {
+    await fs2.writeFile(path3.join(base, "graph.jsonl"), graphLines.join("\n"), "utf-8");
+  }
+  let allSessions = [];
+  try {
+    const data = await fs2.readFile(path3.join(base, "sessions.json"), "utf-8");
+    allSessions = JSON.parse(data);
+    if (!Array.isArray(allSessions)) allSessions = [];
+  } catch {
+  }
+  for (const { dir } of subdirData) {
     try {
-      await fs2.access(src);
-      await fs2.rename(src, src + ".migrated");
+      const data = await fs2.readFile(path3.join(dir, "sessions.json"), "utf-8");
+      const sessions = JSON.parse(data);
+      if (Array.isArray(sessions)) allSessions.push(...sessions);
+    } catch {
+    }
+  }
+  if (allSessions.length > 0) {
+    await fs2.writeFile(path3.join(base, "sessions.json"), JSON.stringify(allSessions, null, 2), "utf-8");
+  }
+  const backupDir = path3.join(base, ".migrated-subdirs");
+  await fs2.mkdir(backupDir, { recursive: true });
+  for (const { dir } of subdirData) {
+    const dirName = path3.basename(dir);
+    try {
+      await fs2.rename(dir, path3.join(backupDir, dirName));
+    } catch {
+    }
+  }
+  for (const dir of dataDirs) {
+    const dirName = path3.basename(dir);
+    try {
+      await fs2.access(dir);
+      await fs2.rename(dir, path3.join(backupDir, dirName));
     } catch {
     }
   }
@@ -3700,23 +3758,18 @@ function resolveHookCommand() {
 }
 function generateClaudeConfig() {
   const cmd = `${resolveHookCommand()} hook`;
-  const hookGroup = {
-    matcher: {},
-    hooks: [
-      {
-        type: "command",
-        command: cmd,
-        timeout: 10
-      }
-    ]
+  const hookEntry = {
+    type: "command",
+    command: cmd,
+    timeout: 10
   };
   return {
     hooks: {
-      SessionStart: [hookGroup],
-      PostToolUse: [hookGroup],
-      UserPromptSubmit: [hookGroup],
-      PreCompact: [hookGroup],
-      Stop: [hookGroup]
+      SessionStart: [{ hooks: [hookEntry] }],
+      PostToolUse: [{ hooks: [hookEntry] }],
+      UserPromptSubmit: [{ hooks: [hookEntry] }],
+      PreCompact: [{ hooks: [hookEntry] }],
+      Stop: [{ hooks: [hookEntry] }]
     }
   };
 }
@@ -5389,10 +5442,10 @@ async function createMemorixServer(cwd, existingServer) {
     );
   }
   try {
-    const { migrateGlobalData: migrateGlobalData2 } = await Promise.resolve().then(() => (init_persistence(), persistence_exports));
-    const migrated = await migrateGlobalData2(project.id);
+    const { migrateSubdirsToFlat: migrateSubdirsToFlat2 } = await Promise.resolve().then(() => (init_persistence(), persistence_exports));
+    const migrated = await migrateSubdirsToFlat2();
     if (migrated) {
-      console.error(`[memorix] Migrated legacy data to project directory: ${project.id}`);
+      console.error(`[memorix] Migrated per-project subdirectories into flat storage`);
     }
   } catch {
   }
@@ -5615,10 +5668,10 @@ Use this as the \`topicKey\` parameter in \`memorix_store\` to enable upsert beh
         maxTokens: safeMaxTokens,
         since,
         until,
-        // Data isolation is handled at the directory level (each project has its own data dir).
-        // No projectId filter needed — avoids cross-IDE search failures when different IDEs
-        // resolve different projectIds for the same directory.
-        projectId: void 0
+        // All data is in a single flat directory. projectId is metadata only.
+        // scope: 'project' → filter by current projectId in Orama
+        // scope: 'global' or omitted → search all observations (default)
+        projectId: scope === "project" ? project.id : void 0
       });
       let text = result.formatted;
       if (!syncAdvisoryShown && syncAdvisory) {