@oomkapwn/enquire-mcp 1.6.0 → 1.8.0

package/dist/tools.js

@@ -1445,6 +1445,381 @@ export async function openInUi(vault, args) {
         title: stripMd(target.basename)
     };
 }
+export async function listCanvases(vault, args) {
+    await vault.ensureExists();
+    const limit = args.limit ?? 100;
+    const all = await vault.listFilesByExtension(".canvas", args.folder);
+    const out = [];
+    for (const e of all) {
+        if (out.length >= limit)
+            break;
+        let nodeCount = 0;
+        let edgeCount = 0;
+        let size = e.mtimeMs; // placeholder; replaced below
+        try {
+            const buf = await vault.readBinaryFile(e.absPath);
+            size = buf.byteLength;
+            const txt = buf.toString("utf8");
+            const parsed = JSON.parse(txt);
+            nodeCount = Array.isArray(parsed.nodes) ? parsed.nodes.length : 0;
+            edgeCount = Array.isArray(parsed.edges) ? parsed.edges.length : 0;
+        }
+        catch {
+            // Malformed canvas — fall through with 0 counts. Don't poison the listing.
+        }
+        out.push({
+            path: e.relPath,
+            name: e.basename.replace(/\.canvas$/i, ""),
+            size_bytes: size,
+            mtime: new Date(e.mtimeMs).toISOString(),
+            node_count: nodeCount,
+            edge_count: edgeCount
+        });
+    }
+    out.sort((a, b) => b.mtime.localeCompare(a.mtime));
+    return out;
+}
+export async function readCanvas(vault, args) {
+    await vault.ensureExists();
+    if (!args.path)
+        throw new Error("path is required");
+    const normalized = args.path.toLowerCase().endsWith(".canvas") ? args.path : `${args.path}.canvas`;
+    const abs = vault.resolveInside(normalized);
+    await vault.stat(abs); // throws if missing or excluded — fail fast
+    const rel = vault.toRel(abs);
+    const buf = await vault.readBinaryFile(abs);
+    let parsed;
+    try {
+        parsed = JSON.parse(buf.toString("utf8"));
+    }
+    catch (err) {
+        throw new Error(`Canvas file is not valid JSON: ${rel} — ${err instanceof Error ? err.message : String(err)}`);
+    }
+    // Resolve each `file:` node's reference against the vault's current
+    // markdown index — surfaces broken canvas links the same way
+    // get_unresolved_wikilinks does for note bodies.
+    const allMarkdown = await vault.listMarkdown();
+    const nodes = [];
+    const summary = { text: 0, file: 0, link: 0, group: 0, unknown: 0 };
+    const brokenRefs = [];
+    if (Array.isArray(parsed.nodes)) {
+        for (const raw of parsed.nodes) {
+            if (!raw || typeof raw !== "object")
+                continue;
+            const n = raw;
+            const id = typeof n.id === "string" ? n.id : "";
+            const x = typeof n.x === "number" ? n.x : 0;
+            const y = typeof n.y === "number" ? n.y : 0;
+            const width = typeof n.width === "number" ? n.width : 0;
+            const height = typeof n.height === "number" ? n.height : 0;
+            const color = typeof n.color === "string" ? n.color : undefined;
+            const type = typeof n.type === "string" ? n.type : "unknown";
+            switch (type) {
+                case "text":
+                    nodes.push({
+                        kind: "text",
+                        id,
+                        x,
+                        y,
+                        width,
+                        height,
+                        text: typeof n.text === "string" ? n.text : "",
+                        ...(color !== undefined ? { color } : {})
+                    });
+                    summary.text += 1;
+                    break;
+                case "file": {
+                    const fileRef = typeof n.file === "string" ? n.file : "";
+                    // Strip leading slash so `findBestMatch` treats it as relative.
+                    const cleaned = fileRef.replace(/^\/+/, "");
+                    // findBestMatch only looks at the basename; for canvases we have a full
+                    // vault-relative path, so try direct match first. Fall through to
+                    // findBestMatch (basename) for the path-stripped case.
+                    const direct = cleaned.length > 0 ? allMarkdown.find((m) => m.relPath.replace(/\\/g, "/") === cleaned) : undefined;
+                    const resolved = direct ?? (cleaned ? findBestMatch(allMarkdown, cleaned) : null);
+                    if (cleaned && !resolved)
+                        brokenRefs.push(cleaned);
+                    nodes.push({
+                        kind: "file",
+                        id,
+                        x,
+                        y,
+                        width,
+                        height,
+                        file: fileRef,
+                        file_resolved: resolved ? resolved.relPath : null,
+                        ...(typeof n.subpath === "string" ? { subpath: n.subpath } : {}),
+                        ...(color !== undefined ? { color } : {})
+                    });
+                    summary.file += 1;
+                    break;
+                }
+                case "link":
+                    nodes.push({
+                        kind: "link",
+                        id,
+                        x,
+                        y,
+                        width,
+                        height,
+                        url: typeof n.url === "string" ? n.url : "",
+                        ...(color !== undefined ? { color } : {})
+                    });
+                    summary.link += 1;
+                    break;
+                case "group":
+                    nodes.push({
+                        kind: "group",
+                        id,
+                        x,
+                        y,
+                        width,
+                        height,
+                        ...(typeof n.label === "string" ? { label: n.label } : {}),
+                        ...(color !== undefined ? { color } : {})
+                    });
+                    summary.group += 1;
+                    break;
+                default:
+                    nodes.push({ kind: "unknown", id, raw_type: type, raw: n });
+                    summary.unknown += 1;
+            }
+        }
+    }
+    const edges = [];
+    if (Array.isArray(parsed.edges)) {
+        for (const raw of parsed.edges) {
+            if (!raw || typeof raw !== "object")
+                continue;
+            const e = raw;
+            const id = typeof e.id === "string" ? e.id : "";
+            const fromNode = typeof e.fromNode === "string" ? e.fromNode : "";
+            const toNode = typeof e.toNode === "string" ? e.toNode : "";
+            if (!fromNode || !toNode)
+                continue;
+            edges.push({
+                id,
+                from_node: fromNode,
+                ...(typeof e.fromSide === "string" ? { from_side: e.fromSide } : {}),
+                to_node: toNode,
+                ...(typeof e.toSide === "string" ? { to_side: e.toSide } : {}),
+                ...(typeof e.label === "string" ? { label: e.label } : {}),
+                ...(typeof e.color === "string" ? { color: e.color } : {})
+            });
+        }
+    }
+    const stat = await vault.stat(abs);
+    return {
+        path: rel,
+        name: path.basename(rel).replace(/\.canvas$/i, ""),
+        size_bytes: stat.size,
+        mtime: new Date(stat.mtimeMs).toISOString(),
+        nodes,
+        edges,
+        summary,
+        broken_file_refs: brokenRefs
+    };
+}
+const tfidfCache = new WeakMap();
+const STOP_WORDS = new Set([
+    "a",
+    "an",
+    "and",
+    "are",
+    "as",
+    "at",
+    "be",
+    "but",
+    "by",
+    "for",
+    "from",
+    "has",
+    "have",
+    "if",
+    "in",
+    "is",
+    "it",
+    "its",
+    "of",
+    "on",
+    "or",
+    "that",
+    "the",
+    "this",
+    "to",
+    "was",
+    "were",
+    "will",
+    "with",
+    "i",
+    "you",
+    "we",
+    "they",
+    "he",
+    "she",
+    "not",
+    "no",
+    "do",
+    "does",
+    "did",
+    "had",
+    "been",
+    "being",
+    "so",
+    "than",
+    "then",
+    "there",
+    "their",
+    "them",
+    "these",
+    "those",
+    "what",
+    "when",
+    "where",
+    "which",
+    "who",
+    "why",
+    "how"
+]);
+function tokenizeForTfidf(text) {
+    const lower = text.toLowerCase();
+    const out = [];
+    for (const m of lower.matchAll(/[a-z0-9][a-z0-9_-]*/g)) {
+        const t = m[0];
+        if (t.length < 2)
+            continue;
+        if (t.length > 40)
+            continue;
+        if (STOP_WORDS.has(t))
+            continue;
+        out.push(t);
+    }
+    return out;
+}
+async function buildTfidfIndex(vault) {
+    const entries = await vault.listMarkdown();
+    const cached = tfidfCache.get(vault);
+    if (cached &&
+        cached.entriesRef.length === entries.length &&
+        cached.entriesRef.every((e, i) => entries[i]?.relPath === e.relPath && entries[i]?.mtimeMs === e.mtimeMs)) {
+        return cached;
+    }
+    const rawDocs = [];
+    const docFreq = new Map();
+    for (const e of entries) {
+        const { parsed } = await vault.readNote(e.absPath, e.mtimeMs);
+        const tokens = tokenizeForTfidf(parsed.body);
+        const tf = new Map();
+        for (const t of tokens)
+            tf.set(t, (tf.get(t) ?? 0) + 1);
+        rawDocs.push({ entry: e, tf });
+        for (const t of tf.keys())
+            docFreq.set(t, (docFreq.get(t) ?? 0) + 1);
+    }
+    // Smoothed IDF: ln(1 + N / (1 + df)). Smoothing keeps every-doc terms
+    // non-zero and tames inflation on small vaults.
+    const N = rawDocs.length || 1;
+    const idf = new Map();
+    for (const [term, df] of docFreq) {
+        idf.set(term, Math.log(1 + N / (1 + df)));
+    }
+    const docs = [];
+    for (const r of rawDocs) {
+        const weights = new Map();
+        let normSq = 0;
+        for (const [term, count] of r.tf) {
+            const w = (1 + Math.log(count)) * (idf.get(term) ?? 0);
+            if (w === 0)
+                continue;
+            weights.set(term, w);
+            normSq += w * w;
+        }
+        const norm = Math.sqrt(normSq);
+        if (norm > 0) {
+            for (const [t, w] of weights)
+                weights.set(t, w / norm);
+        }
+        docs.push({
+            relPath: r.entry.relPath,
+            basename: r.entry.basename,
+            mtimeMs: r.entry.mtimeMs,
+            weights
+        });
+    }
+    const result = { docs, idf, entriesRef: entries };
+    tfidfCache.set(vault, result);
+    return result;
+}
+export async function semanticSearch(vault, args) {
+    await vault.ensureExists();
+    const limit = args.limit ?? 10;
+    const minScore = args.min_score ?? 0.05;
+    if (!args.query.trim())
+        throw new Error("query must not be empty");
+    const { docs, idf } = await buildTfidfIndex(vault);
+    // Vectorize query: same tokenization, IDF from the corpus, L2 normalize.
+    const qTokens = tokenizeForTfidf(args.query);
+    const qTf = new Map();
+    for (const t of qTokens)
+        qTf.set(t, (qTf.get(t) ?? 0) + 1);
+    const qWeights = new Map();
+    let qNormSq = 0;
+    for (const [t, count] of qTf) {
+        const w = (1 + Math.log(count)) * (idf.get(t) ?? 0);
+        if (w === 0)
+            continue;
+        qWeights.set(t, w);
+        qNormSq += w * w;
+    }
+    const qNorm = Math.sqrt(qNormSq);
+    if (qNorm > 0) {
+        for (const [t, w] of qWeights)
+            qWeights.set(t, w / qNorm);
+    }
+    // Cosine = Σ q[t]·d[t] over shared terms (both vectors are L2-normed).
+    const folderPrefix = args.folder ? `${args.folder.replace(/\/+$/, "")}/` : null;
+    const scored = [];
+    for (const doc of docs) {
+        if (folderPrefix && !doc.relPath.startsWith(folderPrefix) && doc.relPath !== args.folder)
+            continue;
+        let s = 0;
+        const matched = [];
+        for (const [t, qw] of qWeights) {
+            const dw = doc.weights.get(t);
+            if (dw !== undefined) {
+                s += qw * dw;
+                matched.push(t);
+            }
+        }
+        if (s < minScore)
+            continue;
+        scored.push({ doc, score: s, matchedTerms: matched });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    const matches = [];
+    for (const { doc, score, matchedTerms } of scored.slice(0, limit)) {
+        matchedTerms.sort((a, b) => (idf.get(b) ?? 0) - (idf.get(a) ?? 0));
+        const { content } = await vault.readNote(vault.resolveInside(doc.relPath), doc.mtimeMs);
+        let snippetText = "";
+        for (const t of matchedTerms) {
+            const idx = content.toLowerCase().indexOf(t);
+            if (idx >= 0) {
+                const { snippet } = sliceSnippet(content, idx, t.length);
+                snippetText = snippet;
+                break;
+            }
+        }
+        matches.push({
+            path: doc.relPath,
+            title: stripMd(doc.basename),
+            score: Math.round(score * 10000) / 10000,
+            snippet: snippetText,
+            matched_terms: matchedTerms.slice(0, 8),
+            mtime: new Date(doc.mtimeMs).toISOString()
+        });
+    }
+    return { query: args.query, total_docs: docs.length, method: "tfidf-cosine", matches };
+}
 // ─── small set / string helpers shared by find_similar / get_note_neighbors ─
 function jaccard(a, b) {
     if (a.size === 0 && b.size === 0)