open-memex 0.3.0 → 0.4.0-alpha.4

package/src/store/lifecycle.ts

@@ -2,7 +2,12 @@ import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { db } from "./db.ts";
-import { paths, memoriesDirPath } from "../paths.ts";
+import {
+  paths,
+  projectRoot,
+  inRepoMemoriesDirPath,
+} from "../paths.ts";
+import { loadConfig } from "../config.ts";
 import { cjkIndexText } from "../retrieve/cjk.ts";
 import {
   parse,
@@ -97,25 +102,33 @@ export function findDuplicates(
   return { exact, near: near.slice(0, 3) };
 }
 
-/** Locate a memory file by id: index first, then a full dir scan fallback. */
+/** Locate a memory file by id: index file_path first, then dir-scan fallback. */
 export function findMemoryFile(id: string): MemoryFile | null {
   const { memories } = paths();
   let filePath: string | null = null;
   try {
     const row = db()
-      .prepare(`SELECT scope_key FROM memories WHERE id = ?`)
-      .get(id) as { scope_key: string } | undefined;
-    if (row) {
-      const p = path.join(memoriesDirPath(row.scope_key), `${id}.md`);
-      if (fs.existsSync(p)) filePath = p;
-    }
+      .prepare(`SELECT file_path FROM memories WHERE id = ?`)
+      .get(id) as { file_path: string } | undefined;
+    if (row && fs.existsSync(row.file_path)) filePath = row.file_path;
   } catch {
     // index unavailable — fall through to scan
   }
-  if (!filePath && fs.existsSync(memories)) {
-    for (const entry of fs.readdirSync(memories, { withFileTypes: true })) {
-      if (!entry.isDirectory()) continue;
-      const p = path.join(memories, entry.name, `${id}.md`);
+  if (!filePath) {
+    // Fallback scan: appdata scope dirs + the in-repo dir (2B/D24).
+    const dirs: string[] = [];
+    if (fs.existsSync(memories)) {
+      for (const entry of fs.readdirSync(memories, { withFileTypes: true })) {
+        if (entry.isDirectory()) dirs.push(path.join(memories, entry.name));
+      }
+    }
+    try {
+      dirs.push(inRepoMemoriesDirPath(projectRoot(), loadConfig().memoryDir));
+    } catch {
+      /* ignore */
+    }
+    for (const dir of dirs) {
+      const p = path.join(dir, `${id}.md`);
       if (fs.existsSync(p)) {
         filePath = p;
         break;
@@ -225,6 +238,11 @@ export function supersede(
     updated_at: now,
     supersedes: oldId,
     superseded_by: null,
+    review_state: "draft",
+    proposed_by: null,
+    approved_by: null,
+    derived_from: null,
+    review_note: null,
   };
   const dir = path.dirname(oldMf.filePath);
   const newPath = path.join(dir, `${newFm.id}.md`);

package/src/store/markdown.ts

@@ -2,7 +2,11 @@ import fs from "node:fs";
 import path from "node:path";
 import { randomBytes } from "node:crypto";
 import yaml from "js-yaml";
-import { memoriesDirFor, memoriesDirPath } from "../paths.ts";
+import {
+  memoriesDirFor,
+  memoriesDirPath,
+  inRepoMemoriesDirPath,
+} from "../paths.ts";
 
 /** v2 content-kind taxonomy (V2-DESIGN §3.1). `type` = what the memory IS. */
 export const MEMORY_TYPE_TAXONOMY = [
@@ -52,6 +56,62 @@ export interface Frontmatter {
   updated_at: string; // RFC 3339
   supersedes: string | null; // on the NEW memory → points BACK (§3.3)
   superseded_by: string | null; // on the OLD memory → points FORWARD
+  /** 2B/D25: where this memory sits in the propose → promote workflow. */
+  review_state: ReviewState;
+  /** Who proposed / approved it (git user.name, fallback OS user). */
+  proposed_by: string | null;
+  approved_by: string | null;
+  /** For propose-copies: the personal memory this was derived from. */
+  derived_from: string | null;
+  /** Curator note on the latest review transition (e.g. rejection reason). */
+  review_note: string | null;
+  /** 2B/D29: append-only audit trail of review transitions. Lives in the
+   *  file (source of truth), so it travels through branches and PRs. */
+  review_history: ReviewTransition[];
+}
+
+/** One step in a memory's review lifecycle — who moved it, when, why. */
+export interface ReviewTransition {
+  at: string; // RFC 3339
+  by: string; // author identity (git user.name, fallback OS user)
+  from: ReviewState;
+  to: ReviewState;
+  note: string | null;
+}
+
+/** Defensive parse: malformed entries are dropped, never fatal. */
+export function asReviewHistory(v: unknown): ReviewTransition[] {
+  if (!Array.isArray(v)) return [];
+  const out: ReviewTransition[] = [];
+  for (const e of v) {
+    if (!e || typeof e !== "object") continue;
+    const r = e as Record<string, unknown>;
+    const from = asReviewState(r.from);
+    const to = asReviewState(r.to);
+    const at = typeof r.at === "string" && r.at ? r.at : null;
+    const by = typeof r.by === "string" && r.by ? r.by : null;
+    if (!at || !by) continue;
+    out.push({
+      at,
+      by,
+      from,
+      to,
+      note: typeof r.note === "string" && r.note ? r.note : null,
+    });
+  }
+  return out;
+}
+
+/** Review lifecycle for shared memories (2B/D25): draft → proposed →
+ *  approved/rejected → published. Personal memories stay `draft`. */
+export type ReviewState = "draft" | "proposed" | "approved" | "rejected" | "published";
+
+const REVIEW_STATES: ReviewState[] = ["draft", "proposed", "approved", "rejected", "published"];
+
+export function asReviewState(v: unknown): ReviewState {
+  return typeof v === "string" && (REVIEW_STATES as string[]).includes(v)
+    ? (v as ReviewState)
+    : "draft";
 }
 
 export interface MemoryFile {
@@ -179,6 +239,16 @@ export function normalizeFrontmatter(
       typeof raw.superseded_by === "string" && raw.superseded_by
         ? raw.superseded_by
         : null,
+    review_state: asReviewState(raw.review_state),
+    proposed_by:
+      typeof raw.proposed_by === "string" && raw.proposed_by ? raw.proposed_by : null,
+    approved_by:
+      typeof raw.approved_by === "string" && raw.approved_by ? raw.approved_by : null,
+    derived_from:
+      typeof raw.derived_from === "string" && raw.derived_from ? raw.derived_from : null,
+    review_note:
+      typeof raw.review_note === "string" && raw.review_note ? raw.review_note : null,
+    review_history: asReviewHistory(raw.review_history),
   };
 }
 
@@ -217,6 +287,9 @@ export function writeMemoryFile(
   fm: Frontmatter,
   body: string,
 ): { filePath: string; mtimeMs: number } {
+  // 2B/D26: project drafts live in appdata (the outbox) — the in-repo dir
+  // only ever holds submitted memories (proposed/approved/published).
+  // Personal stays in appdata and never leaves the machine.
   const dir = memoriesDirFor(fm.scope_key);
   const filePath = path.join(dir, `${fm.id}.md`);
   fs.writeFileSync(filePath, serialize(fm, body), "utf8");
@@ -224,14 +297,16 @@ export function writeMemoryFile(
   return { filePath, mtimeMs: st.mtimeMs };
 }
 
-export function deleteMemoryFile(scopeKey: string, id: string): boolean {
-  const dir = memoriesDirPath(scopeKey);
-  const filePath = path.join(dir, `${id}.md`);
-  if (fs.existsSync(filePath)) {
-    fs.unlinkSync(filePath);
-    return true;
+/** Yield `*.md` files in the in-repo dir (read path — never creates it). */
+export function* iterInRepoMemoryFiles(
+  root: string,
+  memoryDir: string,
+): Generator<string> {
+  const dir = inRepoMemoriesDirPath(root, memoryDir);
+  if (!fs.existsSync(dir)) return;
+  for (const name of fs.readdirSync(dir)) {
+    if (name.endsWith(".md")) yield path.join(dir, name);
   }
-  return false;
 }
 
 export function readMemoryFile(filePath: string): MemoryFile | null {

package/src/store/sync.ts

@@ -1,17 +1,21 @@
 import fs from "node:fs";
+import path from "node:path";
 import { db } from "./db.ts";
 import { cjkIndexText } from "../retrieve/cjk.ts";
 import { contentHash, repairChain } from "./lifecycle.ts";
 import {
   iterMemoryFiles,
+  iterInRepoMemoryFiles,
   readMemoryFile,
   timeToMs,
   type MemoryFile,
 } from "./markdown.ts";
+import { projectRoot, paths } from "../paths.ts";
+import { loadConfig } from "../config.ts";
 
 const UPSERT_SQL = `
-  INSERT INTO memories (id, scope_key, scope, visibility, project_name, type, role, importance, status, tags, content, cjk, content_hash, superseded_by, source, file_path, mtime_ms, created_at, updated_at)
-  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  INSERT INTO memories (id, scope_key, scope, visibility, project_name, type, role, importance, status, tags, content, cjk, content_hash, superseded_by, source, file_path, mtime_ms, created_at, updated_at, review_state)
+  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   ON CONFLICT(id) DO UPDATE SET
     scope_key    = excluded.scope_key,
     scope        = excluded.scope,
@@ -27,6 +31,7 @@ const UPSERT_SQL = `
     content_hash = excluded.content_hash,
     superseded_by = excluded.superseded_by,
     source       = excluded.source,
+    review_state = excluded.review_state,
     file_path    = excluded.file_path,
     mtime_ms     = excluded.mtime_ms,
     updated_at   = excluded.updated_at
@@ -77,6 +82,7 @@ function writeRow(mf: MemoryFile, mtimeMs: number): void {
     mtimeMs,
     timeToMs(fm.created_at),
     timeToMs(fm.updated_at),
+    fm.review_state ?? "draft",
   );
 }
 
@@ -91,7 +97,7 @@ export interface SyncStats {
   scanned: number;
 }
 
-export function syncScope(scopeKey: string): SyncStats {
+export function syncScope(scopeKey: string, kind: SyncKind = "auto"): SyncStats {
   const d = db();
   const stats: SyncStats = { added: 0, updated: 0, removed: 0, scanned: 0 };
 
@@ -101,7 +107,22 @@ export function syncScope(scopeKey: string): SyncStats {
   const existingById = new Map(existing.map((r) => [r.id, r]));
   const seen = new Set<string>();
 
-  for (const fp of iterMemoryFiles(scopeKey)) {
+  // 2B/D26: project scopes have two homes — the appdata outbox (drafts,
+  // branch-independent) and the in-repo dir (submitted memories, following
+  // the current branch). No migration: appdata files stay put until an
+  // explicit `submit` moves them. On the near-impossible id collision the
+  // in-repo (submitted) copy wins, so scan appdata first.
+  const filePaths: string[] = [];
+  if (scopeKey.startsWith("project__")) {
+    const root = projectRoot();
+    const memoryDir = loadConfig().memoryDir;
+    for (const fp of iterMemoryFiles(scopeKey)) filePaths.push(fp);
+    for (const fp of iterInRepoMemoryFiles(root, memoryDir)) filePaths.push(fp);
+  } else {
+    for (const fp of iterMemoryFiles(scopeKey)) filePaths.push(fp);
+  }
+
+  for (const fp of filePaths) {
     const mf = readMemoryFile(fp);
     if (!mf) continue;
     stats.scanned++;
@@ -123,5 +144,65 @@ export function syncScope(scopeKey: string): SyncStats {
     }
   }
 
+  recordSync(scopeKey, kind, stats);
   return stats;
 }
+
+// ---------------------------------------------------------------------------
+// D31: last-sync visibility
+// ---------------------------------------------------------------------------
+
+/** What triggered the sync — shown in sync-status so the user can see it. */
+export type SyncKind = "session" | "request" | "cli" | "submit" | "auto";
+
+export interface SyncStateEntry {
+  lastSyncAt: string; // RFC 3339
+  lastSyncKind: SyncKind;
+  added: number;
+  updated: number;
+  removed: number;
+  scanned: number;
+}
+
+function syncStatePath(): string {
+  return path.join(paths().root, "sync-state.json");
+}
+
+/** Best-effort: a failed write never breaks the sync itself. */
+export function recordSync(scopeKey: string, kind: SyncKind, stats: SyncStats): void {
+  try {
+    const p = syncStatePath();
+    let all: Record<string, SyncStateEntry> = {};
+    if (fs.existsSync(p)) {
+      try {
+        all = JSON.parse(fs.readFileSync(p, "utf8")) as Record<string, SyncStateEntry>;
+      } catch {
+        /* corrupt — start fresh */
+      }
+    }
+    all[scopeKey] = {
+      lastSyncAt: new Date().toISOString(),
+      lastSyncKind: kind,
+      added: stats.added,
+      updated: stats.updated,
+      removed: stats.removed,
+      scanned: stats.scanned,
+    };
+    fs.writeFileSync(p, JSON.stringify(all, null, 2), "utf8");
+  } catch {
+    /* visibility is advisory — never fail a sync over it */
+  }
+}
+
+export function readSyncState(scopeKey: string): SyncStateEntry | null {
+  try {
+    const p = syncStatePath();
+    if (!fs.existsSync(p)) return null;
+    const all = JSON.parse(fs.readFileSync(p, "utf8")) as Record<string, unknown>;
+    const e = all?.[scopeKey] as SyncStateEntry | undefined;
+    if (!e || typeof e.lastSyncAt !== "string") return null;
+    return e;
+  } catch {
+    return null;
+  }
+}