@oomkapwn/enquire-mcp 3.5.13 → 3.6.0-rc.1

package/dist/tools/meta.js

@@ -0,0 +1,752 @@
+import * as path from "node:path";
+import matter from "gray-matter";
+import { getBacklinks, getRecentEdits, listTags } from "./read.js";
+import { searchHybrid } from "./search.js";
+import { resolveTarget, suggestSimilar } from "./write.js";
+export async function validateNoteProposal(vault, args) {
+    await vault.ensureExists();
+    const mode = args.mode ?? "create";
+    const errors = [];
+    const warnings = [];
+    // 1. Path sanity. resolveInside throws on traversal — capture as error,
+    //    don't let it propagate as a generic exception (the validator should
+    //    return a structured result for ANY input).
+    let normalizedPath = args.path.toLowerCase().endsWith(".md") ? args.path : `${args.path}.md`;
+    let absPath = null;
+    try {
+        absPath = vault.resolveInside(normalizedPath);
+        normalizedPath = vault.toRel(absPath);
+    }
+    catch (err) {
+        errors.push({
+            kind: "path-traversal",
+            message: err instanceof Error ? err.message : String(err)
+        });
+    }
+    // 2. YAML parse via gray-matter (the same parser used at write time).
+    const yamlReport = { parsed: false, error: null, keys: [] };
+    let bodyAfterFm = args.content;
+    try {
+        const parsed = matter(args.content);
+        yamlReport.parsed = true;
+        yamlReport.keys = Object.keys(parsed.data ?? {});
+        bodyAfterFm = parsed.content;
+    }
+    catch (err) {
+        yamlReport.error = err instanceof Error ? err.message : String(err);
+        errors.push({ kind: "yaml-invalid", message: `YAML frontmatter could not be parsed: ${yamlReport.error}` });
+    }
+    // 3. Wikilink resolution against the live vault.
+    const all = await vault.listMarkdown();
+    const wikilinkRe = /(?<!!)\[\[([^\]\n]+?)\]\]/g;
+    const wikilinks = [];
+    for (const m of bodyAfterFm.matchAll(wikilinkRe)) {
+        const raw = m[0];
+        const inner = (m[1] ?? "").trim();
+        if (!inner)
+            continue;
+        // Strip alias / section / block to get the bare target name.
+        const beforePipe = inner.split("|")[0] ?? "";
+        const beforeHash = beforePipe.split("#")[0] ?? "";
+        const target = beforeHash.split("^")[0]?.trim() ?? "";
+        if (!target)
+            continue;
+        const match = findBestMatch(all, target, normalizedPath);
+        if (match) {
+            wikilinks.push({
+                raw,
+                target,
+                status: "resolved",
+                resolved_path: match.relPath,
+                suggestions: []
+            });
+        }
+        else {
+            const suggestions = await suggestSimilar(vault, target);
+            wikilinks.push({
+                raw,
+                target,
+                status: "broken",
+                resolved_path: null,
+                suggestions
+            });
+            warnings.push({
+                kind: "broken-wikilink",
+                message: `[[${target}]] does not resolve to any existing note`,
+                suggestion: suggestions.length ? `Closest matches: ${suggestions.join(", ")}` : undefined
+            });
+        }
+    }
+    // 4. Tag pre-classification (existing vs new).
+    const existingTags = new Set((await listTags(vault, {})).map((t) => t.tag.toLowerCase()));
+    const proposedTagsRaw = new Set();
+    // Frontmatter tags.
+    const fmData = yamlReport.parsed ? matter(args.content).data : {};
+    const fmTags = fmData.tags ?? fmData.tag;
+    if (Array.isArray(fmTags)) {
+        for (const t of fmTags)
+            if (typeof t === "string" && t)
+                proposedTagsRaw.add(t.replace(/^#/, ""));
+    }
+    else if (typeof fmTags === "string" && fmTags) {
+        for (const t of fmTags.split(/[\s,]+/))
+            if (t)
+                proposedTagsRaw.add(t.replace(/^#/, ""));
+    }
+    // Inline tags.
+    const inlineTagRe = /(?:^|[\s([{>])#([\p{L}][\p{L}\p{N}_/-]*)/gu;
+    for (const m of bodyAfterFm.matchAll(inlineTagRe)) {
+        if (m[1])
+            proposedTagsRaw.add(m[1]);
+    }
+    const tags = [];
+    for (const t of proposedTagsRaw) {
+        const status = existingTags.has(t.toLowerCase()) ? "existing" : "new";
+        tags.push({ name: t, status });
+        if (status === "new") {
+            warnings.push({
+                kind: "new-tag",
+                message: `#${t} is new — won't fork an existing tag (case-insensitive check)`
+            });
+        }
+    }
+    // 5. Path collision check.
+    let collision = { kind: "none" };
+    if (absPath) {
+        try {
+            await vault.stat(absPath);
+            // Path exists.
+            if (mode === "create") {
+                errors.push({
+                    kind: "path-collision",
+                    message: `Note already exists at ${normalizedPath} (mode="create" refuses overwrite)`
+                });
+            }
+            collision = { kind: "path-exists", existing_path: normalizedPath };
+        }
+        catch {
+            // Path doesn't exist — try title collision (an existing note at a different path).
+            const titleFromBasename = stripMd(path.basename(normalizedPath));
+            const existing = await vault.findByTitle(titleFromBasename);
+            if (existing && existing.relPath !== normalizedPath) {
+                warnings.push({
+                    kind: "title-collision",
+                    message: `A note titled "${titleFromBasename}" already exists at ${existing.relPath} — proceeding will create a same-titled file at a different path`,
+                    suggestion: existing.relPath
+                });
+                collision = { kind: "title-exists-elsewhere", existing_path: existing.relPath };
+            }
+        }
+    }
+    return {
+        ok: errors.length === 0,
+        proposed_path: normalizedPath,
+        mode,
+        errors,
+        warnings,
+        yaml: yamlReport,
+        wikilinks,
+        tags,
+        collision
+    };
+}
+export async function lintWiki(vault, args) {
+    await vault.ensureExists();
+    const stubThreshold = args.stub_word_threshold ?? 100;
+    const staleDays = args.stale_days ?? 365;
+    const conceptMinMentions = args.concept_min_mentions ?? 3;
+    const cap = args.max_per_bucket ?? 50;
+    const entries = await vault.listMarkdown(args.folder);
+    const allEntries = await vault.listMarkdown();
+    const staleMs = Date.now() - staleDays * 24 * 3600 * 1000;
+    // Single pass: collect inbound counts, outbound presence, broken links,
+    // word counts, last-reviewed times, capitalised-phrase mentions.
+    const inbound = new Map();
+    const outboundPresence = new Set();
+    const broken = [];
+    const stubs = [];
+    const stale = [];
+    const titleSet = new Set();
+    for (const e of allEntries)
+        titleSet.add(stripMd(e.basename).toLowerCase());
+    // Capitalised-phrase mentions across the whole vault. A phrase is 1-3
+    // CapitalCase tokens (e.g. "Reinforcement Learning", "Attention Heads").
+    // Stop-words: dropped when they appear at the start of a phrase.
+    const conceptStopwords = new Set([
+        "The",
+        "A",
+        "An",
+        "This",
+        "That",
+        "These",
+        "Those",
+        "If",
+        "When",
+        "While",
+        "But",
+        "And",
+        "Or"
+    ]);
+    const capPhraseRe = /\b((?:[A-Z][a-z][a-z]+(?:\s+[A-Z][a-z][a-z]+){0,2}))\b/g;
+    const conceptMentions = new Map(); // phrase → set of source paths
+    for (const e of entries) {
+        const { parsed, mtimeMs } = await vault.readNote(e.absPath, e.mtimeMs);
+        // Outbound + broken pass.
+        if (parsed.wikilinks.length > 0)
+            outboundPresence.add(e.relPath);
+        for (const link of parsed.wikilinks) {
+            const m = findBestMatch(allEntries, link.target, e.relPath);
+            if (m) {
+                inbound.set(m.relPath, (inbound.get(m.relPath) ?? 0) + 1);
+            }
+            else if (broken.length < cap) {
+                broken.push({
+                    kind: "broken-link",
+                    path: e.relPath,
+                    message: `[[${link.target}]] in ${e.relPath} doesn't resolve`,
+                    suggestion: "create the missing note, fix the link, or remove it",
+                    details: { target: link.target, raw: link.raw }
+                });
+            }
+        }
+        // Stub pass.
+        const wordCount = parsed.body.trim() ? parsed.body.trim().split(/\s+/).length : 0;
+        if (wordCount < stubThreshold && stubs.length < cap) {
+            stubs.push({
+                kind: "stub",
+                path: e.relPath,
+                message: `${e.relPath} is ${wordCount} words (threshold ${stubThreshold})`,
+                suggestion: "develop, merge into a hub, or archive",
+                details: { word_count: wordCount, mtime: new Date(mtimeMs).toISOString() }
+            });
+        }
+        // Stale pass — frontmatter `last_reviewed` overrides mtime if present.
+        // gray-matter (js-yaml) parses ISO dates into Date objects automatically,
+        // so we accept Date | string | number.
+        const lastReviewedRaw = parsed.frontmatter?.last_reviewed ?? parsed.frontmatter?.["last-reviewed"];
+        let lastTouchedMs = mtimeMs;
+        if (lastReviewedRaw instanceof Date) {
+            const t = lastReviewedRaw.getTime();
+            if (Number.isFinite(t))
+                lastTouchedMs = t;
+        }
+        else if (typeof lastReviewedRaw === "string") {
+            const t = Date.parse(lastReviewedRaw);
+            if (Number.isFinite(t))
+                lastTouchedMs = t;
+        }
+        else if (typeof lastReviewedRaw === "number" && Number.isFinite(lastReviewedRaw)) {
+            lastTouchedMs = lastReviewedRaw;
+        }
+        if (lastTouchedMs < staleMs && stale.length < cap) {
+            stale.push({
+                kind: "stale",
+                path: e.relPath,
+                message: `${e.relPath} not touched since ${new Date(lastTouchedMs).toISOString().slice(0, 10)}`,
+                suggestion: "review for accuracy or archive",
+                details: {
+                    last_touched: new Date(lastTouchedMs).toISOString(),
+                    source: lastReviewedRaw !== undefined ? "frontmatter.last_reviewed" : "mtime"
+                }
+            });
+        }
+        // Concept-mention pass — capitalised phrases in the body that aren't
+        // already a wikilink target. Cap at 30 unique phrases per source to
+        // bound memory, but loose enough that real concepts in long notes don't
+        // get truncated.
+        const seenInThisNote = new Set();
+        for (const m of parsed.body.matchAll(capPhraseRe)) {
+            const phrase = m[1];
+            if (!phrase)
+                continue;
+            const firstWord = phrase.split(/\s+/)[0];
+            if (firstWord !== undefined && conceptStopwords.has(firstWord))
+                continue;
+            if (seenInThisNote.has(phrase))
+                continue;
+            if (seenInThisNote.size >= 30)
+                break;
+            // Skip phrases that are already a vault note (basename match).
+            if (titleSet.has(phrase.toLowerCase()))
+                continue;
+            seenInThisNote.add(phrase);
+            const set = conceptMentions.get(phrase) ?? new Set();
+            set.add(e.relPath);
+            conceptMentions.set(phrase, set);
+        }
+    }
+    // Orphan findings (no inbound AND no outbound).
+    const orphans = [];
+    for (const e of entries) {
+        if (orphans.length >= cap)
+            break;
+        if (!inbound.get(e.relPath) && !outboundPresence.has(e.relPath)) {
+            orphans.push({
+                kind: "orphan",
+                path: e.relPath,
+                message: `${e.relPath} has no inbound or outbound wikilinks`,
+                suggestion: "link from a hub note, archive, or delete",
+                details: { mtime: new Date(e.mtimeMs).toISOString() }
+            });
+        }
+    }
+    // Concept candidates — phrases mentioned by ≥ N distinct notes.
+    const conceptCandidates = [];
+    const ranked = [...conceptMentions.entries()]
+        .filter(([, sources]) => sources.size >= conceptMinMentions)
+        .sort((a, b) => b[1].size - a[1].size);
+    for (const [phrase, sources] of ranked) {
+        if (conceptCandidates.length >= cap)
+            break;
+        conceptCandidates.push({
+            kind: "concept-without-page",
+            message: `"${phrase}" is mentioned by ${sources.size} notes but has no page of its own`,
+            suggestion: `create a page \`${phrase}.md\` and refile the most-developed mentions into it`,
+            details: { phrase, mention_count: sources.size, sources: [...sources].slice(0, 5) }
+        });
+    }
+    return {
+        scope: args.folder ?? "(whole vault)",
+        scanned: entries.length,
+        generated_at: new Date().toISOString(),
+        summary: {
+            orphans: orphans.length,
+            broken_links: broken.length,
+            stubs: stubs.length,
+            stale: stale.length,
+            concept_candidates: conceptCandidates.length
+        },
+        findings: {
+            orphans,
+            broken_links: broken,
+            stubs,
+            stale,
+            concept_candidates: conceptCandidates
+        }
+    };
+}
+export async function getOpenQuestions(vault, args) {
+    await vault.ensureExists();
+    const limit = args.limit ?? 100;
+    // Default pattern: "Open question:" / "Open question -" / "Q:" / "TODO?" / "??"
+    // followed by space + question text. Anchored at line start (with optional
+    // list-bullet / quote / heading prefix).
+    // Default pattern matches deferred-thinking markers at line start (with
+    // optional list-bullet / quote / heading prefix). Single-line `i` flag —
+    // we apply it line-by-line below.
+    const defaultPat = "^\\s*(?:[#\\->\\*\\d\\.]+\\s+)?(?:open\\s+question|q|todo\\?|\\?\\?)\\s*[:\\-]?\\s*(.+)$";
+    const re = new RegExp(args.pattern ?? defaultPat, "i");
+    const entries = await vault.listMarkdown(args.folder);
+    const out = [];
+    const now = Date.now();
+    for (const e of entries) {
+        if (out.length >= limit)
+            break;
+        const { parsed, mtimeMs } = await vault.readNote(e.absPath, e.mtimeMs);
+        // Scan parsed.body so frontmatter lines (which can contain "Q:" -ish
+        // tokens) don't pollute results.
+        const lines = parsed.body.split("\n");
+        let currentHeading = null;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i] ?? "";
+            const headingMatch = /^(#{1,6})\s+(.+?)\s*#*\s*$/.exec(line);
+            if (headingMatch?.[2]) {
+                currentHeading = headingMatch[2];
+                // A heading line itself isn't a question hit — skip the regex match.
+                continue;
+            }
+            const m = re.exec(line);
+            if (!m?.[1])
+                continue;
+            out.push({
+                question: m[1].trim(),
+                source_path: e.relPath,
+                source_title: stripMd(e.basename),
+                context_heading: currentHeading,
+                line: i + 1,
+                age_days: Math.round((now - mtimeMs) / (24 * 3600 * 1000)),
+                mtime: new Date(mtimeMs).toISOString()
+            });
+            if (out.length >= limit)
+                break;
+        }
+    }
+    // Sort oldest-first so things aging out surface first.
+    out.sort((a, b) => b.age_days - a.age_days);
+    return out;
+}
+export async function paperAudit(vault, args) {
+    await vault.ensureExists();
+    const tag = (args.tag ?? "paper").replace(/^#+/, "").toLowerCase();
+    const limit = args.limit ?? 100;
+    const entries = await vault.listMarkdown(args.folder);
+    const arxivRe = /\barxiv[:\s]*([0-9]{4}\.[0-9]{4,5}(?:v\d+)?)\b/gi;
+    const doiRe = /\bdoi[:\s]*(10\.\d{4,9}\/[\w\-._;()/:]+)/gi;
+    const urlRe = /\bhttps?:\/\/[^\s<>")\]]+/g;
+    let scanned = 0;
+    const flagged = [];
+    for (const e of entries) {
+        if (flagged.length >= limit)
+            break;
+        const { parsed } = await vault.readNote(e.absPath, e.mtimeMs);
+        const tagsLower = parsed.tags.map((t) => t.toLowerCase());
+        if (!tagsLower.includes(tag))
+            continue;
+        scanned += 1;
+        const fm = parsed.frontmatter ?? {};
+        const fmKeys = new Set(Object.keys(fm).map((k) => k.toLowerCase()));
+        const hasFmCitation = fmKeys.has("arxiv") || fmKeys.has("doi") || fmKeys.has("url") || fmKeys.has("isbn");
+        // Scan parsed.body so the frontmatter's own arxiv/doi keys don't get
+        // re-detected as "found in body".
+        const body = parsed.body;
+        const arxivIds = [...body.matchAll(arxivRe)].map((m) => m[1]).filter((v) => !!v);
+        const doiIds = [...body.matchAll(doiRe)].map((m) => m[1]).filter((v) => !!v);
+        const urls = [...body.matchAll(urlRe)].map((m) => m[0]);
+        const foundInBody = {
+            arxiv: [...new Set(arxivIds)],
+            doi: [...new Set(doiIds)],
+            url: [...new Set(urls)].slice(0, 3)
+        };
+        const bodyHasAnyId = foundInBody.arxiv.length > 0 || foundInBody.doi.length > 0 || foundInBody.url.length > 0;
+        // Clean ⇒ has a frontmatter citation. The body might cite OTHER papers,
+        // but this note itself is properly identified.
+        if (hasFmCitation)
+            continue;
+        let proposed = null;
+        if (bodyHasAnyId) {
+            proposed = {};
+            if (foundInBody.arxiv[0])
+                proposed.arxiv = foundInBody.arxiv[0];
+            if (foundInBody.doi[0])
+                proposed.doi = foundInBody.doi[0];
+            if (foundInBody.url[0] && !proposed.arxiv && !proposed.doi)
+                proposed.url = foundInBody.url[0];
+        }
+        const msg = bodyHasAnyId
+            ? `${e.relPath} has identifiers in body (${[
+                ...foundInBody.arxiv.map((v) => `arxiv:${v}`),
+                ...foundInBody.doi.map((v) => `doi:${v}`)
+            ]
+                .slice(0, 2)
+                .join(", ")}) but missing frontmatter`
+            : `${e.relPath} has #${tag} but no arxiv/doi/url anywhere — citation missing`;
+        flagged.push({
+            path: e.relPath,
+            title: stripMd(e.basename),
+            has_frontmatter_citation: hasFmCitation,
+            found_in_body: foundInBody,
+            proposed_frontmatter_patch: proposed,
+            message: msg
+        });
+    }
+    return { scanned, flagged };
+}
+export async function findPath(vault, args) {
+    await vault.ensureExists();
+    const maxDepth = args.max_depth ?? 5;
+    const includeAlts = args.include_alternatives === true;
+    const followEmbeds = args.follow_embeds !== false;
+    const fromArgs = {};
+    if (args.from !== undefined)
+        fromArgs.path = args.from;
+    else if (args.from_title !== undefined)
+        fromArgs.title = args.from_title;
+    const fromEntry = await resolveTarget(vault, fromArgs);
+    const toArgs = {};
+    if (args.to !== undefined)
+        toArgs.path = args.to;
+    else if (args.to_title !== undefined)
+        toArgs.title = args.to_title;
+    const toEntry = await resolveTarget(vault, toArgs);
+    if (fromEntry.absPath === toEntry.absPath) {
+        return {
+            from: fromEntry.relPath,
+            to: toEntry.relPath,
+            found: true,
+            hops: 0,
+            path: [{ path: fromEntry.relPath, title: stripMd(fromEntry.basename), via: "" }]
+        };
+    }
+    const entries = await vault.listMarkdown();
+    // BFS layer-by-layer. visited tracks shortest-known-depth so we don't
+    // revisit at greater depths. We continue collecting at the depth where
+    // we first hit the target IF include_alternatives is set.
+    // v1.8.1 perf fix: build a relPath → entry map ONCE before the BFS loop.
+    // Pre-fix: entries.find((e) => e.relPath === node.rel) was O(N) per visited
+    // node, making the whole BFS O(N²) on large vaults.
+    const byRel = new Map();
+    for (const e of entries)
+        byRel.set(e.relPath, e);
+    const visited = new Set([fromEntry.relPath]);
+    let frontier = [
+        { rel: fromEntry.relPath, trail: [{ path: fromEntry.relPath, title: stripMd(fromEntry.basename), via: "" }] }
+    ];
+    const found = [];
+    let foundDepth = -1;
+    for (let depth = 0; depth < maxDepth && frontier.length > 0; depth++) {
+        const next = [];
+        for (const node of frontier) {
+            const entry = byRel.get(node.rel);
+            if (!entry)
+                continue;
+            const { parsed } = await vault.readNote(entry.absPath, entry.mtimeMs);
+            const links = followEmbeds ? [...parsed.wikilinks, ...parsed.embeds] : parsed.wikilinks;
+            for (const link of links) {
+                const m = findBestMatch(entries, link.target, entry.relPath);
+                if (!m)
+                    continue;
+                if (visited.has(m.relPath) && m.absPath !== toEntry.absPath)
+                    continue;
+                const newTrail = [...node.trail, { path: m.relPath, title: stripMd(m.basename), via: link.raw }];
+                if (m.absPath === toEntry.absPath) {
+                    if (foundDepth === -1)
+                        foundDepth = depth + 1;
+                    if (foundDepth === depth + 1) {
+                        found.push(newTrail);
+                        if (!includeAlts) {
+                            return {
+                                from: fromEntry.relPath,
+                                to: toEntry.relPath,
+                                found: true,
+                                hops: foundDepth,
+                                path: newTrail
+                            };
+                        }
+                    }
+                }
+                else {
+                    visited.add(m.relPath);
+                    next.push({ rel: m.relPath, trail: newTrail });
+                }
+            }
+        }
+        if (foundDepth !== -1 && depth + 1 === foundDepth)
+            break;
+        frontier = next;
+    }
+    if (found.length > 0) {
+        found.sort((a, b) => a.length - b.length || (a[0]?.path ?? "").localeCompare(b[0]?.path ?? ""));
+        const first = found[0];
+        if (!first) {
+            return { from: fromEntry.relPath, to: toEntry.relPath, found: false, hops: -1, path: [] };
+        }
+        const result = {
+            from: fromEntry.relPath,
+            to: toEntry.relPath,
+            found: true,
+            hops: foundDepth,
+            path: first
+        };
+        if (includeAlts)
+            result.alternatives = found.slice(0, 10);
+        return result;
+    }
+    return { from: fromEntry.relPath, to: toEntry.relPath, found: false, hops: -1, path: [] };
+}
+export async function openInUi(vault, args) {
+    await vault.ensureExists();
+    const target = await resolveTarget(vault, args);
+    // Vault name = leaf of the vault root path. obsidian:// matches by name OR
+    // by the file's absolute path; if the user opened the vault from a
+    // different name in Obsidian, the file argument still resolves correctly.
+    const vaultName = path.basename(vault.root);
+    const noteRel = stripMd(target.relPath);
+    const params = new URLSearchParams({ vault: vaultName, file: noteRel });
+    if (args.new_pane)
+        params.set("newpane", "true");
+    return {
+        uri: `obsidian://open?${params.toString()}`,
+        vault_name: vaultName,
+        path: target.relPath,
+        title: stripMd(target.basename)
+    };
+}
+export async function contextPack(vault, args, ctx) {
+    await vault.ensureExists();
+    if (!args.query?.trim())
+        throw new Error("context_pack: `query` is required");
+    const budget = args.budget_tokens ?? 4000;
+    const charBudget = budget * 4; // ~4 chars/token
+    const includeBacklinks = args.include_backlinks !== false;
+    const recentN = Math.max(0, args.recent_dailies ?? 0);
+    // 1) Hybrid retrieval — top-K notes
+    const search = await searchHybrid(vault, { query: args.query, folder: args.folder, limit: 10 }, { ftsIndex: ctx.ftsIndex, embedFile: ctx.embedFile });
+    const sections = [`# Context for: ${args.query}\n`];
+    const includedNotes = [];
+    let charsUsed = sections[0]?.length ?? 0;
+    let notesBytes = 0;
+    let backlinksBytes = 0;
+    let dailiesBytes = 0;
+    // 2) Pack note bodies until budget exhausted
+    sections.push("## Top notes");
+    for (const m of search.matches) {
+        if (charsUsed >= charBudget)
+            break;
+        try {
+            const note = await vault.readNote(vault.resolveInside(m.path), undefined);
+            const body = note.parsed.body.trim();
+            const headerLen = m.path.length + 5;
+            const remaining = charBudget - charsUsed;
+            // Truncate body to fit remaining budget for THIS note (~50% of remainder
+            // so we leave room for backlinks + dailies).
+            const noteCap = Math.min(body.length, Math.max(500, Math.floor(remaining * 0.5)));
+            const trimmed = body.length <= noteCap ? body : `${body.slice(0, noteCap)}\n\n[…truncated…]`;
+            const block = `### ${m.path}\n\n${trimmed}\n`;
+            sections.push(block);
+            charsUsed += block.length + headerLen;
+            notesBytes += block.length;
+            includedNotes.push(m.path);
+        }
+        catch {
+            // skip unreadable notes
+        }
+    }
+    // 3) 1-line backlink summaries for top-3
+    if (includeBacklinks && includedNotes.length > 0 && charsUsed < charBudget) {
+        sections.push("## Backlinks");
+        let backlinksAdded = 0;
+        for (const notePath of includedNotes.slice(0, 3)) {
+            if (charsUsed >= charBudget)
+                break;
+            try {
+                const links = await getBacklinks(vault, { path: notePath, limit: 5 });
+                if (links.length > 0) {
+                    const block = `### → ${notePath}\n${links.map((l) => `- ${l.path} : ${(l.snippets[0] ?? "").slice(0, 80)}`).join("\n")}\n`;
+                    sections.push(block);
+                    charsUsed += block.length;
+                    backlinksBytes += block.length;
+                    backlinksAdded += links.length;
+                }
+            }
+            catch {
+                // skip
+            }
+        }
+        if (backlinksAdded === 0)
+            sections.pop(); // remove empty heading
+    }
+    // 4) Recent daily notes
+    if (recentN > 0 && charsUsed < charBudget) {
+        try {
+            const recent = await getRecentEdits(vault, { since_minutes: 60 * 24 * 7, limit: recentN, folder: args.folder });
+            const dailies = recent.filter((r) => /\d{4}-\d{2}-\d{2}/.test(r.path));
+            if (dailies.length > 0) {
+                sections.push(`## Recent (${dailies.length} dailies, last 7 days)`);
+                for (const d of dailies) {
+                    if (charsUsed >= charBudget)
+                        break;
+                    const block = `- ${d.path} (${d.mtime})`;
+                    sections.push(block);
+                    charsUsed += block.length;
+                    dailiesBytes += block.length;
+                }
+            }
+        }
+        catch {
+            // skip
+        }
+    }
+    const bundle = sections.join("\n");
+    return {
+        query: args.query,
+        bundle,
+        estimated_tokens: Math.ceil(bundle.length / 4),
+        budget_tokens: budget,
+        sections: { notes: notesBytes, backlinks: backlinksBytes, dailies: dailiesBytes },
+        included_notes: includedNotes
+    };
+}
+// ─── small set / string helpers shared by find_similar / get_note_neighbors ─
+export function jaccard(a, b) {
+    if (a.size === 0 && b.size === 0)
+        return 0;
+    let inter = 0;
+    for (const x of a)
+        if (b.has(x))
+            inter += 1;
+    const union = a.size + b.size - inter;
+    return union === 0 ? 0 : inter / union;
+}
+export function intersectionSize(a, b) {
+    let n = 0;
+    for (const x of a)
+        if (b.has(x))
+            n += 1;
+    return n;
+}
+export function ngrams(s, n) {
+    const out = new Set();
+    if (s.length < n) {
+        if (s)
+            out.add(s);
+        return out;
+    }
+    for (let i = 0; i <= s.length - n; i++)
+        out.add(s.slice(i, i + n));
+    return out;
+}
+const entryIndexCache = new WeakMap();
+export function indexFor(entries) {
+    const cached = entryIndexCache.get(entries);
+    if (cached)
+        return cached;
+    const byBasename = new Map();
+    const byRelPath = new Map();
+    for (const e of entries) {
+        const key = stripMd(e.basename).toLowerCase();
+        const slot = byBasename.get(key);
+        if (slot)
+            slot.push(e);
+        else
+            byBasename.set(key, [e]);
+        byRelPath.set(stripMd(e.relPath).toLowerCase(), e);
+    }
+    const idx = { byBasename, byRelPath };
+    entryIndexCache.set(entries, idx);
+    return idx;
+}
+export function findBestMatch(entries, target, fromNote) {
+    const idx = indexFor(entries);
+    if (target.startsWith("./") || target.startsWith("../") || target.includes("/../")) {
+        if (fromNote) {
+            const fromDir = path.dirname(fromNote);
+            const joined = path.posix.normalize(path.posix.join(fromDir.split(path.sep).join("/"), target));
+            const lower = stripMd(joined).toLowerCase();
+            const rel = idx.byRelPath.get(lower);
+            if (rel)
+                return rel;
+        }
+    }
+    const norm = stripMd(target).toLowerCase();
+    const exact = idx.byBasename.get(norm) ?? [];
+    if (exact.length === 1)
+        return exact[0] ?? null;
+    if (exact.length > 1 && fromNote) {
+        const fromDir = path.dirname(fromNote);
+        const sameDir = exact.find((e) => path.dirname(e.relPath) === fromDir);
+        if (sameDir)
+            return sameDir;
+    }
+    if (exact.length > 0)
+        return exact[0] ?? null;
+    if (target.includes("/")) {
+        const lower = stripMd(target).toLowerCase();
+        const path1 = idx.byRelPath.get(lower);
+        if (path1)
+            return path1;
+        // endsWith match — falls back to a scan, but only for path-qualified
+        // targets that don't exact-match (rare).
+        for (const e of entries) {
+            if (stripMd(e.relPath).toLowerCase().endsWith(`/${lower}`))
+                return e;
+        }
+    }
+    return null;
+}
+export function stripMd(name) {
+    return name.replace(/\.md$/i, "");
+}
+export function normalizeTag(t) {
+    return t.replace(/^#+/, "").toLowerCase();
+}
+//# sourceMappingURL=meta.js.map