omo-memory 0.1.7 → 0.1.8

package/README.md

@@ -11,6 +11,7 @@ It gives lazycodex, omo-on-opencode, lfg, and future OMO adapters a shared local
 
 - Project-local DB: `<project-root>/.omo/memory/state.sqlite`
 - Project namespacing: by git remote + project root hash
+- Move handling: if a project directory moves with its `.omo` ledger, existing rows are migrated to the new root automatically.
 - Privacy default: local-only, no network sync, no secrets by design
 - Intended adapters: Codex/lazycodex, OpenCode/OMO, GrokBuild/lfg
 

package/dist/cli.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { readFileSync } from "node:fs";
 import { installHooks } from "./hooks.js";
-import { bootstrapSession, doctorReport, exportMemory, initMemory, purgeMemory, recentEvents, recordEvent, startSession, writeHandoff } from "./memory.js";
 import { runMcpServer } from "./mcp.js";
+import { bootstrapSession, doctorReport, exportMemory, purgeMemory, recentEvents, recordEvent, startSession, writeHandoff } from "./memory.js";
+import { initMemory } from "./memoryDb.js";
 async function main(argv) {
     const [command, subcommand, ...rest] = argv;
     if (command === undefined || command === "help" || command === "--help" || command === "-h") {
@@ -48,7 +49,10 @@ function runCommand(command, subcommand, rest) {
         const summary = readFlag(rest, "--summary") ?? fail("event record requires --summary");
         const payloadJson = readFlag(rest, "--payload-json");
         const sessionId = readFlag(rest, "--session-id");
-        return { ok: true, ...recordEvent({ type, summary, ...(payloadJson === undefined ? {} : { payloadJson }), ...(sessionId === undefined ? {} : { sessionId }) }) };
+        return {
+            ok: true,
+            ...recordEvent({ type, summary, ...(payloadJson === undefined ? {} : { payloadJson }), ...(sessionId === undefined ? {} : { sessionId }) }),
+        };
     }
     if (command === "recent") {
         const limitRaw = readFlag([subcommand, ...rest].filter((value) => value !== undefined), "--limit");

package/dist/hookTemplates.js

@@ -84,7 +84,7 @@ try {
 export const GROK_HOOK_SCRIPT = SESSION_BOOTSTRAP_SCRIPT.replace('?? "codex"', '?? "grok"').replace('?? "lazycodex"', '?? "lfg"');
 export const GROK_PLUGIN_JSON = `{
   "name": "omo-memory",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Project-local OMO Memory bootstrap hook and MCP server for Grok.",
   "author": {
     "name": "islee23520"
@@ -109,7 +109,7 @@ export const GROK_MCP_JSON = `{
 `;
 export const CODEX_PLUGIN_JSON = `{
   "name": "omo-memory",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Session-start OMO Memory bootstrap hook for Codex.",
   "author": "islee23520",
   "homepage": "https://github.com/islee23520/omo-memory",

package/dist/mcp.js

@@ -1,7 +1,9 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { bootstrapSession, exportMemory, initMemory, memoryPaths, purgeMemory, PurgeConfirmationError, recentEvents, recordEvent, resolveProjectContext, startSession, writeHandoff } from "./memory.js";
+import { bootstrapSession, exportMemory, memoryPaths, PurgeConfirmationError, purgeMemory, recentEvents, recordEvent, startSession, writeHandoff, } from "./memory.js";
+import { initMemory } from "./memoryDb.js";
+import { resolveProjectContext } from "./projectContext.js";
 export async function runMcpServer() {
     const server = new McpServer({ name: "omo-memory", version: "0.1.2" });
     server.registerTool("memory_init", {

package/dist/memory.js

@@ -1,94 +1,22 @@
-import Database from "better-sqlite3";
-import { createHash, randomUUID } from "node:crypto";
-import { mkdirSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { execFileSync } from "node:child_process";
-import { redactSecrets, sanitizeGitRemote } from "./privacy.js";
+import { randomUUID } from "node:crypto";
+import { migrate, openMemoryDb, SCHEMA_VERSION } from "./memoryDb.js";
+import { redactSecrets } from "./privacy.js";
+import { defaultDbPath, resolveProjectContext } from "./projectContext.js";
+import { resolveStoredProject } from "./projectMigration.js";
 export class PurgeConfirmationError extends Error {
     constructor() {
         super("purge requires --yes");
         this.name = "PurgeConfirmationError";
     }
 }
-const SCHEMA_VERSION = 1;
-export function defaultDbPath() {
-    return process.env["OMO_MEMORY_DB"] ?? join(resolveProjectContext().repoRoot, ".omo", "memory", "state.sqlite");
-}
 export function memoryPaths() {
     return { dbPath: defaultDbPath() };
 }
-export function openMemoryDb(dbPath = defaultDbPath()) {
-    mkdirSync(dirname(dbPath), { recursive: true });
-    const db = new Database(dbPath);
-    db.pragma("journal_mode = WAL");
-    return db;
-}
-export function migrate(db) {
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS schema_meta (
-      key TEXT PRIMARY KEY,
-      value TEXT NOT NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS projects (
-      id TEXT PRIMARY KEY,
-      repo_root TEXT NOT NULL,
-      git_remote TEXT,
-      created_at TEXT NOT NULL,
-      last_seen_at TEXT NOT NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS sessions (
-      id TEXT PRIMARY KEY,
-      project_id TEXT NOT NULL,
-      host TEXT NOT NULL,
-      adapter TEXT NOT NULL,
-      started_at TEXT NOT NULL,
-      ended_at TEXT,
-      git_branch TEXT,
-      git_head TEXT,
-      FOREIGN KEY(project_id) REFERENCES projects(id)
-    );
-
-    CREATE TABLE IF NOT EXISTS events (
-      id TEXT PRIMARY KEY,
-      session_id TEXT,
-      project_id TEXT NOT NULL,
-      type TEXT NOT NULL,
-      summary TEXT NOT NULL,
-      payload_json TEXT,
-      created_at TEXT NOT NULL,
-      FOREIGN KEY(project_id) REFERENCES projects(id),
-      FOREIGN KEY(session_id) REFERENCES sessions(id)
-    );
-
-    CREATE TABLE IF NOT EXISTS handoffs (
-      id TEXT PRIMARY KEY,
-      project_id TEXT NOT NULL,
-      session_id TEXT,
-      summary_md TEXT NOT NULL,
-      created_at TEXT NOT NULL,
-      FOREIGN KEY(project_id) REFERENCES projects(id),
-      FOREIGN KEY(session_id) REFERENCES sessions(id)
-    );
-  `);
-    db.prepare("INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', ?)").run(String(SCHEMA_VERSION));
-}
-export function initMemory(dbPath = defaultDbPath()) {
-    const db = openMemoryDb(dbPath);
-    try {
-        migrate(db);
-        return { dbPath, schemaVersion: SCHEMA_VERSION };
-    }
-    finally {
-        db.close();
-    }
-}
 export function doctorReport(dbPath = defaultDbPath()) {
     const db = openMemoryDb(dbPath);
     try {
         migrate(db);
-        const project = resolveProjectContext();
+        const project = resolveStoredProject(db, resolveProjectContext());
         const schemaVersion = Number(db.prepare("SELECT value FROM schema_meta WHERE key = 'schema_version'").pluck().get());
         const count = (table) => Number(db.prepare(`SELECT COUNT(*) FROM ${table}`).pluck().get());
         return {
@@ -107,15 +35,6 @@ export function doctorReport(dbPath = defaultDbPath()) {
         db.close();
     }
 }
-export function resolveProjectContext(cwd = process.cwd()) {
-    const repoRoot = gitValue(["rev-parse", "--show-toplevel"], cwd) ?? resolve(cwd);
-    const rawGitRemote = gitValue(["config", "--get", "remote.origin.url"], repoRoot);
-    const gitRemote = sanitizeGitRemote(rawGitRemote);
-    const gitBranch = gitValue(["rev-parse", "--abbrev-ref", "HEAD"], repoRoot);
-    const gitHead = gitValue(["rev-parse", "HEAD"], repoRoot);
-    const id = createHash("sha256").update(`${rawGitRemote ?? ""}\n${repoRoot}`).digest("hex").slice(0, 24);
-    return { id, repoRoot, gitRemote, gitBranch, gitHead };
-}
 export function upsertProject(db, project) {
     const now = new Date().toISOString();
     db.prepare(`
@@ -131,7 +50,7 @@ export function startSession(input, dbPath = defaultDbPath()) {
     const db = openMemoryDb(dbPath);
     try {
         migrate(db);
-        const project = resolveProjectContext();
+        const project = resolveStoredProject(db, resolveProjectContext());
         upsertProject(db, project);
         const sessionId = randomUUID();
         db.prepare(`
@@ -152,7 +71,7 @@ export function recordEvent(input, dbPath = defaultDbPath()) {
     const db = openMemoryDb(dbPath);
     try {
         migrate(db);
-        const project = resolveProjectContext();
+        const project = resolveStoredProject(db, resolveProjectContext());
         upsertProject(db, project);
         const eventId = randomUUID();
         db.prepare(`
@@ -169,14 +88,16 @@ export function recentEvents(limit, dbPath = defaultDbPath()) {
     const db = openMemoryDb(dbPath);
     try {
         migrate(db);
-        const project = resolveProjectContext();
-        return db.prepare(`
+        const project = resolveStoredProject(db, resolveProjectContext());
+        return db
+            .prepare(`
       SELECT id, type, summary, created_at AS createdAt, session_id AS sessionId
       FROM events
       WHERE project_id = ?
       ORDER BY created_at DESC
       LIMIT ?
-    `).all(project.id, limit);
+    `)
+            .all(project.id, limit);
     }
     finally {
         db.close();
@@ -186,7 +107,7 @@ export function writeHandoff(summaryMd, sessionId, dbPath = defaultDbPath()) {
     const db = openMemoryDb(dbPath);
     try {
         migrate(db);
-        const project = resolveProjectContext();
+        const project = resolveStoredProject(db, resolveProjectContext());
         upsertProject(db, project);
         const handoffId = randomUUID();
         db.prepare(`
@@ -203,19 +124,25 @@ export function exportMemory(dbPath = defaultDbPath()) {
     const db = openMemoryDb(dbPath);
     try {
         migrate(db);
-        const project = resolveProjectContext();
-        const sessions = db.prepare(`
+        const project = resolveStoredProject(db, resolveProjectContext());
+        const sessions = db
+            .prepare(`
       SELECT id, host, adapter, started_at AS startedAt, ended_at AS endedAt, git_branch AS gitBranch, git_head AS gitHead FROM sessions
       WHERE project_id = ? ORDER BY started_at ASC, id ASC
-    `).all(project.id);
-        const events = db.prepare(`
+    `)
+            .all(project.id);
+        const events = db
+            .prepare(`
       SELECT id, session_id AS sessionId, type, summary, payload_json AS payloadJson, created_at AS createdAt FROM events
       WHERE project_id = ? ORDER BY created_at ASC, id ASC
-    `).all(project.id);
-        const handoffs = db.prepare(`
+    `)
+            .all(project.id);
+        const handoffs = db
+            .prepare(`
       SELECT id, session_id AS sessionId, summary_md AS summaryMd, created_at AS createdAt FROM handoffs
       WHERE project_id = ? ORDER BY created_at ASC, id ASC
-    `).all(project.id);
+    `)
+            .all(project.id);
         return {
             schemaVersion: SCHEMA_VERSION,
             exportedAt: new Date().toISOString(),
@@ -236,11 +163,17 @@ export function purgeMemory(input, dbPath = defaultDbPath()) {
     const db = openMemoryDb(dbPath);
     try {
         migrate(db);
-        const project = resolveProjectContext();
+        const project = resolveStoredProject(db, resolveProjectContext());
         const deleteProject = db.transaction(() => {
-            const events = db.prepare("DELETE FROM events WHERE project_id IN (SELECT id FROM projects WHERE id = ? OR repo_root = ?)").run(project.id, project.repoRoot).changes;
-            const handoffs = db.prepare("DELETE FROM handoffs WHERE project_id IN (SELECT id FROM projects WHERE id = ? OR repo_root = ?)").run(project.id, project.repoRoot).changes;
-            const sessions = db.prepare("DELETE FROM sessions WHERE project_id IN (SELECT id FROM projects WHERE id = ? OR repo_root = ?)").run(project.id, project.repoRoot).changes;
+            const events = db
+                .prepare("DELETE FROM events WHERE project_id IN (SELECT id FROM projects WHERE id = ? OR repo_root = ?)")
+                .run(project.id, project.repoRoot).changes;
+            const handoffs = db
+                .prepare("DELETE FROM handoffs WHERE project_id IN (SELECT id FROM projects WHERE id = ? OR repo_root = ?)")
+                .run(project.id, project.repoRoot).changes;
+            const sessions = db
+                .prepare("DELETE FROM sessions WHERE project_id IN (SELECT id FROM projects WHERE id = ? OR repo_root = ?)")
+                .run(project.id, project.repoRoot).changes;
             const projects = db.prepare("DELETE FROM projects WHERE id = ? OR repo_root = ?").run(project.id, project.repoRoot).changes;
             return { events, handoffs, sessions, projects };
         });
@@ -250,11 +183,3 @@ export function purgeMemory(input, dbPath = defaultDbPath()) {
         db.close();
     }
 }
-function gitValue(args, cwd) {
-    try {
-        return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || null;
-    }
-    catch {
-        return null;
-    }
-}

package/dist/memoryDb.js

@@ -0,0 +1,72 @@
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import Database from "better-sqlite3";
+import { defaultDbPath } from "./projectContext.js";
+export const SCHEMA_VERSION = 1;
+export function openMemoryDb(dbPath = defaultDbPath()) {
+    mkdirSync(dirname(dbPath), { recursive: true });
+    const db = new Database(dbPath);
+    db.pragma("journal_mode = WAL");
+    return db;
+}
+export function migrate(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      repo_root TEXT NOT NULL,
+      git_remote TEXT,
+      created_at TEXT NOT NULL,
+      last_seen_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      host TEXT NOT NULL,
+      adapter TEXT NOT NULL,
+      started_at TEXT NOT NULL,
+      ended_at TEXT,
+      git_branch TEXT,
+      git_head TEXT,
+      FOREIGN KEY(project_id) REFERENCES projects(id)
+    );
+
+    CREATE TABLE IF NOT EXISTS events (
+      id TEXT PRIMARY KEY,
+      session_id TEXT,
+      project_id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      payload_json TEXT,
+      created_at TEXT NOT NULL,
+      FOREIGN KEY(project_id) REFERENCES projects(id),
+      FOREIGN KEY(session_id) REFERENCES sessions(id)
+    );
+
+    CREATE TABLE IF NOT EXISTS handoffs (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      session_id TEXT,
+      summary_md TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      FOREIGN KEY(project_id) REFERENCES projects(id),
+      FOREIGN KEY(session_id) REFERENCES sessions(id)
+    );
+  `);
+    db.prepare("INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', ?)").run(String(SCHEMA_VERSION));
+}
+export function initMemory(dbPath = defaultDbPath()) {
+    const db = openMemoryDb(dbPath);
+    try {
+        migrate(db);
+        return { dbPath, schemaVersion: SCHEMA_VERSION };
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/projectContext.js

@@ -0,0 +1,27 @@
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { join, resolve } from "node:path";
+import { sanitizeGitRemote } from "./privacy.js";
+export function defaultDbPath() {
+    return process.env["OMO_MEMORY_DB"] ?? join(resolveProjectContext().repoRoot, ".omo", "memory", "state.sqlite");
+}
+export function resolveProjectContext(cwd = process.cwd()) {
+    const repoRoot = gitValue(["rev-parse", "--show-toplevel"], cwd) ?? resolve(cwd);
+    const rawGitRemote = gitValue(["config", "--get", "remote.origin.url"], repoRoot);
+    const gitRemote = sanitizeGitRemote(rawGitRemote);
+    const gitBranch = gitValue(["rev-parse", "--abbrev-ref", "HEAD"], repoRoot);
+    const gitHead = gitValue(["rev-parse", "HEAD"], repoRoot);
+    const id = createHash("sha256")
+        .update(`${rawGitRemote ?? ""}\n${repoRoot}`)
+        .digest("hex")
+        .slice(0, 24);
+    return { id, repoRoot, gitRemote, gitBranch, gitHead };
+}
+function gitValue(args, cwd) {
+    try {
+        return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/projectMigration.js

@@ -0,0 +1,40 @@
+export function resolveStoredProject(db, project) {
+    const current = readProjectById(db, project.id);
+    if (current !== undefined) {
+        updateProjectMetadata(db, project);
+        return project;
+    }
+    const candidate = findMovedProjectCandidate(db, project);
+    if (candidate === undefined || candidate.id === project.id)
+        return project;
+    updateProjectMetadata(db, { ...project, id: candidate.id });
+    return { ...project, id: candidate.id };
+}
+function findMovedProjectCandidate(db, project) {
+    const byRoot = readProjectByRepoRoot(db, project.repoRoot);
+    if (byRoot !== undefined)
+        return byRoot;
+    if (project.gitRemote !== null) {
+        const byRemote = readProjectByGitRemote(db, project.gitRemote);
+        if (byRemote !== undefined)
+            return byRemote;
+    }
+    const allProjects = db
+        .prepare("SELECT id, repo_root, git_remote, created_at FROM projects ORDER BY last_seen_at DESC, created_at DESC")
+        .all();
+    return allProjects.length === 1 ? allProjects[0] : undefined;
+}
+function readProjectById(db, id) {
+    return db.prepare("SELECT id, repo_root, git_remote, created_at FROM projects WHERE id = ?").get(id);
+}
+function readProjectByRepoRoot(db, repoRoot) {
+    return db.prepare("SELECT id, repo_root, git_remote, created_at FROM projects WHERE repo_root = ?").get(repoRoot);
+}
+function readProjectByGitRemote(db, gitRemote) {
+    return db
+        .prepare("SELECT id, repo_root, git_remote, created_at FROM projects WHERE git_remote = ? ORDER BY last_seen_at DESC, created_at DESC")
+        .get(gitRemote);
+}
+function updateProjectMetadata(db, project) {
+    db.prepare("UPDATE projects SET repo_root = ?, git_remote = ?, last_seen_at = ? WHERE id = ?").run(project.repoRoot, project.gitRemote, new Date().toISOString(), project.id);
+}

package/docs/adapter-integration.md

@@ -11,6 +11,7 @@ No full transcript capture by default. Do not store API keys, tokens, `.env` con
 - Record concise events with a stable `type`, a human-readable `summary`, and optional redacted JSON metadata in `payloadJson`.
 - Store handoffs as summary markdown that another host can read without needing the originating transcript.
 - Treat CLI and MCP as two entrypoints to the same core functions and schema.
+- When a project directory moves with its `.omo` ledger, OMO Memory migrates matching project rows to the new root automatically.
 - Use `OMO_MEMORY_DB` only when the caller explicitly chooses a different database path, such as an isolated smoke test.
 
 ## Adapter Metadata

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omo-memory",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Host-neutral local SQLite memory and session ledger for OMO adapters, exposed through CLI and MCP.",
   "type": "module",
   "files": [
@@ -25,6 +25,9 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc --noEmit",
+    "lint": "biome check .",
+    "format": "biome format --write .",
+    "check": "npm run lint && npm run typecheck && npm run smoke",
     "start": "node dist/cli.js",
     "prepack": "npm run build",
     "presmoke": "npm run build",
@@ -40,6 +43,7 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.5.1",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^24.10.1",
     "typescript": "^6.0.3"