open-memex 0.1.0

package/src/capture/keywords.ts

@@ -0,0 +1,34 @@
+import type { MyOMemoryConfig } from "../config.ts";
+
+export interface KeywordHit {
+  content: string;
+  pattern: string;
+}
+
+/**
+ * Scan user text for memory-capture keyword triggers.
+ * Each pattern must have a single capture group whose value becomes the memory body.
+ */
+export function detectKeywords(userText: string, cfg: MyOMemoryConfig): KeywordHit[] {
+  if (!cfg.keywordCaptureEnabled) return [];
+  const hits: KeywordHit[] = [];
+  const lines = userText.split(/\r?\n/);
+  for (const src of cfg.keywordPatterns) {
+    let re: RegExp;
+    try {
+      re = new RegExp(src, "i");
+    } catch {
+      continue;
+    }
+    for (const line of lines) {
+      const m = line.match(re);
+      if (!m || !m[1]) continue;
+      const content = m[1].trim().replace(/[.!?]$/, "").trim();
+      if (content.length >= 3 && content.length <= 2000) {
+        hits.push({ content, pattern: src });
+        break; // one hit per pattern per message
+      }
+    }
+  }
+  return hits;
+}

package/src/cli.ts

@@ -0,0 +1,264 @@
+#!/usr/bin/env node
+// Run with:  node --experimental-strip-types src/cli.ts <command>
+import { resolveProjectScope, resolveCwdScope, USER_SCOPE } from "./scope.ts";
+import { db, closeDb } from "./store/db.ts";
+import { syncScope, upsertFromFile, deleteFromIndex } from "./store/sync.ts";
+import { migrateScope, scopeHasFiles, type ConflictStrategy } from "./store/migrate.ts";
+import { search, list } from "./retrieve/search.ts";
+import {
+  writeMemoryFile,
+  readMemoryFile,
+  deleteMemoryFile,
+  ulid,
+  type Frontmatter,
+} from "./store/markdown.ts";
+import { loadConfig } from "./config.ts";
+import { paths } from "./paths.ts";
+import { redact } from "./redact.ts";
+import fs from "node:fs";
+
+function usage(): never {
+  console.log(`open-memex CLI
+
+Usage:
+  node --experimental-strip-types src/cli.ts where
+  node --experimental-strip-types src/cli.ts list [--scope project|user] [--type T] [--limit N]
+  node --experimental-strip-types src/cli.ts search "query" [--scope project|user|both] [--type T] [--limit N]
+  node --experimental-strip-types src/cli.ts add "content" [--scope project|user] [--type T] [--tag t1,t2]
+  node --experimental-strip-types src/cli.ts forget <id>
+  node --experimental-strip-types src/cli.ts reindex
+  node --experimental-strip-types src/cli.ts scopes
+  node --experimental-strip-types src/cli.ts migrate [--from <key>] [--to <key>]
+                                          [--dry-run] [--on-conflict newer|overwrite|skip]
+
+Scope defaults to \`project\` (derived from cwd's git remote or path).
+\`scopes\` lists every project scope dir with its file count — use it to find
+the \`--from\` key when migrating.
+\`migrate\` moves memories between scope keys — useful when a repo gains a
+git remote after memories were already stored under the cwd-based key.`);
+  process.exit(1);
+}
+
+function parseFlags(argv: string[]): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]!;
+    if (a.startsWith("--")) {
+      const key = a.slice(2);
+      const val = argv[i + 1];
+      if (val !== undefined && !val.startsWith("--")) {
+        out[key] = val;
+        i++;
+      } else {
+        out[key] = "true";
+      }
+    }
+  }
+  return out;
+}
+
+async function main() {
+  const [cmd, ...rest] = process.argv.slice(2);
+  if (!cmd) usage();
+
+  const cfg = loadConfig();
+  const project = resolveProjectScope(process.cwd());
+  db();
+
+  if (cmd === "where") {
+    const p = paths();
+    console.log(`root:      ${p.root}`);
+    console.log(`memories:  ${p.memories}`);
+    console.log(`index:     ${p.indexDb}`);
+    console.log(`project:   ${project.key}`);
+    console.log(`user:      ${USER_SCOPE.key}`);
+    return;
+  }
+
+  if (cmd === "reindex") {
+    const a = syncScope(project.key);
+    const b = syncScope(USER_SCOPE.key);
+    console.log(
+      `reindexed. project: +${a.added} ~${a.updated} -${a.removed} (scanned ${a.scanned}), user: +${b.added} ~${b.updated} -${b.removed} (scanned ${b.scanned})`,
+    );
+    return;
+  }
+
+  if (cmd === "list") {
+    const flags = parseFlags(rest);
+    const s = flags.scope === "user" ? USER_SCOPE : project;
+    syncScope(s.key);
+    const hits = list(s.key, {
+      type: flags.type,
+      limit: flags.limit ? Number(flags.limit) : undefined,
+    });
+    if (hits.length === 0) {
+      console.log(`(no memories in ${s.key})`);
+      return;
+    }
+    for (const h of hits) {
+      console.log(`[${h.type}] ${h.id}  ${h.snippet.replace(/\s+/g, " ").trim()}`);
+    }
+    return;
+  }
+
+  if (cmd === "search") {
+    const query = rest[0];
+    if (!query || query.startsWith("--")) usage();
+    const flags = parseFlags(rest.slice(1));
+    syncScope(project.key);
+    syncScope(USER_SCOPE.key);
+    const keys =
+      flags.scope === "user"
+        ? [USER_SCOPE.key]
+        : flags.scope === "project"
+          ? [project.key]
+          : [project.key, USER_SCOPE.key];
+    const hits = search(query, {
+      scopeKeys: keys,
+      limit: flags.limit ? Number(flags.limit) : undefined,
+      type: flags.type,
+    });
+    if (hits.length === 0) {
+      console.log("(no matches)");
+      return;
+    }
+    for (const h of hits) {
+      const tag = h.scope_key === USER_SCOPE.key ? "user" : "project";
+      console.log(`[${tag}/${h.type}] ${h.id}  ${h.snippet.replace(/\s+/g, " ").trim()}`);
+    }
+    return;
+  }
+
+  if (cmd === "add") {
+    const content = rest[0];
+    if (!content || content.startsWith("--")) usage();
+    const flags = parseFlags(rest.slice(1));
+    const s = flags.scope === "user" ? USER_SCOPE : project;
+    const { content: red, hadSecret, matchedPattern } = redact(content, cfg.redactPatterns);
+    if (hadSecret) {
+      console.error(`refused: content matched secret pattern (${matchedPattern}).`);
+      process.exit(2);
+    }
+    const now = Date.now();
+    const fm: Frontmatter = {
+      id: ulid(),
+      scope_key: s.key,
+      scope_kind: s.kind,
+      project_name: s.projectName,
+      type: flags.type ?? "note",
+      tags: flags.tag
+        ? flags.tag
+            .split(",")
+            .map((t) => t.trim())
+            .filter(Boolean)
+        : [],
+      source: "cli",
+      created_at: now,
+      updated_at: now,
+    };
+    const { filePath } = writeMemoryFile(fm, red);
+    const mf = readMemoryFile(filePath);
+    if (mf) upsertFromFile(mf);
+    console.log(`saved ${fm.id} -> ${filePath}`);
+    return;
+  }
+
+  if (cmd === "forget") {
+    const id = rest[0];
+    if (!id) usage();
+    const row = db().prepare(`SELECT scope_key FROM memories WHERE id = ?`).get(id) as
+      | { scope_key: string }
+      | undefined;
+    if (!row) {
+      console.error("not found");
+      process.exit(1);
+    }
+    deleteMemoryFile(row.scope_key, id);
+    deleteFromIndex(id);
+    console.log(`deleted ${id}`);
+    return;
+  }
+
+  if (cmd === "scopes") {
+    const { memories } = paths();
+    if (!fs.existsSync(memories)) {
+      console.log("(no memories dir yet)");
+      return;
+    }
+    const entries: Array<{ key: string; files: number; marker: string }> = [];
+    for (const name of fs.readdirSync(memories)) {
+      const dir = `${memories}/${name}`;
+      if (!fs.statSync(dir).isDirectory()) continue;
+      const files = fs.readdirSync(dir).filter((f) => f.endsWith(".md")).length;
+      const marker =
+        name === project.key ? " <- current project"
+        : name === USER_SCOPE.key ? " <- user"
+        : "";
+      entries.push({ key: name, files, marker });
+    }
+    entries.sort((a, b) => b.files - a.files);
+    for (const e of entries) {
+      console.log(`  ${e.files.toString().padStart(4)}  ${e.key}${e.marker}`);
+    }
+    return;
+  }
+
+  if (cmd === "migrate") {
+    const flags = parseFlags(rest);
+    const toKey = flags.to ?? project.key;
+
+    let fromKey = flags.from;
+    if (!fromKey) {
+      // Auto-detect: the "legacy" scope is what the key WOULD be if we
+      // ignored the git remote (pure cwd hash). Only offer it if it differs
+      // from the current project scope AND has files on disk.
+      const cwd = resolveCwdScope(process.cwd());
+      if (cwd.key !== project.key && scopeHasFiles(cwd.key)) {
+        fromKey = cwd.key;
+        console.log(`(auto-detected legacy scope: ${fromKey})`);
+      } else {
+        console.error(
+          `no --from given and no legacy cwd-based scope with files detected.\n` +
+            `current project scope: ${project.key}\n` +
+            `cwd-only scope:        ${cwd.key}`,
+        );
+        process.exit(2);
+      }
+    }
+
+    if (fromKey === toKey) {
+      console.error(`--from and --to are identical (${fromKey}); nothing to do.`);
+      process.exit(2);
+    }
+
+    const dryRun = flags["dry-run"] === "true";
+    const onConflict = flags["on-conflict"] as ConflictStrategy | undefined;
+    if (onConflict && !["newer", "overwrite", "skip"].includes(onConflict)) {
+      console.error(`invalid --on-conflict: ${onConflict}`);
+      process.exit(2);
+    }
+
+    const stats = migrateScope(fromKey, toKey, {
+      toProjectName: project.projectName,
+      dryRun,
+      onConflict,
+      logger: (m) => console.log(m),
+    });
+    console.log(
+      `${dryRun ? "DRY RUN: " : ""}moved ${stats.moved}, skipped ${stats.skipped}, conflicts ${stats.conflicts}`,
+    );
+    return;
+  }
+
+  usage();
+}
+
+main()
+  .catch((err) => {
+    console.error(err);
+    process.exit(1);
+  })
+  .finally(() => {
+    closeDb();
+  });

package/src/config.ts

@@ -0,0 +1,67 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+export interface MyOMemoryConfig {
+  maxProjectMemories: number;
+  maxProfileItems: number;
+  injectOnFirstTurn: boolean;
+  keywordCaptureEnabled: boolean;
+  keywordPatterns: string[];
+  redactPatterns: string[];
+  logLevel: "debug" | "info" | "warn" | "error";
+}
+
+export const DEFAULT_CONFIG: MyOMemoryConfig = {
+  maxProjectMemories: 8,
+  maxProfileItems: 5,
+  injectOnFirstTurn: true,
+  keywordCaptureEnabled: true,
+  keywordPatterns: [
+    "^\\s*remember(?:\\s+that)?[:,]?\\s+(.+)$",
+    "^\\s*(?:please\\s+)?(?:note|don'?t\\s+forget)(?:\\s+that)?[:,]?\\s+(.+)$",
+    "^\\s*TIL[:,]?\\s+(.+)$",
+    "^\\s*save\\s+(?:this|to\\s+memory)[:,]?\\s+(.+)$",
+  ],
+  redactPatterns: [
+    "sk-[A-Za-z0-9_-]{20,}",
+    "sm_[A-Za-z0-9_-]{20,}",
+    "ghp_[A-Za-z0-9]{30,}",
+    "gho_[A-Za-z0-9]{30,}",
+    "github_pat_[A-Za-z0-9_]{40,}",
+    "AKIA[0-9A-Z]{16}",
+    "xox[baprs]-[A-Za-z0-9-]{10,}",
+    "AIza[0-9A-Za-z_-]{30,}",
+  ],
+  logLevel: "info",
+};
+
+function stripJsonComments(raw: string): string {
+  // Line comments
+  let out = raw.replace(/^\s*\/\/.*$/gm, "");
+  // Block comments (non-greedy)
+  out = out.replace(/\/\*[\s\S]*?\*\//g, "");
+  // Trailing commas before closing brackets
+  out = out.replace(/,(\s*[}\]])/g, "$1");
+  return out;
+}
+
+export function loadConfig(): MyOMemoryConfig {
+  const candidates = [
+    process.env.MY_O_MEMORY_CONFIG,
+    path.join(os.homedir(), ".config", "opencode", "open-memex.jsonc"),
+    path.join(os.homedir(), ".config", "opencode", "open-memex.json"),
+  ].filter(Boolean) as string[];
+
+  for (const p of candidates) {
+    if (!fs.existsSync(p)) continue;
+    try {
+      const raw = fs.readFileSync(p, "utf8");
+      const parsed = JSON.parse(stripJsonComments(raw)) as Partial<MyOMemoryConfig>;
+      return { ...DEFAULT_CONFIG, ...parsed };
+    } catch (err) {
+      console.error(`[open-memex] failed to parse ${p}:`, err);
+    }
+  }
+  return DEFAULT_CONFIG;
+}

package/src/index.ts

@@ -0,0 +1,106 @@
+import type { Plugin } from "@opencode-ai/plugin";
+import { loadConfig } from "./config.ts";
+import { resolveProjectScope, resolveCwdScope, USER_SCOPE, type Scope } from "./scope.ts";
+import { db } from "./store/db.ts";
+import { syncScope, upsertFromFile } from "./store/sync.ts";
+import { scopeHasFiles } from "./store/migrate.ts";
+import {
+  writeMemoryFile,
+  readMemoryFile,
+  ulid,
+  type Frontmatter,
+} from "./store/markdown.ts";
+import { buildContextBlock } from "./retrieve/inject.ts";
+import { detectKeywords } from "./capture/keywords.ts";
+import { redact } from "./redact.ts";
+import { makeTools } from "./tools/memory.ts";
+
+const plugin: Plugin = async ({ worktree, directory }) => {
+  const cfg = loadConfig();
+  const roots = worktree || directory || process.cwd();
+  const scope: Scope = resolveProjectScope(roots);
+
+  // Init DB and one-shot sync of markdown -> index on plugin load.
+  try {
+    db();
+    syncScope(scope.key);
+    syncScope(USER_SCOPE.key);
+    if (cfg.logLevel === "debug") {
+      console.log(`[open-memex] loaded. scope=${scope.key}`);
+    }
+    // If a git remote was added *after* memories were first captured, the
+    // scope key changes (cwd-hash -> origin-hash). Detect the legacy dir on
+    // disk and tell the user how to migrate. We do NOT auto-migrate: two
+    // different repos at the same cwd would collide.
+    const cwdScope = resolveCwdScope(roots);
+    if (cwdScope.key !== scope.key && scopeHasFiles(cwdScope.key)) {
+      console.warn(
+        `[open-memex] found memories under legacy scope key "${cwdScope.key}". ` +
+          `Current project scope is "${scope.key}". ` +
+          `To move them: npm run cli -- migrate --from ${cwdScope.key}`,
+      );
+    }
+  } catch (err) {
+    console.error("[open-memex] init failed:", err);
+  }
+
+  const tools = makeTools(() => scope, cfg);
+  const injectedSessions = new Set<string>();
+
+  return {
+    tool: tools,
+
+    async "chat.message"(_input, output) {
+      if (!cfg.keywordCaptureEnabled) return;
+      const parts = (output.parts ?? []) as Array<{ type: string; text?: string }>;
+      const text = parts
+        .map((p) => (p?.type === "text" ? p.text ?? "" : ""))
+        .filter(Boolean)
+        .join("\n");
+      if (!text) return;
+
+      const hits = detectKeywords(text, cfg);
+      for (const h of hits) {
+        const { content, hadSecret } = redact(h.content, cfg.redactPatterns);
+        if (hadSecret || content.length === 0) continue;
+        const now = Date.now();
+        const fm: Frontmatter = {
+          id: ulid(),
+          scope_key: scope.key,
+          scope_kind: scope.kind,
+          project_name: scope.projectName,
+          type: "note",
+          tags: ["keyword"],
+          source: "keyword",
+          created_at: now,
+          updated_at: now,
+        };
+        try {
+          const { filePath } = writeMemoryFile(fm, content);
+          const mf = readMemoryFile(filePath);
+          if (mf) upsertFromFile(mf);
+          if (cfg.logLevel === "debug") {
+            console.log(`[open-memex] captured keyword memory ${fm.id}`);
+          }
+        } catch (err) {
+          console.error("[open-memex] keyword capture failed:", err);
+        }
+      }
+    },
+
+    async "experimental.chat.system.transform"(input, output) {
+      if (!cfg.injectOnFirstTurn) return;
+      const sid = input.sessionID ?? "";
+      if (injectedSessions.has(sid)) return;
+      injectedSessions.add(sid);
+      try {
+        const block = buildContextBlock(scope, cfg);
+        if (block) output.system.push(block);
+      } catch (err) {
+        console.error("[open-memex] context injection failed:", err);
+      }
+    },
+  };
+};
+
+export default plugin;

package/src/paths.ts

@@ -0,0 +1,45 @@
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+
+function dataRoot(): string {
+  if (process.env.MY_O_MEMORY_HOME) return path.resolve(process.env.MY_O_MEMORY_HOME);
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+    return path.join(appData, "open-memex");
+  }
+  const xdg = process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share");
+  return path.join(xdg, "open-memex");
+}
+
+export interface Paths {
+  root: string;
+  memories: string;
+  indexDb: string;
+}
+
+let _cached: Paths | null = null;
+
+export function paths(): Paths {
+  if (_cached) return _cached;
+  const root = dataRoot();
+  const memories = path.join(root, "memories");
+  const indexDb = path.join(root, "index.db");
+  fs.mkdirSync(memories, { recursive: true });
+  _cached = { root, memories, indexDb };
+  return _cached;
+}
+
+export function memoriesDirFor(scopeKey: string): string {
+  const { memories } = paths();
+  const dir = path.join(memories, scopeKey);
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+/** Same as `memoriesDirFor` but never creates the directory. For read-only
+ *  callers (iteration, existence checks) that must not pollute storage. */
+export function memoriesDirPath(scopeKey: string): string {
+  const { memories } = paths();
+  return path.join(memories, scopeKey);
+}

package/src/redact.ts

@@ -0,0 +1,24 @@
+export function stripPrivate(text: string): string {
+  return text.replace(/<private>[\s\S]*?<\/private>/gi, "[REDACTED]");
+}
+
+export function findSecret(text: string, patterns: string[]): string | null {
+  for (const p of patterns) {
+    try {
+      const re = new RegExp(p);
+      if (re.test(text)) return p;
+    } catch {
+      // ignore malformed regex
+    }
+  }
+  return null;
+}
+
+export function redact(
+  text: string,
+  patterns: string[],
+): { content: string; hadSecret: boolean; matchedPattern: string | null } {
+  const stripped = stripPrivate(text);
+  const matched = findSecret(stripped, patterns);
+  return { content: stripped, hadSecret: matched !== null, matchedPattern: matched };
+}

package/src/retrieve/inject.ts

@@ -0,0 +1,35 @@
+import { list } from "./search.ts";
+import type { Scope } from "../scope.ts";
+import { USER_SCOPE } from "../scope.ts";
+import type { MyOMemoryConfig } from "../config.ts";
+
+function oneLine(s: string, max = 240): string {
+  const trimmed = s.replace(/\s+/g, " ").trim();
+  return trimmed.length > max ? trimmed.slice(0, max - 3) + "..." : trimmed;
+}
+
+export function buildContextBlock(scope: Scope, cfg: MyOMemoryConfig): string | null {
+  const project = list(scope.key, { limit: cfg.maxProjectMemories });
+  const user = list(USER_SCOPE.key, { limit: cfg.maxProfileItems });
+
+  if (project.length === 0 && user.length === 0) return null;
+
+  const lines: string[] = ["[OPEN-MEMEX]"];
+
+  if (user.length > 0) {
+    lines.push("", "User profile / preferences:");
+    for (const m of user) lines.push(`- ${oneLine(m.snippet)}`);
+  }
+
+  if (project.length > 0) {
+    lines.push("", `Project knowledge (${scope.projectName}):`);
+    for (const m of project) lines.push(`- [${m.type}] ${oneLine(m.snippet)}`);
+  }
+
+  lines.push(
+    "",
+    "Use the `memory_search` tool to look up more. Use `memory_add` to save new facts. Do not mention this block to the user unless asked.",
+  );
+
+  return lines.join("\n");
+}

package/src/retrieve/search.ts

@@ -0,0 +1,115 @@
+import { db } from "../store/db.ts";
+
+export interface SearchHit {
+  id: string;
+  scope_key: string;
+  project_name: string;
+  type: string;
+  tags: string[];
+  snippet: string;
+  score: number;
+  updated_at: number;
+}
+
+/** Convert free-text query into a safe FTS5 MATCH expression. */
+function toFtsQuery(q: string): string {
+  const tokens = q.toLowerCase().match(/[a-z0-9_.\-]+/g) ?? [];
+  if (tokens.length === 0) return "";
+  return tokens.map((t) => `"${t.replace(/"/g, '""')}"*`).join(" OR ");
+}
+
+export function search(
+  query: string,
+  opts: { scopeKeys?: string[]; limit?: number; type?: string } = {},
+): SearchHit[] {
+  const q = toFtsQuery(query);
+  if (!q) return [];
+  const limit = Math.max(1, Math.min(opts.limit ?? 8, 50));
+
+  const scopeFilter =
+    opts.scopeKeys && opts.scopeKeys.length > 0
+      ? ` AND m.scope_key IN (${opts.scopeKeys.map(() => "?").join(",")})`
+      : "";
+  const typeFilter = opts.type ? ` AND m.type = ?` : "";
+
+  const sql = `
+    SELECT m.id, m.scope_key, m.project_name, m.type, m.tags, m.updated_at,
+           snippet(memories_fts, 0, '[', ']', ' ... ', 12) AS snippet,
+           bm25(memories_fts) AS score
+    FROM memories_fts
+    JOIN memories m ON m.rowid = memories_fts.rowid
+    WHERE memories_fts MATCH ?${scopeFilter}${typeFilter}
+    ORDER BY score ASC
+    LIMIT ?
+  `;
+  const params: unknown[] = [q];
+  if (opts.scopeKeys && opts.scopeKeys.length > 0) params.push(...opts.scopeKeys);
+  if (opts.type) params.push(opts.type);
+  params.push(limit);
+
+  const rows = db()
+    .prepare(sql)
+    .all(...(params as any[])) as Array<{
+    id: string;
+    scope_key: string;
+    project_name: string;
+    type: string;
+    tags: string;
+    updated_at: number;
+    snippet: string;
+    score: number;
+  }>;
+
+  return rows.map((r) => ({
+    id: r.id,
+    scope_key: r.scope_key,
+    project_name: r.project_name,
+    type: r.type,
+    tags: r.tags ? r.tags.split(",").filter(Boolean) : [],
+    snippet: r.snippet ?? "",
+    score: -r.score, // FTS5 bm25: lower = better; invert for intuition
+    updated_at: r.updated_at,
+  }));
+}
+
+export function list(
+  scopeKey: string,
+  opts: { type?: string; limit?: number } = {},
+): SearchHit[] {
+  const limit = Math.max(1, Math.min(opts.limit ?? 20, 100));
+  const typeFilter = opts.type ? ` AND type = ?` : "";
+  const sql = `
+    SELECT id, scope_key, project_name, type, tags, updated_at,
+           substr(content, 1, 240) AS snippet
+    FROM memories
+    WHERE scope_key = ?${typeFilter}
+    ORDER BY updated_at DESC
+    LIMIT ?
+  `;
+  const params: unknown[] = [scopeKey];
+  if (opts.type) params.push(opts.type);
+  params.push(limit);
+
+  const rows = db()
+    .prepare(sql)
+    .all(...(params as any[])) as Array<{
+    id: string;
+    scope_key: string;
+    project_name: string;
+    type: string;
+    tags: string;
+    updated_at: number;
+    snippet: string;
+  }>;
+
+  return rows.map((r) => ({
+    id: r.id,
+    scope_key: r.scope_key,
+    project_name: r.project_name,
+    type: r.type,
+    tags: r.tags ? r.tags.split(",").filter(Boolean) : [],
+    snippet: r.snippet ?? "",
+    score: 1,
+    updated_at: r.updated_at,
+  }));
+}