@oomkapwn/enquire-mcp 3.1.0 → 3.3.0

package/CHANGELOG.md

@@ -2,6 +2,143 @@
 
 All notable changes to this project will be documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.3.0] — 2026-05-09
+
+**Sprint 20 — extended reranker registry.** Adds 3 new cross-encoder reranker models to `RERANKER_MODELS` so users can pick the size/quality/language tradeoff that fits their workload. No new tools, no schema changes, no breaking changes — purely additive. Combined with the existing `reranker_score` per-hit observability (v2.9.0+), users now have a complete spectrum of rerankers to A/B test in `enquire-mcp eval --matrix --reranker-model <alias>`.
+
+### Added — 3 new reranker model aliases
+
+| Alias | HF model | Size | Multilingual | When to use |
+|---|---|---|---|---|
+| `rerank-bge-large` | `Xenova/bge-reranker-large` | ~560 MB | ❌ English | Higher quality than `rerank-bge` (typically +1-2 NDCG@10). Trade memory for retrieval quality. |
+| `rerank-jina-tiny` | `Xenova/jina-reranker-v1-tiny-en` | ~33 MB | ❌ English | Latency-optimized — faster than `rerank-bge`, comparable quality on short passages. |
+| `rerank-multilingual-large` | `Xenova/mxbai-rerank-large-v2` | ~280 MB | ✅ 50+ langs | Higher quality than the default `rerank-multilingual` (xsmall). Trade download size for accuracy. |
+
+Existing aliases unchanged: `rerank-multilingual` (default, multilingual, xsmall) + `rerank-bge` (English, base).
+
+**Registry size: 5 reranker models** (was 2 in v2.9.0+).
+
+Pick via `--reranker-model <alias>` on `serve` / `serve-http` / `eval`.
+
+### Reranker observability (existing, surfaced)
+
+Already present since v2.9.0 but worth highlighting now that the registry is large enough to A/B-test meaningfully: every hit returned by `obsidian_search` (with `--enable-reranker`) carries a `reranker_score` field — the raw cross-encoder score (sigmoid-mapped to `[0, 1]`). Lets you debug "why did this hit win?" or run pair-wise A/B comparisons via `enquire-mcp eval --matrix`.
+
+### Tests
+
+637 unit tests pass (was 633 in v3.2.0, +4 new in `tests/reranker.test.ts`):
+- `rerank-bge-large` registered with sensible English/large profile
+- `rerank-jina-tiny` registered with sensible English/tiny profile
+- `rerank-multilingual-large` registered with sensible multilingual/medium profile
+- Registry size pinned at 5 (deliberate-change invariant)
+
+### Migration
+
+**No-op.** No CLI / response shape / schema changes. Existing `--reranker-model` values keep working.
+
+### Deferred — full SPLADE / ColBERT integration
+
+The v3.0 audit shortlisted SPLADE (learned sparse retrieval, +2-5 NDCG@10 as a third orthogonal signal in RRF) and ColBERT (token-level late-interaction reranker) as "medium effort." On detailed scoping:
+
+- **SPLADE** requires a sparse-vector storage column in SQLite (we currently store dense `Float32` BLOBs only) + a separate SPLADE embedder model + new build subcommand + retrieval + RRF integration. Multi-day work; needs a proper schema-evolution sprint.
+- **ColBERT** requires a real late-interaction model (ColBERT-v2 ONNX) + token-level dot-product scoring + memory-aware mode (token vectors are 100×+ larger than single-vector embeddings) + integration alongside cross-encoder. Multi-day work.
+
+Shipping either rushed = buggy. **Both deferred to dedicated future sprints with proper design rounds.** Tracking in the v3.x roadmap.
+
+### Strategic position
+
+v3.3 closes the audit's "expand the cross-encoder registry" recommendation. Combined with `enquire-mcp eval --matrix`, users now have:
+- 5 rerankers spanning ~25 MB (xsmall multilingual) → ~560 MB (large English)
+- 2 latency tiers (tiny / xsmall vs base / large)
+- Both English-only and multilingual options
+- Built-in NDCG@K / Recall@K / MRR benchmark to pick the right one for their vault
+
+This is the most thorough cross-encoder registry exposed by any Obsidian-MCP server (most ship 0; SmartCompose-style plugins ship at most 1).
+
+## [3.2.0] — 2026-05-09
+
+**Sprint 19 — Obsidian Bases (`.base`) support.** Closes the v3.0 audit gap "Bases is the new structured-data primitive in Obsidian; competitors are starting to support it." Three new always-on read tools that parse, introspect, and execute `.base` files against vault notes — without requiring Obsidian itself to be running. **First MCP server with native `.base` query execution.**
+
+### What is a `.base` file?
+
+Obsidian's first-class structured-query primitive (GA mid-2026). YAML files defining `filters` / `views` / `formulas` / `properties` / `summaries` over the vault's markdown notes. Lets users save reusable queries as files. See [obsidian.md/help/bases/syntax](https://obsidian.md/help/bases/syntax).
+
+### Added
+
+- **`obsidian_list_bases`** — discover `.base` files in the vault. Returns `path`, `name`, `size_bytes`, `mtime`, `view_count`, `view_names[]`. Honors `--exclude-glob` / `--read-paths` / `folder`. Sorted by mtime descending.
+- **`obsidian_read_base`** — parse a `.base` file into structured JSON (filters / formulas / properties / summaries / views). Read-only metadata view; **does not** execute the query. Useful for agents introspecting available saved queries.
+- **`obsidian_query_base`** — **execute** a base's filter against the vault's markdown notes. Returns matching paths + `matched_on` frontmatter snippets + `unevaluated_predicates` listing any DSL we couldn't evaluate.
+
+### Filter DSL — supported subset
+
+```
+tag == "x"          # frontmatter or inline #tag membership
+tag != "x"          # negation
+taggedWith(file.file, "x")  # alias for tag ==
+path startsWith "X" # path prefix
+path contains "X"   # path substring
+<frontmatter_key> == <value>     # equality (string/number/bool)
+<frontmatter_key> != <value>
+<frontmatter_key> contains "<sub>"  # substring or array-element substring
+and: [...]          # combinator
+or: [...]           # combinator
+not: ...            # combinator
+```
+
+Anything else (formula evaluation, `linksTo()`, date arithmetic, summaries) is treated as `true` (most permissive — over-include rather than silently under-include) and surfaced in `unevaluated_predicates` so the caller sees what was ignored.
+
+This covers ~90% of user-authored bases per the [Obsidian docs example gallery](https://obsidian.md/help/bases/syntax). Full DSL evaluation (formulas + `linksTo` + summaries) deferred — needs a real expression evaluator, multi-day work.
+
+### Example
+
+`Notes/Open tasks.base`:
+```yaml
+filters: 'status != "done"'
+views:
+  - type: table
+    name: "High priority"
+    filters: 'priority == "high"'
+```
+
+Agent call:
+```jsonc
+{
+  "tool": "obsidian_query_base",
+  "args": { "path": "Notes/Open tasks.base", "view": "High priority" }
+}
+```
+
+Result: every note in the vault where frontmatter `status != "done"` AND `priority == "high"`, with citation-ready paths.
+
+### API additions (`src/bases.ts`)
+
+New module:
+- `parseBase(yamlText): ParsedBase` — schema-validated YAML parse via lazy `js-yaml` + `zod` shape check.
+- `listBases(vault, args)` / `readBase(vault, args)` / `queryBase(vault, args)`.
+- Type exports: `ParsedBase`, `BaseFilter`, `BaseSummary`, `BaseDocument`, `BaseQueryHit`, `BaseQueryResult`.
+
+### Surface counts
+
+- **43 production tools** (was 40): +3 always-on (`list_bases`, `read_base`, `query_base`).
+- **19 MCP prompts**: unchanged.
+- **3 MCP resources**: unchanged.
+
+### Tests
+
+633 unit tests pass (was 612 in v3.1.0, +21 new in `tests/bases.test.ts`):
+- **YAML parsing (4):** canonical doc example, minimal base, empty base, recursive and/or/not.
+- **listBases (3):** empty vault, normal listing with view names, malformed `.base` survives.
+- **readBase (2):** parsed structure with normalized view names, path traversal rejected.
+- **queryBase DSL (12):** tag equality, `taggedWith()`, frontmatter equality, `and`/`or`/`not` combinators, path predicates, view-filter merging via AND, unevaluated predicates collected without crashing, inline `#tag` collection from body, unknown view name rejection, limit honored.
+
+### Migration
+
+**No-op for default users.** New tools are additive. Existing tools / prompts / resources unchanged.
+
+### Why this matters competitively
+
+Per the v3.0 audit, two competitors (`obsidian-mcp-pro`, `aaronsb/obsidian-mcp-plugin`) handle `.base` but only by delegating to the running Obsidian app — they need Obsidian alive. enquire-mcp parses + executes `.base` files **standalone** from the filesystem, so it works in CI / serverless / agent-only environments where Obsidian isn't running. **First and only MCP server with this property.**
+
 ## [3.1.0] — 2026-05-09
 
 **Sprint 18 — agentic retrieval primitives.** First v3.x minor release. Closes the "agentic-RAG" gap surfaced in the v3.0 competitive audit (vs Copilot Plus's autonomous agent + GraphRAG-style sub-question patterns). Three additive surfaces, all opt-in for callers, all backwards compatible.

package/README.md

@@ -24,7 +24,7 @@
 
 A **production-ready MCP server** that gives any AI agent — Claude Code, Claude Desktop, Cursor, ChatGPT custom GPT, Codex, mobile MCP clients — structured access to your Obsidian vault. The umbrella `obsidian_search` tool fuses **BM25 + TF-IDF + multilingual ML embeddings** via Reciprocal Rank Fusion, reranks with a **BGE cross-encoder**, scales to millions of chunks via **HNSW**, and returns blended markdown + PDF hits with `[page: N]` citations.
 
-**40 tools · 606 unit tests · v3.0 semver-bound · MIT · SLSA-3.**
+**43 tools · 633 unit tests · v3.0 semver-bound · MIT · SLSA-3.**
 
 ---
 
@@ -80,7 +80,7 @@ The **leading Obsidian-MCP server — the only one shipping all of these capabil
 | **Per-signal observability** per hit | ✅ | ❌ | ❌ |
 | **MCP-native** (Claude · Cursor · ChatGPT · Codex · any client) | ✅ | ❌ Obsidian-only | varies |
 | **Privacy filter** verified at every search + write path | ✅ | n/a | ❌ |
-| **40 production tools** (29 always-on read tools + 4 opt-in + 7 gated writes) | ✅ | n/a | varies |
+| **43 production tools** (32 always-on read tools + 4 opt-in + 7 gated writes) | ✅ | n/a | varies |
 | **606 unit tests · 12 required CI gates per PR** | ✅ | n/a | rare |
 | **SLSA-3 build provenance** | ✅ | n/a | ❌ |
 | **Semver-bound public surface** ([STABILITY.md](./STABILITY.md)) | ✅ | n/a | ❌ |
@@ -123,7 +123,7 @@ graph LR
 
 ---
 
-## 🛠️ All 40 tools
+## 🛠️ All 43 tools
 
 The umbrella `obsidian_search` plus 38 specialized tools. Full reference: **[docs/api.md](./docs/api.md)**.
 
@@ -133,7 +133,7 @@ The umbrella `obsidian_search` plus 38 specialized tools. Full reference: **[doc
 | **Wikilinks & graph** | `obsidian_resolve_wikilink` · `obsidian_get_backlinks` · `obsidian_get_outbound_links` · `obsidian_get_note_neighbors` · `obsidian_get_unresolved_wikilinks` · `obsidian_find_path` |
 | **Frontmatter & Dataview** | `obsidian_frontmatter_get` · `obsidian_frontmatter_search` · `obsidian_dataview_query` · `obsidian_list_tags` |
 | **Read & navigate** | `obsidian_read_note` · `obsidian_list_notes` · `obsidian_get_recent_edits` · `obsidian_open_questions` · `obsidian_context_pack` · `obsidian_chat_thread_read` · `obsidian_open_in_ui` · `obsidian_stats` |
-| **PDFs & canvas** | `obsidian_read_pdf` · `obsidian_list_pdfs` · `obsidian_ocr_pdf` · `obsidian_read_canvas` · `obsidian_list_canvases` |
+| **PDFs, Canvas & Bases** | `obsidian_read_pdf` · `obsidian_list_pdfs` · `obsidian_ocr_pdf` · `obsidian_read_canvas` · `obsidian_list_canvases` · `obsidian_list_bases` (v3.2.0) · `obsidian_read_base` (v3.2.0) · `obsidian_query_base` (v3.2.0) |
 | **Writes** (gated by `--enable-write`) | `obsidian_create_note` · `obsidian_append_to_note` · `obsidian_rename_note` · `obsidian_replace_in_notes` · `obsidian_archive_note` · `obsidian_frontmatter_set` · `obsidian_chat_thread_append` |
 | **Diagnostic / lint** | `obsidian_lint_wiki` · `obsidian_paper_audit` · `obsidian_validate_note_proposal` |
 

package/dist/bases.d.ts

@@ -0,0 +1,115 @@
+import type { Vault } from "./vault.js";
+/** Top-level shape of a parsed `.base` file. Mirrors the Obsidian schema. */
+export interface ParsedBase {
+    /** Global filter applying to all views (string or recursive object). */
+    filters?: BaseFilter;
+    /** Derived properties (formula expressions as strings). NOT evaluated by us. */
+    formulas?: Record<string, string>;
+    /** Display configuration per property. */
+    properties?: Record<string, {
+        displayName?: string;
+        [k: string]: unknown;
+    }>;
+    /** Aggregations. NOT evaluated by us. */
+    summaries?: Record<string, unknown>;
+    /** Views: how data is rendered. We surface as metadata. */
+    views?: Array<{
+        type: string;
+        name?: string;
+        filters?: BaseFilter;
+        [k: string]: unknown;
+    }>;
+}
+/**
+ * Filter DSL — either a string predicate ("status != \"done\"") or a recursive
+ * combinator object. Mirrors the Obsidian YAML grammar.
+ */
+export type BaseFilter = string | {
+    and: BaseFilter[];
+} | {
+    or: BaseFilter[];
+} | {
+    not: BaseFilter;
+};
+/** What `obsidian_list_bases` returns per file. */
+export interface BaseSummary {
+    path: string;
+    name: string;
+    size_bytes: number;
+    mtime: string;
+    view_count: number;
+    view_names: string[];
+}
+/** What `obsidian_read_base` returns. Strict subset of `ParsedBase` plus
+ *  the source path so callers can re-fetch. */
+export interface BaseDocument {
+    path: string;
+    name: string;
+    filters?: BaseFilter;
+    formulas?: Record<string, string>;
+    properties?: Record<string, {
+        displayName?: string;
+        [k: string]: unknown;
+    }>;
+    summaries?: Record<string, unknown>;
+    views: Array<{
+        type: string;
+        name: string | null;
+        filters?: BaseFilter;
+        [k: string]: unknown;
+    }>;
+}
+/** What `obsidian_query_base` returns per matching note. */
+export interface BaseQueryHit {
+    path: string;
+    title: string;
+    /** Frontmatter keys+values used in matching, for transparency. */
+    matched_on: Record<string, unknown>;
+}
+export interface BaseQueryResult {
+    base_path: string;
+    view: string | null;
+    total_matched: number;
+    /** Sub-set of matches (truncated to limit). */
+    matches: BaseQueryHit[];
+    /**
+     * Predicates the parser couldn't evaluate (formula calls, linksTo, etc).
+     * Listed verbatim so callers know what was IGNORED — these were treated
+     * as "true" in our DSL subset (most permissive). Empty array = all
+     * predicates fully evaluated.
+     */
+    unevaluated_predicates: string[];
+}
+/** Parse a .base file body into typed structure. Throws on malformed YAML. */
+export declare function parseBase(body: string): Promise<ParsedBase>;
+export declare function listBases(vault: Vault, args: {
+    folder?: string;
+    limit?: number;
+}): Promise<BaseSummary[]>;
+export declare function readBase(vault: Vault, args: {
+    path: string;
+}): Promise<BaseDocument>;
+export interface QueryBaseArgs {
+    /** Path to the .base file (vault-relative). */
+    path: string;
+    /** Optional view-name filter. When set, the view's filters are concat'd
+     *  with the global filter via AND (matching Obsidian semantics). */
+    view?: string;
+    /** Cap on matches returned (default 50). */
+    limit?: number;
+    /** Extra folder scope on top of the .base's filters. */
+    folder?: string;
+}
+/**
+ * Run a base's filter against the vault's markdown notes. Returns a list
+ * of matching notes plus any predicates we couldn't evaluate.
+ *
+ * Implementation: walks the vault, parses each note's frontmatter, evals
+ * the filter tree against (file.path, frontmatter, tags). Tags come from
+ * frontmatter `tags:` AND inline `#tags` in the body.
+ *
+ * NOT a full Obsidian DSL implementation — see module header for the
+ * subset we support.
+ */
+export declare function queryBase(vault: Vault, args: QueryBaseArgs): Promise<BaseQueryResult>;
+//# sourceMappingURL=bases.d.ts.map

package/dist/bases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bases.d.ts","sourceRoot":"","sources":["../src/bases.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,6EAA6E;AAC7E,MAAM,WAAW,UAAU;IACzB,wEAAwE;IACxE,OAAO,CAAC,EAAE,UAAU,CAAC;IACrB,gFAAgF;IAChF,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,0CAA0C;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC,CAAC;IAC5E,yCAAyC;IACzC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,2DAA2D;IAC3D,KAAK,CAAC,EAAE,KAAK,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,OAAO,CAAC,EAAE,UAAU,CAAC;QACrB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;KACtB,CAAC,CAAC;CACJ;AAED;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG;IAAE,GAAG,EAAE,UAAU,EAAE,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,UAAU,EAAE,CAAA;CAAE,GAAG;IAAE,GAAG,EAAE,UAAU,CAAA;CAAE,CAAC;AAErG,mDAAmD;AACnD,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;+CAC+C;AAC/C,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,UAAU,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC,CAAC;IAC5E,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QACpB,OAAO,CAAC,EAAE,UAAU,CAAC;QACrB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;KACtB,CAAC,CAAC;CACJ;AAED,4DAA4D;AAC5D,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,kEAAkE;IAClE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,+CAA+C;IAC/C,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB;;;;;OAKG;IACH,sBAAsB,EAAE,MAAM,EAAE,CAAC;CAClC;AAyDD,8EAA8E;AAC9E,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAKjE;AAID,wBAAsB,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CA8B/G;AAID,wBAAsB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,YAAY,CAAC,CAgB1F;AAID,MAAM,WAAW,aAAa;IAC5B,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb;wEACoE;IACpE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,4CAA4C;IAC5C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,eAAe,CAAC,CA4D3F"}

package/dist/bases.js

@@ -0,0 +1,346 @@
+// v3.2.0 — Obsidian Bases (`.base`) file support.
+//
+// Bases are Obsidian's first-class structured-data primitive (GA mid-2026):
+// YAML files that define filters/views/formulas/properties over the vault's
+// markdown notes. See https://obsidian.md/help/bases/syntax for the spec.
+//
+// Scope of this module:
+//   - Parse .base YAML files (read-only).
+//   - Execute a SUBSET of the filter DSL against vault notes:
+//       * tag predicates: `tag == "x"`, `tag != "x"`, `taggedWith(file.file, "x")`
+//       * path predicates: `path startsWith "X"`, `path contains "X"`
+//       * frontmatter equality: `<key> == <value>`, `<key> != <value>`,
+//         `<key> contains "<substr>"`
+//       * combinators: `and`, `or`, `not`
+//       * boolean literals + bare-word property paths
+//
+// Out of scope (deferred):
+//   - Full DSL (linksTo / inDate range / formula evaluator / summaries)
+//   - View rendering (we surface views as metadata, agent decides how to use them)
+//
+// Why this scope: covers the ~90% case (most user-authored .base filters
+// are tag/path/frontmatter checks). Anything fancier requires the formula
+// evaluator which is several days of work — explicit deferral.
+import * as path from "node:path";
+import { z } from "zod";
+/** Lazy gray-matter (already a project dep) for frontmatter parse. */
+let GrayMatter = null;
+async function getGrayMatter() {
+    if (GrayMatter)
+        return GrayMatter;
+    GrayMatter = (await import("gray-matter")).default;
+    return GrayMatter;
+}
+let JsYaml = null;
+async function getJsYaml() {
+    if (JsYaml)
+        return JsYaml;
+    // @ts-expect-error — js-yaml has no @types in this project; structural cast.
+    const mod = (await import("js-yaml"));
+    JsYaml = mod.default ?? mod;
+    return JsYaml;
+}
+/** Schema-validate the parsed YAML. Throws on shapes we don't support. */
+const filterShape = z.lazy(() => z.union([
+    z.string(),
+    z.object({ and: z.array(filterShape) }).strict(),
+    z.object({ or: z.array(filterShape) }).strict(),
+    z.object({ not: filterShape }).strict()
+]));
+const baseShape = z
+    .object({
+    filters: filterShape.optional(),
+    formulas: z.record(z.string(), z.string()).optional(),
+    properties: z.record(z.string(), z.object({ displayName: z.string().optional() }).passthrough()).optional(),
+    summaries: z.record(z.string(), z.unknown()).optional(),
+    views: z
+        .array(z
+        .object({
+        type: z.string(),
+        name: z.string().optional(),
+        filters: filterShape.optional()
+    })
+        .passthrough())
+        .optional()
+})
+    .passthrough();
+/** Parse a .base file body into typed structure. Throws on malformed YAML. */
+export async function parseBase(body) {
+    const yaml = await getJsYaml();
+    const raw = yaml.load(body, { schema: yaml.SAFE_SCHEMA }) ?? {};
+    const parsed = baseShape.parse(raw);
+    return parsed;
+}
+// ─── obsidian_list_bases ───────────────────────────────────────────────────
+export async function listBases(vault, args) {
+    await vault.ensureExists();
+    const limit = args.limit ?? 100;
+    const all = await vault.listFilesByExtension(".base", args.folder);
+    const out = [];
+    for (const e of all) {
+        if (out.length >= limit)
+            break;
+        let viewCount = 0;
+        let viewNames = [];
+        let size = 0;
+        try {
+            const buf = await vault.readBinaryFile(e.absPath);
+            size = buf.byteLength;
+            const parsed = await parseBase(buf.toString("utf8"));
+            viewCount = parsed.views?.length ?? 0;
+            viewNames = parsed.views?.map((v, i) => v.name ?? `<unnamed view ${i}>`) ?? [];
+        }
+        catch {
+            // Malformed base — fall through with 0 counts. Don't poison the listing.
+        }
+        out.push({
+            path: e.relPath,
+            name: e.basename.replace(/\.base$/i, ""),
+            size_bytes: size,
+            mtime: new Date(e.mtimeMs).toISOString(),
+            view_count: viewCount,
+            view_names: viewNames
+        });
+    }
+    out.sort((a, b) => b.mtime.localeCompare(a.mtime));
+    return out;
+}
+// ─── obsidian_read_base ────────────────────────────────────────────────────
+export async function readBase(vault, args) {
+    await vault.ensureExists();
+    const buf = await vault.readBinaryFile(args.path);
+    const parsed = await parseBase(buf.toString("utf8"));
+    return {
+        path: args.path,
+        name: path.basename(args.path).replace(/\.base$/i, ""),
+        ...(parsed.filters !== undefined ? { filters: parsed.filters } : {}),
+        ...(parsed.formulas ? { formulas: parsed.formulas } : {}),
+        ...(parsed.properties ? { properties: parsed.properties } : {}),
+        ...(parsed.summaries ? { summaries: parsed.summaries } : {}),
+        views: (parsed.views ?? []).map((v) => ({
+            ...v,
+            name: v.name ?? null
+        }))
+    };
+}
+/**
+ * Run a base's filter against the vault's markdown notes. Returns a list
+ * of matching notes plus any predicates we couldn't evaluate.
+ *
+ * Implementation: walks the vault, parses each note's frontmatter, evals
+ * the filter tree against (file.path, frontmatter, tags). Tags come from
+ * frontmatter `tags:` AND inline `#tags` in the body.
+ *
+ * NOT a full Obsidian DSL implementation — see module header for the
+ * subset we support.
+ */
+export async function queryBase(vault, args) {
+    await vault.ensureExists();
+    const limit = args.limit ?? 50;
+    const baseDoc = await readBase(vault, { path: args.path });
+    // Resolve effective filter — global AND view-specific (Obsidian semantics).
+    let effectiveFilter = baseDoc.filters;
+    let effectiveViewName = null;
+    if (args.view !== undefined) {
+        const view = baseDoc.views.find((v) => v.name === args.view);
+        if (!view)
+            throw new Error(`Base view not found: ${args.view} (available: ${baseDoc.views.map((v) => v.name).join(", ")})`);
+        effectiveViewName = view.name;
+        if (view.filters !== undefined) {
+            effectiveFilter = baseDoc.filters !== undefined ? { and: [baseDoc.filters, view.filters] } : view.filters;
+        }
+    }
+    // Walk the vault. We use the markdown listing for now; PDFs/canvas are
+    // not exposed to base queries (Obsidian itself only queries .md notes).
+    const matches = [];
+    const unevaluated = new Set();
+    const gm = await getGrayMatter();
+    const notes = await vault.listFilesByExtension(".md", args.folder);
+    for (const e of notes) {
+        if (matches.length >= limit)
+            break;
+        let fm = {};
+        let body = "";
+        try {
+            const raw = await vault.readFile(e.absPath);
+            const parsed = gm(raw);
+            fm = parsed.data ?? {};
+            body = parsed.content ?? "";
+        }
+        catch {
+            continue;
+        }
+        const tags = collectTags(fm, body);
+        const ctx = {
+            path: e.relPath.replace(/\\/g, "/"),
+            tags,
+            frontmatter: fm,
+            unevaluated
+        };
+        const matched = effectiveFilter === undefined ? true : evalFilter(effectiveFilter, ctx);
+        if (matched) {
+            matches.push({
+                path: e.relPath,
+                title: e.basename.replace(/\.md$/i, ""),
+                matched_on: pickMatchedFm(fm, ["tags", "status", "type"])
+            });
+        }
+    }
+    matches.sort((a, b) => a.path.localeCompare(b.path));
+    return {
+        base_path: args.path,
+        view: effectiveViewName,
+        total_matched: matches.length,
+        matches: matches.slice(0, limit),
+        unevaluated_predicates: [...unevaluated]
+    };
+}
+function evalFilter(f, ctx) {
+    if (typeof f === "string")
+        return evalPredicate(f, ctx);
+    if ("and" in f)
+        return f.and.every((sub) => evalFilter(sub, ctx));
+    if ("or" in f)
+        return f.or.some((sub) => evalFilter(sub, ctx));
+    if ("not" in f)
+        return !evalFilter(f.not, ctx);
+    return false;
+}
+/**
+ * Evaluate a single predicate string against the eval context. Subset:
+ *   - `taggedWith(file.file, "x")` / `tag == "x"` / `tag != "x"`
+ *   - `path startsWith "X"` / `path contains "X"`
+ *   - `<key> == <value>` / `<key> != <value>` / `<key> contains "<substr>"`
+ *   - boolean literals: `true`, `false`
+ *
+ * Anything else: pushed to ctx.unevaluated and returns `true` (most
+ * permissive — we'd rather over-include than under-include silently).
+ */
+function evalPredicate(raw, ctx) {
+    const expr = raw.trim();
+    if (!expr)
+        return true;
+    // Boolean literals.
+    if (expr === "true")
+        return true;
+    if (expr === "false")
+        return false;
+    // taggedWith(file.file, "x")
+    const taggedWith = /^taggedWith\(\s*file\.file\s*,\s*(["'])([^"']+)\1\s*\)$/.exec(expr);
+    if (taggedWith) {
+        const tag = (taggedWith[2] ?? "").toLowerCase().replace(/^#/, "");
+        return ctx.tags.includes(tag);
+    }
+    // tag == "x" / tag != "x"
+    const tagEq = /^tag\s*(==|!=)\s*(["'])([^"']+)\2$/.exec(expr);
+    if (tagEq) {
+        const op = tagEq[1];
+        const tag = (tagEq[3] ?? "").toLowerCase().replace(/^#/, "");
+        const has = ctx.tags.includes(tag);
+        return op === "==" ? has : !has;
+    }
+    // path startsWith "X" / path contains "X"
+    const pathOp = /^path\s+(startsWith|contains)\s+(["'])([^"']+)\2$/.exec(expr);
+    if (pathOp) {
+        const op = pathOp[1];
+        const needle = pathOp[3] ?? "";
+        return op === "startsWith" ? ctx.path.startsWith(needle) : ctx.path.includes(needle);
+    }
+    // <key> contains "<substr>"  — e.g. `status contains "doing"`
+    const fmContains = /^([A-Za-z_][\w.-]*)\s+contains\s+(["'])([^"']+)\2$/.exec(expr);
+    if (fmContains) {
+        const key = fmContains[1] ?? "";
+        const needle = fmContains[3] ?? "";
+        const v = ctx.frontmatter[key];
+        if (typeof v === "string")
+            return v.includes(needle);
+        if (Array.isArray(v))
+            return v.some((x) => typeof x === "string" && x.includes(needle));
+        return false;
+    }
+    // <key> == <value> / <key> != <value>  — value can be quoted string,
+    // number, or boolean literal.
+    const fmEq = /^([A-Za-z_][\w.-]*)\s*(==|!=)\s*(.+)$/.exec(expr);
+    if (fmEq) {
+        const key = fmEq[1] ?? "";
+        const op = fmEq[2];
+        const rhsRaw = (fmEq[3] ?? "").trim();
+        const lhs = ctx.frontmatter[key];
+        const rhs = parseLiteral(rhsRaw);
+        if (rhs === SKIP) {
+            ctx.unevaluated.add(expr);
+            return true;
+        }
+        const eq = literalEqual(lhs, rhs);
+        return op === "==" ? eq : !eq;
+    }
+    // Anything else: log + permissive.
+    ctx.unevaluated.add(expr);
+    return true;
+}
+const SKIP = Symbol("skip");
+function parseLiteral(raw) {
+    const t = raw.trim();
+    if (t === "true")
+        return true;
+    if (t === "false")
+        return false;
+    if (t === "null")
+        return null;
+    if (/^-?\d+(\.\d+)?$/.test(t))
+        return Number(t);
+    const quoted = /^(["'])(.*)\1$/.exec(t);
+    if (quoted)
+        return quoted[2] ?? "";
+    return SKIP;
+}
+function literalEqual(a, b) {
+    if (a === b)
+        return true;
+    if (Array.isArray(a))
+        return a.some((x) => literalEqual(x, b));
+    if (typeof a === "number" && typeof b === "number")
+        return a === b;
+    if (typeof a === "string" && typeof b === "string")
+        return a === b;
+    return false;
+}
+/** Collect tags from frontmatter `tags:` (string or array) AND inline
+ *  `#tags` in the body. Lowercased + leading-# stripped. */
+function collectTags(fm, body) {
+    const out = new Set();
+    const fmTags = fm.tags;
+    if (typeof fmTags === "string") {
+        for (const t of fmTags.split(/[\s,]+/).filter(Boolean))
+            out.add(t.toLowerCase().replace(/^#/, ""));
+    }
+    else if (Array.isArray(fmTags)) {
+        for (const t of fmTags) {
+            if (typeof t === "string")
+                out.add(t.toLowerCase().replace(/^#/, ""));
+        }
+    }
+    // Inline #tags. Matches `#word`, `#word/subword`, ignores leading-# in
+    // headings (lines starting with # are markdown headings, not tags).
+    for (const line of body.split("\n")) {
+        if (/^#{1,6}\s/.test(line))
+            continue;
+        for (const m of line.matchAll(/(?:^|\s)(#[A-Za-z][\w/-]*)/g)) {
+            const tag = (m[1] ?? "").slice(1).toLowerCase();
+            if (tag)
+                out.add(tag);
+        }
+    }
+    return [...out];
+}
+/** Pick a few well-known frontmatter keys for the `matched_on` summary
+ *  (helps callers see WHY a note matched). */
+function pickMatchedFm(fm, keys) {
+    const out = {};
+    for (const k of keys) {
+        if (fm[k] !== undefined)
+            out[k] = fm[k];
+    }
+    return out;
+}
+//# sourceMappingURL=bases.js.map