@mathew-cf/opencode-memory 0.2.0

package/dist/lib/db.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Helpers for locating the OpenCode session database and running read-only
+ * SQL queries against it.
+ *
+ * The session tools wrap these helpers so they can be pointed at a temp DB
+ * during tests by setting `$OPENCODE_DB`.
+ */
+/**
+ * Resolve the path to the OpenCode SQLite database.
+ *
+ * OpenCode uses `xdg-basedir@5.1.0` which joins `os.homedir()` with
+ * `.local/share` on every platform (including Windows, where it resolves
+ * under `%USERPROFILE%`). So once HOME resolves correctly, the layout is
+ * identical cross-platform.
+ *
+ * Tests and power users can override the path with `$OPENCODE_DB`.
+ */
+export declare function resolveDbPath(env?: NodeJS.ProcessEnv): string;
+/**
+ * Escape a value for use in a SQLite single-quoted string literal.
+ * Exported for tests — the exact quoting rules matter for ensuring we
+ * don't construct SQL injection vectors when building queries from user
+ * input.
+ */
+export declare function sqlStr(s: string): string;
+/**
+ * Run a SQLite statement against the given db and return the parsed JSON
+ * result. Returns an empty array on any error — callers then present a
+ * graceful "no results" response instead of propagating an exception.
+ */
+export declare function querySqlite<T = unknown>(dbPath: string, sql: string): Promise<T[]>;
+//# sourceMappingURL=db.d.ts.map

package/dist/lib/db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/lib/db.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAG1E;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAExC;AAED;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,CAAC,GAAG,OAAO,EAC3C,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,CAAC,EAAE,CAAC,CAWd"}

package/dist/lib/frontmatter.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Minimal YAML frontmatter parser/updater.
+ *
+ * Memory files use a small, opinionated frontmatter schema (title, tags,
+ * summary, importance, updated, last_accessed, access_count, related). A full
+ * YAML parser would be overkill — this hand-rolled parser understands just
+ * enough to feed the search ranker and update the access-tracking fields.
+ *
+ * Keeping it simple also means the parser behaves predictably on broken or
+ * partial frontmatter: unknown keys are ignored, malformed arrays become
+ * empty arrays, etc. Tests exercise those failure modes directly.
+ */
+export interface FrontMatter {
+    title?: string;
+    tags?: string[];
+    summary?: string;
+    importance?: string;
+    updated?: string;
+    related?: string[];
+    last_accessed?: string;
+    access_count?: number;
+}
+/**
+ * Split a markdown file into `{meta, body}`. If no frontmatter is present,
+ * `meta` is empty and the entire input becomes `body` — callers still get
+ * something usable rather than a thrown error.
+ */
+export declare function parseFrontmatter(content: string): {
+    meta: FrontMatter;
+    body: string;
+};
+/**
+ * Update or insert the `last_accessed` and `access_count` fields in a YAML
+ * block. Returns the new YAML string. The caller is responsible for gluing
+ * it back onto the body with the `---` sentinels.
+ *
+ * Kept pure so tests can verify the exact text transformation without
+ * touching the filesystem.
+ */
+export declare function bumpAccessFields(yaml: string, dateStr: string): {
+    yaml: string;
+    newCount: number;
+};
+/**
+ * Current date as `YYYY-MM-DD` in UTC. Exposed so tests can compare against
+ * the exact string format written to memory files.
+ */
+export declare function todayISO(): string;
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/lib/frontmatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontmatter.d.ts","sourceRoot":"","sources":["../../src/lib/frontmatter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,WAAW;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAID;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG;IACjD,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd,CAoCA;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAmBpC;AAED;;;GAGG;AACH,wBAAgB,QAAQ,IAAI,MAAM,CAEjC"}

package/dist/lib/paths.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Cross-platform path helpers.
+ *
+ * The memory and session tools were originally written for macOS/Linux where
+ * paths use forward slashes and process.env.HOME is always set. On Windows,
+ * both assumptions break. These helpers centralize the compatibility shim so
+ * the rest of the plugin can assume a single canonical path shape.
+ */
+/**
+ * Resolve the user's home directory across platforms.
+ *
+ * Unix conventionally exposes the home via $HOME; Windows exposes it via
+ * %USERPROFILE%. When both are set, HOME wins so explicit overrides work
+ * on either platform. Backslashes in the resolved value are normalized to
+ * forward slashes so downstream string operations behave uniformly.
+ *
+ * Empty-string values are treated as unset (so an inherited-but-blank
+ * HOME on Windows falls through to USERPROFILE). Throws if neither
+ * variable resolves to a non-empty string — silently returning an empty
+ * path would cause every downstream file operation to resolve against
+ * the filesystem root, which is both surprising and extremely hard to
+ * debug.
+ */
+export declare function resolveHome(env?: NodeJS.ProcessEnv): string;
+/**
+ * Normalize a filesystem path to use forward slashes.
+ *
+ * On Windows, ripgrep emits paths with backslashes even when invoked with
+ * forward-slash arguments. When our code strips a forward-slash MEMORY_DIR
+ * prefix from a backslash-separated rg output line, the replace silently
+ * fails and the prefix is left in place — which breaks every downstream
+ * file read. Normalizing rg output through this helper restores the
+ * invariant that paths handled inside the tool always use /.
+ *
+ * On macOS/Linux this is a no-op: paths already use forward slashes.
+ */
+export declare function normPath(p: string): string;
+/**
+ * Resolve the root memory directory. Honors `$MEMORY_DIR` (used by tests
+ * and by users who keep their knowledge base in a non-default location),
+ * falling back to `$HOME/opencode-memory`.
+ */
+export declare function resolveMemoryDir(env?: NodeJS.ProcessEnv): string;
+/**
+ * Convenience: the rag index directory for a given memory root.
+ */
+export declare function ragIndexDir(memoryDir: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/lib/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../src/lib/paths.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CASxE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE1C;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAG7E;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAErD"}

package/dist/lib/rag.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Thin wrappers around the `rag` CLI (https://github.com/mathew-cf/rag-cli).
+ *
+ * `@mathew-cf/rag-cli` is declared as a runtime dependency of this plugin,
+ * so its JS shim is always available in `node_modules/@mathew-cf/rag-cli/
+ * bin/rag.js` after installation. The shim handles platform detection and
+ * execs the platform-specific prebuilt binary published alongside it.
+ *
+ * We resolve the shim's absolute path via `require.resolve` at call time
+ * rather than trusting `$PATH`, because:
+ *   - opencode installs plugins into a cache dir whose `node_modules/.bin`
+ *     is NOT on $PATH when the plugin's code runs.
+ *   - An absolute path also fails loudly if the dep is missing, which is
+ *     easier to diagnose than a confusing "command not found".
+ *
+ * Semantic search is still optional: if resolution fails for any reason
+ * (broken install, unusual layout, native binary missing for the host
+ * platform), every public helper here degrades gracefully. Callers see
+ * `null` from `resolveRagBinary()` and fall back to keyword-only search.
+ */
+export interface RagStatus {
+    /** Absolute path to the JS shim, if resolvable. `null` otherwise. */
+    shimPath: string | null;
+}
+/**
+ * Locate the rag shim via node module resolution. Returns `null` when the
+ * package isn't installed (usually indicates the user added the plugin
+ * via a non-standard loader that skipped optionalDependencies or the
+ * rag-cli package failed to install for their platform).
+ *
+ * Exported so tests can assert the resolution behaviour directly.
+ */
+export declare function resolveRagBinary(): string | null;
+/**
+ * Probe once for the installation status. Kept as a separate function
+ * (even though it's currently a thin wrapper) so future logic around
+ * caching, version checks, or alternate lookup paths has a single home.
+ */
+export declare function probeRag(): RagStatus;
+/** True iff the shim is resolvable. */
+export declare function ragAvailable(): boolean;
+/**
+ * Human-readable guidance for when `rag` can't be resolved. Called from
+ * error paths and from `memory_setup` so the message lives in one place.
+ *
+ * With rag-cli as a declared dependency, the expected remedy is a
+ * reinstall — not a separate `cargo install` dance.
+ */
+export declare function installGuidance(): string;
+/**
+ * Run `rag search` against an index. Returns the raw JSON text so callers
+ * can parse it themselves. Any failure (missing shim, missing index,
+ * parse error upstream) resolves to the empty string — degrading
+ * gracefully rather than propagating shell exceptions.
+ */
+export declare function ragSearch(args: {
+    query: string;
+    indexDir: string;
+    topK?: number;
+}): Promise<string>;
+/**
+ * Spawn `rag index` as a detached background process. The caller does
+ * not block on the index build because it can be slow on large corpora
+ * and users don't want their save operations to stall.
+ *
+ * Returns `true` if we kicked off an index build, `false` if the shim
+ * couldn't be resolved.
+ */
+export declare function spawnRagIndex(args: {
+    memoryDir: string;
+    indexDir: string;
+}): boolean;
+/**
+ * Pre-download the embedding model by running `rag download`. Returns a
+ * human-readable status string — either the command's output or the
+ * installation guidance if the shim isn't resolvable.
+ */
+export declare function downloadModel(): Promise<string>;
+//# sourceMappingURL=rag.d.ts.map

package/dist/lib/rag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rag.d.ts","sourceRoot":"","sources":["../../src/lib/rag.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAQH,MAAM,WAAW,SAAS;IACxB,qEAAqE;IACrE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,GAAG,IAAI,CAMhD;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,IAAI,SAAS,CAEpC;AAED,uCAAuC;AACvC,wBAAgB,YAAY,IAAI,OAAO,CAEtC;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAoBxC;AAED;;;;;GAKG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,GAAG,OAAO,CAAC,MAAM,CAAC,CAOlB;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAQV;AAED;;;;GAIG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,CAUrD"}

package/dist/lib/ripgrep.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Thin wrapper around the `@vscode/ripgrep` package.
+ *
+ * `@vscode/ripgrep` is a required dependency of this plugin. On install,
+ * its postinstall script downloads the platform's prebuilt `rg` binary
+ * and exposes its absolute path via `rgPath`. We import it via a dynamic
+ * `require` so tests (and code paths where the dep happens to be missing)
+ * can still execute — returning `null` from `resolveRgBinary` so callers
+ * surface a clean error rather than crashing on import.
+ *
+ * We resolve at call time rather than at module-top-level so a broken
+ * install doesn't prevent the plugin from loading at all. `memory_search`
+ * will then fall through to the "no results" branch with a helpful message.
+ */
+/**
+ * Resolve the absolute path to the `rg` binary shipped by the
+ * `@vscode/ripgrep` package. Returns `null` if the package isn't
+ * installed (unusual — should never happen in practice because it's
+ * a required dep) or if its published layout changes.
+ *
+ * Exported for tests and for `memory_setup`.
+ */
+export declare function resolveRgBinary(): string | null;
+/** True iff a usable `rg` binary is resolvable. */
+export declare function rgAvailable(): boolean;
+/**
+ * Human-readable guidance for when ripgrep can't be resolved. Mirrors the
+ * shape of `rag.installGuidance()` so `memory_setup` can surface either
+ * message consistently.
+ */
+export declare function rgInstallGuidance(): string;
+//# sourceMappingURL=ripgrep.d.ts.map

package/dist/lib/ripgrep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ripgrep.d.ts","sourceRoot":"","sources":["../../src/lib/ripgrep.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH;;;;;;;GAOG;AACH,wBAAgB,eAAe,IAAI,MAAM,GAAG,IAAI,CAY/C;AAED,mDAAmD;AACnD,wBAAgB,WAAW,IAAI,OAAO,CAErC;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAmB1C"}

package/dist/lib/search-terms.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Search-term tokenization and scoring helpers.
+ *
+ * All the logic in this file is pure — no filesystem, no shell, no
+ * timestamps. That lets tests pin down ranking behaviour deterministically
+ * without setting up a temp directory or spawning `rg`.
+ */
+/**
+ * Split a query into individual search terms.
+ * - Quoted phrases become a single term (with the quotes stripped).
+ * - Whitespace-separated words become individual terms.
+ * - Very short words (<2 chars) and common stop words are filtered out.
+ *
+ * The original casing is preserved in the return value; downstream callers
+ * lowercase when they need to compare. That's intentional: a future ranker
+ * might want to treat `SQL` differently from `sql`.
+ */
+export declare function parseSearchTerms(query: string): string[];
+/**
+ * Count how many of the given search terms appear anywhere in the text
+ * (case-insensitive). Used as one of the ranking signals in the memory
+ * search scorer.
+ */
+export declare function countTermMatches(text: string, terms: string[]): number;
+/**
+ * Structured inputs for the memory ranker. Kept as a record of primitives
+ * so callers can fill in whatever subset of signals they have — e.g. tests
+ * can exercise just the importance weighting without constructing a full
+ * ripgrep/rag result.
+ */
+export interface ScoreInputs {
+    /** True if ripgrep found a keyword match in this file. */
+    rgMatch: boolean;
+    /** Cosine similarity from the semantic index, if available. */
+    ragScore?: number;
+    /** Per-file count of how many search terms appeared in the body. */
+    termMatches: number;
+    /** Total number of search terms in the query. */
+    totalTerms: number;
+    /** Frontmatter tags (used for tag-match bonus). */
+    tags?: string[];
+    /** Relative path (used for filename-match bonus). */
+    path: string;
+    /** Importance bucket: `high`, `medium`, or `low`. */
+    importance?: string;
+    /** Historical access count (frequently-used memories get a bump). */
+    accessCount?: number;
+    /** The original search terms. */
+    terms: string[];
+}
+/**
+ * Deterministic scorer for a single candidate memory file. The weights were
+ * tuned against a real corpus, but the key insight is that they're all
+ * bounded — no single signal can dominate. `rg` gives coarse recall; `rag`
+ * gives semantic discrimination; the metadata bonuses reward curation.
+ *
+ * Exported so tests can verify the exact ranking under mixed signals
+ * without going through the full `memory_search` tool.
+ */
+export declare function scoreCandidate(input: ScoreInputs): number;
+//# sourceMappingURL=search-terms.d.ts.map

package/dist/lib/search-terms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-terms.d.ts","sourceRoot":"","sources":["../../src/lib/search-terms.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAcxD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAItE;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,0DAA0D;IAC1D,OAAO,EAAE,OAAO,CAAC;IACjB,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,WAAW,EAAE,MAAM,CAAC;IACpB,iDAAiD;IACjD,UAAU,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,qDAAqD;IACrD,IAAI,EAAE,MAAM,CAAC;IACb,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,qEAAqE;IACrE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iCAAiC;IACjC,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAgDzD"}

package/dist/tools/memory.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Memory tools: search, list, save, access.
+ *
+ * The memory root is resolved lazily via `resolveMemoryDir()` so that
+ * tests can point the whole plugin at a temp directory by setting
+ * `$MEMORY_DIR` before importing.
+ */
+/**
+ * Build a ripgrep argument list for OR-matching multiple terms.
+ * Kept as a pure function so tests can verify the exact args shape.
+ */
+export declare function buildRgArgs(terms: string[]): string[];
+/**
+ * Parse the output of a `rag search --json` invocation. Returns an empty
+ * array on any failure. Exported for tests.
+ */
+export declare function parseRagHits(ragText: string): Array<{
+    source: string;
+    score: number;
+    text: string;
+}>;
+/**
+ * Relative path from the memory root, with backslashes normalized.
+ * Exposed for tests that need to assert the exact key written into the
+ * result map.
+ */
+export declare function toRelPath(memoryDir: string, absPath: string): string;
+export declare const search: {
+    description: string;
+    args: {
+        query: import("zod").ZodString;
+        category: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        query: string;
+        category?: string | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+};
+/**
+ * Pure entry point for memory search. Exposed separately from the `tool()`
+ * wrapper so tests can call it with plain arguments and assert against the
+ * returned string without constructing a full tool context.
+ */
+export declare function runSearch(input: {
+    query: string;
+    category?: string;
+}): Promise<string>;
+export declare const list: {
+    description: string;
+    args: {
+        category: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        category?: string | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+};
+export declare function runList(input: {
+    category?: string;
+}): Promise<string>;
+export declare const access: {
+    description: string;
+    args: {
+        path: import("zod").ZodString;
+    };
+    execute(args: {
+        path: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+};
+export declare function runAccess(input: {
+    path: string;
+}): Promise<string>;
+export declare const save: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+};
+export declare function runSave(): Promise<string>;
+export declare const setup: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+};
+export declare function runSetup(): Promise<string>;
+//# sourceMappingURL=memory.d.ts.map

package/dist/tools/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/tools/memory.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA8BH;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAgBrD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,GACd,KAAK,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAexD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAEpE;AAID,eAAO,MAAM,MAAM;;;;;;;;;;CAgCjB,CAAC;AAEH;;;;GAIG;AACH,wBAAsB,SAAS,CAAC,KAAK,EAAE;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,MAAM,CAAC,CA+OlB;AAED,eAAO,MAAM,IAAI;;;;;;;;CAef,CAAC;AAEH,wBAAsB,OAAO,CAAC,KAAK,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAoE3E;AAED,eAAO,MAAM,MAAM;;;;;;;;CAgBjB,CAAC;AAEH,wBAAsB,SAAS,CAAC,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAmBxE;AAED,eAAO,MAAM,IAAI;;;;CAkCf,CAAC;AAEH,wBAAsB,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,CA+B/C;AAED,eAAO,MAAM,KAAK;;;;CAShB,CAAC;AAEH,wBAAsB,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,CAwBhD"}

package/dist/tools/session.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Session tools: search, list, read.
+ *
+ * These read from the OpenCode SQLite database (WAL mode, safe to query
+ * concurrently while OpenCode is running). The database path is resolved
+ * lazily so tests can override it with `$OPENCODE_DB`.
+ */
+/**
+ * Build an `<col> LIKE <pattern>` OR clause. When there's a single term we
+ * return a bare expression; multi-term queries get parenthesized so they
+ * can be composed into larger `WHERE` clauses without operator-precedence
+ * surprises.
+ */
+export declare function likeOr(col: string, patterns: string[]): string;
+/**
+ * Build a `term_hits` expression that counts how many patterns match —
+ * used as a ranking signal so rows matching more terms surface first.
+ */
+export declare function termHits(col: string, patterns: string[]): string;
+export interface SessionSearchRow {
+    id: string;
+    title: string | null;
+    directory: string;
+    updated: string;
+    snippet: string | null;
+    match_offset: number | null;
+    term_hits: number;
+}
+export interface SessionListRow {
+    id: string;
+    title: string | null;
+    directory: string;
+    created: string;
+    updated: string;
+}
+export declare const search: {
+    description: string;
+    args: {
+        query: import("zod").ZodString;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        directory: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        query: string;
+        limit?: number | undefined;
+        directory?: string | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+};
+export declare function runSessionSearch(input: {
+    query: string;
+    limit?: number;
+    directory?: string;
+    currentSessionId?: string;
+}): Promise<string>;
+export declare const list: {
+    description: string;
+    args: {
+        from: import("zod").ZodOptional<import("zod").ZodString>;
+        to: import("zod").ZodOptional<import("zod").ZodString>;
+        directory: import("zod").ZodOptional<import("zod").ZodString>;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    };
+    execute(args: {
+        from?: string | undefined;
+        to?: string | undefined;
+        directory?: string | undefined;
+        limit?: number | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+};
+export declare function runSessionList(input: {
+    from?: string;
+    to?: string;
+    directory?: string;
+    limit?: number;
+    currentSessionId?: string;
+}): Promise<string>;
+export declare const read: {
+    description: string;
+    args: {
+        session_id: import("zod").ZodString;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        offset: import("zod").ZodOptional<import("zod").ZodNumber>;
+        role: import("zod").ZodOptional<import("zod").ZodEnum<{
+            all: "all";
+            user: "user";
+            assistant: "assistant";
+        }>>;
+    };
+    execute(args: {
+        session_id: string;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        role?: "all" | "user" | "assistant" | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+};
+export declare function runSessionRead(input: {
+    sessionId: string;
+    limit?: number;
+    offset?: number;
+    role?: "all" | "user" | "assistant";
+    currentSessionId?: string;
+}): Promise<string>;
+//# sourceMappingURL=session.d.ts.map

package/dist/tools/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/tools/session.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAOH;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAI9D;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAIhE;AAID,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAID,eAAO,MAAM,MAAM;;;;;;;;;;;;CA2BjB,CAAC;AAEH,wBAAsB,gBAAgB,CAAC,KAAK,EAAE;IAC5C,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,GAAG,OAAO,CAAC,MAAM,CAAC,CAoIlB;AAED,eAAO,MAAM,IAAI;;;;;;;;;;;;;;CAqCf,CAAC;AAEH,wBAAsB,cAAc,CAAC,KAAK,EAAE;IAC1C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,GAAG,OAAO,CAAC,MAAM,CAAC,CAqDlB;AAED,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;CAiCf,CAAC;AAEH,wBAAsB,cAAc,CAAC,KAAK,EAAE;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,WAAW,CAAC;IACpC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,GAAG,OAAO,CAAC,MAAM,CAAC,CA0ElB"}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@mathew-cf/opencode-memory",
+  "version": "0.2.0",
+  "description": "Persistent cross-session memory for OpenCode \u2014 a hybrid keyword + semantic search layer over a local markdown knowledge base, plus session history tools and guardrails that nudge agents to use them.",
+  "author": "mat",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mathew-cf/opencode-memory"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "skills"
+  ],
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target node && tsc --emitDeclarationOnly",
+    "test": "bun test",
+    "prepublishOnly": "bun run build",
+    "typecheck": "tsc --noEmit",
+    "sync-version": "bun scripts/sync-version.ts",
+    "version": "bun run sync-version && git add README.md"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "memory",
+    "rag",
+    "semantic-search",
+    "persistence"
+  ],
+  "dependencies": {
+    "@mathew-cf/rag-cli": "^0.4.0",
+    "@vscode/ripgrep": "^1.17.1"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.1.49",
+    "@types/bun": "^1.3.12",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.0.0"
+  }
+}