@vaur94/agz-memory 0.4.0-beta.1 → 0.4.1

package/dist/admin.js

@@ -2,7 +2,7 @@
 // @bun
 
 // src/admin/index.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { Database as Database3 } from "bun:sqlite";
 import {
   existsSync as existsSync4,
@@ -41,7 +41,8 @@ function normalizeProjectName(value) {
 }
 
 // src/types.ts
-var SCHEMA_VERSION = 9;
+var SCHEMA_VERSION = 10;
+var KINDS = ["decision", "fact", "procedure", "context", "research", "preference", "task"];
 var PREDICATES = ["SUPPORTS", "DERIVED_FROM", "PART_OF", "ABOUT", "PRECEDES", "SUPERSEDES"];
 
 // src/db/backup.ts
@@ -103,9 +104,12 @@ function hasTable(db, table) {
 }
 
 // src/db/backup.ts
-var BACKUP_FORMAT = "opencode2-memory-backup/1";
+var BACKUP_FORMAT = "agz-memory-backup/1";
 function createVerifiedBackup(db, databasePath, sourceSchema, targetSchema, productVersion) {
   const sourceHealth = assertHealthyDatabase(db);
+  if (sourceHealth.schemaVersion !== undefined && sourceHealth.schemaVersion !== sourceSchema) {
+    throw new Error(`backup source schema v${sourceSchema} does not match database schema v${sourceHealth.schemaVersion}`);
+  }
   const checkpoint = db.query("PRAGMA wal_checkpoint(TRUNCATE)").get();
   if (checkpoint.busy !== 0)
     throw new Error("database WAL checkpoint is busy");
@@ -133,6 +137,9 @@ function createVerifiedBackup(db, databasePath, sourceSchema, targetSchema, prod
     if (JSON.stringify(backupHealth.counts) !== JSON.stringify(sourceHealth.counts)) {
       throw new Error("backup row counts differ from source database");
     }
+    if (backupHealth.schemaVersion !== undefined && backupHealth.schemaVersion !== sourceSchema) {
+      throw new Error("backup schema does not match source schema");
+    }
     const bytes = readFileSync(temporaryDatabasePath);
     const manifest = {
       format: BACKUP_FORMAT,
@@ -205,6 +212,9 @@ function verifyBackupManifest(manifestPath) {
     if (JSON.stringify(health.counts) !== JSON.stringify(manifest.counts)) {
       throw new Error("backup manifest row counts do not match");
     }
+    if (health.schemaVersion !== undefined && health.schemaVersion !== manifest.sourceSchema) {
+      throw new Error("backup manifest source schema does not match database");
+    }
   } finally {
     db.close();
   }
@@ -390,7 +400,7 @@ function acquireMigrationLock(databasePath, targetSchema, timeoutMs = 30000) {
           rmSync2(path, { recursive: true, force: true });
           throw error;
         }
-        if (!existsSync2(path))
+        if (!isAlreadyExistsError(error))
           throw error;
         if (Date.now() >= deadline) {
           const current = readMigrationLockOwner(path);
@@ -463,12 +473,84 @@ function processIsAlive(pid) {
     return false;
   }
 }
+function isAlreadyExistsError(error) {
+  return Boolean(error && typeof error === "object" && "code" in error && String(error.code) === "EEXIST");
+}
 
 // src/db/migrations/v009.ts
 import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
 
+// src/capture/contract.ts
+import * as z from "zod/v4";
+var CAPTURE_SCHEMA = "agz-memory.capture/1";
+var SUPPORTED_OPENCODE_VERSION = "0.0.0-beta-18743";
+var CAPTURE_EVENT_MAX_BYTES = 16 * 1024;
+var CAPTURE_CONTENT_MAX_CHARACTERS = 4800;
+var CAPTURE_SUMMARY_MAX_CHARACTERS = 1200;
+var CAPTURE_SUBJECT_MAX_CHARACTERS = 240;
+var candidateSchema = z.object({
+  kind: z.enum(KINDS),
+  title: z.string().min(1).max(240),
+  summary: z.string().min(1).max(CAPTURE_SUMMARY_MAX_CHARACTERS),
+  content: z.string().min(1).max(CAPTURE_CONTENT_MAX_CHARACTERS),
+  subjectKey: z.string().min(1).max(CAPTURE_SUBJECT_MAX_CHARACTERS).optional(),
+  intent: z.enum(["create", "supersede", "ignore", "review"]),
+  targetNoteID: z.string().min(1).max(240).optional(),
+  confidence: z.number().finite().min(0).max(1),
+  evidence: z.enum(["explicit-user", "verified-outcome", "session-summary"])
+}).strict();
+var signalSchema = z.object({
+  tool: z.string().min(1).max(160),
+  status: z.enum(["completed", "error"]),
+  errorType: z.string().min(1).max(160).optional()
+}).strict();
+var captureEventSchema = z.object({
+  schema: z.literal(CAPTURE_SCHEMA),
+  idempotencyKey: z.string().regex(/^[0-9a-f]{64}$/),
+  projectID: z.uuid(),
+  bindingKey: z.string().regex(/^[0-9a-f]{64}$/),
+  kind: z.enum(["user-candidate", "assistant-candidate", "session-summary", "tool-signal"]),
+  source: z.object({
+    system: z.literal("opencode-v2"),
+    opencodeVersion: z.literal(SUPPORTED_OPENCODE_VERSION),
+    pluginVersion: z.string().min(1).max(80),
+    sessionID: z.string().min(1).max(240),
+    messageID: z.string().min(1).max(240).optional(),
+    ordinal: z.number().int().nonnegative().optional(),
+    toolCallID: z.string().min(1).max(240).optional(),
+    observedAt: z.number().int().nonnegative()
+  }).strict(),
+  candidate: candidateSchema.optional(),
+  signal: signalSchema.optional(),
+  redaction: z.object({
+    policyVersion: z.string().min(1).max(80),
+    replacements: z.number().int().nonnegative(),
+    truncated: z.boolean()
+  }).strict()
+}).strict().superRefine((event, context) => {
+  if (event.kind === "tool-signal" && !event.signal) {
+    context.addIssue({ code: "custom", message: "tool-signal requires signal" });
+  }
+  if (event.kind !== "tool-signal" && !event.candidate) {
+    context.addIssue({ code: "custom", message: `${event.kind} requires candidate` });
+  }
+  if (event.kind === "tool-signal" && event.candidate) {
+    context.addIssue({ code: "custom", message: "tool-signal cannot carry candidate" });
+  }
+  if (event.kind !== "tool-signal" && event.signal) {
+    context.addIssue({ code: "custom", message: `${event.kind} cannot carry signal` });
+  }
+});
+function parseCaptureEvent(value) {
+  const event = captureEventSchema.parse(value);
+  if (Buffer.byteLength(JSON.stringify(event), "utf8") > CAPTURE_EVENT_MAX_BYTES) {
+    throw new Error(`capture event exceeds ${CAPTURE_EVENT_MAX_BYTES} UTF-8 bytes`);
+  }
+  return event;
+}
+
 // src/db/schema.ts
-var SCHEMA_V9_TABLES = `
+var SCHEMA_TABLES = `
 CREATE TABLE IF NOT EXISTS projects (
   id TEXT PRIMARY KEY,
   name TEXT NOT NULL,
@@ -538,28 +620,7 @@ CREATE TABLE IF NOT EXISTS capture_checkpoints (
 );
 CREATE INDEX IF NOT EXISTS capture_checkpoints_due_idx
   ON capture_checkpoints(state, next_reconcile_at);
-CREATE TABLE IF NOT EXISTS capture_events (
-  idempotency_key TEXT PRIMARY KEY,
-  contract TEXT NOT NULL CHECK (contract = 'opencode2-memory.capture/1'),
-  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-  binding_key TEXT NOT NULL REFERENCES project_bindings(binding_key) ON DELETE CASCADE,
-  event_kind TEXT NOT NULL CHECK (event_kind IN ('user-candidate','assistant-candidate','session-summary','tool-signal')),
-  source_session_id TEXT NOT NULL,
-  source_message_id TEXT,
-  source_ordinal INTEGER CHECK (source_ordinal IS NULL OR source_ordinal >= 0),
-  source_tool_call_id TEXT,
-  payload_json TEXT CHECK (payload_json IS NULL OR json_valid(payload_json)),
-  payload_hash TEXT,
-  redaction_version TEXT NOT NULL,
-  state TEXT NOT NULL CHECK (state IN ('pending','shadowed','review','materialized','duplicate','ignored','rejected','quarantined','failed','dead')),
-  attempt_count INTEGER NOT NULL DEFAULT 0 CHECK (attempt_count >= 0),
-  note_id TEXT,
-  last_error_code TEXT,
-  generation INTEGER NOT NULL DEFAULT 0 CHECK (generation >= 0),
-  created_at INTEGER NOT NULL,
-  updated_at INTEGER NOT NULL,
-  processed_at INTEGER
-);
+${captureEventsTable()}
 CREATE INDEX IF NOT EXISTS capture_events_state_idx ON capture_events(state, updated_at);
 CREATE INDEX IF NOT EXISTS capture_events_session_idx ON capture_events(project_id, source_session_id);
 CREATE INDEX IF NOT EXISTS capture_events_note_idx ON capture_events(project_id, note_id);
@@ -643,15 +704,39 @@ CREATE TRIGGER IF NOT EXISTS notes_fts_au AFTER UPDATE OF title, summary, conten
   VALUES (new.rowid, new.title, new.summary, new.content);
 END;
 `;
-function createSchemaV9(db) {
-  db.exec(SCHEMA_V9_TABLES);
+function createSchema(db) {
+  db.exec(SCHEMA_TABLES);
   db.exec(FTS_V9);
   db.query("DELETE FROM schema_state").run();
-  db.query("INSERT INTO schema_state(version) VALUES (9)").run();
+  db.query("INSERT INTO schema_state(version) VALUES (10)").run();
 }
 function rebuildFts(db) {
   db.query("INSERT INTO notes_fts(notes_fts) VALUES ('rebuild')").run();
 }
+function captureEventsTable(table = "capture_events") {
+  return `CREATE TABLE IF NOT EXISTS ${table} (
+  idempotency_key TEXT PRIMARY KEY,
+  contract TEXT NOT NULL CHECK (contract = '${CAPTURE_SCHEMA}'),
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  binding_key TEXT NOT NULL REFERENCES project_bindings(binding_key) ON DELETE CASCADE,
+  event_kind TEXT NOT NULL CHECK (event_kind IN ('user-candidate','assistant-candidate','session-summary','tool-signal')),
+  source_session_id TEXT NOT NULL,
+  source_message_id TEXT,
+  source_ordinal INTEGER CHECK (source_ordinal IS NULL OR source_ordinal >= 0),
+  source_tool_call_id TEXT,
+  payload_json TEXT CHECK (payload_json IS NULL OR json_valid(payload_json)),
+  payload_hash TEXT,
+  redaction_version TEXT NOT NULL,
+  state TEXT NOT NULL CHECK (state IN ('pending','shadowed','review','materialized','duplicate','ignored','rejected','quarantined','failed','dead')),
+  attempt_count INTEGER NOT NULL DEFAULT 0 CHECK (attempt_count >= 0),
+  note_id TEXT,
+  last_error_code TEXT,
+  generation INTEGER NOT NULL DEFAULT 0 CHECK (generation >= 0),
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  processed_at INTEGER
+);`;
+}
 
 // src/db/migrations/v009.ts
 function migrateV8ToV9(db) {
@@ -720,7 +805,7 @@ function migrateV8ToV9(db) {
     ALTER TABLE notes_v9 RENAME TO notes;
     ALTER TABLE note_edges_v9 RENAME TO note_edges;
   `);
-  db.exec(SCHEMA_V9_TABLES);
+  db.exec(SCHEMA_TABLES);
   for (const note of notes) {
     const provenanceID = randomUUID3();
     db.query(`
@@ -744,6 +829,57 @@ function noteContentHash(kind, title, summary, content) {
   return createHash3("sha256").update(`${kind}\x00${title}\x00${summary}\x00${content}`, "utf8").digest("hex");
 }
 
+// src/db/migrations/v010.ts
+import { createHash as createHash4 } from "crypto";
+function migrateV9ToV10(db) {
+  const payloads = db.query("SELECT idempotency_key, payload_json FROM capture_events WHERE payload_json IS NOT NULL").all();
+  const migratedPayloads = payloads.map((row) => {
+    const event = JSON.parse(row.payload_json);
+    if (!event || typeof event !== "object" || Array.isArray(event)) {
+      throw new Error(`capture event ${row.idempotency_key} payload is not an object`);
+    }
+    event.schema = CAPTURE_SCHEMA;
+    const payload = JSON.stringify(parseCaptureEvent(event));
+    return {
+      idempotencyKey: row.idempotency_key,
+      payload,
+      payloadHash: createHash4("sha256").update(payload, "utf8").digest("hex")
+    };
+  });
+  db.exec("DROP TABLE IF EXISTS capture_events_v10");
+  db.exec(captureEventsTable("capture_events_v10"));
+  db.query(`
+    INSERT INTO capture_events_v10
+      (idempotency_key, contract, project_id, binding_key, event_kind,
+       source_session_id, source_message_id, source_ordinal, source_tool_call_id,
+       payload_json, payload_hash, redaction_version, state, attempt_count,
+       note_id, last_error_code, generation, created_at, updated_at, processed_at)
+    SELECT idempotency_key, ?, project_id, binding_key, event_kind,
+           source_session_id, source_message_id, source_ordinal, source_tool_call_id,
+           payload_json, payload_hash, redaction_version, state, attempt_count,
+           note_id, last_error_code, generation, created_at, updated_at, processed_at
+      FROM capture_events
+  `).run(CAPTURE_SCHEMA);
+  const updatePayload = db.query(`
+    UPDATE capture_events_v10
+       SET payload_json = ?, payload_hash = ?
+     WHERE idempotency_key = ?
+  `);
+  for (const row of migratedPayloads) {
+    updatePayload.run(row.payload, row.payloadHash, row.idempotencyKey);
+  }
+  db.exec(`
+    DROP TABLE capture_events;
+    ALTER TABLE capture_events_v10 RENAME TO capture_events;
+  `);
+  db.exec(SCHEMA_TABLES);
+  db.query("DELETE FROM schema_state").run();
+  db.query("INSERT INTO schema_state(version) VALUES (10)").run();
+}
+
+// src/version.ts
+var PRODUCT_VERSION = "0.4.1";
+
 // src/db.ts
 var DDL = `
 CREATE TABLE IF NOT EXISTS projects (
@@ -785,13 +921,11 @@ CREATE INDEX IF NOT EXISTS note_edges_target_idx ON note_edges(project_id, targe
 CREATE TABLE IF NOT EXISTS schema_state (version INTEGER PRIMARY KEY);
 `;
 function openMemoryDatabase(path) {
-  const db = new Database2(path, { create: true });
-  chmodSync2(path, 384);
+  let db = openDatabase(path);
+  let dbOpen = true;
   let lock;
   let backup;
   try {
-    db.exec("PRAGMA busy_timeout=5000");
-    db.exec("PRAGMA journal_mode=WAL");
     const existingVersion = getSchemaVersion(db);
     if (existingVersion && existingVersion.version > SCHEMA_VERSION) {
       throw new Error(`database schema v${existingVersion.version} is newer than supported v${SCHEMA_VERSION}`);
@@ -799,19 +933,36 @@ function openMemoryDatabase(path) {
     const hasExistingData = hasLegacyV2(db) || hasTable2(db, "notes") || Boolean(existingVersion);
     if (!hasExistingData) {
       db.exec("PRAGMA foreign_keys=ON");
-      db.transaction(() => createSchemaV9(db))();
+      db.transaction(() => createSchema(db))();
       assertHealthyDatabase(db);
       return { db, close: () => db.close() };
     }
     if ((existingVersion?.version ?? 0) < SCHEMA_VERSION) {
+      db.close();
+      dbOpen = false;
       lock = acquireMigrationLock(path, SCHEMA_VERSION);
-      backup = createVerifiedBackup(db, path, existingVersion?.version ?? 2, SCHEMA_VERSION, "0.4.0-beta.1");
+      db = openDatabase(path);
+      dbOpen = true;
+      const migrationVersion = getSchemaVersion(db);
+      if (migrationVersion && migrationVersion.version > SCHEMA_VERSION) {
+        throw new Error(`database schema v${migrationVersion.version} is newer than supported v${SCHEMA_VERSION}`);
+      }
+      if ((migrationVersion?.version ?? 0) === SCHEMA_VERSION) {
+        lock.release();
+        lock = undefined;
+        db.exec("PRAGMA foreign_keys=ON");
+        db.exec(SCHEMA_TABLES);
+        db.exec(FTS_V9);
+        assertHealthyDatabase(db);
+        return { db, close: () => db.close() };
+      }
+      backup = createVerifiedBackup(db, path, migrationVersion?.version ?? 2, SCHEMA_VERSION, PRODUCT_VERSION);
       db.exec("PRAGMA foreign_keys=OFF");
-      if (!existingVersion && hasLegacyV2(db)) {
+      if (!migrationVersion && hasLegacyV2(db)) {
         db.exec(DDL);
         db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(id UNINDEXED, title, summary, content, tokenize='unicode61')");
         migrateFromV2(db, path);
-      } else if (!existingVersion) {
+      } else if (!migrationVersion) {
         db.exec(DDL);
         db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(id UNINDEXED, title, summary, content, tokenize='unicode61')");
         db.transaction(() => {
@@ -819,14 +970,18 @@ function openMemoryDatabase(path) {
           db.query("DELETE FROM schema_state").run();
           db.query("INSERT INTO schema_state (version) VALUES (8)").run();
         })();
-      } else if (existingVersion.version < 8) {
+      } else if (migrationVersion.version < 8) {
         db.exec(DDL);
         db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(id UNINDEXED, title, summary, content, tokenize='unicode61')");
         migrateToV8(db);
       }
-      const version = getSchemaVersion(db)?.version ?? 8;
-      if (version < 9)
+      let version = getSchemaVersion(db)?.version ?? 8;
+      if (version < 9) {
         db.transaction(() => migrateV8ToV9(db))();
+        version = 9;
+      }
+      if (version < 10)
+        db.transaction(() => migrateV9ToV10(db))();
       db.exec("PRAGMA foreign_keys=ON");
       if (db.query("PRAGMA foreign_keys").get().foreign_keys !== 1) {
         throw new Error("failed to enable database foreign keys");
@@ -838,13 +993,14 @@ function openMemoryDatabase(path) {
       return { db, close: () => db.close() };
     }
     db.exec("PRAGMA foreign_keys=ON");
-    db.exec(SCHEMA_V9_TABLES);
+    db.exec(SCHEMA_TABLES);
     db.exec(FTS_V9);
     assertHealthyDatabase(db);
     db.exec("PRAGMA foreign_keys=ON");
     return { db, close: () => db.close() };
   } catch (error) {
-    db.close();
+    if (dbOpen)
+      db.close();
     if (backup) {
       try {
         restoreVerifiedBackup(backup.manifestPath, path, "RESTORE_DATABASE_FROM_VERIFIED_BACKUP");
@@ -857,6 +1013,18 @@ function openMemoryDatabase(path) {
     lock?.release();
   }
 }
+function openDatabase(path) {
+  const db = new Database2(path, { create: true });
+  try {
+    chmodSync2(path, 384);
+    db.exec("PRAGMA busy_timeout=5000");
+    db.exec("PRAGMA journal_mode=WAL");
+    return db;
+  } catch (error) {
+    db.close();
+    throw error;
+  }
+}
 function getSchemaVersion(db) {
   if (!hasTable2(db, "schema_state"))
     return;
@@ -1159,7 +1327,7 @@ function count(db, sql, ...bindings) {
 }
 
 // src/retrieval/derived.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 
 // src/capture/redact.ts
 var RULES = [
@@ -1190,15 +1358,15 @@ function redactText(value, options = {}) {
   let replacements = 0;
   let highRisk = 0;
   const classes = {};
-  for (const literal of options.denylist ?? []) {
-    if (!literal)
+  for (const literal2 of options.denylist ?? []) {
+    if (!literal2)
       continue;
-    const count2 = text.split(literal).length - 1;
+    const count2 = text.split(literal2).length - 1;
     if (count2 === 0)
       continue;
     replacements += count2;
     classes.denylist = (classes.denylist ?? 0) + count2;
-    text = text.replaceAll(literal, "[REDACTED:denylist]");
+    text = text.replaceAll(literal2, "[REDACTED:denylist]");
   }
   for (const rule of RULES) {
     text = text.replace(rule.pattern, () => {
@@ -1248,7 +1416,7 @@ function deriveDocument(source) {
   const content = redactText(source.content);
   if (title.quarantined || summary.quarantined || content.quarantined)
     return;
-  const contentHash = createHash4("sha256").update(`${source.kind}\x00${title.text}\x00${summary.text}\x00${content.text}`, "utf8").digest("hex");
+  const contentHash = createHash5("sha256").update(`${source.kind}\x00${title.text}\x00${summary.text}\x00${content.text}`, "utf8").digest("hex");
   return {
     projectID: source.projectID,
     noteID: source.noteID,
@@ -1282,7 +1450,7 @@ async function runAdmin(argv = process.argv.slice(2)) {
     const db = new Database3(databasePath);
     try {
       const version = schemaVersion(db);
-      return createVerifiedBackup(db, databasePath, version, version, "0.4.0-beta.1");
+      return createVerifiedBackup(db, databasePath, version, version, PRODUCT_VERSION);
     } finally {
       db.close();
       lock.release();
@@ -1390,7 +1558,7 @@ async function runAdmin(argv = process.argv.slice(2)) {
   if (command === "backup" && subcommand === "prune") {
     const entries = backupEntries(databasePath);
     const root = resolve2(`${databasePath}.backup`);
-    const digest = createHash5("sha256").update(`${resolve2(databasePath)}\x00${root}
+    const digest = createHash6("sha256").update(`${resolve2(databasePath)}\x00${root}
 ${entries.map((entry) => `${basename2(entry.manifest)}\x00${basename2(entry.database)}\x00${entry.sha256}\x00${entry.size}\x00${entry.manifestHash}`).join(`
 `)}`).digest("hex");
     if (option(argv, "--confirm") !== "DELETE_VERIFIED_BACKUPS") {
@@ -1472,7 +1640,7 @@ function verifiedBackupEntry(root, manifest) {
     database: verified.databasePath,
     sha256: verified.manifest.sha256,
     size: verified.manifest.size,
-    manifestHash: createHash5("sha256").update(bytes).digest("hex")
+    manifestHash: createHash6("sha256").update(bytes).digest("hex")
   };
 }
 if (import.meta.main) {