@openparachute/vault 0.7.3-rc.13 → 0.7.3-rc.2

package/core/src/display-title.test.ts

@@ -1,190 +0,0 @@
-/**
- * Title axis (ratified 2026-07-17): a note's title IS its first line —
- * derived from content, never stored. This file covers:
- *   - `computeDisplayTitle` derivation (first non-empty line, heading
- *     markers stripped, truncation, null-on-empty);
- *   - `displayTitle` presence on the lean `NoteIndex` shape, both via the
- *     MCP `query-notes` list path and the REST `GET /notes` list path.
- *
- * The search title-BOOST (ranking notes whose first line matches query
- * terms above the rest) lives in `search-title-boost.test.ts` — a
- * different concern (ranking) from derivation (this file).
- */
-import { describe, it, expect, beforeEach } from "bun:test";
-import { Database } from "bun:sqlite";
-import { SqliteStore } from "./store.js";
-import { generateMcpTools } from "./mcp.js";
-import { computeDisplayTitle, toNoteIndex, DISPLAY_TITLE_MAX_LEN } from "./notes.js";
-import type { Note } from "./types.js";
-
-describe("computeDisplayTitle", () => {
-  it("returns the first line when content is a single line", () => {
-    expect(computeDisplayTitle("Grocery List")).toBe("Grocery List");
-  });
-
-  it("returns the first NON-EMPTY line, skipping leading blank lines", () => {
-    expect(computeDisplayTitle("\n\n  \nReal Title\nbody text")).toBe("Real Title");
-  });
-
-  it("strips a leading markdown heading marker + its whitespace", () => {
-    expect(computeDisplayTitle("# Grocery List\nmilk, eggs")).toBe("Grocery List");
-    expect(computeDisplayTitle("## Section Two\nbody")).toBe("Section Two");
-    expect(computeDisplayTitle("###### h6\nbody")).toBe("h6");
-  });
-
-  it("strips a heading marker with no space after it", () => {
-    expect(computeDisplayTitle("###Title\nbody")).toBe("Title");
-  });
-
-  it("treats a heading-marker-only line as blank and moves to the next line", () => {
-    expect(computeDisplayTitle("##\nReal Title")).toBe("Real Title");
-  });
-
-  it("does not strip markers past the first six (never a valid heading)", () => {
-    // 7 leading `#`s: the regex only matches 1-6, so the 7th `#` survives
-    // as ordinary content.
-    expect(computeDisplayTitle("####### Title")).toBe("# Title");
-  });
-
-  it("returns null for empty content", () => {
-    expect(computeDisplayTitle("")).toBeNull();
-  });
-
-  it("returns null for null/undefined content", () => {
-    expect(computeDisplayTitle(null)).toBeNull();
-    expect(computeDisplayTitle(undefined)).toBeNull();
-  });
-
-  it("returns null when content is whitespace-only", () => {
-    expect(computeDisplayTitle("   \n\t\n   ")).toBeNull();
-  });
-
-  it("returns null when every line is a bare heading marker", () => {
-    expect(computeDisplayTitle("#\n##\n### ")).toBeNull();
-  });
-
-  it("truncates to DISPLAY_TITLE_MAX_LEN code points", () => {
-    const longTitle = "a".repeat(200);
-    const result = computeDisplayTitle(longTitle)!;
-    expect(result.length).toBe(DISPLAY_TITLE_MAX_LEN);
-    expect(result).toBe("a".repeat(DISPLAY_TITLE_MAX_LEN));
-  });
-
-  it("does not truncate a title at or under the limit", () => {
-    const exact = "a".repeat(DISPLAY_TITLE_MAX_LEN);
-    expect(computeDisplayTitle(exact)).toBe(exact);
-    const short = "short title";
-    expect(computeDisplayTitle(short)).toBe(short);
-  });
-
-  it("truncates by Unicode code point, not UTF-16 code unit (no split surrogate pairs)", () => {
-    // Astral-plane emoji are 2 UTF-16 code units each but 1 code point.
-    const emojiTitle = "😀".repeat(150);
-    const result = computeDisplayTitle(emojiTitle)!;
-    expect(Array.from(result).length).toBe(DISPLAY_TITLE_MAX_LEN);
-  });
-
-  describe("leading frontmatter block (misuse path — direct create with raw frontmatter)", () => {
-    it("skips a closed frontmatter block and derives the first line of the DOCUMENT", () => {
-      expect(computeDisplayTitle("---\ntitle: X\n---\n# Real Title")).toBe("Real Title");
-    });
-
-    it("skips a closed frontmatter block with multiple fields + blank lines after", () => {
-      expect(
-        computeDisplayTitle("---\ntitle: X\ntags: [a, b]\n---\n\n\nReal Title\nbody"),
-      ).toBe("Real Title");
-    });
-
-    it("falls back to treating an UNTERMINATED opening `---` as ordinary content", () => {
-      // No closing fence anywhere in the content — a note whose real first
-      // line is literally "---" (e.g. a markdown horizontal rule opener)
-      // must not be mangled.
-      expect(computeDisplayTitle("---\nnot frontmatter, just a rule\nmore text")).toBe("---");
-    });
-
-    it("returns null when content is EXACTLY a closed frontmatter block (nothing after)", () => {
-      expect(computeDisplayTitle("---\ntitle: X\n---\n")).toBeNull();
-      expect(computeDisplayTitle("---\ntitle: X\n---")).toBeNull();
-    });
-
-    it("returns null when only blank lines follow a closed frontmatter block", () => {
-      expect(computeDisplayTitle("---\ntitle: X\n---\n\n  \n")).toBeNull();
-    });
-
-    it("does not treat a closing fence found past the bounded scan window as a frontmatter close", () => {
-      // Opening `---` with the closing fence past FRONTMATTER_SCAN_LINES
-      // (100): the scan gives up and falls back to ordinary-content
-      // behavior, deriving from line 0.
-      const filler = Array.from({ length: 150 }, (_, i) => `line ${i}`).join("\n");
-      expect(computeDisplayTitle(`---\n${filler}\n---\nReal Title`)).toBe("---");
-    });
-
-    it("normal content with no leading `---` is byte-identical to prior behavior", () => {
-      expect(computeDisplayTitle("# Grocery List\nmilk, eggs")).toBe("Grocery List");
-      expect(computeDisplayTitle("Just a note\nbody text")).toBe("Just a note");
-    });
-  });
-});
-
-describe("toNoteIndex — displayTitle wiring", () => {
-  const baseNote: Note = {
-    id: "n1",
-    content: "# Real Title\nbody",
-    createdAt: new Date().toISOString(),
-    tags: [],
-    metadata: {},
-  };
-
-  it("carries the computed display title onto the lean shape", () => {
-    const index = toNoteIndex(baseNote);
-    expect(index.displayTitle).toBe("Real Title");
-  });
-
-  it("is null when content is empty", () => {
-    const index = toNoteIndex({ ...baseNote, content: "" });
-    expect(index.displayTitle).toBeNull();
-  });
-
-  it("is null when content is missing entirely (defensive — matches preview's ?? \"\" fallback)", () => {
-    const { content: _drop, ...rest } = baseNote;
-    const index = toNoteIndex(rest as Note);
-    expect(index.displayTitle).toBeNull();
-  });
-});
-
-let store: SqliteStore;
-let db: Database;
-
-beforeEach(() => {
-  db = new Database(":memory:");
-  store = new SqliteStore(db);
-});
-
-describe("displayTitle — list-shape presence (MCP)", () => {
-  it("query-notes list mode (include_content default false) carries displayTitle", async () => {
-    await store.createNote("# Meeting Notes\nagenda: budget", { path: "a" });
-    const tools = generateMcpTools(store);
-    const queryNotes = tools.find((t) => t.name === "query-notes")!;
-    const result = await queryNotes.execute({}) as any[];
-    expect(result).toHaveLength(1);
-    expect(result[0].displayTitle).toBe("Meeting Notes");
-    expect(result[0].content).toBeUndefined();
-  });
-
-  it("query-notes include_content=true does NOT carry displayTitle (full Note shape, unchanged)", async () => {
-    await store.createNote("# Meeting Notes\nagenda: budget", { path: "a" });
-    const tools = generateMcpTools(store);
-    const queryNotes = tools.find((t) => t.name === "query-notes")!;
-    const result = await queryNotes.execute({ include_content: true }) as any[];
-    expect(result[0].content).toBeTruthy();
-    expect(result[0].displayTitle).toBeUndefined();
-  });
-
-  it("displayTitle is null on the lean shape for an empty note", async () => {
-    await store.createNote("", { path: "empty" });
-    const tools = generateMcpTools(store);
-    const queryNotes = tools.find((t) => t.name === "query-notes")!;
-    const result = await queryNotes.execute({}) as any[];
-    expect(result[0].displayTitle).toBeNull();
-  });
-});

package/core/src/lede.test.ts

@@ -1,96 +0,0 @@
-/**
- * `computeLede` — the first non-empty paragraph AFTER a note's title line,
- * used by `expand_mode: "summary"` (core/src/expand.ts) as a fallback when
- * `metadata.summary` is absent (summaries-as-content, 2026-07-17 dialogue).
- *
- * Shares its title-line rule (including the leading-frontmatter skip) with
- * `computeDisplayTitle` — see `display-title.test.ts` for that function's
- * own coverage. This file covers only the lede-specific behavior: where the
- * paragraph starts, how it's collapsed, the length cap, and the
- * title-only/no-content null cases.
- */
-import { describe, it, expect } from "bun:test";
-import { computeLede, LEDE_MAX_LEN } from "./notes.js";
-
-describe("computeLede", () => {
-  it("returns the first paragraph after a heading title, blank-line separated", () => {
-    expect(
-      computeLede("# Title\n\nThis is the lede paragraph.\n\nSecond paragraph — not the lede."),
-    ).toBe("This is the lede paragraph.");
-  });
-
-  it("joins a multi-line paragraph into one collapsed line", () => {
-    expect(
-      computeLede("# Title\n\nThis lede paragraph\nspans two lines.\n\nSecond paragraph."),
-    ).toBe("This lede paragraph spans two lines.");
-  });
-
-  it("treats text immediately following the title (no blank line) as the lede", () => {
-    expect(computeLede("Grocery List\nmilk, eggs\ncheese")).toBe("milk, eggs cheese");
-  });
-
-  it("collapses internal whitespace runs to single spaces", () => {
-    expect(computeLede("Title\n\nLine one   with    extra   spaces.")).toBe(
-      "Line one with extra spaces.",
-    );
-  });
-
-  it("returns null for a title-only note (does not repeat the title)", () => {
-    expect(computeLede("Just a title")).toBeNull();
-    expect(computeLede("# Just a title")).toBeNull();
-  });
-
-  it("returns null when only blank lines follow the title", () => {
-    expect(computeLede("# Title\n\n\n   \n")).toBeNull();
-  });
-
-  it("returns null for empty, null, or undefined content", () => {
-    expect(computeLede("")).toBeNull();
-    expect(computeLede(null)).toBeNull();
-    expect(computeLede(undefined)).toBeNull();
-  });
-
-  it("returns null when content is whitespace-only (no title at all)", () => {
-    expect(computeLede("   \n\t\n   ")).toBeNull();
-  });
-
-  describe("leading frontmatter block", () => {
-    it("finds the lede after a closed frontmatter block AND its title line", () => {
-      expect(
-        computeLede("---\ntitle: X\n---\n# Real Title\n\nThe lede text."),
-      ).toBe("The lede text.");
-    });
-
-    it("finds the lede when the title immediately follows frontmatter with no blank line", () => {
-      expect(
-        computeLede("---\ntitle: X\n---\nReal Title\nlede text right after."),
-      ).toBe("lede text right after.");
-    });
-
-    it("returns null for a frontmatter-only note with no body after the title", () => {
-      expect(computeLede("---\ntitle: X\n---\nReal Title")).toBeNull();
-    });
-  });
-
-  describe("length cap", () => {
-    it("truncates to LEDE_MAX_LEN code points", () => {
-      const longParagraph = "a".repeat(1000);
-      const result = computeLede(`# Title\n\n${longParagraph}`)!;
-      expect(result.length).toBe(LEDE_MAX_LEN);
-      expect(result).toBe("a".repeat(LEDE_MAX_LEN));
-    });
-
-    it("does not truncate a lede at or under the cap", () => {
-      const exact = "a".repeat(LEDE_MAX_LEN);
-      expect(computeLede(`# Title\n\n${exact}`)).toBe(exact);
-      const short = "short lede";
-      expect(computeLede(`# Title\n\n${short}`)).toBe(short);
-    });
-
-    it("truncates by Unicode code point, not UTF-16 code unit (no split surrogate pairs)", () => {
-      const emojiParagraph = "😀".repeat(500);
-      const result = computeLede(`# Title\n\n${emojiParagraph}`)!;
-      expect(Array.from(result).length).toBe(LEDE_MAX_LEN);
-    });
-  });
-});

package/core/src/search-title-boost.test.ts

@@ -1,125 +0,0 @@
-/**
- * Search title-boost (title axis, ratified 2026-07-17): literal-mode
- * search results whose `displayTitle` (first non-empty content line, NOT
- * `path`) contains every query term are post-ranked ahead of body-only
- * matches. No-migration — an in-memory re-rank of the already-fetched
- * page, not a `notes_fts` schema change (see `applySearchTitleBoost` /
- * `boostTitleMatches` in `notes.ts`).
- *
- * This is a DIFFERENT axis from the existing `path`-weighted bm25 ranking
- * covered in `search-fts-v25.test.ts` — a note's title here is its first
- * CONTENT line, not its `path`.
- */
-import { describe, it, expect, beforeEach } from "bun:test";
-import { Database } from "bun:sqlite";
-import { SqliteStore } from "./store.js";
-
-let store: SqliteStore;
-let db: Database;
-
-beforeEach(() => {
-  db = new Database(":memory:");
-  store = new SqliteStore(db);
-});
-
-describe("search title-boost", () => {
-  it("ranks a first-line (title) match above a body-only match", async () => {
-    // Body-only match: "budget" appears only deep in the body, first line
-    // is unrelated.
-    await store.createNote(
-      "Weekly Standup\nlots of unrelated notes here, but somewhere we discuss the budget in passing",
-      { path: "standup-notes" },
-    );
-    // First-line (title) match: "Budget" is the first line itself.
-    await store.createNote("Budget Review\nQ3 numbers", { path: "budget-review" });
-
-    const hits = await store.searchNotes("budget");
-    expect(hits.length).toBeGreaterThanOrEqual(2);
-    expect(hits[0].path).toBe("budget-review");
-  });
-
-  it("requires ALL query terms to be present in the first line to boost (a partial title match doesn't qualify)", async () => {
-    // "budget" is in the title but "review" is only in the body — a
-    // PARTIAL title match, which stays in the body-only tier.
-    await store.createNote("Budget notes\nsee the quarterly review for details", { path: "partial" });
-    // Both "budget" and "review" are in the title — a FULL title match.
-    await store.createNote("Budget Review\nQ3 numbers", { path: "full-match" });
-
-    const hits = await store.searchNotes("budget review");
-    expect(hits.map((n) => n.path)).toEqual(["full-match", "partial"]);
-  });
-
-  it("ties (both notes in the same tier) keep the existing relevance order", async () => {
-    // Two title-matching notes plus one body-only note. Comparing literal
-    // mode (boosted) against advanced mode with the same plain-word query
-    // (identical FTS5 syntax, so identical underlying bm25 order, but no
-    // boost pass) isolates the boost's effect: within the title-match
-    // tier, the boost must preserve whatever relative order the
-    // underlying relevance ranking already gave — a stable sort, not a
-    // fresh comparator that could reshuffle ties.
-    await store.createNote("Project Widget\nfirst, mentions widget again for relevance", { path: "w1" });
-    await store.createNote("Project Widget\nsecond", { path: "w2" });
-    await store.createNote("Unrelated\nbody-only mention of widget project", { path: "body-only" });
-
-    const boosted = await store.searchNotes("widget project");
-    const rawOrder = await store.searchNotes("widget project", { mode: "advanced" });
-
-    const titleTierBoosted = boosted.map((n) => n.path).filter((p) => p === "w1" || p === "w2");
-    const titleTierRaw = rawOrder.map((n) => n.path).filter((p) => p === "w1" || p === "w2");
-    expect(titleTierBoosted).toEqual(titleTierRaw);
-    // The title-match tier precedes the body-only note in the boosted result.
-    expect(boosted.map((n) => n.path).indexOf("body-only")).toBeGreaterThan(
-      Math.max(...["w1", "w2"].map((p) => boosted.map((n) => n.path).indexOf(p))),
-    );
-  });
-
-  it("does not disturb ordering when an explicit sort is requested", async () => {
-    await store.createNote("Zebra body-only mention of gadget", { path: "z" });
-    await store.createNote("Gadget Launch\nfirst line title match", { path: "a" });
-
-    const asc = await store.searchNotes("gadget", { sort: "asc" });
-    // created_at ASC means "z" (created first) comes before "a" — the
-    // title-boost must NOT override an explicit sort.
-    expect(asc.map((n) => n.path)).toEqual(["z", "a"]);
-  });
-
-  it("does not apply the boost under search_mode: advanced (raw FTS5 syntax, not naively tokenizable)", async () => {
-    await store.createNote("Body only mentions gadget in passing text here", { path: "body-only" });
-    await store.createNote("Gadget\nfirst line title match", { path: "title-match" });
-
-    const advanced = await store.searchNotes("gadget", { mode: "advanced" });
-    const literal = await store.searchNotes("gadget");
-
-    // Literal mode boosts the title match to the front.
-    expect(literal[0].path).toBe("title-match");
-    // Advanced mode is unaffected by the boost — order comes from bm25
-    // relevance alone (title-match still likely ranks first via the
-    // EXISTING path-weighted bm25, but that's a different mechanism; the
-    // test here just confirms advanced mode doesn't throw and returns
-    // both notes, not that ordering matches/mismatches literal mode).
-    expect(advanced.map((n) => n.path).sort()).toEqual(["body-only", "title-match"]);
-  });
-
-  it("a query with no results is unaffected (empty array in, empty array out)", async () => {
-    const hits = await store.searchNotes("nonexistent_term_xyz");
-    expect(hits).toEqual([]);
-  });
-
-  it("boosts on the post-frontmatter title line, not the `---` delimiter (shares computeDisplayTitle's frontmatter skip)", async () => {
-    // Direct-create misuse path: raw frontmatter-bearing content. Without
-    // the frontmatter skip, the derived "title" would be the literal
-    // string "---", which never matches any query term, so this note
-    // would wrongly land in the body-only tier.
-    await store.createNote(
-      "---\ntitle: irrelevant\n---\n# Budget Review\nQ3 numbers",
-      { path: "frontmatter-led" },
-    );
-    await store.createNote(
-      "Weekly Standup\nsomewhere we discuss the budget in passing",
-      { path: "body-only" },
-    );
-
-    const hits = await store.searchNotes("budget review");
-    expect(hits[0].path).toBe("frontmatter-led");
-  });
-});

package/src/attachment-bytes.ts

@@ -1,68 +0,0 @@
-/**
- * Attachment bytes — bun's filesystem implementation of the model-lane
- * (Wave 2) `AttachmentBytesProvider` seam (`core/src/attachment/bytes-provider.ts`).
- *
- * Stateless by design (unlike the ticket provider, there's no in-memory
- * state to share across requests) — a fresh instance per MCP session is
- * cheap, so `createFsAttachmentBytesProvider` is a plain factory, not a
- * shared singleton.
- *
- * `readRange` uses `Bun.file(path).slice(start, end)` — a bounded,
- * positional read (Bun resolves the slice lazily via `pread` under the
- * hood), never the whole-file `readFileSync` this design explicitly moves
- * away from (see `handleStorage`'s REST `Range` support in `src/routes.ts`
- * for the sibling fix on the byte-serve side).
- */
-
-import { existsSync, statSync } from "fs";
-import { join, normalize } from "path";
-import type { Attachment } from "../core/src/types.ts";
-import type { AttachmentBytesProvider } from "../core/src/attachment/bytes-provider.ts";
-import { assetsDir } from "./config.ts";
-import { transcriptPathFor } from "./transcript-note.ts";
-import { getVaultStore } from "./vault-store.ts";
-
-/**
- * Resolve + confine an attachment's on-disk path under this vault's assets
- * dir. Same guard as the ticket download spend route (`src/attachment-tickets.ts`)
- * and the REST byte-serve route (`src/routes.ts`): normalize, then require
- * the result to still start with the (normalized) assets root — a stored
- * `path` can never resolve outside it, but a defense-in-depth check costs
- * nothing. Returns `null` on a traversal attempt (treated identically to
- * "file doesn't exist" by every caller here).
- */
-function resolveConfinedPath(vaultName: string, attachment: Attachment): string | null {
-  const assets = assetsDir(vaultName);
-  const filePath = normalize(join(assets, attachment.path));
-  if (!filePath.startsWith(normalize(assets))) return null;
-  return filePath;
-}
-
-class FsAttachmentBytesProvider implements AttachmentBytesProvider {
-  constructor(private readonly vaultName: string) {}
-
-  async stat(attachment: Attachment): Promise<{ size: number } | null> {
-    const filePath = resolveConfinedPath(this.vaultName, attachment);
-    if (!filePath || !existsSync(filePath)) return null;
-    return { size: statSync(filePath).size };
-  }
-
-  async readRange(attachment: Attachment, start: number, end: number): Promise<Uint8Array> {
-    const filePath = resolveConfinedPath(this.vaultName, attachment);
-    if (!filePath) return new Uint8Array(0);
-    const slice = Bun.file(filePath).slice(start, end);
-    return new Uint8Array(await slice.arrayBuffer());
-  }
-
-  async resolveTranscriptNote(attachment: Attachment): Promise<{ id: string; path: string } | null> {
-    const store = getVaultStore(this.vaultName);
-    const note = await store.getNoteByPath(transcriptPathFor(attachment.path));
-    if (!note) return null;
-    return { id: note.id, path: note.path ?? transcriptPathFor(attachment.path) };
-  }
-}
-
-/** Build a fresh `AttachmentBytesProvider` scoped to one vault. Cheap — safe to call per-request. */
-export function createFsAttachmentBytesProvider(vaultName: string): AttachmentBytesProvider {
-  return new FsAttachmentBytesProvider(vaultName);
-}