@tekmidian/pai 0.25.1 → 0.26.0

package/dist/zettelkasten-C8BikWss.mjs

@@ -0,0 +1,1063 @@
+import { a as generateEmbedding, n as cosineSimilarity, r as deserializeEmbedding } from "./embeddings-Bn86ssxR.mjs";
+import { t as zettelThemes } from "./themes-DICajLf-.mjs";
+import { n as saveQueryResult } from "./query-feedback-BX5nSyRm.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);
+	}
+	let linkConfidence;
+	if (scope === "full") try {
+		const samplePaths = await backend.getAllVaultFilePaths();
+		const sampleSize = Math.min(samplePaths.length, 200);
+		const sampled = samplePaths.slice(0, sampleSize);
+		let extracted = 0;
+		let inferred = 0;
+		let ambiguous = 0;
+		for (const path of sampled) {
+			const links = await backend.getLinksFromSource(path);
+			for (const link of links) {
+				const c = link.confidence ?? "EXTRACTED";
+				if (c === "EXTRACTED") extracted++;
+				else if (c === "INFERRED") inferred++;
+				else ambiguous++;
+			}
+		}
+		const factor = samplePaths.length > 0 ? samplePaths.length / sampleSize : 1;
+		linkConfidence = {
+			extracted: Math.round(extracted * factor),
+			inferred: Math.round(inferred * factor),
+			ambiguous: Math.round(ambiguous * factor)
+		};
+	} catch {}
+	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,
+		linkConfidence
+	};
+}
+
+//#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
+//#region src/zettelkasten/god-notes.ts
+/** Patterns that identify structural/meta pages rather than concept notes. */
+const STRUCTURAL_PATTERNS = [
+	/\bindex\b/i,
+	/\bMOC\b/,
+	/\bmaster\b/i,
+	/\btag\s*page/i,
+	/\bhome\b/i,
+	/\bdashboard\b/i,
+	/\btemplate/i,
+	/^_/
+];
+function isStructuralNote(title, path) {
+	const text = title ?? path;
+	return STRUCTURAL_PATTERNS.some((pattern) => pattern.test(text));
+}
+/**
+* Find hub/"god" notes in the vault — notes with the highest inbound link counts,
+* excluding structural pages.
+*/
+async function zettelGodNotes(backend, opts) {
+	const limit = opts?.limit ?? 20;
+	const minInbound = opts?.minInbound ?? 3;
+	const linkGraph = await backend.getVaultLinkGraph();
+	const inboundCounts = /* @__PURE__ */ new Map();
+	const outboundCounts = /* @__PURE__ */ new Map();
+	for (const { source_path, target_path } of linkGraph) {
+		inboundCounts.set(target_path, (inboundCounts.get(target_path) ?? 0) + 1);
+		outboundCounts.set(source_path, (outboundCounts.get(source_path) ?? 0) + 1);
+	}
+	const allFiles = await backend.getAllVaultFiles();
+	const titleMap = /* @__PURE__ */ new Map();
+	for (const f of allFiles) titleMap.set(f.vaultPath, f.title);
+	const totalVaultFiles = allFiles.length;
+	const allInbounds = allFiles.map((f) => inboundCounts.get(f.vaultPath) ?? 0);
+	allInbounds.sort((a, b) => a - b);
+	const medianInbound = allInbounds.length > 0 ? allInbounds[Math.floor(allInbounds.length / 2)] : 0;
+	const candidates = [];
+	for (const [path, inbound] of inboundCounts) {
+		if (inbound < minInbound) continue;
+		const title = titleMap.get(path) ?? null;
+		if (isStructuralNote(title, path)) continue;
+		const outbound = outboundCounts.get(path) ?? 0;
+		const totalDegree = inbound + outbound;
+		const inboundRatio = totalDegree > 0 ? inbound / totalDegree : 0;
+		candidates.push({
+			path,
+			title,
+			inboundCount: inbound,
+			outboundCount: outbound,
+			inboundRatio: Math.round(inboundRatio * 1e3) / 1e3
+		});
+	}
+	candidates.sort((a, b) => b.inboundCount - a.inboundCount);
+	return {
+		godNotes: candidates.slice(0, limit),
+		totalVaultFiles,
+		medianInbound
+	};
+}
+
+//#endregion
+//#region src/zettelkasten/communities.ts
+function buildUndirectedGraph(edges) {
+	const adj = /* @__PURE__ */ new Map();
+	const nodeSet = /* @__PURE__ */ new Set();
+	function getOrCreate(node) {
+		let m = adj.get(node);
+		if (!m) {
+			m = /* @__PURE__ */ new Map();
+			adj.set(node, m);
+		}
+		nodeSet.add(node);
+		return m;
+	}
+	let totalWeight = 0;
+	for (const { source_path, target_path } of edges) {
+		if (source_path === target_path) continue;
+		const aMap = getOrCreate(source_path);
+		const bMap = getOrCreate(target_path);
+		aMap.set(target_path, (aMap.get(target_path) ?? 0) + 1);
+		bMap.set(source_path, (bMap.get(source_path) ?? 0) + 1);
+		totalWeight += 1;
+	}
+	const degree = /* @__PURE__ */ new Map();
+	for (const [node, neighbors] of adj) {
+		let d = 0;
+		for (const w of neighbors.values()) d += w;
+		degree.set(node, d);
+	}
+	return {
+		nodes: Array.from(nodeSet),
+		adj,
+		totalWeight,
+		degree
+	};
+}
+/**
+* Run one pass of Phase 1: local node movement.
+* Returns true if any node changed community.
+*/
+function louvainPhase1(graph, community, resolution) {
+	const m2 = 2 * graph.totalWeight;
+	if (m2 === 0) return false;
+	const communityDegreeSum = /* @__PURE__ */ new Map();
+	const communityInternalWeight = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) {
+		const c = community.get(node);
+		communityDegreeSum.set(c, (communityDegreeSum.get(c) ?? 0) + (graph.degree.get(node) ?? 0));
+	}
+	for (const [node, neighbors] of graph.adj) {
+		const nc = community.get(node);
+		for (const [neighbor, weight] of neighbors) if (community.get(neighbor) === nc) communityInternalWeight.set(nc, (communityInternalWeight.get(nc) ?? 0) + weight);
+	}
+	for (const [c, w] of communityInternalWeight) communityInternalWeight.set(c, w / 2);
+	let improved = false;
+	const shuffled = [...graph.nodes];
+	for (let i = shuffled.length - 1; i > 0; i--) {
+		const j = Math.floor(Math.random() * (i + 1));
+		[shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+	}
+	for (const node of shuffled) {
+		const currentComm = community.get(node);
+		const ki = graph.degree.get(node) ?? 0;
+		const neighbors = graph.adj.get(node) ?? /* @__PURE__ */ new Map();
+		const weightToComm = /* @__PURE__ */ new Map();
+		for (const [neighbor, weight] of neighbors) {
+			const nc = community.get(neighbor);
+			weightToComm.set(nc, (weightToComm.get(nc) ?? 0) + weight);
+		}
+		communityDegreeSum.set(currentComm, (communityDegreeSum.get(currentComm) ?? 0) - ki);
+		const weightToCurrent = weightToComm.get(currentComm) ?? 0;
+		communityInternalWeight.set(currentComm, (communityInternalWeight.get(currentComm) ?? 0) - weightToCurrent);
+		let bestComm = currentComm;
+		let bestDelta = 0;
+		for (const [candidateComm, weightToCandidate] of weightToComm) {
+			const delta = weightToCandidate - resolution * (ki * (communityDegreeSum.get(candidateComm) ?? 0)) / m2;
+			if (delta > bestDelta) {
+				bestDelta = delta;
+				bestComm = candidateComm;
+			}
+		}
+		community.set(node, bestComm);
+		communityDegreeSum.set(bestComm, (communityDegreeSum.get(bestComm) ?? 0) + ki);
+		const weightToBest = weightToComm.get(bestComm) ?? 0;
+		communityInternalWeight.set(bestComm, (communityInternalWeight.get(bestComm) ?? 0) + weightToBest);
+		if (bestComm !== currentComm) improved = true;
+	}
+	return improved;
+}
+/**
+* Compute modularity for a given partition.
+*/
+function computeModularity(graph, community, resolution) {
+	const m2 = 2 * graph.totalWeight;
+	if (m2 === 0) return 0;
+	let q = 0;
+	for (const [node, neighbors] of graph.adj) {
+		const ci = community.get(node);
+		const ki = graph.degree.get(node) ?? 0;
+		for (const [neighbor, weight] of neighbors) if (community.get(neighbor) === ci) q += weight - resolution * (ki * (graph.degree.get(neighbor) ?? 0)) / m2;
+	}
+	return q / m2;
+}
+/**
+* Run Louvain community detection on the vault link graph.
+*/
+function runLouvain(graph, resolution) {
+	const community = /* @__PURE__ */ new Map();
+	let nextComm = 0;
+	for (const node of graph.nodes) community.set(node, nextComm++);
+	const MAX_ITERATIONS = 20;
+	for (let iter = 0; iter < MAX_ITERATIONS; iter++) if (!louvainPhase1(graph, community, resolution)) break;
+	const commRemap = /* @__PURE__ */ new Map();
+	let remapIdx = 0;
+	for (const [, c] of community) if (!commRemap.has(c)) commRemap.set(c, remapIdx++);
+	for (const [node, c] of community) community.set(node, commRemap.get(c));
+	return community;
+}
+const STOP_WORDS = new Set([
+	"the",
+	"and",
+	"for",
+	"are",
+	"but",
+	"not",
+	"you",
+	"all",
+	"can",
+	"her",
+	"was",
+	"one",
+	"our",
+	"out",
+	"has",
+	"had",
+	"how",
+	"its",
+	"may",
+	"new",
+	"now",
+	"old",
+	"see",
+	"way",
+	"who",
+	"did",
+	"get",
+	"let",
+	"say",
+	"she",
+	"too",
+	"use",
+	"from",
+	"with",
+	"this",
+	"that",
+	"will",
+	"been",
+	"have",
+	"each",
+	"make",
+	"like",
+	"long",
+	"look",
+	"many",
+	"them",
+	"then",
+	"what",
+	"when",
+	"some",
+	"time",
+	"very",
+	"your",
+	"about",
+	"could",
+	"into",
+	"just",
+	"more",
+	"note",
+	"notes",
+	"than",
+	"over"
+]);
+function generateCommunityLabel(titles) {
+	const wordCounts = /* @__PURE__ */ new Map();
+	for (const title of titles) {
+		if (!title) continue;
+		const words = title.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !STOP_WORDS.has(w));
+		for (const word of words) wordCounts.set(word, (wordCounts.get(word) ?? 0) + 1);
+	}
+	return [...wordCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([w]) => w).join(" / ") || "unnamed";
+}
+function getTopFolder(path) {
+	const slash = path.indexOf("/");
+	return slash === -1 ? path : path.slice(0, slash);
+}
+/**
+* Detect communities in the vault link graph using the Louvain algorithm.
+* Returns clusters of densely connected notes with labels and cohesion scores.
+*/
+async function zettelCommunities(backend, opts) {
+	const minSize = opts?.minSize ?? 3;
+	const maxCommunities = opts?.maxCommunities ?? 20;
+	const resolution = opts?.resolution ?? 1;
+	const graph = buildUndirectedGraph(await backend.getVaultLinkGraph());
+	if (graph.nodes.length === 0) return {
+		communities: [],
+		totalNodes: 0,
+		totalEdges: 0,
+		modularity: 0
+	};
+	const communityMap = runLouvain(graph, resolution);
+	const modularity = computeModularity(graph, communityMap, resolution);
+	const groups = /* @__PURE__ */ new Map();
+	for (const [node, comm] of communityMap) {
+		const arr = groups.get(comm);
+		if (arr) arr.push(node);
+		else groups.set(comm, [node]);
+	}
+	const allFiles = await backend.getAllVaultFiles();
+	const titleMap = /* @__PURE__ */ new Map();
+	for (const f of allFiles) titleMap.set(f.vaultPath, f.title);
+	const communities = [];
+	let commId = 0;
+	for (const [, members] of groups) {
+		if (members.length < minSize) continue;
+		const memberSet = new Set(members);
+		const label = generateCommunityLabel(members.map((p) => titleMap.get(p) ?? null));
+		const nodes = members.map((path) => {
+			const neighbors = graph.adj.get(path) ?? /* @__PURE__ */ new Map();
+			let internalDeg = 0;
+			for (const [neighbor, weight] of neighbors) if (memberSet.has(neighbor)) internalDeg += weight;
+			return {
+				path,
+				title: titleMap.get(path) ?? null,
+				internalDegree: internalDeg
+			};
+		});
+		nodes.sort((a, b) => b.internalDegree - a.internalDegree);
+		let internalEdges = 0;
+		for (const node of nodes) internalEdges += node.internalDegree;
+		internalEdges /= 2;
+		const possibleEdges = members.length * (members.length - 1) / 2;
+		const cohesion = possibleEdges > 0 ? Math.round(internalEdges / possibleEdges * 1e3) / 1e3 : 0;
+		const folderCounts = /* @__PURE__ */ new Map();
+		for (const path of members) {
+			const folder = getTopFolder(path);
+			folderCounts.set(folder, (folderCounts.get(folder) ?? 0) + 1);
+		}
+		const topFolders = [...folderCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([f]) => f);
+		communities.push({
+			id: commId++,
+			label,
+			nodes,
+			size: members.length,
+			cohesion,
+			topFolders
+		});
+	}
+	communities.sort((a, b) => b.size - a.size);
+	return {
+		communities: communities.slice(0, maxCommunities),
+		totalNodes: graph.nodes.length,
+		totalEdges: graph.totalWeight,
+		modularity: Math.round(modularity * 1e4) / 1e4
+	};
+}
+
+//#endregion
+export { zettelCommunities, zettelConverse, zettelExplore, zettelGodNotes, zettelHealth, zettelSuggest, zettelSurprise, zettelThemes };
+//# sourceMappingURL=zettelkasten-C8BikWss.mjs.map