npm - @powerhousedao/knowledge-note - Versions diffs - 1.0.0 - Mend

Files changed (1410) hide show

package/dist/processors/graph-indexer/query.js ADDED Viewed

@@ -0,0 +1,234 @@
+function rowToNode(row) {
+    return {
+        id: row.id,
+        documentId: row.document_id,
+        title: row.title,
+        description: row.description,
+        noteType: row.note_type,
+        status: row.status,
+        updatedAt: row.updated_at,
+    };
+}
+function rowToEdge(row) {
+    return {
+        id: row.id,
+        sourceDocumentId: row.source_document_id,
+        targetDocumentId: row.target_document_id,
+        linkType: row.link_type,
+        targetTitle: row.target_title,
+        updatedAt: row.updated_at,
+    };
+}
+export function createGraphQuery(db) {
+    return {
+        async allNodes() {
+            const rows = await db.selectFrom("graph_nodes").selectAll().execute();
+            return rows.map(rowToNode);
+        },
+        async allEdges() {
+            const rows = await db.selectFrom("graph_edges").selectAll().execute();
+            return rows.map(rowToEdge);
+        },
+        async nodeByDocumentId(documentId) {
+            const row = await db
+                .selectFrom("graph_nodes")
+                .where("document_id", "=", documentId)
+                .selectAll()
+                .executeTakeFirst();
+            return row ? rowToNode(row) : undefined;
+        },
+        async nodesByStatus(status) {
+            const rows = await db
+                .selectFrom("graph_nodes")
+                .where("status", "=", status)
+                .selectAll()
+                .execute();
+            return rows.map(rowToNode);
+        },
+        async orphanNodes() {
+            // Nodes that have zero incoming edges
+            const rows = await db
+                .selectFrom("graph_nodes")
+                .selectAll()
+                .where("document_id", "not in", db.selectFrom("graph_edges").select("target_document_id"))
+                .execute();
+            return rows.map(rowToNode);
+        },
+        async stats() {
+            const nodes = await db.selectFrom("graph_nodes").selectAll().execute();
+            const edges = await db.selectFrom("graph_edges").selectAll().execute();
+            const targetIds = new Set(edges.map((e) => e.target_document_id));
+            const orphanCount = nodes.filter((n) => !targetIds.has(n.document_id)).length;
+            return {
+                nodeCount: nodes.length,
+                edgeCount: edges.length,
+                orphanCount,
+            };
+        },
+        async connections(documentId, maxDepth = 2) {
+            const results = [];
+            const visited = new Set();
+            visited.add(documentId);
+            let frontier = [documentId];
+            for (let depth = 1; depth <= maxDepth; depth++) {
+                if (frontier.length === 0)
+                    break;
+                const edges = await db
+                    .selectFrom("graph_edges")
+                    .where("source_document_id", "in", frontier)
+                    .selectAll()
+                    .execute();
+                const nextFrontier = [];
+                for (const edge of edges) {
+                    if (visited.has(edge.target_document_id))
+                        continue;
+                    visited.add(edge.target_document_id);
+                    const node = await db
+                        .selectFrom("graph_nodes")
+                        .where("document_id", "=", edge.target_document_id)
+                        .selectAll()
+                        .executeTakeFirst();
+                    if (node) {
+                        results.push({
+                            node: rowToNode(node),
+                            depth,
+                            viaLinkType: edge.link_type,
+                        });
+                        nextFrontier.push(edge.target_document_id);
+                    }
+                }
+                frontier = nextFrontier;
+            }
+            return results;
+        },
+        async backlinks(documentId) {
+            const rows = await db
+                .selectFrom("graph_edges")
+                .where("target_document_id", "=", documentId)
+                .selectAll()
+                .execute();
+            return rows.map(rowToEdge);
+        },
+        async density() {
+            const nodes = await db.selectFrom("graph_nodes").selectAll().execute();
+            const edges = await db.selectFrom("graph_edges").selectAll().execute();
+            if (nodes.length <= 1)
+                return 0;
+            return edges.length / (nodes.length * (nodes.length - 1));
+        },
+        async searchNodes(query, limit = 50) {
+            const q = `%${query.toLowerCase()}%`;
+            const rows = await db
+                .selectFrom("graph_nodes")
+                .where((eb) => eb.or([
+                eb(eb.fn("lower", ["title"]), "like", q),
+                eb(eb.fn("lower", ["description"]), "like", q),
+            ]))
+                .selectAll()
+                .limit(limit)
+                .execute();
+            return rows.map(rowToNode);
+        },
+        async forwardLinks(documentId) {
+            const rows = await db
+                .selectFrom("graph_edges")
+                .where("source_document_id", "=", documentId)
+                .selectAll()
+                .execute();
+            return rows.map(rowToEdge);
+        },
+        async triangles(limit = 20) {
+            // Find pairs (A,B) that both link to C but A doesn't link to B
+            const edges = await db.selectFrom("graph_edges").selectAll().execute();
+            const nodeRows = await db.selectFrom("graph_nodes").selectAll().execute();
+            const nodeMap = new Map(nodeRows.map((n) => [n.document_id, rowToNode(n)]));
+            // Build incoming map: target → [source1, source2, ...]
+            const incoming = new Map();
+            const edgeSet = new Set();
+            for (const e of edges) {
+                const sources = incoming.get(e.target_document_id) ?? [];
+                sources.push(e.source_document_id);
+                incoming.set(e.target_document_id, sources);
+                edgeSet.add(`${e.source_document_id}->${e.target_document_id}`);
+            }
+            const results = [];
+            for (const [targetId, sources] of incoming) {
+                if (sources.length < 2)
+                    continue;
+                const target = nodeMap.get(targetId);
+                if (!target)
+                    continue;
+                for (let i = 0; i < sources.length && results.length < limit; i++) {
+                    for (let j = i + 1; j < sources.length && results.length < limit; j++) {
+                        const aId = sources[i];
+                        const bId = sources[j];
+                        // Check if A→B or B→A exists
+                        if (!edgeSet.has(`${aId}->${bId}`) && !edgeSet.has(`${bId}->${aId}`)) {
+                            const a = nodeMap.get(aId);
+                            const b = nodeMap.get(bId);
+                            if (a && b) {
+                                results.push({ a, b, sharedTarget: target });
+                            }
+                        }
+                    }
+                }
+            }
+            return results;
+        },
+        async bridges() {
+            // Find articulation points using a simplified DFS approach
+            const edges = await db.selectFrom("graph_edges").selectAll().execute();
+            const nodeRows = await db.selectFrom("graph_nodes").selectAll().execute();
+            const nodeMap = new Map(nodeRows.map((n) => [n.document_id, rowToNode(n)]));
+            // Build undirected adjacency list
+            const adj = new Map();
+            for (const e of edges) {
+                if (!adj.has(e.source_document_id))
+                    adj.set(e.source_document_id, new Set());
+                if (!adj.has(e.target_document_id))
+                    adj.set(e.target_document_id, new Set());
+                adj.get(e.source_document_id).add(e.target_document_id);
+                adj.get(e.target_document_id).add(e.source_document_id);
+            }
+            const allNodes = [...adj.keys()];
+            if (allNodes.length <= 2)
+                return [];
+            // For each node, check if removing it increases connected components
+            const bridgeNodes = [];
+            function countComponents(exclude) {
+                const remaining = allNodes.filter((n) => n !== exclude);
+                if (remaining.length === 0)
+                    return 0;
+                const visited = new Set();
+                let components = 0;
+                for (const start of remaining) {
+                    if (visited.has(start))
+                        continue;
+                    components++;
+                    const stack = [start];
+                    while (stack.length > 0) {
+                        const current = stack.pop();
+                        if (visited.has(current))
+                            continue;
+                        visited.add(current);
+                        for (const neighbor of adj.get(current) ?? []) {
+                            if (neighbor !== exclude && !visited.has(neighbor)) {
+                                stack.push(neighbor);
+                            }
+                        }
+                    }
+                }
+                return components;
+            }
+            const baseComponents = countComponents("");
+            for (const nodeId of allNodes) {
+                if (countComponents(nodeId) > baseComponents) {
+                    const node = nodeMap.get(nodeId);
+                    if (node)
+                        bridgeNodes.push(node);
+                }
+            }
+            return bridgeNodes;
+        },
+    };
+}

@@ -0,0 +1,22 @@
+export interface GraphNode {
+    id: string;
+    document_id: string;
+    title: string | null;
+    description: string | null;
+    note_type: string | null;
+    status: string | null;
+    updated_at: string;
+}
+export interface GraphEdge {
+    id: string;
+    source_document_id: string;
+    target_document_id: string;
+    link_type: string | null;
+    target_title: string | null;
+    updated_at: string;
+}
+export interface DB {
+    graph_nodes: GraphNode;
+    graph_edges: GraphEdge;
+}
+//# sourceMappingURL=schema.d.ts.map

@@ -0,0 +1,3 @@
+export { GraphIndexerProcessor } from "./graph-indexer/index.js";
+export { graphIndexerProcessorFactory } from "./graph-indexer/factory.js";
+//# sourceMappingURL=switchboard.d.ts.map

	@@ -0,0 +1,2 @@
1	+ export { processorFactory } from "./factory.js";
2	+ //# sourceMappingURL=index.d.ts.map

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../processors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC"}

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"switchboard.d.ts","sourceRoot":"","sources":["../../processors/switchboard.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,4BAA4B,EAAE,MAAM,4BAA4B,CAAC"}

	@@ -0,0 +1,2 @@
1	+ export { GraphIndexerProcessor } from "./graph-indexer/index.js";
2	+ export { graphIndexerProcessorFactory } from "./graph-indexer/factory.js";

@powerhousedao/knowledge-note 1.0.0