opencode-codex-memory 0.1.2 → 0.1.5

package/src/capture.ts

@@ -1,137 +0,0 @@
-import { Database } from "bun:sqlite"
-import { opencodeDbPath } from "./paths.js"
-import { MemoryStore, SCAN_LIMIT } from "./store.js"
-
-export interface SessionRow {
-  id: string
-  updated_at: number
-  directory: string | null
-}
-
-let opencodeDb: Database | null = null
-
-function openOpencodeDb(): Database | null {
-  if (opencodeDb) return opencodeDb
-  const p = opencodeDbPath()
-  try {
-    opencodeDb = new Database(p, { readonly: true })
-  } catch {
-    opencodeDb = null
-  }
-  return opencodeDb
-}
-
-export function listRecentSessions(limit: number = SCAN_LIMIT): SessionRow[] {
-  const db = openOpencodeDb()
-  if (!db) return []
-  try {
-    // Top-level sessions only: task-tool children are summarized into their
-    // parent, and the plugin's own sub-sessions must never be memorized.
-    return db
-      .prepare(
-        `SELECT id, time_updated AS updated_at, directory FROM session
-         WHERE parent_id IS NULL AND title NOT LIKE 'codex-memory-%'
-         ORDER BY time_updated DESC LIMIT ?`,
-      )
-      .all(limit) as SessionRow[]
-  } catch {
-    return []
-  }
-}
-
-export interface TranscriptMessage {
-  type: string
-  role?: string
-  text?: string
-  seq: number
-}
-
-export function loadTranscript(sessionId: string): TranscriptMessage[] {
-  const db = openOpencodeDb()
-  if (!db) return []
-  try {
-    const rows = db
-      .prepare(
-        `SELECT p.data, m.data AS msg_data
-         FROM part p
-         JOIN message m ON p.message_id = m.id
-         WHERE p.session_id = ?
-         ORDER BY p.time_created ASC`,
-      )
-      .all(sessionId) as { data: string; msg_data: string }[]
-    return rows.map((r, i) => {
-      let parsed: any = {}
-      try {
-        parsed = JSON.parse(r.data)
-      } catch {
-      }
-      let role: string | undefined
-      try {
-        const msg = JSON.parse(r.msg_data)
-        role = msg.role
-      } catch {
-      }
-      return {
-        seq: i,
-        type: parsed.type ?? "unknown",
-        role,
-        text: extractText(parsed),
-      }
-    })
-  } catch {
-    return []
-  }
-}
-
-function extractText(msg: any): string | undefined {
-  if (!msg) return undefined
-  if (typeof msg.text === "string") return msg.text
-  if (msg.type === "tool") {
-    // Full tool payloads: codex serializes complete FunctionCall/Output items
-    // and relies solely on the global transcript truncation. Tool outputs are
-    // the extractor's strongest evidence — do not slice them per call.
-    const tool = msg.tool ?? "unknown"
-    const input = msg.state?.input ? JSON.stringify(msg.state.input) : ""
-    const output = typeof msg.state?.output === "string" ? msg.state.output : ""
-    return `[tool: ${tool}] ${input}${output ? "\n" + output : ""}`
-  }
-  if (msg.type === "step-start" || msg.type === "step-finish") return undefined
-  if (Array.isArray(msg.parts)) {
-    return msg.parts
-      .filter((p: any) => p?.type === "text" && typeof p.text === "string")
-      .map((p: any) => p.text)
-      .join("\n")
-  }
-  if (Array.isArray(msg.content)) {
-    return msg.content
-      .filter((c: any) => typeof c === "string" || typeof c?.text === "string")
-      .map((c: any) => (typeof c === "string" ? c : c.text))
-      .join("\n")
-  }
-  return undefined
-}
-
-export interface EligibilityOptions {
-  maxAgeDays: number
-  minIdleHours: number
-  excludeSession?: string
-}
-
-export function selectEligibleSessions(
-  store: MemoryStore,
-  opts: EligibilityOptions,
-): SessionRow[] {
-  const now = Date.now()
-  const minUpdated = now - opts.maxAgeDays * 24 * 60 * 60 * 1000
-  const maxUpdated = now - opts.minIdleHours * 60 * 60 * 1000
-  const sessions = listRecentSessions()
-  return sessions.filter((s) => {
-    if (opts.excludeSession && s.id === opts.excludeSession) return false
-    if (s.updated_at < minUpdated) return false
-    if (s.updated_at > maxUpdated) return false
-    const mode = store.getMemoryMode(s.id)
-    if (mode === "disabled") return false
-    if (store.isPolluted(s.id)) return false
-    return true
-  })
-}

package/src/citation.ts

@@ -1,94 +0,0 @@
-export interface MemoryCitationEntry {
-  path: string
-  lineStart: number
-  lineEnd: number
-  note: string
-}
-
-export interface ParsedCitation {
-  sessionIds: string[]
-  entries: MemoryCitationEntry[]
-  raw: string
-}
-
-const CITATION_BLOCK_RE = /<memory-citation>[\s\S]*?<\/memory-citation>/gi
-
-function extractSection(block: string, name: string): string | null {
-  const m = block.match(new RegExp(`<${name}>([\\s\\S]*?)</${name}>`, "i"))
-  return m ? m[1] : null
-}
-
-function parseEntry(line: string): MemoryCitationEntry | null {
-  const trimmed = line.trim()
-  if (!trimmed) return null
-  const noteSplit = trimmed.lastIndexOf("|note=[")
-  if (noteSplit === -1 || !trimmed.endsWith("]")) return null
-  const location = trimmed.slice(0, noteSplit)
-  const note = trimmed.slice(noteSplit + "|note=[".length, -1).trim()
-  const colon = location.lastIndexOf(":")
-  if (colon === -1) return null
-  const path = location.slice(0, colon).trim()
-  const range = location.slice(colon + 1)
-  const dash = range.indexOf("-")
-  if (dash === -1) return null
-  const lineStart = Number.parseInt(range.slice(0, dash).trim(), 10)
-  const lineEnd = Number.parseInt(range.slice(dash + 1).trim(), 10)
-  if (!path || Number.isNaN(lineStart) || Number.isNaN(lineEnd)) return null
-  return { path, lineStart, lineEnd, note }
-}
-
-export function parseCitations(text: string): ParsedCitation[] {
-  const results: ParsedCitation[] = []
-  const re = new RegExp(CITATION_BLOCK_RE)
-  let m: RegExpExecArray | null
-  while ((m = re.exec(text)) !== null) {
-    const raw = m[0]
-    const entries: MemoryCitationEntry[] = []
-    const sessionIds: string[] = []
-    const seen = new Set<string>()
-
-    const entriesBlock = extractSection(raw, "citation_entries")
-    if (entriesBlock) {
-      for (const line of entriesBlock.split(/\r?\n/)) {
-        const entry = parseEntry(line)
-        if (entry) entries.push(entry)
-      }
-    }
-
-    const idsBlock = extractSection(raw, "session_ids")
-    if (idsBlock) {
-      for (const line of idsBlock.split(/\r?\n/)) {
-        const id = line.trim()
-        if (id && !seen.has(id)) {
-          seen.add(id)
-          sessionIds.push(id)
-        }
-      }
-    } else if (entriesBlock && entries.length === 0) {
-      // Legacy format: <citation_entries> held a comma-separated session-id list.
-      for (const id of entriesBlock.split(",").map((s) => s.trim()).filter(Boolean)) {
-        if (!seen.has(id)) {
-          seen.add(id)
-          sessionIds.push(id)
-        }
-      }
-    }
-
-    if (entries.length > 0 || sessionIds.length > 0) {
-      results.push({ sessionIds, entries, raw })
-    }
-  }
-  return results
-}
-
-export function extractCitedSessionIds(text: string): string[] {
-  const seen = new Set<string>()
-  for (const c of parseCitations(text)) {
-    for (const id of c.sessionIds) seen.add(id)
-  }
-  return Array.from(seen)
-}
-
-export function stripCitations(text: string): string {
-  return text.replace(CITATION_BLOCK_RE, "").replace(/[ \t]*\n{3,}/g, "\n\n").trimEnd()
-}

package/src/db.ts

@@ -1,84 +0,0 @@
-import { Database } from "bun:sqlite"
-import { memoryDbPath } from "./paths.js"
-
-export const SCHEMA_V1 = [
-  `CREATE TABLE IF NOT EXISTS memory_stage1_outputs (
-    session_id TEXT PRIMARY KEY,
-    source_updated_at INTEGER NOT NULL,
-    raw_memory TEXT NOT NULL,
-    rollout_summary TEXT NOT NULL,
-    rollout_slug TEXT,
-    cwd TEXT,
-    generated_at INTEGER NOT NULL,
-    usage_count INTEGER DEFAULT 0,
-    last_usage INTEGER,
-    selected_for_phase2 INTEGER NOT NULL DEFAULT 0,
-    selected_for_phase2_source_updated_at INTEGER
-  )`,
-  `CREATE INDEX IF NOT EXISTS idx_memory_stage1_source_updated_at
-    ON memory_stage1_outputs(source_updated_at DESC, session_id DESC)`,
-  `CREATE TABLE IF NOT EXISTS memory_jobs (
-    kind TEXT NOT NULL,
-    job_key TEXT NOT NULL,
-    status TEXT NOT NULL,
-    worker_id TEXT,
-    ownership_token TEXT,
-    started_at INTEGER,
-    finished_at INTEGER,
-    lease_until INTEGER,
-    retry_at INTEGER,
-    retry_remaining INTEGER NOT NULL,
-    last_error TEXT,
-    input_watermark INTEGER,
-    last_success_watermark INTEGER,
-    PRIMARY KEY (kind, job_key)
-  )`,
-  `CREATE INDEX IF NOT EXISTS idx_memory_jobs_kind_status_retry_lease
-    ON memory_jobs(kind, status, retry_at, lease_until)`,
-  `CREATE TABLE IF NOT EXISTS memory_session_meta (
-    session_id TEXT PRIMARY KEY,
-    memory_mode TEXT NOT NULL DEFAULT 'enabled',
-    polluted INTEGER NOT NULL DEFAULT 0,
-    updated_at INTEGER NOT NULL
-  )`,
-]
-
-let dbInstance: Database | null = null
-
-export function openDb(): Database {
-  if (dbInstance) return dbInstance
-  const dbPath = memoryDbPath()
-  const db = new Database(dbPath, { create: true, readwrite: true, strict: false })
-  // Match codex's memories-DB open options (runtime.rs): WAL, NORMAL sync,
-  // 5s busy timeout for cross-process access, incremental auto-vacuum.
-  db.exec("PRAGMA journal_mode=WAL")
-  db.exec("PRAGMA synchronous=NORMAL")
-  db.exec("PRAGMA busy_timeout=5000")
-  db.exec("PRAGMA auto_vacuum=INCREMENTAL")
-  runMigrations(db)
-  dbInstance = db
-  return db
-}
-
-function runMigrations(db: Database): void {
-  db.exec(`CREATE TABLE IF NOT EXISTS schema_version (
-    version INTEGER NOT NULL,
-    applied_at INTEGER NOT NULL
-  )`)
-  const current = db.prepare("SELECT version FROM schema_version ORDER BY version DESC LIMIT 1").get() as { version: number } | null
-  const currentVersion = current?.version ?? 0
-  if (currentVersion >= 1) return
-  for (const stmt of SCHEMA_V1) db.exec(stmt)
-  db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (?, ?)").run(1, Date.now())
-}
-
-export function closeDb(): void {
-  if (dbInstance) {
-    dbInstance.close()
-    dbInstance = null
-  }
-}
-
-export function resetDbForTest(): void {
-  closeDb()
-}

package/src/git-baseline.ts

@@ -1,162 +0,0 @@
-import fs from "fs"
-import path from "path"
-import { memoryRoot } from "./paths.js"
-import * as isogit from "isomorphic-git"
-import { createPatch } from "diff"
-
-const AUTHOR = { name: "opencode-codex-memory", email: "memory@opencode.local" }
-
-// Generated prompt artifact; removed before diffing and before baseline
-// commits (mirrors codex's remove_workspace_diff) so it never enters the
-// baseline history or shows up as memory content.
-export const DIFF_ARTIFACT = "phase2_workspace_diff.md"
-
-export interface WorkspaceChange {
-  status: "A" | "M" | "D"
-  path: string
-}
-
-export interface WorkspaceDiff {
-  changes: WorkspaceChange[]
-  unifiedDiff: string
-}
-
-function removeDiffArtifact(dir: string): void {
-  try {
-    fs.unlinkSync(path.join(dir, DIFF_ARTIFACT))
-  } catch {
-  }
-}
-
-async function ensureInit(dir: string): Promise<void> {
-  const gitDir = path.join(dir, ".git")
-  if (!fs.existsSync(gitDir)) {
-    await isogit.init({ fs, dir })
-  }
-}
-
-// statusMatrix rows are [filepath, head, workdir, stage]; head !== workdir
-// means the working tree differs from HEAD (added, modified, or deleted).
-async function stageAll(dir: string): Promise<number> {
-  const matrix = await isogit.statusMatrix({ fs, dir })
-  let changes = 0
-  for (const [filepath, head, workdir, stage] of matrix) {
-    if (head === 1 && workdir === 1 && stage === 1) continue
-    if (workdir === 0) {
-      // isogit.add throws on deleted files; they must be staged via remove
-      await isogit.remove({ fs, dir, filepath })
-    } else {
-      await isogit.add({ fs, dir, filepath })
-    }
-    if (head !== workdir) changes++
-  }
-  return changes
-}
-
-async function hasHeadCommit(dir: string): Promise<boolean> {
-  try {
-    await isogit.resolveRef({ fs, dir, ref: "HEAD" })
-    return true
-  } catch {
-    return false
-  }
-}
-
-async function commitBaseline(dir: string): Promise<string> {
-  await stageAll(dir)
-  return isogit.commit({ fs, dir, message: "memory baseline", author: AUTHOR })
-}
-
-/**
- * Mirrors codex prepare_memory_workspace: an existing baseline is preserved
- * untouched so the phase-2 diff spans last-successful-run -> now — including
- * manual user edits and newly added ad-hoc notes. Committing here would
- * swallow those changes and consolidation would never see them. Only a root
- * without any commit gets a fresh baseline.
- */
-export async function ensureBaseline(): Promise<boolean> {
-  try {
-    const dir = memoryRoot()
-    removeDiffArtifact(dir)
-    await ensureInit(dir)
-    if (!(await hasHeadCommit(dir))) {
-      await commitBaseline(dir)
-    }
-    return true
-  } catch (err) {
-    console.error("[opencode-codex-memory] ensureBaseline error:", err)
-    return false
-  }
-}
-
-async function readBaselineText(dir: string, headOid: string, filepath: string): Promise<string> {
-  try {
-    const { blob } = await isogit.readBlob({ fs, dir, oid: headOid, filepath })
-    return new TextDecoder().decode(blob)
-  } catch {
-    return ""
-  }
-}
-
-function readWorkdirText(dir: string, filepath: string): string {
-  try {
-    return fs.readFileSync(path.join(dir, filepath), "utf8")
-  } catch {
-    return ""
-  }
-}
-
-export async function captureWorkspaceDiff(): Promise<WorkspaceDiff> {
-  try {
-    const dir = memoryRoot()
-    await ensureInit(dir)
-    removeDiffArtifact(dir)
-    const matrix = await isogit.statusMatrix({ fs, dir })
-    const changedRows = matrix.filter(
-      ([filepath, head, workdir]) => head !== workdir && filepath !== DIFF_ARTIFACT,
-    )
-    const changes: WorkspaceChange[] = changedRows.map(([filepath, head, workdir]) => {
-      if (head === 0) return { status: "A", path: filepath }
-      if (workdir === 0) return { status: "D", path: filepath }
-      return { status: "M", path: filepath }
-    })
-
-    let headOid: string | null = null
-    try {
-      headOid = await isogit.resolveRef({ fs, dir, ref: "HEAD" })
-    } catch {
-      // no commits yet — every file diffs against empty
-    }
-    const patches: string[] = []
-    for (const [filepath, head, workdir] of changedRows) {
-      const oldText = head === 1 && headOid ? await readBaselineText(dir, headOid, filepath) : ""
-      const newText = workdir === 0 ? "" : readWorkdirText(dir, filepath)
-      // No per-file cap: codex renders every file's patch in full and relies
-      // on the global 4 MiB truncation in writeWorkspaceDiff.
-      patches.push(createPatch(filepath, oldText, newText))
-    }
-    return { changes, unifiedDiff: patches.join("\n") }
-  } catch (err) {
-    console.error("[opencode-codex-memory] captureWorkspaceDiff error:", err)
-    return { changes: [], unifiedDiff: "" }
-  }
-}
-
-/**
- * Mirrors codex reset_git_repository: delete .git and re-create a fresh
- * single-commit baseline so deleted/redacted memory content is not retained
- * in unreachable git objects (history is intentionally dropped).
- */
-export async function resetBaseline(): Promise<boolean> {
-  try {
-    const dir = memoryRoot()
-    removeDiffArtifact(dir)
-    fs.rmSync(path.join(dir, ".git"), { recursive: true, force: true })
-    await isogit.init({ fs, dir })
-    await commitBaseline(dir)
-    return true
-  } catch (err) {
-    console.error("[opencode-codex-memory] resetBaseline error:", err)
-    return false
-  }
-}