open-memex 0.1.0

package/src/scope.ts

@@ -0,0 +1,76 @@
+import { execSync } from "node:child_process";
+import crypto from "node:crypto";
+import path from "node:path";
+
+export interface Scope {
+  key: string;
+  kind: "user" | "project";
+  projectName: string;
+}
+
+export const USER_SCOPE: Scope = { key: "user", kind: "user", projectName: "user" };
+
+function normalizeRemote(url: string): string {
+  return url
+    .trim()
+    .replace(/\.git$/i, "")
+    .replace(/^git@([^:]+):/, "https://$1/")
+    .replace(/^ssh:\/\/git@/, "https://")
+    .toLowerCase();
+}
+
+function tryGitRemote(cwd: string): string | null {
+  try {
+    const url = execSync("git config --get remote.origin.url", {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf8",
+    }).trim();
+    return url || null;
+  } catch {
+    return null;
+  }
+}
+
+function sanitize(name: string): string {
+  const cleaned = name.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 40);
+  return cleaned.length > 0 ? cleaned : "project";
+}
+
+function scopeFromSeed(seed: string, projectName: string): Scope {
+  const hash = crypto.createHash("sha256").update(seed).digest("hex").slice(0, 12);
+  return {
+    key: `project__${sanitize(projectName)}__${hash}`,
+    kind: "project",
+    projectName,
+  };
+}
+
+/** Scope keyed purely on the absolute cwd. Never consults git. Used both as
+ *  the fallback for `resolveProjectScope` when no remote is set, and as the
+ *  "legacy" scope detector for migration when a remote is added later. */
+export function resolveCwdScope(worktree: string): Scope {
+  const target = worktree && worktree.length > 0 ? worktree : ".";
+  const resolved = path.resolve(target);
+  const seed = resolved.toLowerCase();
+  // basename can return "" on Windows drive roots (e.g. "C:\\"); walk the path
+  // segments and pick the last non-empty, non-drive-letter component.
+  const parts = resolved
+    .split(/[\\/]+/)
+    .filter((p) => p && !/^[A-Za-z]:$/.test(p));
+  let projectName = parts[parts.length - 1] ?? path.basename(resolved) ?? "workspace";
+  if (!projectName) projectName = "workspace";
+  return scopeFromSeed(seed, projectName);
+}
+
+export function resolveProjectScope(worktree: string): Scope {
+  const target = worktree && worktree.length > 0 ? worktree : ".";
+  const remote = tryGitRemote(target);
+  if (remote) {
+    const norm = normalizeRemote(remote);
+    const m = norm.match(/\/([^/]+)$/);
+    const projectName = m?.[1] ?? "workspace";
+    return scopeFromSeed(norm, projectName);
+  }
+  return resolveCwdScope(target);
+}

package/src/store/db.ts

@@ -0,0 +1,98 @@
+import { createRequire } from "node:module";
+import { paths } from "../paths.ts";
+
+// Runtime-agnostic SQLite:
+//   - Inside opencode (Bun runtime): bun:sqlite (built-in, no native module load)
+//   - Under Node CLI: better-sqlite3
+// Both expose the same shape: new Database(path), .exec(sql), .prepare(sql).{run,all,get}, .close()
+const require = createRequire(import.meta.url);
+const isBun = typeof (globalThis as { Bun?: unknown }).Bun !== "undefined";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyDatabase = any;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyDatabaseCtor = new (path: string) => AnyDatabase;
+
+function loadDatabase(): AnyDatabaseCtor {
+  if (isBun) {
+    // bun:sqlite is a built-in module; only resolvable under the Bun runtime.
+    return require("bun:sqlite").Database as AnyDatabaseCtor;
+  }
+  return require("better-sqlite3") as AnyDatabaseCtor;
+}
+
+let _db: AnyDatabase | null = null;
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS memories (
+  id           TEXT PRIMARY KEY,
+  scope_key    TEXT NOT NULL,
+  scope_kind   TEXT NOT NULL,
+  project_name TEXT NOT NULL,
+  type         TEXT NOT NULL DEFAULT 'note',
+  tags         TEXT NOT NULL DEFAULT '',
+  content      TEXT NOT NULL,
+  source       TEXT NOT NULL DEFAULT '',
+  file_path    TEXT NOT NULL,
+  mtime_ms     INTEGER NOT NULL,
+  created_at   INTEGER NOT NULL,
+  updated_at   INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_memories_scope_updated
+  ON memories(scope_key, updated_at DESC);
+CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+  content,
+  tags,
+  type,
+  scope_key UNINDEXED,
+  content='memories',
+  content_rowid='rowid',
+  tokenize='porter unicode61'
+);
+
+CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+  INSERT INTO memories_fts(rowid, content, tags, type, scope_key)
+  VALUES (new.rowid, new.content, new.tags, new.type, new.scope_key);
+END;
+
+CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+  INSERT INTO memories_fts(memories_fts, rowid, content, tags, type, scope_key)
+  VALUES ('delete', old.rowid, old.content, old.tags, old.type, old.scope_key);
+END;
+
+CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+  INSERT INTO memories_fts(memories_fts, rowid, content, tags, type, scope_key)
+  VALUES ('delete', old.rowid, old.content, old.tags, old.type, old.scope_key);
+  INSERT INTO memories_fts(rowid, content, tags, type, scope_key)
+  VALUES (new.rowid, new.content, new.tags, new.type, new.scope_key);
+END;
+`;
+
+export function db(): AnyDatabase {
+  if (_db) return _db;
+  const { indexDb } = paths();
+  const Database = loadDatabase();
+  const d = new Database(indexDb);
+  d.exec("PRAGMA journal_mode = WAL;");
+  d.exec("PRAGMA synchronous = NORMAL;");
+  d.exec("PRAGMA foreign_keys = ON;");
+  d.exec(SCHEMA);
+  _db = d;
+  return d;
+}
+
+/** Close the DB. Only used by tests / CLI teardown. */
+export function closeDb(): void {
+  if (_db) {
+    _db.close();
+    _db = null;
+  }
+}
+
+/** Which backend this process is using. Useful for diagnostics. */
+export function backendName(): "bun:sqlite" | "better-sqlite3" {
+  return isBun ? "bun:sqlite" : "better-sqlite3";
+}

package/src/store/markdown.ts

@@ -0,0 +1,100 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomBytes } from "node:crypto";
+import yaml from "js-yaml";
+import { memoriesDirFor, memoriesDirPath } from "../paths.ts";
+
+export interface Frontmatter {
+  id: string;
+  scope_key: string;
+  scope_kind: "user" | "project";
+  project_name: string;
+  type: string;
+  tags: string[];
+  source: string;
+  created_at: number;
+  updated_at: number;
+}
+
+export interface MemoryFile {
+  fm: Frontmatter;
+  body: string;
+  filePath: string;
+  mtimeMs: number;
+}
+
+const CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+
+/** ULID-ish: 10 chars of base32 timestamp + 16 chars of base32 randomness. */
+export function ulid(): string {
+  let ts = "";
+  let n = Date.now();
+  for (let i = 0; i < 10; i++) {
+    ts = CROCKFORD[n % 32]! + ts;
+    n = Math.floor(n / 32);
+  }
+  const bytes = randomBytes(16);
+  let rand = "";
+  for (const b of bytes) rand += CROCKFORD[b % 32]!;
+  return ts + rand;
+}
+
+export function serialize(fm: Frontmatter, body: string): string {
+  const yml = yaml.dump(fm, { lineWidth: -1, quotingType: '"' });
+  return `---\n${yml}---\n\n${body.trimEnd()}\n`;
+}
+
+export function parse(raw: string): { fm: Frontmatter; body: string } | null {
+  const m = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!m) return null;
+  try {
+    const fm = yaml.load(m[1]!) as Frontmatter;
+    if (!fm || typeof fm !== "object" || !fm.id) return null;
+    // Normalize
+    fm.tags = Array.isArray(fm.tags) ? fm.tags : [];
+    fm.type = fm.type ?? "note";
+    fm.source = fm.source ?? "";
+    const body = (m[2] ?? "").replace(/^\n+/, "");
+    return { fm, body };
+  } catch {
+    return null;
+  }
+}
+
+export function writeMemoryFile(
+  fm: Frontmatter,
+  body: string,
+): { filePath: string; mtimeMs: number } {
+  const dir = memoriesDirFor(fm.scope_key);
+  const filePath = path.join(dir, `${fm.id}.md`);
+  fs.writeFileSync(filePath, serialize(fm, body), "utf8");
+  const st = fs.statSync(filePath);
+  return { filePath, mtimeMs: st.mtimeMs };
+}
+
+export function deleteMemoryFile(scopeKey: string, id: string): boolean {
+  const dir = memoriesDirPath(scopeKey);
+  const filePath = path.join(dir, `${id}.md`);
+  if (fs.existsSync(filePath)) {
+    fs.unlinkSync(filePath);
+    return true;
+  }
+  return false;
+}
+
+export function readMemoryFile(filePath: string): MemoryFile | null {
+  if (!fs.existsSync(filePath)) return null;
+  const raw = fs.readFileSync(filePath, "utf8");
+  const parsed = parse(raw);
+  if (!parsed) return null;
+  const st = fs.statSync(filePath);
+  return { fm: parsed.fm, body: parsed.body, filePath, mtimeMs: st.mtimeMs };
+}
+
+export function* iterMemoryFiles(scopeKey: string): Generator<string> {
+  const dir = memoriesDirPath(scopeKey);
+  if (!fs.existsSync(dir)) return;
+  for (const name of fs.readdirSync(dir)) {
+    if (name.endsWith(".md")) yield path.join(dir, name);
+  }
+}

package/src/store/migrate.ts

@@ -0,0 +1,141 @@
+import fs from "node:fs";
+import path from "node:path";
+import { memoriesDirFor, memoriesDirPath } from "../paths.ts";
+import { db } from "./db.ts";
+import {
+  iterMemoryFiles,
+  readMemoryFile,
+  serialize,
+  type Frontmatter,
+} from "./markdown.ts";
+import { syncScope } from "./sync.ts";
+
+export type ConflictStrategy = "newer" | "overwrite" | "skip";
+
+export interface MigrateOptions {
+  /** New `project_name` to stamp into each moved memory's frontmatter. If
+   *  omitted, keeps the original file's project_name. */
+  toProjectName?: string;
+  dryRun?: boolean;
+  /** How to resolve id collisions in the destination scope. Default: "newer". */
+  onConflict?: ConflictStrategy;
+  logger?: (msg: string) => void;
+}
+
+export interface MigrateStats {
+  moved: number;
+  skipped: number;
+  conflicts: number;
+  dryRun: boolean;
+}
+
+/** True if this scope has at least one `.md` file on disk. Does not create
+ *  the directory if it doesn't already exist. */
+export function scopeHasFiles(scopeKey: string): boolean {
+  const dir = memoriesDirPath(scopeKey);
+  if (!fs.existsSync(dir)) return false;
+  return fs.readdirSync(dir).some((f) => f.endsWith(".md"));
+}
+
+/**
+ * Move all memories from `fromKey` to `toKey`. Rewrites each file's
+ * `scope_key` (and optionally `project_name`) frontmatter. On id collision
+ * in the destination, `onConflict` decides:
+ *   - "newer"     (default): keep the file with the greater `updated_at`
+ *   - "overwrite": always take the source
+ *   - "skip":     always keep the destination
+ *
+ * After moving files, clears any lingering FTS rows for `fromKey` and
+ * re-runs `syncScope(toKey)` so the index reflects reality. Removes the
+ * empty source directory when possible.
+ */
+export function migrateScope(
+  fromKey: string,
+  toKey: string,
+  opts: MigrateOptions = {},
+): MigrateStats {
+  const log = opts.logger ?? (() => {});
+  const strategy: ConflictStrategy = opts.onConflict ?? "newer";
+  const dryRun = !!opts.dryRun;
+  const stats: MigrateStats = { moved: 0, skipped: 0, conflicts: 0, dryRun };
+
+  if (fromKey === toKey) {
+    throw new Error("migrate: --from and --to are identical");
+  }
+
+  const fromDir = memoriesDirPath(fromKey);
+  const toDir = memoriesDirFor(toKey);
+  if (!fs.existsSync(fromDir)) {
+    log(`no source directory: ${fromDir}`);
+    return stats;
+  }
+
+  for (const srcPath of iterMemoryFiles(fromKey)) {
+    const mf = readMemoryFile(srcPath);
+    if (!mf) {
+      log(`skip unparseable: ${srcPath}`);
+      stats.skipped++;
+      continue;
+    }
+    const dstPath = path.join(toDir, path.basename(srcPath));
+
+    let action: "write" | "skip" = "write";
+    if (fs.existsSync(dstPath)) {
+      stats.conflicts++;
+      const dst = readMemoryFile(dstPath);
+      if (!dst) {
+        log(`conflict but destination unreadable, overwriting: ${dstPath}`);
+      } else if (strategy === "skip") {
+        action = "skip";
+        log(`conflict: kept destination (--on-conflict=skip): ${dstPath}`);
+      } else if (strategy === "overwrite") {
+        log(`conflict: overwriting destination (--on-conflict=overwrite): ${dstPath}`);
+      } else if (dst.fm.updated_at >= mf.fm.updated_at) {
+        action = "skip";
+        log(`conflict: kept destination (newer updated_at): ${dstPath}`);
+      } else {
+        log(`conflict: replaced destination (source newer): ${dstPath}`);
+      }
+    }
+
+    if (action === "skip") {
+      stats.skipped++;
+      continue;
+    }
+
+    const newFm: Frontmatter = {
+      ...mf.fm,
+      scope_key: toKey,
+      project_name: opts.toProjectName ?? mf.fm.project_name,
+    };
+    const raw = serialize(newFm, mf.body);
+    if (!dryRun) {
+      fs.writeFileSync(dstPath, raw, "utf8");
+      // Only unlink source if it's a different path (paths differ because
+      // scope dir differs; belt-and-suspenders check).
+      if (path.resolve(srcPath) !== path.resolve(dstPath)) {
+        fs.unlinkSync(srcPath);
+      }
+    }
+    log(`${dryRun ? "would move" : "moved"}: ${srcPath} -> ${dstPath}`);
+    stats.moved++;
+  }
+
+  if (!dryRun) {
+    // Best-effort: remove now-empty source dir.
+    try {
+      if (fs.existsSync(fromDir) && fs.readdirSync(fromDir).length === 0) {
+        fs.rmdirSync(fromDir);
+      }
+    } catch {
+      /* ignore */
+    }
+    // Drop any remaining FTS/memories rows for the old scope, then rebuild
+    // the destination index from disk. `syncScope` also handles removals for
+    // the destination scope if a conflict-skip left stale rows behind.
+    db().prepare(`DELETE FROM memories WHERE scope_key = ?`).run(fromKey);
+    syncScope(toKey);
+  }
+
+  return stats;
+}

package/src/store/sync.ts

@@ -0,0 +1,83 @@
+import fs from "node:fs";
+import { db } from "./db.ts";
+import { iterMemoryFiles, readMemoryFile, type MemoryFile } from "./markdown.ts";
+
+const UPSERT_SQL = `
+  INSERT INTO memories (id, scope_key, scope_kind, project_name, type, tags, content, source, file_path, mtime_ms, created_at, updated_at)
+  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  ON CONFLICT(id) DO UPDATE SET
+    scope_key    = excluded.scope_key,
+    scope_kind   = excluded.scope_kind,
+    project_name = excluded.project_name,
+    type         = excluded.type,
+    tags         = excluded.tags,
+    content      = excluded.content,
+    source       = excluded.source,
+    file_path    = excluded.file_path,
+    mtime_ms     = excluded.mtime_ms,
+    updated_at   = excluded.updated_at
+`;
+
+export function upsertFromFile(mf: MemoryFile): void {
+  const { fm, body, filePath, mtimeMs } = mf;
+  db().prepare(UPSERT_SQL).run(
+    fm.id,
+    fm.scope_key,
+    fm.scope_kind,
+    fm.project_name,
+    fm.type,
+    (fm.tags ?? []).join(","),
+    body,
+    fm.source ?? "",
+    filePath,
+    mtimeMs,
+    fm.created_at,
+    fm.updated_at,
+  );
+}
+
+export function deleteFromIndex(id: string): void {
+  db().prepare(`DELETE FROM memories WHERE id = ?`).run(id);
+}
+
+export interface SyncStats {
+  added: number;
+  updated: number;
+  removed: number;
+  scanned: number;
+}
+
+export function syncScope(scopeKey: string): SyncStats {
+  const d = db();
+  const stats: SyncStats = { added: 0, updated: 0, removed: 0, scanned: 0 };
+
+  const existing = d
+    .prepare(`SELECT id, file_path, mtime_ms FROM memories WHERE scope_key = ?`)
+    .all(scopeKey) as Array<{ id: string; file_path: string; mtime_ms: number }>;
+  const existingById = new Map(existing.map((r) => [r.id, r]));
+  const seen = new Set<string>();
+
+  for (const fp of iterMemoryFiles(scopeKey)) {
+    const mf = readMemoryFile(fp);
+    if (!mf) continue;
+    stats.scanned++;
+    seen.add(mf.fm.id);
+    const prev = existingById.get(mf.fm.id);
+    if (!prev) {
+      upsertFromFile(mf);
+      stats.added++;
+    } else if (prev.mtime_ms !== mf.mtimeMs || prev.file_path !== mf.filePath) {
+      upsertFromFile(mf);
+      stats.updated++;
+    }
+  }
+
+  for (const row of existing) {
+    if (!seen.has(row.id) || !fs.existsSync(row.file_path)) {
+      deleteFromIndex(row.id);
+      stats.removed++;
+    }
+  }
+
+  return stats;
+}

package/src/tools/memory.ts

@@ -0,0 +1,174 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import type { Scope } from "../scope.ts";
+import type { MyOMemoryConfig } from "../config.ts";
+import { USER_SCOPE } from "../scope.ts";
+import { search, list } from "../retrieve/search.ts";
+import {
+  writeMemoryFile,
+  deleteMemoryFile,
+  readMemoryFile,
+  ulid,
+  type Frontmatter,
+} from "../store/markdown.ts";
+import { upsertFromFile, deleteFromIndex } from "../store/sync.ts";
+import { db } from "../store/db.ts";
+import { redact } from "../redact.ts";
+
+const z = tool.schema;
+
+const MEMORY_TYPES = [
+  "note",
+  "preference",
+  "project-config",
+  "architecture",
+  "error-solution",
+  "learned-pattern",
+  "conversation",
+] as const;
+
+export function makeTools(getScope: () => Scope, cfg: MyOMemoryConfig) {
+  const scopeArg = z
+    .enum(["project", "user"])
+    .optional()
+    .describe(
+      "Memory scope. `project` = tied to this repo. `user` = global across all your projects. Default: project.",
+    );
+
+  function resolveScope(kind?: "project" | "user"): Scope {
+    return kind === "user" ? USER_SCOPE : getScope();
+  }
+
+  const memory_add = tool({
+    description:
+      "Save a fact, preference, decision, or note to persistent local memory. Call this whenever the user tells you something you should remember in future sessions (project conventions, tool choices, personal preferences, error fixes). Keep each memory to one self-contained statement.",
+    args: {
+      content: z.string().min(1).describe("The fact to remember. One idea per memory."),
+      type: z
+        .enum(MEMORY_TYPES)
+        .optional()
+        .describe("Category of memory. Default: note."),
+      scope: scopeArg,
+      tags: z.array(z.string()).optional().describe("Optional tags for filtering."),
+    },
+    async execute(args) {
+      const { content: redacted, hadSecret, matchedPattern } = redact(
+        args.content,
+        cfg.redactPatterns,
+      );
+      if (hadSecret) {
+        return {
+          title: "memory: rejected (secret detected)",
+          output: `Refused to save: content matched a secret pattern (${matchedPattern}). Wrap the sensitive part in <private>...</private> tags or paraphrase, then try again.`,
+        };
+      }
+      const s = resolveScope(args.scope);
+      const now = Date.now();
+      const fm: Frontmatter = {
+        id: ulid(),
+        scope_key: s.key,
+        scope_kind: s.kind,
+        project_name: s.projectName,
+        type: args.type ?? "note",
+        tags: args.tags ?? [],
+        source: "tool",
+        created_at: now,
+        updated_at: now,
+      };
+      const { filePath } = writeMemoryFile(fm, redacted);
+      const mf = readMemoryFile(filePath);
+      if (mf) upsertFromFile(mf);
+      return {
+        title: `memory: saved ${fm.id}`,
+        output: `Saved to ${s.key} as ${fm.type}. id=${fm.id}`,
+      };
+    },
+  });
+
+  const memory_search = tool({
+    description:
+      "Search persistent memory by keyword (BM25 full-text). Returns matching memories from the current project and/or user scope. Use before asking the user something they may have told you before.",
+    args: {
+      query: z
+        .string()
+        .min(1)
+        .describe("Free-text query. File paths, error strings, identifiers work well."),
+      scope: z
+        .enum(["project", "user", "both"])
+        .optional()
+        .describe("Which scope(s) to search. Default: both."),
+      type: z.string().optional().describe("Restrict to memories of this type."),
+      limit: z.number().int().min(1).max(50).optional(),
+    },
+    async execute(args) {
+      const project = getScope();
+      const scopeKeys =
+        args.scope === "user"
+          ? [USER_SCOPE.key]
+          : args.scope === "project"
+            ? [project.key]
+            : [project.key, USER_SCOPE.key];
+      const hits = search(args.query, {
+        scopeKeys,
+        limit: args.limit,
+        type: args.type,
+      });
+      if (hits.length === 0) {
+        return {
+          title: "memory: 0 results",
+          output: `No memories matched "${args.query}".`,
+        };
+      }
+      const lines = hits.map(
+        (h) =>
+          `- [${h.scope_key === USER_SCOPE.key ? "user" : "project"}/${h.type}] id=${h.id}\n  ${h.snippet.replace(/\s+/g, " ").trim()}`,
+      );
+      return {
+        title: `memory: ${hits.length} result(s)`,
+        output: lines.join("\n"),
+      };
+    },
+  });
+
+  const memory_list = tool({
+    description: "List memories in a scope, newest first. Useful for browsing.",
+    args: {
+      scope: scopeArg,
+      type: z.string().optional(),
+      limit: z.number().int().min(1).max(100).optional(),
+    },
+    async execute(args) {
+      const s = resolveScope(args.scope);
+      const hits = list(s.key, { type: args.type, limit: args.limit });
+      if (hits.length === 0) {
+        return { title: "memory: empty", output: `No memories in scope ${s.key}.` };
+      }
+      const lines = hits.map(
+        (h) => `- [${h.type}] id=${h.id} — ${h.snippet.replace(/\s+/g, " ").trim()}`,
+      );
+      return {
+        title: `memory: ${hits.length} in ${s.key}`,
+        output: lines.join("\n"),
+      };
+    },
+  });
+
+  const memory_forget = tool({
+    description: "Delete a memory by id. Use when the user asks to forget something.",
+    args: {
+      id: z.string().min(1),
+    },
+    async execute(args) {
+      const row = db()
+        .prepare(`SELECT scope_key FROM memories WHERE id = ?`)
+        .get(args.id) as { scope_key: string } | undefined;
+      if (!row) {
+        return { title: "memory: not found", output: `No memory with id ${args.id}.` };
+      }
+      deleteMemoryFile(row.scope_key, args.id);
+      deleteFromIndex(args.id);
+      return { title: "memory: forgotten", output: `Deleted ${args.id}.` };
+    },
+  });
+
+  return { memory_add, memory_search, memory_list, memory_forget };
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "types": ["node"],
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": false,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*.ts"]
+}