memorix 0.5.2 → 0.6.0

package/dist/dashboard/static/app.js

@@ -241,9 +241,15 @@ document.querySelectorAll('.nav-btn').forEach(btn => {
 // API Client
 // ============================================================
 
+let selectedProject = ''; // empty = current project (default)
+
 async function api(endpoint) {
   try {
-    const res = await fetch(`/api/${endpoint}`);
+    const sep = endpoint.includes('?') ? '&' : '?';
+    const url = selectedProject
+      ? `/api/${endpoint}${sep}project=${encodeURIComponent(selectedProject)}`
+      : `/api/${endpoint}`;
+    const res = await fetch(url);
     if (!res.ok) throw new Error(`HTTP ${res.status}`);
     return await res.json();
   } catch (err) {
@@ -252,6 +258,49 @@ async function api(endpoint) {
   }
 }
 
+// ============================================================
+// Project Switcher
+// ============================================================
+
+async function initProjectSwitcher() {
+  const select = document.getElementById('project-select');
+  if (!select) return;
+
+  // Fetch project list
+  try {
+    const res = await fetch('/api/projects');
+    const projects = await res.json();
+    if (!Array.isArray(projects) || projects.length === 0) {
+      select.innerHTML = '<option value="">No projects</option>';
+      return;
+    }
+
+    select.innerHTML = '';
+    for (const p of projects) {
+      const opt = document.createElement('option');
+      opt.value = p.isCurrent ? '' : p.id;
+      opt.textContent = p.name + (p.isCurrent ? ' ●' : '');
+      opt.title = p.id;
+      if (p.isCurrent) opt.selected = true;
+      select.appendChild(opt);
+    }
+  } catch {
+    select.innerHTML = '<option value="">Error</option>';
+  }
+
+  // Switch handler
+  select.addEventListener('change', () => {
+    selectedProject = select.value;
+    // Clear all cached pages and reload current
+    Object.keys(loaded).forEach(k => delete loaded[k]);
+    loadPage(currentPage);
+  });
+}
+
+document.addEventListener('DOMContentLoaded', () => {
+  initProjectSwitcher();
+});
+
 // ============================================================
 // Page Loaders
 // ============================================================

package/dist/dashboard/static/index.html

@@ -18,6 +18,11 @@
     <div class="sidebar-brand">
       <img src="/logo.png" alt="Memorix" class="brand-logo" />
     </div>
+    <div class="project-switcher">
+      <select id="project-select" title="Switch project / 切换项目">
+        <option value="">Loading...</option>
+      </select>
+    </div>
     <div class="sidebar-nav">
       <button class="nav-btn active" data-page="dashboard" title="Dashboard">
         <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">

package/dist/dashboard/static/style.css

@@ -1045,4 +1045,51 @@ body {
   .page {
     padding: 16px;
   }
+}
+
+/* ============================================================
+ * Project Switcher
+ * ============================================================ */
+
+.project-switcher {
+  padding: 4px 8px 8px;
+  display: flex;
+  justify-content: center;
+}
+
+.project-switcher select {
+  width: 44px;
+  height: 28px;
+  background: var(--bg-card);
+  color: var(--text-primary);
+  border: 1px solid var(--border-subtle);
+  border-radius: 6px;
+  font-size: 10px;
+  font-family: var(--font-mono);
+  cursor: pointer;
+  padding: 0 2px;
+  text-align: center;
+  -webkit-appearance: none;
+  -moz-appearance: none;
+  appearance: none;
+  transition: var(--transition-fast);
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.project-switcher select:hover {
+  border-color: var(--accent-cyan);
+  box-shadow: var(--glow-cyan);
+}
+
+.project-switcher select:focus {
+  outline: none;
+  border-color: var(--accent-cyan);
+}
+
+.project-switcher select option {
+  background: var(--bg-surface);
+  color: var(--text-primary);
+  font-size: 12px;
+  padding: 4px 8px;
 }

package/dist/index.js

@@ -29,17 +29,138 @@ var init_esm_shims = __esm({
 });
 
 // src/store/persistence.ts
+var persistence_exports = {};
+__export(persistence_exports, {
+  getBaseDataDir: () => getBaseDataDir,
+  getDbFilePath: () => getDbFilePath,
+  getGraphFilePath: () => getGraphFilePath,
+  getProjectDataDir: () => getProjectDataDir,
+  hasExistingData: () => hasExistingData,
+  listProjectDirs: () => listProjectDirs,
+  loadGraphJsonl: () => loadGraphJsonl,
+  loadIdCounter: () => loadIdCounter,
+  loadObservationsJson: () => loadObservationsJson,
+  migrateGlobalData: () => migrateGlobalData,
+  saveGraphJsonl: () => saveGraphJsonl,
+  saveIdCounter: () => saveIdCounter,
+  saveObservationsJson: () => saveObservationsJson
+});
 import { promises as fs } from "fs";
 import path2 from "path";
 import os from "os";
+function sanitizeProjectId(projectId) {
+  return projectId.replace(/\//g, "--").replace(/[<>:"|?*\\]/g, "_");
+}
 async function getProjectDataDir(projectId, baseDir) {
-  const dataDir = baseDir ?? DEFAULT_DATA_DIR;
+  const base = baseDir ?? DEFAULT_DATA_DIR;
+  const dirName = sanitizeProjectId(projectId);
+  const dataDir = path2.join(base, dirName);
   await fs.mkdir(dataDir, { recursive: true });
   return dataDir;
 }
+function getBaseDataDir(baseDir) {
+  return baseDir ?? DEFAULT_DATA_DIR;
+}
+async function listProjectDirs(baseDir) {
+  const base = baseDir ?? DEFAULT_DATA_DIR;
+  try {
+    const entries = await fs.readdir(base, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => path2.join(base, e.name));
+  } catch {
+    return [];
+  }
+}
+async function migrateGlobalData(projectId, baseDir) {
+  const base = baseDir ?? DEFAULT_DATA_DIR;
+  const globalObsPath = path2.join(base, "observations.json");
+  const migratedObsPath = path2.join(base, "observations.json.migrated");
+  let sourceObsPath = null;
+  try {
+    await fs.access(globalObsPath);
+    sourceObsPath = globalObsPath;
+  } catch {
+    try {
+      await fs.access(migratedObsPath);
+      sourceObsPath = migratedObsPath;
+    } catch {
+      return false;
+    }
+  }
+  let globalObs = [];
+  try {
+    const data = await fs.readFile(sourceObsPath, "utf-8");
+    globalObs = JSON.parse(data);
+    if (!Array.isArray(globalObs) || globalObs.length === 0) return false;
+  } catch {
+    return false;
+  }
+  const projectDir2 = await getProjectDataDir(projectId, baseDir);
+  const projectObsPath = path2.join(projectDir2, "observations.json");
+  let projectObs = [];
+  try {
+    const data = await fs.readFile(projectObsPath, "utf-8");
+    projectObs = JSON.parse(data);
+    if (!Array.isArray(projectObs)) projectObs = [];
+  } 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);
+    }
+  }
+  merged.sort((a, b) => (a.id ?? 0) - (b.id ?? 0));
+  for (const obs of merged) {
+    obs.projectId = projectId;
+  }
+  await fs.writeFile(projectObsPath, JSON.stringify(merged, null, 2), "utf-8");
+  for (const file of ["graph.jsonl", "counter.json"]) {
+    const src = path2.join(base, file);
+    const srcMigrated = path2.join(base, file + ".migrated");
+    const dst = path2.join(projectDir2, file);
+    for (const source of [src, srcMigrated]) {
+      try {
+        await fs.access(source);
+        await fs.copyFile(source, dst);
+        break;
+      } catch {
+      }
+    }
+  }
+  const maxId = merged.reduce((max, o) => Math.max(max, o.id ?? 0), 0);
+  await fs.writeFile(
+    path2.join(projectDir2, "counter.json"),
+    JSON.stringify({ nextId: maxId + 1 }),
+    "utf-8"
+  );
+  for (const file of ["observations.json", "graph.jsonl", "counter.json"]) {
+    const src = path2.join(base, file);
+    try {
+      await fs.access(src);
+      await fs.rename(src, src + ".migrated");
+    } catch {
+    }
+  }
+  return true;
+}
+function getDbFilePath(projectDir2) {
+  return path2.join(projectDir2, "memorix.msp");
+}
 function getGraphFilePath(projectDir2) {
   return path2.join(projectDir2, "graph.jsonl");
 }
+async function hasExistingData(projectDir2) {
+  try {
+    await fs.access(getDbFilePath(projectDir2));
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function saveGraphJsonl(projectDir2, entities, relations) {
   const lines = [
     ...entities.map(
@@ -645,6 +766,18 @@ async function detectInstalledAgents() {
     agents.push("kiro");
   } catch {
   }
+  const codexDir = path5.join(home, ".codex");
+  try {
+    await fs3.access(codexDir);
+    agents.push("codex");
+  } catch {
+  }
+  const antigravityDir = path5.join(home, ".gemini", "antigravity");
+  try {
+    await fs3.access(antigravityDir);
+    agents.push("antigravity");
+  } catch {
+  }
   return agents;
 }
 async function installHooks(agent, projectRoot, global = false) {
@@ -721,15 +854,34 @@ async function installAgentRules(agent, projectRoot) {
     case "copilot":
       rulesPath = path5.join(projectRoot, ".github", "copilot-instructions.md");
       break;
+    case "codex":
+      rulesPath = path5.join(projectRoot, "AGENTS.md");
+      break;
+    case "kiro":
+      rulesPath = path5.join(projectRoot, ".kiro", "rules", "memorix.md");
+      break;
     default:
-      return;
+      rulesPath = path5.join(projectRoot, ".agent", "rules", "memorix.md");
+      break;
   }
   try {
     await fs3.mkdir(path5.dirname(rulesPath), { recursive: true });
-    try {
-      await fs3.access(rulesPath);
-    } catch {
-      await fs3.writeFile(rulesPath, rulesContent, "utf-8");
+    if (agent === "codex") {
+      try {
+        const existing = await fs3.readFile(rulesPath, "utf-8");
+        if (existing.includes("Memorix")) {
+          return;
+        }
+        await fs3.writeFile(rulesPath, existing + "\n\n" + rulesContent, "utf-8");
+      } catch {
+        await fs3.writeFile(rulesPath, rulesContent, "utf-8");
+      }
+    } else {
+      try {
+        await fs3.access(rulesPath);
+      } catch {
+        await fs3.writeFile(rulesPath, rulesContent, "utf-8");
+      }
     }
   } catch {
   }
@@ -743,22 +895,50 @@ You have access to Memorix memory tools. Follow these rules to maintain persiste
 
 At the **beginning of every conversation**, before responding to the user:
 
-1. Call \`memorix_search\` with query related to the user's first message or the current project
-2. If results are found, use them to understand the current project state, recent decisions, and pending tasks
-3. Reference relevant memories naturally in your response
+1. Call \`memorix_search\` with a query related to the user's first message or the current project
+2. If results are found, use \`memorix_detail\` to fetch the most relevant ones
+3. Reference relevant memories naturally in your response \u2014 the user should feel you "remember" them
 
 This ensures you already know the project context without the user re-explaining.
 
 ## During Session \u2014 Capture Important Context
 
-Proactively call \`memorix_store\` when any of the following happen:
+**Proactively** call \`memorix_store\` whenever any of the following happen:
+
+### Architecture & Decisions
+- Technology choice, framework selection, or design pattern adopted
+- Trade-off discussion with a clear conclusion
+- API design, database schema, or project structure decisions
+
+### Bug Fixes & Problem Solving
+- A bug is identified and resolved \u2014 store root cause + fix
+- Workaround applied for a known issue
+- Performance issue diagnosed and optimized
 
-- **Architecture decision**: You or the user decide on a technology, pattern, or approach
-- **Bug fix**: A bug is identified and resolved \u2014 store the root cause and fix
-- **Gotcha/pitfall**: Something unexpected or tricky is discovered
-- **Configuration change**: Environment, port, path, or tooling changes
+### Gotchas & Pitfalls
+- Something unexpected or tricky is discovered
+- A common mistake is identified and corrected
+- Platform-specific behavior that caused issues
 
-Use appropriate types: \`decision\`, \`problem-solution\`, \`gotcha\`, \`what-changed\`, \`discovery\`.
+### Configuration & Environment
+- Environment variables, port numbers, paths changed
+- Docker, nginx, Caddy, or reverse proxy config modified
+- Package dependencies added, removed, or version-pinned
+
+### Deployment & Operations
+- Server deployment steps (Docker, VPS, cloud)
+- DNS, SSL/TLS certificate, domain configuration
+- CI/CD pipeline setup or changes
+- Database migration or data transfer procedures
+- Server topology (ports, services, reverse proxy chain)
+- SSH keys, access credentials setup (store pattern, NOT secrets)
+
+### Project Milestones
+- Feature completed or shipped
+- Version released or published to npm/PyPI/etc.
+- Repository made public, README updated, PR submitted
+
+Use appropriate types: \`decision\`, \`problem-solution\`, \`gotcha\`, \`what-changed\`, \`discovery\`, \`how-it-works\`.
 
 ## Session End \u2014 Store Summary
 
@@ -766,18 +946,21 @@ When the conversation is ending or the user says goodbye:
 
 1. Call \`memorix_store\` with type \`session-request\` to record:
    - What was accomplished in this session
-   - Current project state
+   - Current project state and any blockers
    - Pending tasks or next steps
-   - Any unresolved issues
+   - Key files modified
 
-This creates a "handoff note" for the next session.
+This creates a "handoff note" for the next session (or for another AI agent).
 
 ## Guidelines
 
-- **Don't store trivial information** (greetings, acknowledgments, simple file reads)
+- **Don't store trivial information** (greetings, acknowledgments, simple file reads, ls/dir output)
 - **Do store anything you'd want to know if you lost all context**
-- **Use concise titles** and structured facts
+- **Do store anything a different AI agent would need to continue this work**
+- **Use concise titles** (~5-10 words) and structured facts
 - **Include file paths** in filesModified when relevant
+- **Include related concepts** for better searchability
+- **Prefer storing too much over too little** \u2014 the retention system will auto-decay stale memories
 `;
 }
 async function uninstallHooks(agent, projectRoot, global = false) {
@@ -802,7 +985,7 @@ async function uninstallHooks(agent, projectRoot, global = false) {
 }
 async function getHookStatus(projectRoot) {
   const results = [];
-  const agents = ["claude", "copilot", "windsurf", "cursor", "kiro", "codex"];
+  const agents = ["claude", "copilot", "windsurf", "cursor", "kiro", "codex", "antigravity"];
   for (const agent of agents) {
     const projectPath = getProjectConfigPath(agent, projectRoot);
     const globalPath = getGlobalConfigPath(agent);
@@ -967,31 +1150,65 @@ function sendError(res, message, status = 500) {
 function filterByProject(items, projectId) {
   return items.filter((item) => item.projectId === projectId);
 }
-async function handleApi(req, res, dataDir, projectId, projectName) {
+async function handleApi(req, res, dataDir, projectId, projectName, baseDir) {
   const url = new URL(req.url || "/", `http://${req.headers.host}`);
   const apiPath = url.pathname.replace("/api", "");
+  const requestedProject = url.searchParams.get("project");
+  let effectiveDataDir = dataDir;
+  let effectiveProjectId = projectId;
+  let effectiveProjectName = projectName;
+  if (requestedProject && requestedProject !== projectId) {
+    const sanitized = requestedProject.replace(/\//g, "--").replace(/[<>:"|?*\\]/g, "_");
+    const candidateDir = path6.join(baseDir, sanitized);
+    try {
+      await fs4.access(candidateDir);
+      effectiveDataDir = candidateDir;
+      effectiveProjectId = requestedProject;
+      effectiveProjectName = requestedProject.split("/").pop() || requestedProject;
+    } catch {
+    }
+  }
   try {
     switch (apiPath) {
+      case "/projects": {
+        try {
+          const entries = await fs4.readdir(baseDir, { withFileTypes: true });
+          const projects = entries.filter((e) => e.isDirectory() && e.name.includes("--")).map((e) => {
+            const dirName = e.name;
+            const id = dirName.replace(/--/g, "/");
+            return {
+              id,
+              name: id.split("/").pop() || id,
+              dirName,
+              isCurrent: id === projectId
+            };
+          });
+          sendJson(res, projects);
+        } catch {
+          sendJson(res, []);
+        }
+        break;
+      }
       case "/project": {
-        sendJson(res, { id: projectId, name: projectName });
+        sendJson(res, { id: effectiveProjectId, name: effectiveProjectName });
         break;
       }
       case "/graph": {
-        const graph = await loadGraphJsonl(dataDir);
+        const graph = await loadGraphJsonl(effectiveDataDir);
         sendJson(res, graph);
         break;
       }
       case "/observations": {
-        const allObs = await loadObservationsJson(dataDir);
-        const observations2 = filterByProject(allObs, projectId);
+        const allObs = await loadObservationsJson(effectiveDataDir);
+        const observations2 = filterByProject(allObs, effectiveProjectId);
         sendJson(res, observations2);
         break;
       }
       case "/stats": {
-        const graph = await loadGraphJsonl(dataDir);
-        const allObs = await loadObservationsJson(dataDir);
-        const observations2 = filterByProject(allObs, projectId);
-        const nextId2 = await loadIdCounter(dataDir);
+        const graph = await loadGraphJsonl(effectiveDataDir);
+        const allObs = await loadObservationsJson(effectiveDataDir);
+        const observations2 = filterByProject(allObs, effectiveProjectId);
+        const nextId2 = await loadIdCounter(effectiveDataDir);
         const typeCounts = {};
         for (const obs of observations2) {
           const t = obs.type || "unknown";
@@ -1009,8 +1226,8 @@ async function handleApi(req, res, dataDir, projectId, projectName) {
         break;
       }
       case "/retention": {
-        const allObs = await loadObservationsJson(dataDir);
-        const observations2 = filterByProject(allObs, projectId);
+        const allObs = await loadObservationsJson(effectiveDataDir);
+        const observations2 = filterByProject(allObs, effectiveProjectId);
         const now = Date.now();
         const scored = observations2.map((obs) => {
           const age = now - new Date(obs.createdAt || now).getTime();
@@ -1087,10 +1304,11 @@ function openBrowser(url) {
 }
 async function startDashboard(dataDir, port, staticDir, projectId, projectName, autoOpen = true) {
   const resolvedStaticDir = staticDir;
+  const baseDir = getBaseDataDir();
   const server = createServer(async (req, res) => {
     const url = req.url || "/";
     if (url.startsWith("/api/")) {
-      await handleApi(req, res, dataDir, projectId, projectName);
+      await handleApi(req, res, dataDir, projectId, projectName, baseDir);
     } else {
       await serveStatic(req, res, resolvedStaticDir);
     }
@@ -1719,12 +1937,14 @@ function detectProject(cwd) {
   const rootPath = getGitRoot(basePath) ?? findPackageRoot(basePath) ?? basePath;
   const gitRemote = getGitRemote(rootPath);
   if (gitRemote) {
-    const id = normalizeGitRemote(gitRemote);
-    const name2 = id.split("/").pop() ?? path3.basename(rootPath);
-    return { id, name: name2, gitRemote, rootPath };
+    const id2 = normalizeGitRemote(gitRemote);
+    const name2 = id2.split("/").pop() ?? path3.basename(rootPath);
+    return { id: id2, name: name2, gitRemote, rootPath };
   }
   const name = path3.basename(rootPath);
-  return { id: name, name, rootPath };
+  const id = `local/${name}`;
+  console.error(`[memorix] Warning: no git remote found at ${rootPath}, using fallback projectId: ${id}`);
+  return { id, name, rootPath };
 }
 function findPackageRoot(cwd) {
   let dir = path3.resolve(cwd);
@@ -3384,6 +3604,14 @@ var OBSERVATION_TYPES = [
 ];
 async function createMemorixServer(cwd) {
   const project = detectProject(cwd);
+  try {
+    const { migrateGlobalData: migrateGlobalData2 } = await Promise.resolve().then(() => (init_persistence(), persistence_exports));
+    const migrated = await migrateGlobalData2(project.id);
+    if (migrated) {
+      console.error(`[memorix] Migrated legacy data to project directory: ${project.id}`);
+    }
+  } catch {
+  }
   const projectDir2 = await getProjectDataDir(project.id);
   const graphManager = new KnowledgeGraphManager(projectDir2);
   await graphManager.init();
@@ -3398,15 +3626,14 @@ async function createMemorixServer(cwd) {
     const { getHookStatus: getHookStatus2, installHooks: installHooks2, detectInstalledAgents: detectInstalledAgents2 } = await Promise.resolve().then(() => (init_installers(), installers_exports));
     const workDir = cwd ?? process.cwd();
     const statuses = await getHookStatus2(workDir);
-    const anyInstalled = statuses.some((s) => s.installed);
-    if (!anyInstalled) {
-      const agents = await detectInstalledAgents2();
-      for (const agent of agents) {
-        try {
-          const config = await installHooks2(agent, workDir);
-          console.error(`[memorix] Auto-installed hooks for ${agent} \u2192 ${config.configPath}`);
-        } catch {
-        }
+    const installedAgents = new Set(statuses.filter((s) => s.installed).map((s) => s.agent));
+    const detectedAgents = await detectInstalledAgents2();
+    for (const agent of detectedAgents) {
+      if (installedAgents.has(agent)) continue;
+      try {
+        const config = await installHooks2(agent, workDir);
+        console.error(`[memorix] Auto-installed hooks for ${agent} \u2192 ${config.configPath}`);
+      } catch {
       }
     }
   } catch {
@@ -3543,15 +3770,20 @@ Entity: ${entityName} | Type: ${type} | Project: ${project.id}${enrichment}`
         query: z.string().describe("Search query (natural language or keywords)"),
         limit: z.number().optional().describe("Max results (default: 20)"),
         type: z.enum(OBSERVATION_TYPES).optional().describe("Filter by observation type"),
-        maxTokens: z.number().optional().describe("Token budget \u2014 trim results to fit (0 = unlimited)")
+        maxTokens: z.number().optional().describe("Token budget \u2014 trim results to fit (0 = unlimited)"),
+        scope: z.enum(["project", "global"]).optional().describe(
+          'Search scope: "project" (default) only searches current project, "global" searches all projects'
+        )
       }
     },
-    async ({ query, limit, type, maxTokens }) => {
+    async ({ query, limit, type, maxTokens, scope }) => {
       const result = await compactSearch({
         query,
         limit,
         type,
-        maxTokens
+        maxTokens,
+        // Default to current project scope; 'global' removes the project filter
+        projectId: scope === "global" ? void 0 : project.id
       });
       let text = result.formatted;
       if (!syncAdvisoryShown && syncAdvisory) {