open-memex 0.3.0 → 0.4.0-alpha.1

package/src/mcp.ts

@@ -30,11 +30,23 @@ import {
   listMemories,
   supersedeMemory,
   forgetMemory,
+  statusMemories,
+  submitMemoriesOp,
+  proposeMemoriesOp,
+  promoteMemoryOp,
+  resolveMemoryOp,
+  prStatusOp,
   memoryAddArgs,
   memorySearchArgs,
   memoryListArgs,
   memorySupersedeArgs,
   memoryForgetArgs,
+  memoryStatusArgs,
+  memorySubmitArgs,
+  memoryProposeArgs,
+  memoryPromoteArgs,
+  memoryResolveArgs,
+  memoryPrStatusArgs,
   TOOL_DESCRIPTIONS,
   type ToolResult,
 } from "./tools/ops.ts";
@@ -64,10 +76,21 @@ export async function runMcpServer() {
 
   // Init DB and one-shot sync of markdown -> index, mirroring the plugin.
   db();
-  syncScope(scope.key);
-  syncScope(PERSONAL_SCOPE.key);
+  syncScope(scope.key, "session");
+  syncScope(PERSONAL_SCOPE.key, "session");
   console.error(`[open-memex] MCP server up. scope=${scope.key}`);
 
+  // D26: re-sync on every request, not just at startup. The in-repo dir
+  // follows the current git branch, so a branch switch mid-session would
+  // otherwise leave the index pointing at files that no longer exist.
+  const withSync = <A extends object, R>(fn: (args: A) => R) => {
+    return (args: A): R => {
+      syncScope(scope.key, "request");
+      syncScope(PERSONAL_SCOPE.key, "request");
+      return fn(args);
+    };
+  };
+
   const server = new McpServer({ name: "open-memex", version: SERVER_VERSION });
 
   server.registerTool(
@@ -76,7 +99,7 @@ export async function runMcpServer() {
       description: TOOL_DESCRIPTIONS.memory_add,
       inputSchema: z.object(memoryAddArgs),
     },
-    (args) => toMcp(addMemory(getScope, cfg, args)),
+    withSync((args) => toMcp(addMemory(getScope, cfg, args))),
   );
 
   server.registerTool(
@@ -86,7 +109,7 @@ export async function runMcpServer() {
       inputSchema: z.object(memorySearchArgs),
       annotations: { readOnlyHint: true },
     },
-    (args) => toMcp(searchMemories(getScope, args)),
+    withSync((args) => toMcp(searchMemories(getScope, args))),
   );
 
   server.registerTool(
@@ -96,7 +119,7 @@ export async function runMcpServer() {
       inputSchema: z.object(memoryListArgs),
       annotations: { readOnlyHint: true },
     },
-    (args) => toMcp(listMemories(getScope, args)),
+    withSync((args) => toMcp(listMemories(getScope, args))),
   );
 
   server.registerTool(
@@ -105,7 +128,7 @@ export async function runMcpServer() {
       description: TOOL_DESCRIPTIONS.memory_supersede,
       inputSchema: z.object(memorySupersedeArgs),
     },
-    (args) => toMcp(supersedeMemory(cfg, args)),
+    withSync((args) => toMcp(supersedeMemory(cfg, args))),
   );
 
   server.registerTool(
@@ -115,7 +138,63 @@ export async function runMcpServer() {
       inputSchema: z.object(memoryForgetArgs),
       annotations: { destructiveHint: true },
     },
-    (args) => toMcp(forgetMemory(args)),
+    withSync((args) => toMcp(forgetMemory(args))),
+  );
+
+  server.registerTool(
+    "memory_status",
+    {
+      description: TOOL_DESCRIPTIONS.memory_status,
+      inputSchema: z.object(memoryStatusArgs),
+      annotations: { readOnlyHint: true },
+    },
+    withSync((_args) => toMcp(statusMemories())),
+  );
+
+  server.registerTool(
+    "memory_submit",
+    {
+      description: TOOL_DESCRIPTIONS.memory_submit,
+      inputSchema: z.object(memorySubmitArgs),
+    },
+    withSync((args) => toMcp(submitMemoriesOp(args))),
+  );
+
+  server.registerTool(
+    "memory_propose",
+    {
+      description: TOOL_DESCRIPTIONS.memory_propose,
+      inputSchema: z.object(memoryProposeArgs),
+    },
+    withSync((args) => toMcp(proposeMemoriesOp(args))),
+  );
+
+  server.registerTool(
+    "memory_promote",
+    {
+      description: TOOL_DESCRIPTIONS.memory_promote,
+      inputSchema: z.object(memoryPromoteArgs),
+    },
+    withSync((args) => toMcp(promoteMemoryOp(args))),
+  );
+
+  server.registerTool(
+    "memory_resolve",
+    {
+      description: TOOL_DESCRIPTIONS.memory_resolve,
+      inputSchema: z.object(memoryResolveArgs),
+    },
+    withSync((args) => toMcp(resolveMemoryOp(args))),
+  );
+
+  server.registerTool(
+    "memory_pr_status",
+    {
+      description: TOOL_DESCRIPTIONS.memory_pr_status,
+      inputSchema: z.object(memoryPrStatusArgs),
+      annotations: { readOnlyHint: true },
+    },
+    withSync((args) => toMcp(prStatusOp(args))),
   );
 
   const transport = new StdioServerTransport();

package/src/paths.ts

@@ -1,6 +1,7 @@
 import path from "node:path";
 import fs from "node:fs";
 import os from "node:os";
+import { execFileSync } from "node:child_process";
 
 function dataRoot(): string {
   if (process.env.MY_O_MEMORY_HOME) return path.resolve(process.env.MY_O_MEMORY_HOME);
@@ -43,3 +44,34 @@ export function memoriesDirPath(scopeKey: string): string {
   const { memories } = paths();
   return path.join(memories, scopeKey);
 }
+
+/** Project root: git top-level, falling back to cwd (2B: in-repo memory dir anchor). */
+export function projectRoot(cwd: string = process.cwd()): string {
+  try {
+    const top = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    if (top) return top;
+  } catch {
+    /* not a git repo — use cwd */
+  }
+  return path.resolve(cwd);
+}
+
+/**
+ * In-repo memory directory for a project scope (2B/D23): `<root>/<memoryDir>/`,
+ * default `<root>/.ai/open-memex/`. Created on demand. `memoryDir` must be a
+ * relative path without `..` segments (validated by `config set`).
+ */
+export function inRepoMemoriesDir(root: string, memoryDir: string): string {
+  const dir = path.join(root, memoryDir);
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+/** Same as `inRepoMemoriesDir` but never creates the directory. */
+export function inRepoMemoriesDirPath(root: string, memoryDir: string): string {
+  return path.join(root, memoryDir);
+}

package/src/retrieve/inject.ts

@@ -1,4 +1,4 @@
-import { list } from "./search.ts";
+import { list, hitStateLabel } from "./search.ts";
 import type { Scope } from "../scope.ts";
 import { PERSONAL_SCOPE } from "../scope.ts";
 import type { MyOMemoryConfig } from "../config.ts";
@@ -23,7 +23,7 @@ export function buildContextBlock(scope: Scope, cfg: MyOMemoryConfig): string |
 
   if (project.length > 0) {
     lines.push("", `Project knowledge (${scope.projectName}):`);
-    for (const m of project) lines.push(`- [${m.type}] ${oneLine(m.snippet)}`);
+    for (const m of project) lines.push(`- [${m.type}]${hitStateLabel(m)} ${oneLine(m.snippet)}`);
   }
 
   lines.push(

package/src/retrieve/search.ts

@@ -11,6 +11,7 @@ export interface SearchHit {
   score: number;
   updated_at: number;
   status: string;
+  review_state: string;
 }
 
 interface RawRow {
@@ -24,6 +25,7 @@ interface RawRow {
   score: number;
   status: string;
   superseded_by: string | null;
+  review_state: string;
 }
 
 function toHit(r: RawRow): SearchHit {
@@ -37,13 +39,36 @@ function toHit(r: RawRow): SearchHit {
     score: r.score,
     updated_at: r.updated_at,
     status: r.status,
+    review_state: r.review_state ?? "draft",
   };
 }
 
+/**
+ * D30: review-state ranking tiers for shared (project) memories.
+ * Reviewed knowledge (approved/published) outranks unreviewed outbox drafts;
+ * personal memories are always `draft` by design and are NOT demoted.
+ * Stable: order within a tier keeps the incoming score/recency order.
+ */
+function reviewTier(r: RawRow): number {
+  if (r.scope_key === "personal") return 1;
+  if (r.review_state === "approved" || r.review_state === "published") return 0;
+  if (r.review_state === "draft" || r.review_state === "rejected") return 2;
+  return 1; // proposed and anything unexpected
+}
+
+/** D30: `[draft]` / `[proposed]` / … marker for project memories.
+ *  Personal memories stay unmarked (always draft — the marker would be noise). */
+export function hitStateLabel(h: Pick<SearchHit, "scope_key" | "review_state">): string {
+  if (h.scope_key === "personal") return "";
+  return ` [${h.review_state || "draft"}]`;
+}
+
 /**
  * Lifecycle-aware post-processing (§3.3):
  * - retracted / archived are excluded from retrieval (kept for audit);
  * - a superseded memory resolves to the newest of its chain (cycle-safe);
+ * - D30: approved/published project memories rank first, project
+ *   drafts/rejected rank after unreviewed content;
  * - deprecated stays visible as a warning but ranks after active.
  */
 function resolveVisible(rows: RawRow[], limit: number): SearchHit[] {
@@ -54,7 +79,7 @@ function resolveVisible(rows: RawRow[], limit: number): SearchHit[] {
     const r = db()
       .prepare(
         `SELECT id, scope_key, project_name, type, tags, updated_at, status,
-                superseded_by, substr(content, 1, 240) AS snippet
+                superseded_by, review_state, substr(content, 1, 240) AS snippet
          FROM memories WHERE id = ?`,
       )
       .get(id) as
@@ -67,7 +92,7 @@ function resolveVisible(rows: RawRow[], limit: number): SearchHit[] {
   };
 
   const seen = new Set<string>();
-  const active: SearchHit[] = [];
+  const tiers: SearchHit[][] = [[], [], [], []];
   const deprecated: SearchHit[] = [];
 
   for (const r of rows) {
@@ -90,9 +115,9 @@ function resolveVisible(rows: RawRow[], limit: number): SearchHit[] {
     seen.add(target.id);
     const hit = toHit(target);
     if (target.status === "deprecated") deprecated.push(hit);
-    else active.push(hit);
+    else tiers[reviewTier(target)].push(hit);
   }
-  return [...active, ...deprecated].slice(0, limit);
+  return [...tiers[0], ...tiers[1], ...tiers[2], ...deprecated].slice(0, limit);
 }
 
 /**
@@ -130,7 +155,7 @@ export function search(
 
   const sql = `
     SELECT m.id, m.scope_key, m.project_name, m.type, m.tags, m.updated_at,
-           m.status, m.superseded_by,
+           m.status, m.superseded_by, m.review_state,
            snippet(memories_fts, 0, '[', ']', ' ... ', 12) AS snippet,
            bm25(memories_fts) AS score
     FROM memories_fts
@@ -155,6 +180,7 @@ export function search(
     updated_at: number;
     status: string;
     superseded_by: string | null;
+    review_state: string;
     snippet: string;
     score: number;
   }>;
@@ -173,7 +199,7 @@ export function list(
   const typeFilter = opts.type ? ` AND type = ?` : "";
   const sql = `
     SELECT id, scope_key, project_name, type, tags, updated_at, status,
-           superseded_by, substr(content, 1, 240) AS snippet
+           superseded_by, review_state, substr(content, 1, 240) AS snippet
     FROM memories
     WHERE scope_key = ?${typeFilter}
     ORDER BY updated_at DESC
@@ -194,6 +220,7 @@ export function list(
     updated_at: number;
     status: string;
     superseded_by: string | null;
+    review_state: string;
     snippet: string;
   }>;