@dzhi/ocpg 0.1.0

package/README.md

@@ -0,0 +1,56 @@
+# ocpg
+
+
+Postgres-backed persistent memory plugin for [OpenCode](https://opencode.ai). Replaces the previous Postgres MCP memory server — same database, same schema, no MCP process to run.
+
+Uses the existing `memories` table (`content`, `tags`, `session_id`, `project`, `created_at`, `search_vector`). Injects recent project memories into the system prompt and exposes `memory_recall` / `memory_remember` tools.
+
+## Install
+
+In `opencode.json`:
+
+```json
+{
+  "plugin": [
+    ["@dzhi/ocpg", {}]
+  ]
+}
+```
+
+## Connecting to the database
+
+Pass connection params as the plugin options tuple (all optional):
+
+```json
+{
+  "plugin": [
+    [
+      "@dzhi/ocpg",
+      {
+        "host": "localhost",
+        "port": 5432,
+        "user": "pguser",
+        "database": "agent-memory"
+      }
+    ]
+  ]
+}
+```
+
+Precedence: plugin options > env vars > defaults.
+
+| Param      | Env var (fallback) | Default        |
+| ---------- | ------------------ | -------------- |
+| `host`     | `OCPG_HOST`        | `localhost`    |
+| `port`     | `OCPG_PORT`        | `5432`         |
+| `user`     | `OCPG_USER`        | `pguser`       |
+| `database` | `OCPG_DB`          | `agent-memory` |
+
+**Password is never set via params** — it resolves from `OCPG_PASSWORD`, falling back to `pass show postgres-workstation-password`.
+
+## Tools
+
+- `memory_remember` — store a memory (dedups against similar entries per project)
+- `memory_recall` — search past memories (`query`, `global`, `limit`)
+
+Memories are project-scoped by working directory; use `global: true` on recall to search across projects.

package/ocpg.ts

@@ -0,0 +1,309 @@
+// ocpg - DB access layer for OpenCode persistent memory plugin.
+import { SQL } from "bun";
+import type { Plugin } from "@opencode-ai/plugin";
+import { tool } from "@opencode-ai/plugin";
+import { z } from "zod";
+
+// --- DB config: plugin options > env > defaults. Password is deliberately env-only (never in config).
+type DbOptions = {
+  host?: string;
+  port?: number;
+  user?: string;
+  database?: string;
+};
+type DbConfig = Required<DbOptions>;
+
+// Defaults resolved ONCE at module init — the pass lookup here is the only permitted spawn in this file.
+const defaultConfig: DbConfig = {
+  host: process.env.OCPG_HOST || "localhost",
+  port: Number(process.env.OCPG_PORT) || 5432,
+  user: process.env.OCPG_USER || "pguser",
+  database: process.env.OCPG_DB || "agent-memory",
+};
+const password =
+  process.env.OCPG_PASSWORD ||
+  Bun.spawnSync(["pass", "show", "postgres-workstation-password"])
+    .stdout.toString()
+    .trim();
+
+// Options-object constructor, not a URL string: Bun's SQL parses string URLs via
+// url.parse(), which emits the DEP0169 DeprecationWarning at plugin load under opencode.
+function makeSql(cfg: DbConfig): SQL {
+  return new SQL({
+    hostname: cfg.host,
+    port: cfg.port,
+    username: cfg.user,
+    password,
+    database: cfg.database,
+    max: 2,
+  });
+}
+
+let sql = makeSql(defaultConfig);
+
+// Swap the pool when the plugin loads with config options (["pentago/ocpg", {...}] in opencode.json).
+// No-op without options so the module-level env/default config stands. Pools are lazy — a never-connected pool closes cleanly.
+function reconfigure(options?: DbOptions): void {
+  if (!options) return;
+  void sql.close().catch(() => {});
+  sql = makeSql({ ...defaultConfig, ...options });
+}
+
+export interface MemoryRow {
+  id: number;
+  content: string;
+  tags: string[] | null;
+  project: string;
+  date: string;
+}
+
+// --- Rate-limited error logging ---
+
+const lastLogTime = new Map<string, number>();
+
+function rateLimitOk(kind: string): boolean {
+  const now = Date.now();
+  const last = lastLogTime.get(kind) ?? 0;
+  if (now - last < 60_000) return false;
+  lastLogTime.set(kind, now);
+  return true;
+}
+
+let pluginClient: { app: { log: (entry: unknown) => void } } | null = null;
+
+function setClient(client: { app: { log: (entry: unknown) => void } }): void {
+  pluginClient = client;
+}
+
+function logError(
+  client: { app: { log: (entry: unknown) => void } } | null,
+  message: string,
+): void {
+  const c = client ?? pluginClient;
+  if (!c?.app?.log) return;
+  if (!rateLimitOk("db-error")) return;
+  c.app.log({ body: { service: "ocpg", level: "error", message } });
+}
+
+// --- Injection pipeline ---
+
+function truncateMemory(content: string): string {
+  if (content.length <= 600) return content;
+  return content.slice(0, 600) + "…[truncated]";
+}
+
+function formatBlock(rows: MemoryRow[], projectDir: string): string {
+  const lines: string[] = [
+    "<persistent-project-memory>",
+    `Project: ${projectDir}`,
+    "Memories:",
+  ];
+  for (const row of rows) {
+    const tags = row.tags ?? [];
+    const tagStr = tags.length ? ` [${tags.join(", ")}]` : "";
+    lines.push(`- [${row.date}]${tagStr} ${truncateMemory(row.content)}`);
+  }
+  lines.push("");
+  lines.push(
+    "Before non-trivial work, check these. After user corrections, architecture decisions, or non-trivial fixes, call memory_remember. Use memory_recall to search past lessons.",
+  );
+  lines.push("</persistent-project-memory>");
+  return lines.join("\n");
+}
+
+const injectionCache = new Map<string, string>();
+
+async function handleTransform(
+  input: { sessionID?: string; model: Record<string, unknown> },
+  output: { system: string[] },
+  directory: string,
+): Promise<void> {
+  if (!input.sessionID) return;
+  const sid = input.sessionID;
+  const cached = injectionCache.get(sid);
+  if (cached !== undefined) {
+    output.system.push(cached);
+    return;
+  }
+  try {
+    const rows = await sql`
+      SELECT content, coalesce(tags, '{}') AS tags,
+             to_char(created_at, 'YYYY-MM-DD') AS date
+      FROM memories
+      WHERE project = ${directory}
+      ORDER BY created_at DESC
+      LIMIT 5
+    ` as MemoryRow[];
+    const block = formatBlock(rows, directory);
+    // Evict oldest entry when cache exceeds 32
+    if (injectionCache.size >= 32) {
+      const firstKey = injectionCache.keys().next().value!;
+      injectionCache.delete(firstKey);
+    }
+    injectionCache.set(sid, block);
+    output.system.push(block);
+  } catch (e: unknown) {
+    logError(null, `ocpg injection failed: ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
+
+// --- Dispose ---
+
+async function dispose(): Promise<void> {
+  await sql.close().catch(() => {});
+}
+
+// --- Agent tools: recall + remember with dedup-on-write ---
+
+function normalizeTags(tags: string[] | undefined, projectDir: string): string[] {
+  const input = tags ?? [];
+  const base = projectDir.split('/').pop() ?? projectDir;
+  return [...input, `project:${base}`];
+}
+
+async function recall(
+  args: { query?: string; global?: boolean; limit?: number },
+  ctx: { directory: string },
+): Promise<string> {
+  try {
+    const limit = Math.min(Math.max(args.limit ?? 5, 1), 20);
+    const projectCond = args.global
+      ? sql``
+      : sql`AND project = ${ctx.directory}`;
+    const queryCond = args.query
+      ? sql`AND search_vector @@ plainto_tsquery('english', ${args.query})`
+      : sql``;
+
+    const rows = await sql`
+      SELECT id, content, coalesce(tags, '{}') AS tags,
+             to_char(created_at, 'YYYY-MM-DD') AS date,
+             project
+      FROM memories
+      WHERE 1=1 ${projectCond} ${queryCond}
+      ORDER BY created_at DESC
+      LIMIT ${limit}
+    ` as MemoryRow[];
+
+    if (rows.length === 0) return "No memories found.";
+
+    return rows
+      .map((r) => {
+        const tags = r.tags ?? [];
+        const tagStr = tags.length ? ` (${tags.join(', ')})` : '';
+        return `[${r.date}] [${r.project}]${tagStr}\n#${r.id}\n${r.content}`;
+      })
+      .join('\n---\n');
+  } catch (e: unknown) {
+    logError(null, `ocpg recall failed: ${e instanceof Error ? e.message : String(e)}`);
+    return `ERROR: ${e instanceof Error ? e.message : String(e)}`;
+  }
+}
+
+async function remember(
+  args: { content: string; tags?: string[] },
+  ctx: { directory: string; sessionID: string },
+): Promise<string> {
+  try {
+    if (args.content.length < 10) {
+      return 'ERROR: content must be at least 10 characters.';
+    }
+
+    const normalizedTags = normalizeTags(args.tags, ctx.directory);
+    const basename = ctx.directory.split('/').pop() ?? ctx.directory;
+
+    // Dedup: project-scoped, common-opening-words AND-match via FTS
+    const dedup = await sql`
+      SELECT id FROM memories
+      WHERE project = ${ctx.directory}
+        AND (
+          content = ${args.content}
+          OR search_vector @@ plainto_tsquery('english', ${args.content.slice(0, 60)})
+        )
+      ORDER BY created_at DESC
+      LIMIT 1
+    ` as { id: number }[];
+
+    if (dedup.length > 0) {
+      // ponytail: dedup uses common-opening-words AND-match across rows via FTS
+      // so false positives are expected; upgrade path = pg_trgm similarity or
+      // wider dedup scope.
+      return `Similar memory already stored as #${dedup[0].id} for this project; skipping insert.`;
+    }
+
+    const inserted = await sql`
+      INSERT INTO memories (content, tags, session_id, project)
+      VALUES (${args.content}, ${normalizedTags}, ${ctx.sessionID}, ${ctx.directory})
+      RETURNING id
+    ` as { id: number }[];
+
+    invalidateInjection(ctx.sessionID);
+    return `Stored memory #${inserted[0].id} for project ${basename}.`;
+  } catch (e: unknown) {
+    logError(null, `ocpg remember failed: ${e instanceof Error ? e.message : String(e)}`);
+    return `ERROR: ${e instanceof Error ? e.message : String(e)}`;
+  }
+}
+
+function invalidateInjection(sessionID: string): void {
+  injectionCache.delete(sessionID);
+}
+
+const __internals = {
+  get sql() {
+    return sql;
+  },
+  reconfigure,
+  truncateMemory,
+  formatBlock,
+  handleTransform,
+  normalizeTags,
+  recall,
+  remember,
+  invalidateInjection,
+  logError,
+  rateLimitOk,
+  setClient,
+  dispose,
+};
+
+const plugin = (async (client, options) => {
+  setClient(client);
+  reconfigure(options as DbOptions | undefined);
+  return {
+    "experimental.chat.system.transform": async (input, output) => {
+      await handleTransform(input, output, client.directory);
+    },
+    tool: {
+      memory_recall: tool({
+        description:
+          "Search past memories stored for this project. Use before non-trivial work to check for relevant lessons, fixes, and decisions.",
+        args: {
+          query: z.string().optional(),
+          global: z.boolean().optional(),
+          limit: z.number().optional(),
+        },
+        execute: async (args, ctx) => {
+          return await recall(args, ctx);
+        },
+      }),
+      memory_remember: tool({
+        description:
+          "Store a memory for this project. Use after user corrections, architecture decisions, or non-trivial fixes.",
+        args: {
+          content: z.string().min(10),
+          tags: z.array(z.string()).optional(),
+        },
+        execute: async (args, ctx) => {
+          return await remember(args, ctx);
+        },
+      }),
+    },
+    dispose,
+  };
+}) satisfies Plugin;
+
+// Attach internals to the default export instead of as a named export: opencode's
+// plugin loader rejects modules whose exports aren't all plugin entry functions.
+export default Object.assign(plugin, { __internals }) as typeof plugin & {
+  __internals: typeof __internals;
+};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@dzhi/ocpg",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Postgres-backed persistent memory plugin for OpenCode",
+  "main": "ocpg.ts",
+  "exports": {
+    ".": "./ocpg.ts",
+    "./server": "./ocpg.ts"
+  },
+  "files": [
+    "ocpg.ts"
+  ],
+  "dependencies": {
+    "zod": "^4.1.8"
+  },
+  "keywords": [
+    "opencode-plugin",
+    "opencode",
+    "postgres",
+    "memory"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pentago/ocpg.git"
+  }
+}