@tekmidian/pai 0.5.7 → 0.6.0

package/dist/zettelkasten-cdajbnPr.mjs

@@ -0,0 +1,708 @@
+import { a as generateEmbedding, n as cosineSimilarity, r as deserializeEmbedding } from "./embeddings-DGRAPAYb.mjs";
+import { t as zettelThemes } from "./themes-BvYF0W8T.mjs";
+import { basename, dirname } from "node:path";
+
+//#region src/zettelkasten/explore.ts
+function classifyEdge(source, target) {
+	return dirname(source) === dirname(target) ? "sequential" : "associative";
+}
+async function resolveStart(backend, startNote) {
+	const files = await backend.getVaultFilesByPaths([startNote]);
+	if (files.length > 0) return files[0].vaultPath;
+	const alias = await backend.getVaultAlias(startNote);
+	if (!alias) return null;
+	const canonical = await backend.getVaultFilesByPaths([alias.canonicalPath]);
+	return canonical.length > 0 ? canonical[0].vaultPath : null;
+}
+async function getForwardNeighbors(backend, path) {
+	return (await backend.getLinksFromSource(path)).filter((l) => l.targetPath !== null).map((l) => l.targetPath);
+}
+async function getBackwardNeighbors(backend, path) {
+	return (await backend.getLinksToTarget(path)).map((l) => l.sourcePath);
+}
+async function getFileInfo(backend, path) {
+	const [files, health] = await Promise.all([backend.getVaultFilesByPaths([path]), backend.getVaultHealth(path)]);
+	return {
+		title: files[0]?.title ?? null,
+		inbound: health?.inboundCount ?? 0,
+		outbound: health?.outboundCount ?? 0
+	};
+}
+/**
+* Traverse the Zettelkasten link graph using BFS, following chains of thought
+* from a starting note up to a configurable depth.
+*/
+async function zettelExplore(backend, opts) {
+	const depth = Math.min(Math.max(opts.depth ?? 3, 1), 10);
+	const direction = opts.direction ?? "both";
+	const mode = opts.mode ?? "all";
+	const root = await resolveStart(backend, opts.startNote);
+	if (!root) return {
+		root: opts.startNote,
+		nodes: [],
+		edges: [],
+		branchingPoints: [],
+		maxDepthReached: false
+	};
+	const visited = new Set([root]);
+	const nodes = [];
+	const edges = [];
+	let maxDepthReached = false;
+	const queue = [{
+		path: root,
+		depth: 0
+	}];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		if (current.depth >= depth) {
+			maxDepthReached = true;
+			continue;
+		}
+		const neighbors = [];
+		if (direction === "forward" || direction === "both") for (const n of await getForwardNeighbors(backend, current.path)) neighbors.push({
+			neighbor: n,
+			from: current.path,
+			to: n
+		});
+		if (direction === "backward" || direction === "both") for (const n of await getBackwardNeighbors(backend, current.path)) neighbors.push({
+			neighbor: n,
+			from: n,
+			to: current.path
+		});
+		for (const { neighbor, from, to } of neighbors) {
+			const edgeType = classifyEdge(from, to);
+			if (mode !== "all" && edgeType !== mode) continue;
+			if (!edges.some((e) => e.from === from && e.to === to)) edges.push({
+				from,
+				to,
+				type: edgeType
+			});
+			if (!visited.has(neighbor)) {
+				visited.add(neighbor);
+				const info = await getFileInfo(backend, neighbor);
+				nodes.push({
+					path: neighbor,
+					title: info.title,
+					depth: current.depth + 1,
+					linkType: edgeType,
+					inbound: info.inbound,
+					outbound: info.outbound
+				});
+				queue.push({
+					path: neighbor,
+					depth: current.depth + 1
+				});
+			}
+		}
+	}
+	const branchingPoints = nodes.filter((n) => n.outbound > 2).map((n) => n.path);
+	if ((await getFileInfo(backend, root)).outbound > 2) branchingPoints.unshift(root);
+	return {
+		root,
+		nodes,
+		edges,
+		branchingPoints,
+		maxDepthReached
+	};
+}
+
+//#endregion
+//#region src/zettelkasten/surprise.ts
+const MAX_CHUNKS$1 = 5e3;
+const BFS_HOP_CAP = 20;
+async function getFileEmbeddings(backend, projectId) {
+	const rows = await backend.getChunksWithEmbeddings(projectId, MAX_CHUNKS$1);
+	const byPath = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const vec = deserializeEmbedding(row.embedding);
+		const entry = byPath.get(row.path);
+		if (!entry) byPath.set(row.path, {
+			sum: new Float32Array(vec),
+			count: 1,
+			text: row.text
+		});
+		else {
+			for (let i = 0; i < vec.length; i++) entry.sum[i] += vec[i];
+			entry.count++;
+		}
+	}
+	const result = /* @__PURE__ */ new Map();
+	for (const [path, { sum, count, text }] of byPath) {
+		const avg = new Float32Array(sum.length);
+		for (let i = 0; i < sum.length; i++) avg[i] = sum[i] / count;
+		result.set(path, {
+			embedding: avg,
+			text
+		});
+	}
+	return result;
+}
+async function getReferenceEmbedding(backend, projectId, path) {
+	const rows = await backend.getChunksForPath(projectId, path);
+	if (rows.length === 0) return {
+		embedding: new Float32Array(0),
+		found: false
+	};
+	const embRows = rows.filter((r) => r.embedding !== null);
+	if (embRows.length === 0) return {
+		embedding: new Float32Array(0),
+		found: false
+	};
+	const dim = deserializeEmbedding(embRows[0].embedding).length;
+	const sum = new Float32Array(dim);
+	for (const row of embRows) {
+		const vec = deserializeEmbedding(row.embedding);
+		for (let i = 0; i < dim; i++) sum[i] += vec[i];
+	}
+	const avg = new Float32Array(dim);
+	for (let i = 0; i < dim; i++) avg[i] = sum[i] / embRows.length;
+	return {
+		embedding: avg,
+		found: true
+	};
+}
+async function bfsGraphDistance(backend, source, target) {
+	if (source === target) return 0;
+	const visited = new Set([source]);
+	const queue = [{
+		path: source,
+		hops: 0
+	}];
+	while (queue.length > 0) {
+		const { path, hops } = queue.shift();
+		if (hops >= BFS_HOP_CAP) continue;
+		const [forwardLinks, backwardLinks] = await Promise.all([backend.getLinksFromSource(path), backend.getLinksToTarget(path)]);
+		const neighbors = [...forwardLinks.filter((l) => l.targetPath !== null).map((l) => l.targetPath), ...backwardLinks.map((l) => l.sourcePath)];
+		for (const neighbor of neighbors) {
+			if (neighbor === target) return hops + 1;
+			if (!visited.has(neighbor)) {
+				visited.add(neighbor);
+				queue.push({
+					path: neighbor,
+					hops: hops + 1
+				});
+			}
+		}
+	}
+	return Infinity;
+}
+function getBestChunkText(chunkRows, refEmbedding) {
+	const rows = chunkRows.filter((r) => r.embedding !== null);
+	if (rows.length === 0) return "";
+	let bestText = rows[0].text;
+	let bestSim = -Infinity;
+	for (const row of rows) {
+		const sim = cosineSimilarity(refEmbedding, deserializeEmbedding(row.embedding));
+		if (sim > bestSim) {
+			bestSim = sim;
+			bestText = row.text;
+		}
+	}
+	return bestText.trim().slice(0, 200);
+}
+/**
+* Find notes that are semantically similar to a reference note but graph-distant —
+* revealing surprising conceptual connections across unrelated areas of the Zettelkasten.
+*/
+async function zettelSurprise(backend, opts) {
+	const limit = opts.limit ?? 10;
+	const minSimilarity = opts.minSimilarity ?? .3;
+	const minGraphDistance = opts.minGraphDistance ?? 3;
+	let { embedding: refEmbedding, found } = await getReferenceEmbedding(backend, opts.vaultProjectId, opts.referencePath);
+	if (!found) refEmbedding = await generateEmbedding((await backend.getVaultFilesByPaths([opts.referencePath]))[0]?.title ?? opts.referencePath, true);
+	const allFileEmbeddings = await getFileEmbeddings(backend, opts.vaultProjectId);
+	allFileEmbeddings.delete(opts.referencePath);
+	const semanticCandidates = [];
+	for (const [path, { embedding }] of allFileEmbeddings) {
+		const sim = cosineSimilarity(refEmbedding, embedding);
+		if (sim >= minSimilarity) semanticCandidates.push({
+			path,
+			sim
+		});
+	}
+	const results = [];
+	for (const { path, sim } of semanticCandidates) {
+		const graphDistance = await bfsGraphDistance(backend, opts.referencePath, path);
+		const effectiveDistance = isFinite(graphDistance) ? graphDistance : BFS_HOP_CAP;
+		if (effectiveDistance < minGraphDistance) continue;
+		const files = await backend.getVaultFilesByPaths([path]);
+		const chunkRows = await backend.getChunksForPath(opts.vaultProjectId, path, 20);
+		const surpriseScore = sim * Math.log2(effectiveDistance + 1);
+		const sharedSnippet = getBestChunkText(chunkRows, refEmbedding);
+		results.push({
+			path,
+			title: files[0]?.title ?? null,
+			cosineSimilarity: sim,
+			graphDistance: isFinite(graphDistance) ? graphDistance : Infinity,
+			surpriseScore,
+			sharedSnippet
+		});
+	}
+	results.sort((a, b) => b.surpriseScore - a.surpriseScore);
+	return results.slice(0, limit);
+}
+
+//#endregion
+//#region src/zettelkasten/converse.ts
+/** Extract the top-level folder from a vault path (first path segment). */
+function extractDomain(vaultPath) {
+	const slash = vaultPath.indexOf("/");
+	return slash === -1 ? vaultPath : vaultPath.slice(0, slash);
+}
+/**
+* Expand one level of graph neighbors for a set of paths.
+* Returns all outbound and inbound neighbor paths (excluding already-visited).
+*/
+async function expandNeighbors(backend, paths) {
+	if (paths.size === 0) return [];
+	const pathList = Array.from(paths);
+	const [forwardLinks, backwardLinks] = await Promise.all([backend.getVaultLinksFromPaths(pathList), Promise.all(pathList.map((p) => backend.getLinksToTarget(p)))]);
+	const neighbors = [];
+	for (const link of forwardLinks) if (link.targetPath) neighbors.push(link.targetPath);
+	for (const linkList of backwardLinks) for (const link of linkList) neighbors.push(link.sourcePath);
+	return neighbors;
+}
+/**
+* Hybrid search combining keyword + semantic results using the StorageBackend.
+*/
+async function hybridSearch(backend, query, queryEmbedding, opts) {
+	const maxResults = opts.maxResults ?? 10;
+	const kw = .5;
+	const sw = .5;
+	const [keywordResults, semanticResults] = await Promise.all([backend.searchKeyword(query, {
+		...opts,
+		maxResults: 50
+	}), backend.searchSemantic(queryEmbedding, {
+		...opts,
+		maxResults: 50
+	})]);
+	if (keywordResults.length === 0 && semanticResults.length === 0) return [];
+	const keyFor = (r) => `${r.projectId}:${r.path}:${r.startLine}:${r.endLine}`;
+	function minMaxNormalize(scores) {
+		const min = Math.min(...scores);
+		const range = Math.max(...scores) - min;
+		if (range === 0) return scores.map(() => 1);
+		return scores.map((s) => (s - min) / range);
+	}
+	const kwNorm = minMaxNormalize(keywordResults.map((r) => r.score));
+	const semNorm = minMaxNormalize(semanticResults.map((r) => r.score));
+	const combined = /* @__PURE__ */ new Map();
+	for (let i = 0; i < keywordResults.length; i++) {
+		const r = keywordResults[i];
+		const k = keyFor(r);
+		combined.set(k, {
+			...r,
+			combinedScore: kw * kwNorm[i]
+		});
+	}
+	for (let i = 0; i < semanticResults.length; i++) {
+		const r = semanticResults[i];
+		const k = keyFor(r);
+		const existing = combined.get(k);
+		if (existing) existing.combinedScore += sw * semNorm[i];
+		else combined.set(k, {
+			...r,
+			combinedScore: sw * semNorm[i]
+		});
+	}
+	return Array.from(combined.values()).sort((a, b) => b.combinedScore - a.combinedScore).slice(0, maxResults).map((r) => ({
+		...r,
+		score: r.combinedScore
+	}));
+}
+/**
+* Let the vault "talk back" — find notes relevant to a question, expand
+* through the link graph, identify cross-domain connections, and return a
+* structured result including a synthesis prompt for an AI to generate insights.
+*/
+async function zettelConverse(backend, opts) {
+	const depth = Math.max(opts.depth ?? 2, 0);
+	const limit = Math.max(opts.limit ?? 15, 1);
+	const candidateLimit = 20;
+	const queryEmbedding = await generateEmbedding(opts.question, true);
+	const searchResults = await hybridSearch(backend, opts.question, queryEmbedding, {
+		projectIds: [opts.vaultProjectId],
+		maxResults: candidateLimit
+	});
+	const searchHits = /* @__PURE__ */ new Map();
+	for (const r of searchResults) {
+		const existing = searchHits.get(r.path);
+		if (!existing || r.score > existing.score) searchHits.set(r.path, {
+			score: r.score,
+			snippet: r.snippet
+		});
+	}
+	const allPaths = new Set(searchHits.keys());
+	let frontier = new Set(searchHits.keys());
+	for (let d = 0; d < depth; d++) {
+		const neighbors = await expandNeighbors(backend, frontier);
+		const newFrontier = /* @__PURE__ */ new Set();
+		for (const n of neighbors) if (!allPaths.has(n)) {
+			allPaths.add(n);
+			newFrontier.add(n);
+		}
+		if (newFrontier.size === 0) break;
+		frontier = newFrontier;
+	}
+	const searchRanked = Array.from(searchHits.entries()).sort((a, b) => b[1].score - a[1].score).map(([path, info]) => ({
+		path,
+		...info,
+		isSearchResult: true
+	}));
+	const neighborPaths = Array.from(allPaths).filter((p) => !searchHits.has(p));
+	const neighborHealthRows = await Promise.all(neighborPaths.map((p) => backend.getVaultHealth(p)));
+	const neighborRanked = neighborPaths.map((path, idx) => ({
+		path,
+		score: 0,
+		snippet: "",
+		inbound: neighborHealthRows[idx]?.inboundCount ?? 0,
+		isSearchResult: false
+	})).sort((a, b) => b.inbound - a.inbound);
+	const budgetForNeighbors = Math.max(limit - searchRanked.length, 0);
+	const selectedNeighbors = neighborRanked.slice(0, budgetForNeighbors);
+	const selectedSearchPaths = searchRanked.slice(0, limit);
+	const selectedPaths = new Set([...selectedSearchPaths.map((r) => r.path), ...selectedNeighbors.map((r) => r.path)]);
+	const allSelectedPaths = Array.from(selectedPaths);
+	const fileRows = await backend.getVaultFilesByPaths(allSelectedPaths);
+	const titleMap = new Map(fileRows.map((f) => [f.vaultPath, f.title]));
+	const relevantNotes = [];
+	for (const r of selectedSearchPaths) {
+		if (!selectedPaths.has(r.path)) continue;
+		relevantNotes.push({
+			path: r.path,
+			title: titleMap.get(r.path) ?? null,
+			snippet: r.snippet,
+			score: r.score,
+			domain: extractDomain(r.path)
+		});
+	}
+	for (const r of selectedNeighbors) relevantNotes.push({
+		path: r.path,
+		title: titleMap.get(r.path) ?? null,
+		snippet: r.snippet,
+		score: 0,
+		domain: extractDomain(r.path)
+	});
+	let connections = [];
+	if (selectedPaths.size > 0) {
+		const pathList = Array.from(selectedPaths);
+		const pathSet = new Set(pathList);
+		const linkRows = await backend.getVaultLinksFromPaths(pathList);
+		const edgeCounts = /* @__PURE__ */ new Map();
+		for (const link of linkRows) if (link.targetPath && pathSet.has(link.targetPath)) {
+			const key = `${link.sourcePath}|||${link.targetPath}`;
+			edgeCounts.set(key, (edgeCounts.get(key) ?? 0) + 1);
+		}
+		for (const [key, cnt] of edgeCounts) {
+			const [sourcePath, targetPath] = key.split("|||");
+			connections.push({
+				fromPath: sourcePath,
+				toPath: targetPath,
+				fromDomain: extractDomain(sourcePath),
+				toDomain: extractDomain(targetPath),
+				strength: cnt
+			});
+		}
+	}
+	const domainSet = new Set(relevantNotes.map((n) => n.domain));
+	const domains = Array.from(domainSet).sort();
+	const crossDomainConnections = connections.filter((c) => c.fromDomain !== c.toDomain);
+	const notesSummary = relevantNotes.map((n, i) => {
+		const title = n.title ? `"${n.title}"` : "(untitled)";
+		const domain = n.domain;
+		const scoreLabel = n.score > 0 ? ` [relevance: ${n.score.toFixed(3)}]` : " [context]";
+		const snippet = n.snippet.trim().slice(0, 300);
+		return `${i + 1}. [${domain}] ${title}${scoreLabel}\n   Path: ${n.path}\n   "${snippet}"`;
+	}).join("\n\n");
+	const connectionSummary = crossDomainConnections.length > 0 ? crossDomainConnections.map((c) => `- "${c.fromPath}" (${c.fromDomain}) → "${c.toPath}" (${c.toDomain}) [strength: ${c.strength}]`).join("\n") : "(no cross-domain connections found)";
+	const domainList = domains.join(", ");
+	return {
+		relevantNotes,
+		connections: crossDomainConnections,
+		domains,
+		synthesisPrompt: `You are a Zettelkasten research assistant. The vault has surfaced the following notes in response to this question:
+
+QUESTION: ${opts.question}
+
+---
+
+RELEVANT NOTES (${relevantNotes.length} notes across ${domains.length} domain(s): ${domainList}):
+
+${notesSummary}
+
+---
+
+CROSS-DOMAIN CONNECTIONS (links bridging different knowledge areas):
+
+${connectionSummary}
+
+---
+
+SYNTHESIS TASK:
+
+Based on these notes and the connections between them, please:
+
+1. Identify the key insights that emerge in direct response to the question.
+2. Highlight any unexpected connections between notes from different domains (${domainList}).
+3. Point out tensions, contradictions, or open questions the vault raises but does not resolve.
+4. Suggest what is notably absent — what the vault does NOT yet contain that would strengthen the understanding of this topic.
+5. Propose 2-3 new notes that would meaningfully extend this knowledge cluster.
+
+Think like a scholar who has deeply internalized these ideas and is now synthesizing them for the first time.`
+	};
+}
+
+//#endregion
+//#region src/zettelkasten/health.ts
+function countComponents(nodes, edges) {
+	if (nodes.length === 0) return 0;
+	const parent = /* @__PURE__ */ new Map();
+	const rank = /* @__PURE__ */ new Map();
+	for (const n of nodes) {
+		parent.set(n, n);
+		rank.set(n, 0);
+	}
+	function find(x) {
+		let root = x;
+		while (parent.get(root) !== root) root = parent.get(root);
+		let current = x;
+		while (current !== root) {
+			const next = parent.get(current);
+			parent.set(current, root);
+			current = next;
+		}
+		return root;
+	}
+	function union(a, b) {
+		const ra = find(a);
+		const rb = find(b);
+		if (ra === rb) return;
+		const rankA = rank.get(ra) ?? 0;
+		const rankB = rank.get(rb) ?? 0;
+		if (rankA < rankB) parent.set(ra, rb);
+		else if (rankA > rankB) parent.set(rb, ra);
+		else {
+			parent.set(rb, ra);
+			rank.set(ra, rankA + 1);
+		}
+	}
+	for (const { source, target } of edges) if (parent.has(source) && parent.has(target)) union(source, target);
+	const roots = /* @__PURE__ */ new Set();
+	for (const n of nodes) roots.add(find(n));
+	return roots.size;
+}
+/**
+* Audit the structural health of the Zettelkasten vault using graph metrics.
+*/
+async function zettelHealth(backend, opts) {
+	const options = opts ?? {};
+	const scope = options.scope ?? "full";
+	const include = options.include ?? [
+		"dead_links",
+		"orphans",
+		"disconnected",
+		"low_connectivity"
+	];
+	const computedAt = Date.now();
+	let totalFiles = 0;
+	if (scope === "full") totalFiles = await backend.countVaultFiles();
+	else if (scope === "project") {
+		const prefix = options.projectPath ?? "";
+		totalFiles = await backend.countVaultFilesWithPrefix(prefix);
+	} else {
+		const cutoff = computedAt - (options.recentDays ?? 30) * 864e5;
+		totalFiles = await backend.countVaultFilesAfter(cutoff);
+	}
+	let totalLinks = 0;
+	if (scope === "full") totalLinks = (await backend.getVaultLinkGraph()).length;
+	else if (scope === "project") {
+		const prefix = options.projectPath ?? "";
+		totalLinks = await backend.countVaultLinksWithPrefix(prefix);
+	} else {
+		const cutoff = computedAt - (options.recentDays ?? 30) * 864e5;
+		totalLinks = await backend.countVaultLinksAfter(cutoff);
+	}
+	let deadLinks = [];
+	if (include.includes("dead_links")) if (scope === "full") deadLinks = await backend.getDeadLinksWithLineNumbers();
+	else if (scope === "project") {
+		const prefix = options.projectPath ?? "";
+		deadLinks = await backend.getDeadLinksWithPrefix(prefix);
+	} else {
+		const cutoff = computedAt - (options.recentDays ?? 30) * 864e5;
+		deadLinks = await backend.getDeadLinksAfter(cutoff);
+	}
+	let orphans = [];
+	if (include.includes("orphans")) if (scope === "full") orphans = (await backend.getOrphans()).map((r) => r.vaultPath);
+	else if (scope === "project") {
+		const prefix = options.projectPath ?? "";
+		orphans = await backend.getOrphansWithPrefix(prefix);
+	} else {
+		const cutoff = computedAt - (options.recentDays ?? 30) * 864e5;
+		orphans = await backend.getOrphansAfter(cutoff);
+	}
+	let disconnectedClusters = 1;
+	if (include.includes("disconnected")) {
+		let allNodes;
+		let allEdges;
+		if (scope === "full") [allNodes, allEdges] = await Promise.all([backend.getAllVaultFilePaths(), backend.getVaultLinkEdges()]);
+		else if (scope === "project") {
+			const prefix = options.projectPath ?? "";
+			[allNodes, allEdges] = await Promise.all([backend.getVaultFilePathsWithPrefix(prefix), backend.getVaultLinkEdgesWithPrefix(prefix)]);
+		} else {
+			const cutoff = computedAt - (options.recentDays ?? 30) * 864e5;
+			[allNodes, allEdges] = await Promise.all([backend.getVaultFilePathsAfter(cutoff), backend.getVaultLinkEdgesAfter(cutoff)]);
+		}
+		disconnectedClusters = countComponents(allNodes, allEdges);
+	}
+	let lowConnectivity = [];
+	if (include.includes("low_connectivity")) if (scope === "full") lowConnectivity = await backend.getLowConnectivity();
+	else if (scope === "project") {
+		const prefix = options.projectPath ?? "";
+		lowConnectivity = await backend.getLowConnectivityWithPrefix(prefix);
+	} else {
+		const cutoff = computedAt - (options.recentDays ?? 30) * 864e5;
+		lowConnectivity = await backend.getLowConnectivityAfter(cutoff);
+	}
+	const deadRatio = totalLinks > 0 ? deadLinks.length / totalLinks : 0;
+	const orphanRatio = totalFiles > 0 ? orphans.length / totalFiles : 0;
+	const lowConnRatio = totalFiles > 0 ? lowConnectivity.length / totalFiles : 0;
+	const healthScore = Math.round(100 * (1 - deadRatio) * (1 - orphanRatio * .5) * (1 - lowConnRatio * .3));
+	return {
+		totalFiles,
+		totalLinks,
+		deadLinks,
+		orphans,
+		disconnectedClusters,
+		lowConnectivity,
+		healthScore,
+		computedAt
+	};
+}
+
+//#endregion
+//#region src/zettelkasten/suggest.ts
+const MAX_CHUNKS = 5e3;
+const SEMANTIC_WEIGHT = .5;
+const TAG_WEIGHT = .2;
+const NEIGHBOR_WEIGHT = .3;
+function extractTagsFromChunkTexts(texts) {
+	const tags = /* @__PURE__ */ new Set();
+	for (const text of texts) {
+		const match = text.match(/^tags:\s*\n((?:[ \t]*-[ \t]*.+\n?)*)/m);
+		if (!match) continue;
+		const lines = match[1].split("\n");
+		for (const line of lines) {
+			const tagMatch = line.match(/^[ \t]*-[ \t]*(.+)/);
+			if (tagMatch) {
+				const tag = tagMatch[1].trim().toLowerCase();
+				if (tag) tags.add(tag);
+			}
+		}
+	}
+	return tags;
+}
+function jaccardSimilarity(a, b) {
+	if (a.size === 0 && b.size === 0) return 0;
+	let intersection = 0;
+	for (const tag of a) if (b.has(tag)) intersection++;
+	const union = a.size + b.size - intersection;
+	return union === 0 ? 0 : intersection / union;
+}
+function buildReason(semanticScore, tagScore, neighborScore, neighborCount) {
+	const signals = [
+		{
+			label: `Semantically similar (${semanticScore.toFixed(2)})`,
+			value: semanticScore * SEMANTIC_WEIGHT
+		},
+		{
+			label: `Shared tags (${tagScore.toFixed(2)} Jaccard)`,
+			value: tagScore * TAG_WEIGHT
+		},
+		{
+			label: `Linked by ${neighborCount} mutual connection${neighborCount !== 1 ? "s" : ""}`,
+			value: neighborScore * NEIGHBOR_WEIGHT
+		}
+	];
+	signals.sort((a, b) => b.value - a.value);
+	return signals[0].label;
+}
+function suggestedWikilink(vaultPath) {
+	const base = basename(vaultPath);
+	return `[[${base.endsWith(".md") ? base.slice(0, -3) : base}]]`;
+}
+/**
+* Proactively find notes worth linking to a given note, combining semantic similarity,
+* shared tags, and graph-neighborhood signals into a ranked list of suggestions.
+*/
+async function zettelSuggest(backend, opts) {
+	const limit = opts.limit ?? 5;
+	const excludeLinked = opts.excludeLinked ?? true;
+	const outboundLinks = await backend.getLinksFromSource(opts.notePath);
+	const linkedPaths = new Set(outboundLinks.filter((l) => l.targetPath !== null).map((l) => l.targetPath));
+	const chunkRows = await backend.getChunksWithEmbeddings(opts.vaultProjectId, MAX_CHUNKS);
+	const byPath = /* @__PURE__ */ new Map();
+	for (const row of chunkRows) {
+		const vec = deserializeEmbedding(row.embedding);
+		const entry = byPath.get(row.path);
+		if (!entry) byPath.set(row.path, {
+			sum: new Float32Array(vec),
+			count: 1
+		});
+		else {
+			for (let i = 0; i < vec.length; i++) entry.sum[i] += vec[i];
+			entry.count++;
+		}
+	}
+	const allEmbeddings = /* @__PURE__ */ new Map();
+	for (const [path, { sum, count }] of byPath) {
+		const avg = new Float32Array(sum.length);
+		for (let i = 0; i < sum.length; i++) avg[i] = sum[i] / count;
+		allEmbeddings.set(path, avg);
+	}
+	allEmbeddings.delete(opts.notePath);
+	const sourceEmbedding = allEmbeddings.get(opts.notePath) ?? null;
+	const sourceTags = extractTagsFromChunkTexts((await backend.getChunksForPath(opts.vaultProjectId, opts.notePath, 5)).map((r) => r.text));
+	const directTargets = (await backend.getLinksFromSource(opts.notePath)).filter((l) => l.targetPath !== null).map((l) => l.targetPath);
+	const friendLinkCounts = /* @__PURE__ */ new Map();
+	for (const target of directTargets) {
+		const friendLinks = await backend.getLinksFromSource(target);
+		for (const link of friendLinks) if (link.targetPath && link.targetPath !== opts.notePath) friendLinkCounts.set(link.targetPath, (friendLinkCounts.get(link.targetPath) ?? 0) + 1);
+	}
+	const maxFriendLinks = Math.max(1, ...friendLinkCounts.values());
+	const allFiles = await backend.getAllVaultFiles();
+	const suggestions = [];
+	for (const fileRow of allFiles) {
+		const vault_path = fileRow.vaultPath;
+		const title = fileRow.title;
+		if (vault_path === opts.notePath) continue;
+		if (excludeLinked && linkedPaths.has(vault_path)) continue;
+		let semanticScore = 0;
+		if (sourceEmbedding) {
+			const candidateEmbedding = allEmbeddings.get(vault_path);
+			if (candidateEmbedding) semanticScore = Math.max(0, cosineSimilarity(sourceEmbedding, candidateEmbedding));
+		}
+		let tagScore = 0;
+		if (allEmbeddings.has(vault_path)) tagScore = jaccardSimilarity(sourceTags, extractTagsFromChunkTexts((await backend.getChunksForPath(opts.vaultProjectId, vault_path, 5)).map((r) => r.text)));
+		const friendCount = friendLinkCounts.get(vault_path) ?? 0;
+		const neighborScore = friendCount / maxFriendLinks;
+		const score = SEMANTIC_WEIGHT * semanticScore + TAG_WEIGHT * tagScore + NEIGHBOR_WEIGHT * neighborScore;
+		if (score <= 0) continue;
+		const reason = buildReason(semanticScore, tagScore, neighborScore, friendCount);
+		suggestions.push({
+			path: vault_path,
+			title,
+			score,
+			semanticScore,
+			tagScore,
+			neighborScore,
+			reason,
+			suggestedWikilink: suggestedWikilink(vault_path)
+		});
+	}
+	suggestions.sort((a, b) => b.score - a.score);
+	return suggestions.slice(0, limit);
+}
+
+//#endregion
+export { zettelConverse, zettelExplore, zettelHealth, zettelSuggest, zettelSurprise, zettelThemes };
+//# sourceMappingURL=zettelkasten-cdajbnPr.mjs.map