open-memex 0.1.0

package/AGENTS.md

@@ -0,0 +1,73 @@
+# AGENTS.md
+
+Local-first memory plugin for opencode. See `README.md` and `PLAN.md` for user-facing docs and the roadmap. This file lists only the non-obvious things an agent needs to work in this repo.
+
+## Runtime model — read before touching anything
+
+Two runtimes execute the same TypeScript source, with **no build step**:
+
+- **opencode host** loads `src/index.ts` under embedded **Bun**. SQLite here is `bun:sqlite` (built-in).
+- **CLI** (`src/cli.ts`) and smoke test run under **Node 22+** with `--experimental-strip-types`. SQLite here is `better-sqlite3` (native module).
+
+`src/store/db.ts` picks the backend at runtime by sniffing `globalThis.Bun`. Both backends share the same surface (`new Database(path)`, `.exec`, `.prepare().run/all/get`, `.close`). Any DB code you write must stay on that common subset — do not import `better-sqlite3` or `bun:sqlite` directly outside `db.ts`.
+
+Consequences:
+- Imports **must** use explicit `.ts` extensions (`allowImportingTsExtensions: true`, `moduleResolution: "Bundler"`).
+- No transpile / bundle output. Do not add one; opencode loads the `.ts` file directly.
+- Adding a native dep means it must work under both Bun's N-API compat and Node.
+
+## Commands
+
+```
+npm install                                          # once
+npm run typecheck                                    # tsc --noEmit — the only lint/type gate
+npm run cli -- where | list | search "q" | add ... | forget <id> | reindex
+node --experimental-strip-types scripts\smoke-pure.ts   # runs pure-logic checks (no sqlite)
+```
+
+There is **no `npm test`** and no CI. Verification loop is: `npm run typecheck` + `smoke-pure.ts` + (if touching sqlite) `npm run cli -- reindex` against a scratch `MY_O_MEMORY_HOME`.
+
+To load the plugin in opencode locally, `~/.config/opencode/opencode.jsonc` must have:
+```
+"plugin": ["file:///c:/github/open-memex/src/index.ts"]
+```
+Restart opencode after any change — the plugin is not hot-reloaded.
+
+## Data lives outside the repo
+
+Storage root:
+- Windows: `%APPDATA%\open-memex\`
+- Linux/macOS: `$XDG_DATA_HOME/open-memex/` (fallback `~/.local/share/open-memex/`)
+- Override with `MY_O_MEMORY_HOME` (use this for tests to avoid clobbering real data).
+
+Layout: `memories/<scope_key>/<id>.md` (YAML frontmatter + body) + `index.db` (SQLite FTS5).
+
+**Markdown files are the source of truth; `index.db` is rebuildable.** `syncScope()` (in `src/store/sync.ts`) reconciles the two by mtime on plugin load and before every CLI read. When adding new frontmatter fields, update `Frontmatter` in `src/store/markdown.ts`, the `memories` table in `src/store/db.ts`, and `upsertFromFile` in `src/store/sync.ts` together, and bump the reindex path.
+
+## Scope keys
+
+- `user` scope key is literal `"user"`.
+- `project` scope key: `project__<sanitized-name>__<12-hex-sha256>`, seeded from normalized git origin URL, else lowercased cwd. See `src/scope.ts`. Same repo across machines → same key (intentional; enables future git-commit of memories).
+- The scope key **changes** when a repo gains/loses a git origin. `src/index.ts` logs a one-shot warning on load if it finds files under the legacy cwd-only key (`resolveCwdScope`). Use `cli scopes` to enumerate all scope dirs and `cli migrate --from <old>` to reconcile — see `src/store/migrate.ts`. No auto-migration; two unrelated repos at the same cwd would silently merge.
+- Read-only callers must use `memoriesDirPath` (in `src/paths.ts`), never `memoriesDirFor`. The latter `mkdir -p`s the directory as a side effect and will pollute storage with empty scope dirs.
+
+## Capture / write path invariants
+
+Every write path (tool, keyword hook, CLI `add`) must:
+1. Call `redact(content, cfg.redactPatterns)`.
+2. If `hadSecret` → refuse the write (do not save `[REDACTED]` unless the user wrapped it in `<private>…</private>`).
+3. `writeMemoryFile` first, then `readMemoryFile` + `upsertFromFile` to keep FTS in sync.
+
+Keyword capture fires from `chat.message` on the assistant's `output.parts` text. Patterns live in `src/capture/keywords.ts` / config `keywordPatterns`; regex group 1 is the memory body.
+
+Context injection happens exactly once per session in `experimental.chat.system.transform`, guarded by an in-memory `Set<sessionID>` in `src/index.ts`. It is not persisted — restarting opencode re-injects on the next first turn.
+
+## Design constraints from PLAN.md worth honoring
+
+MVP is intentionally: no cloud, no embeddings/vector search, no LLM-driven extraction, no knowledge graph. Do not add these without updating `PLAN.md`. Items 1–8 in the v2 roadmap have a rough priority order; prefer extending existing modules over new top-level concepts.
+
+## Style notes
+
+- `strict: true`, `verbatimModuleSyntax: false`. Prefer `import type` for types anyway.
+- Log prefix is `[open-memex]`. Gate verbose logs behind `cfg.logLevel === "debug"`.
+- Windows is a first-class target (this workspace is Windows). Use `node:path` and never hardcode `/`.

package/LICENSE

@@ -0,0 +1,198 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      Use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format.
+
+   Copyright 2026 Wei Sun
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/PLAN.md

@@ -0,0 +1,168 @@
+# open-memex — Design & Roadmap
+
+## Goal
+
+A local-only persistent memory plugin for opencode. No SaaS, no account, no
+network calls. Memories live as human-readable markdown files, indexed by
+SQLite FTS5 for BM25 keyword search.
+
+## Non-goals (MVP)
+
+- No cloud sync
+- No embeddings / vector search (v2)
+- No LLM-driven memory extraction (v2)
+- No knowledge graph / entity linking
+- No multi-user collaboration
+
+## Architecture
+
+```
++-----------------------------+
+|         opencode (Bun)      |
+|                             |
+|  chat.message hook  ------> keyword capture ---+
+|  system.transform   ------> context inject <---|--- memory files
+|  tool.memory_*      ------> add/search/list/forget    (source of truth)
++-----------------------------+                  |
+                                                 v
+                                        +----------------+
+                                        |  SQLite index  |
+                                        | (FTS5, BM25)   |
+                                        +----------------+
+```
+
+- `memories` — one file per memory. YAML frontmatter + body.
+- `index.db` — SQLite (via `better-sqlite3`) with FTS5 virtual table over content/tags/type.
+- Loads under opencode's embedded Bun runtime (better-sqlite3 works via N-API compat).
+- CLI runs under Node 22+ with `--experimental-strip-types` — no Bun required, no build step.
+
+## Data model
+
+### File on disk
+
+`memories/<scope_key>/<id>.md`
+
+```markdown
+---
+id: 01HZ...
+scope_key: project__open-memex__a1b2c3d4e5f6
+scope_kind: project
+project_name: open-memex
+type: project-config
+tags: [bun, sqlite]
+source: tool
+created_at: 1770000000000
+updated_at: 1770000000000
+---
+
+This project runs under Bun and uses bun:sqlite. Do not add better-sqlite3.
+```
+
+### SQLite tables
+
+- `memories(id PK, scope_key, scope_kind, project_name, type, tags CSV, content, source, file_path, mtime_ms, created_at, updated_at)`
+- `memories_fts` — FTS5 virtual table over `content`, `tags`, `type`, external-content mode pointing at `memories.rowid`.
+- Triggers keep `memories_fts` in sync on insert/update/delete.
+
+## Scoping
+
+- **user** scope key: literal `"user"`
+- **project** scope key: `project__<sanitized-name>__<12-hex-of-sha256>`
+  - Seed: normalized git origin URL if present, else absolute cwd path (lowercased)
+  - Same repo across machines -> same key, so memories can be `git`-committed (future)
+
+### Scope-key drift and migration
+
+Because the scope key changes when a repo's git origin appears or changes,
+memories captured *before* a remote was added end up orphaned under the
+cwd-based key. The plugin logs a one-shot warning at load when it detects
+this, and ships two CLI commands to resolve it:
+
+- `cli scopes` — list every project scope directory with a file count.
+- `cli migrate --from <old> [--to <current>] [--dry-run] [--on-conflict newer|overwrite|skip]`
+  — rewrites `scope_key` in each file's frontmatter, moves the files, and
+  reindexes. Default conflict strategy is "keep the newer `updated_at`".
+
+Auto-migration on load is intentionally *not* done: two unrelated repos at
+the same cwd would silently merge.
+
+## Capture mechanisms
+
+MVP:
+1. **Explicit tool call** — agent calls `memory_add`.
+2. **Keyword trigger** — regex against the user message parts. Captured group 1 becomes the memory body. Defaults: `remember`, `note that`, `TIL`, `save this`.
+
+Not in MVP:
+3. Auto-capture every N turns via LLM summary.
+4. LLM-decided "should I recall?" per turn (supermemory's reasoned-recall).
+
+## Retrieval
+
+MVP: **BM25 via SQLite FTS5.** Query is tokenized, punctuation stripped, each token becomes a prefix match. `bm25(memories_fts)` used as the score. Snippets via `snippet(memories_fts, ...)`.
+
+Not in MVP:
+- Local embeddings (Transformers.js `Xenova/bge-small-en-v1.5`) + sqlite-vec.
+- Reciprocal Rank Fusion across BM25 + vector lanes.
+- Cross-encoder rerank (FastEmbed jina-reranker-tiny).
+
+## Context injection
+
+On the first `experimental.chat.system.transform` for each session, push a
+`[OPEN-MEMEX]` block containing:
+- User profile / preferences (top N from `user` scope)
+- Project knowledge (top N from current project scope, newest first)
+
+Injected once per session per plugin load (in-memory set keyed by sessionID).
+
+## Redaction
+
+Applied to any content on the way in (tool + keyword capture):
+1. Strip `<private>...</private>` -> `[REDACTED]`.
+2. Match remaining text against secret regex list (OpenAI, GitHub, AWS, Slack...). If any hit -> refuse write, tell agent to redact.
+
+## Config surface
+
+`~/.config/opencode/open-memex.jsonc`:
+
+```jsonc
+{
+  "maxProjectMemories": 8,
+  "maxProfileItems": 5,
+  "injectOnFirstTurn": true,
+  "keywordCaptureEnabled": true,
+  "keywordPatterns": ["^\\s*remember...", ...],
+  "redactPatterns": ["sk-[A-Za-z0-9]{20,}", ...],
+  "logLevel": "info"
+}
+```
+
+Env overrides:
+- `MY_O_MEMORY_HOME` — override storage root
+- `MY_O_MEMORY_CONFIG` — override config file path
+
+## v2 roadmap (in rough priority)
+
+1. **Local embeddings** — Xenova/bge-small ONNX via Transformers.js; sqlite-vec table; RRF fuse with BM25.
+2. **Auto-capture** every N turns using the host LLM (opt-in).
+3. **Preemptive compaction hook** — inject memories into `experimental.session.compacting` context.
+4. **Deduplication** on write (hash + fuzzy).
+5. **`/memory-init`** slash command — walk the repo, summarize modules, save.
+6. **Recall receipts** — return which lane matched (BM25 / vector / recency) for debuggability.
+7. **Bitemporal** valid_from/valid_to for facts that supersede each other.
+8. **Admission barrier** — reject retrieved memories from being re-ingested, reject assistant self-writes, block prompt-injection in file content.
+
+## v3+
+
+- Ollama detection -> use `nomic-embed-text` when present.
+- Cross-encoder rerank.
+- Memory decay / consolidation.
+- Import/export to markdown archives.
+- Optional knowledge-graph layer for entity linking.
+
+## Prior art referenced
+
+- `opencode-supermemory` — plugin lifecycle, capture heuristics
+- `doobidoo/mcp-memory-service` — local sqlite-vec + BM25 hybrid, decay
+- `memoripy` — RRF, admission barrier, dependency-free hash embeddings
+- `basic-memory` — markdown-first store, obsidian-compatible
+- Anthropic client-managed memory tool pattern — filesystem primitives

package/README.md

@@ -0,0 +1,95 @@
+# open-memex
+
+Local-first persistent memory plugin for [opencode](https://opencode.ai).
+
+- **Markdown files** as the source of truth (human-editable, git-friendly)
+- **SQLite FTS5** as a rebuildable index (BM25 keyword search, via `better-sqlite3`)
+- **Zero cloud**, zero account, zero third-party API
+- Loads directly under opencode's embedded Bun runtime; CLI runs under Node — no build step, no Bun install
+
+## Install (dev)
+
+```
+cd c:\github\open-memex
+npm install
+```
+
+Then add to `~/.config/opencode/opencode.jsonc`:
+
+```jsonc
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["file:///c:/github/open-memex/src/index.ts"]
+}
+```
+
+Restart opencode.
+
+## Tools the plugin exposes to the agent
+
+| Tool | What it does |
+|---|---|
+| `memory_add`     | Save a fact, preference, decision, note |
+| `memory_search`  | Keyword search (BM25) across project + user memories |
+| `memory_list`    | List memories in a scope, newest first |
+| `memory_forget`  | Delete a memory by id |
+
+## Capture
+
+- **Keyword triggers** in user messages: `remember ...`, `note that ...`, `TIL ...`, `save this: ...`
+- **Explicit tool calls** by the agent (via `memory_add`)
+- **Redaction**: content inside `<private>...</private>` tags is stripped; content matching secret patterns (API keys, tokens) is refused
+
+## Scopes
+
+- **project** — scoped to the current repo (keyed off the git origin URL hash, or the cwd if no remote). Default for new memories.
+- **user** — global across all your projects; use for personal preferences.
+
+## Retrieval
+
+On the first turn of every session, `open-memex` injects a `[OPEN-MEMEX]` block into the system prompt containing top-N recent project memories + top-N user preferences. The agent can also call `memory_search` on demand.
+
+## Storage layout
+
+```
+%APPDATA%\open-memex\               (Windows)
+$XDG_DATA_HOME/open-memex/          (Linux/macOS)
+├── index.db                         # SQLite FTS5 index (rebuildable)
+└── memories/
+    ├── user/
+    │   └── <id>.md
+    └── project__<name>__<hash12>/
+        └── <id>.md
+```
+
+Each `.md` file has YAML frontmatter (`id, scope_key, type, tags, created_at, ...`) followed by the memory content. You can edit them by hand — the plugin re-syncs on startup by comparing file mtimes.
+
+## Config
+
+Optional file at `~/.config/opencode/open-memex.jsonc`. See `PLAN.md` for defaults.
+
+## CLI
+
+Runs under Node 22 with the built-in experimental TypeScript loader (no build step).
+
+```
+node --experimental-strip-types src/cli.ts where
+node --experimental-strip-types src/cli.ts list --scope project
+node --experimental-strip-types src/cli.ts search "auth flow"
+node --experimental-strip-types src/cli.ts add "This repo uses better-sqlite3" --type project-config
+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 <old-scope-key> [--dry-run]
+```
+
+Or via the npm script: `npm run cli -- list --scope project`.
+**Note:** flag arguments beyond the first must be passed via direct `node` invocation, not `npm run cli --`, because npm swallows unknown `--flag` args.
+
+## Status
+
+MVP. See `PLAN.md` for the v2 roadmap (local embeddings, auto-capture, compaction hook, etc).
+
+## License
+
+[MIT](./LICENSE)

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "open-memex",
+  "version": "0.1.0",
+  "description": "Local-first memory layer and protocol for AI coding agents. Markdown source of truth, SQLite FTS5 index, zero cloud.",
+  "type": "module",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stoneskin/open-memex.git"
+  },
+  "homepage": "https://github.com/stoneskin/open-memex#readme",
+  "bugs": {
+    "url": "https://github.com/stoneskin/open-memex/issues"
+  },
+  "main": "src/index.ts",
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "cli": "node --experimental-strip-types src/cli.ts"
+  },
+  "dependencies": {
+    "better-sqlite3": "^11.7.0",
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.18.30",
+    "@types/better-sqlite3": "^7.6.11",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  }
+}

package/scripts/smoke-pure.ts

@@ -0,0 +1,91 @@
+// Quick smoke test — runs the pure-logic modules (no bun:sqlite dependency).
+// Usage:  node --experimental-strip-types scripts\smoke-pure.ts
+import { parse, serialize, ulid, type Frontmatter } from "../src/store/markdown.ts";
+import { redact, findSecret } from "../src/redact.ts";
+import { detectKeywords } from "../src/capture/keywords.ts";
+import { DEFAULT_CONFIG } from "../src/config.ts";
+import { resolveProjectScope, resolveCwdScope, USER_SCOPE } from "../src/scope.ts";
+
+let fails = 0;
+function ok(name: string, cond: boolean, info?: unknown) {
+  if (cond) console.log(`  ok  ${name}`);
+  else {
+    console.log(`  FAIL ${name}`, info ?? "");
+    fails++;
+  }
+}
+
+console.log("== ulid ==");
+const a = ulid();
+const b = ulid();
+ok("length is 26", a.length === 26);
+ok("two calls differ", a !== b);
+ok("sortable", a < b || a === b);
+
+console.log("== markdown round-trip ==");
+const fm: Frontmatter = {
+  id: a,
+  scope_key: "project__test__abcdef123456",
+  scope_kind: "project",
+  project_name: "test",
+  type: "note",
+  tags: ["hello", "world"],
+  source: "test",
+  created_at: 1000,
+  updated_at: 2000,
+};
+const body = "hello\n\nworld";
+const raw = serialize(fm, body);
+ok("has frontmatter fence", raw.startsWith("---\n"));
+const parsed = parse(raw);
+ok("parses", parsed !== null);
+ok("id survives", parsed?.fm.id === a);
+ok("tags survive", JSON.stringify(parsed?.fm.tags) === '["hello","world"]');
+ok("body survives", parsed?.body.trim() === body);
+
+console.log("== redact ==");
+const r1 = redact("api key is <private>sk-supersecretkey</private> ok", DEFAULT_CONFIG.redactPatterns);
+ok("private stripped", !r1.content.includes("sk-supersecretkey"));
+ok("no secret after strip", !r1.hadSecret);
+
+const r2 = redact("sk-1234567890abcdefghij1234", DEFAULT_CONFIG.redactPatterns);
+ok("bare secret detected", r2.hadSecret === true);
+
+const r3 = redact("ghp_" + "a".repeat(36), DEFAULT_CONFIG.redactPatterns);
+ok("github PAT detected", r3.hadSecret === true);
+
+console.log("== keywords ==");
+const hits1 = detectKeywords("remember that this repo uses Bun, not Node", DEFAULT_CONFIG);
+ok("basic remember matched", hits1.length === 1);
+ok("body captured", hits1[0]?.content === "this repo uses Bun, not Node");
+
+const hits2 = detectKeywords("TIL: sqlite bm25 returns lower=better", DEFAULT_CONFIG);
+ok("TIL matched", hits2.length === 1);
+
+const hits3 = detectKeywords("hello world", DEFAULT_CONFIG);
+ok("no false positive", hits3.length === 0);
+
+const hits4 = detectKeywords("Please note that FTS5 needs prefix matches", DEFAULT_CONFIG);
+ok("please-note matched", hits4.length === 1);
+
+console.log("== scope ==");
+const s = resolveProjectScope(process.cwd());
+ok("kind=project", s.kind === "project");
+ok("key starts with project__", s.key.startsWith("project__"));
+ok("hash length 12", /__[a-f0-9]{12}$/.test(s.key));
+console.log("     scope.key =", s.key);
+console.log("     user.key  =", USER_SCOPE.key);
+
+console.log("== scope (cwd-only legacy) ==");
+const cwdOnly = resolveCwdScope(process.cwd());
+ok("cwd scope kind=project", cwdOnly.kind === "project");
+ok("cwd scope key format", /^project__[^_]+.*__[a-f0-9]{12}$/.test(cwdOnly.key));
+// Deterministic: same input -> same key
+const cwdOnly2 = resolveCwdScope(process.cwd());
+ok("cwd scope deterministic", cwdOnly.key === cwdOnly2.key);
+// In a repo with a git remote, cwd-only scope must differ from git-origin scope.
+// (This repo does have an origin after `git push`.)
+console.log("     cwd.key   =", cwdOnly.key);
+
+console.log(fails === 0 ? "\nALL PASS" : `\n${fails} FAILURES`);
+process.exit(fails === 0 ? 0 : 1);