@powerhousedao/knowledge-note 1.0.3 → 1.0.4

package/dist/subgraphs/knowledge-graph/subgraph.js

@@ -2,6 +2,8 @@ import { gql } from "graphql-tag";
 import { BaseSubgraph } from "@powerhousedao/reactor-api";
 import { GraphIndexerProcessor } from "../../processors/graph-indexer/index.js";
 import { createGraphQuery } from "../../processors/graph-indexer/query.js";
+import { generateEmbedding } from "../../processors/graph-indexer/embedder.js";
+import { searchSimilar, getEmbedding, upsertEmbedding, } from "../../processors/graph-indexer/embedding-store.js";
 export class KnowledgeGraphSubgraph extends BaseSubgraph {
     name = "knowledgeGraph";
     typeDefs = gql `
@@ -12,6 +14,11 @@ export class KnowledgeGraphSubgraph extends BaseSubgraph {
       description: String
       noteType: String
       status: String
+      content: String
+      author: String
+      sourceOrigin: String
+      createdAt: String
+      topics: [String!]!
       updatedAt: String!
     }
 
@@ -36,6 +43,17 @@ export class KnowledgeGraphSubgraph extends BaseSubgraph {
       viaLinkType: String
     }
 
+    type TopicInfo {
+      name: String!
+      noteCount: Int!
+    }
+
+    type RelatedNode {
+      node: KnowledgeGraphNode!
+      sharedTopics: [String!]!
+      sharedTopicCount: Int!
+    }
+
     extend type Query {
       knowledgeGraphNodes(driveId: ID!): [KnowledgeGraphNode!]!
       knowledgeGraphEdges(driveId: ID!): [KnowledgeGraphEdge!]!
@@ -72,6 +90,46 @@ export class KnowledgeGraphSubgraph extends BaseSubgraph {
         documentId: String!
       ): [KnowledgeGraphEdge!]!
 
+      knowledgeGraphTopics(driveId: ID!): [TopicInfo!]!
+      knowledgeGraphByTopic(
+        driveId: ID!
+        topic: String!
+      ): [KnowledgeGraphNode!]!
+      knowledgeGraphRelatedByTopic(
+        driveId: ID!
+        documentId: String!
+        limit: Int
+      ): [RelatedNode!]!
+      knowledgeGraphFullSearch(
+        driveId: ID!
+        query: String!
+        limit: Int
+      ): [KnowledgeGraphNode!]!
+      knowledgeGraphByAuthor(
+        driveId: ID!
+        author: String!
+      ): [KnowledgeGraphNode!]!
+      knowledgeGraphByOrigin(
+        driveId: ID!
+        origin: String!
+      ): [KnowledgeGraphNode!]!
+      knowledgeGraphRecent(
+        driveId: ID!
+        limit: Int
+        since: String
+      ): [KnowledgeGraphNode!]!
+
+      knowledgeGraphSemanticSearch(
+        driveId: ID!
+        query: String!
+        limit: Int
+      ): [SemanticResult!]!
+      knowledgeGraphSimilar(
+        driveId: ID!
+        documentId: String!
+        limit: Int
+      ): [SemanticResult!]!
+
       """
       Debug: raw processor DB tables
       """
@@ -84,6 +142,11 @@ export class KnowledgeGraphSubgraph extends BaseSubgraph {
       sharedTarget: KnowledgeGraphNode!
     }
 
+    type SemanticResult {
+      node: KnowledgeGraphNode!
+      similarity: Float!
+    }
+
     type GraphDebugInfo {
       rawNodeCount: Int!
       rawEdgeCount: Int!
@@ -107,6 +170,19 @@ export class KnowledgeGraphSubgraph extends BaseSubgraph {
     }
   `;
     resolvers = {
+        KnowledgeGraphNode: {
+            topics: async (parent) => {
+                // If topics were already resolved inline, return them
+                if (parent.topics)
+                    return parent.topics;
+                // Otherwise resolve via field resolver using _driveId hint
+                if (parent._driveId) {
+                    const query = this.getQuery(parent._driveId);
+                    return query.topicsForNode(parent.documentId);
+                }
+                return [];
+            },
+        },
         Mutation: {
             knowledgeGraphReindex: (_, args) => this.reindexDrive(args.driveId),
         },
@@ -114,7 +190,8 @@ export class KnowledgeGraphSubgraph extends BaseSubgraph {
             knowledgeGraphNodes: async (_, args) => {
                 await this.ensureGraphDoc(args.driveId);
                 const query = this.getQuery(args.driveId);
-                return query.allNodes();
+                const nodes = await query.allNodes();
+                return nodes.map((n) => ({ ...n, _driveId: args.driveId }));
             },
             knowledgeGraphEdges: async (_, args) => {
                 await this.ensureGraphDoc(args.driveId);
@@ -128,19 +205,26 @@ export class KnowledgeGraphSubgraph extends BaseSubgraph {
             },
             knowledgeGraphNodeByDocumentId: async (_, args) => {
                 const query = this.getQuery(args.driveId);
-                return query.nodeByDocumentId(args.documentId) ?? null;
+                const node = await query.nodeByDocumentId(args.documentId);
+                return node ? { ...node, _driveId: args.driveId } : null;
             },
             knowledgeGraphOrphans: async (_, args) => {
                 const query = this.getQuery(args.driveId);
-                return query.orphanNodes();
+                const nodes = await query.orphanNodes();
+                return nodes.map((n) => ({ ...n, _driveId: args.driveId }));
             },
             knowledgeGraphConnections: async (_, args) => {
                 const query = this.getQuery(args.driveId);
-                return query.connections(args.documentId, args.depth ?? 2);
+                const connections = await query.connections(args.documentId, args.depth ?? 2);
+                return connections.map((c) => ({
+                    ...c,
+                    node: { ...c.node, _driveId: args.driveId },
+                }));
             },
             knowledgeGraphNodesByStatus: async (_, args) => {
                 const query = this.getQuery(args.driveId);
-                return query.nodesByStatus(args.status);
+                const nodes = await query.nodesByStatus(args.status);
+                return nodes.map((n) => ({ ...n, _driveId: args.driveId }));
             },
             knowledgeGraphBacklinks: async (_, args) => {
                 const query = this.getQuery(args.driveId);
@@ -152,25 +236,101 @@ export class KnowledgeGraphSubgraph extends BaseSubgraph {
             },
             knowledgeGraphSearch: async (_, args) => {
                 const query = this.getQuery(args.driveId);
-                return query.searchNodes(args.query, args.limit ?? 50);
+                const nodes = await query.searchNodes(args.query, args.limit ?? 50);
+                return nodes.map((n) => ({ ...n, _driveId: args.driveId }));
             },
             knowledgeGraphTriangles: async (_, args) => {
                 const query = this.getQuery(args.driveId);
                 const triangles = await query.triangles(args.limit ?? 20);
                 return triangles.map((t) => ({
-                    noteA: t.a,
-                    noteB: t.b,
-                    sharedTarget: t.sharedTarget,
+                    noteA: { ...t.a, _driveId: args.driveId },
+                    noteB: { ...t.b, _driveId: args.driveId },
+                    sharedTarget: { ...t.sharedTarget, _driveId: args.driveId },
                 }));
             },
             knowledgeGraphBridges: async (_, args) => {
                 const query = this.getQuery(args.driveId);
-                return query.bridges();
+                const nodes = await query.bridges();
+                return nodes.map((n) => ({ ...n, _driveId: args.driveId }));
             },
             knowledgeGraphForwardLinks: async (_, args) => {
                 const query = this.getQuery(args.driveId);
                 return query.forwardLinks(args.documentId);
             },
+            // --- Phase 1: new query resolvers ---
+            knowledgeGraphTopics: async (_, args) => {
+                const query = this.getQuery(args.driveId);
+                return query.topicStats();
+            },
+            knowledgeGraphByTopic: async (_, args) => {
+                const query = this.getQuery(args.driveId);
+                const nodes = await query.nodesByTopic(args.topic);
+                return nodes.map((n) => ({ ...n, _driveId: args.driveId }));
+            },
+            knowledgeGraphRelatedByTopic: async (_, args) => {
+                const query = this.getQuery(args.driveId);
+                const results = await query.relatedByTopic(args.documentId, args.limit ?? 10);
+                return results.map((r) => ({
+                    ...r,
+                    node: { ...r.node, _driveId: args.driveId },
+                }));
+            },
+            knowledgeGraphFullSearch: async (_, args) => {
+                const query = this.getQuery(args.driveId);
+                const nodes = await query.fullSearch(args.query, args.limit ?? 50);
+                return nodes.map((n) => ({ ...n, _driveId: args.driveId }));
+            },
+            knowledgeGraphByAuthor: async (_, args) => {
+                const query = this.getQuery(args.driveId);
+                const nodes = await query.nodesByAuthor(args.author);
+                return nodes.map((n) => ({ ...n, _driveId: args.driveId }));
+            },
+            knowledgeGraphByOrigin: async (_, args) => {
+                const query = this.getQuery(args.driveId);
+                const nodes = await query.nodesByOrigin(args.origin);
+                return nodes.map((n) => ({ ...n, _driveId: args.driveId }));
+            },
+            knowledgeGraphRecent: async (_, args) => {
+                const query = this.getQuery(args.driveId);
+                const nodes = await query.recentNodes(args.limit ?? 20, args.since ?? undefined);
+                return nodes.map((n) => ({ ...n, _driveId: args.driveId }));
+            },
+            knowledgeGraphSemanticSearch: async (_, args) => {
+                const queryEmbedding = await generateEmbedding(args.query);
+                const results = await searchSimilar(queryEmbedding, args.limit ?? 10);
+                const graphQuery = this.getQuery(args.driveId);
+                const semanticResults = [];
+                for (const result of results) {
+                    const node = await graphQuery.nodeByDocumentId(result.documentId);
+                    if (node) {
+                        semanticResults.push({
+                            node: { ...node, _driveId: args.driveId },
+                            similarity: result.similarity,
+                        });
+                    }
+                }
+                return semanticResults;
+            },
+            knowledgeGraphSimilar: async (_, args) => {
+                const embedding = await getEmbedding(args.documentId);
+                if (!embedding)
+                    return [];
+                const results = await searchSimilar(embedding, (args.limit ?? 10) + 1);
+                const graphQuery = this.getQuery(args.driveId);
+                const semanticResults = [];
+                for (const result of results) {
+                    if (result.documentId === args.documentId)
+                        continue;
+                    const node = await graphQuery.nodeByDocumentId(result.documentId);
+                    if (node) {
+                        semanticResults.push({
+                            node: { ...node, _driveId: args.driveId },
+                            similarity: result.similarity,
+                        });
+                    }
+                }
+                return semanticResults.slice(0, args.limit ?? 10);
+            },
             knowledgeGraphDebug: async (_, args) => {
                 const namespace = GraphIndexerProcessor.getNamespace(args.driveId);
                 try {
@@ -193,7 +353,13 @@ export class KnowledgeGraphSubgraph extends BaseSubgraph {
                             description: r.description,
                             noteType: r.note_type,
                             status: r.status,
+                            content: r.content,
+                            author: r.author,
+                            sourceOrigin: r.source_origin,
+                            createdAt: r.created_at,
+                            topics: [],
                             updatedAt: r.updated_at,
+                            _driveId: args.driveId,
                         })),
                         rawEdges: rawEdges.map((r) => ({
                             id: r.id,
@@ -224,17 +390,28 @@ export class KnowledgeGraphSubgraph extends BaseSubgraph {
     }
     /**
      * Returns a Kysely<DB> instance scoped to the processor's namespace
-     * for the given drive. Centralizes the Legacy → IRelationalDb cast.
+     * for the given drive. Centralizes the Legacy -> IRelationalDb cast.
+     */
+    /**
+     * Read-only namespaced query builder — use for all SELECT resolvers.
      */
     getDb(driveId) {
         return GraphIndexerProcessor.query(driveId, this.relationalDb);
     }
+    /**
+     * Writable namespaced Kysely instance — use for reindex (INSERT/DELETE).
+     * createNamespace returns a full Kysely, not the read-only query builder.
+     */
+    async getWritableDb(driveId) {
+        const namespace = GraphIndexerProcessor.getNamespace(driveId);
+        return (await this.relationalDb.createNamespace(namespace));
+    }
     getQuery(driveId) {
         return createGraphQuery(this.getDb(driveId));
     }
     /**
      * Ensures a bai/knowledge-graph document exists in the given drive.
-     * Called lazily on first query — supports API/plugin access without
+     * Called lazily on first query -- supports API/plugin access without
      * requiring the Connect UI to have initialized the drive first.
      */
     ensuredDrives = new Set();
@@ -246,13 +423,15 @@ export class KnowledgeGraphSubgraph extends BaseSubgraph {
             const drive = await this.reactorClient.get(driveId);
             const nodes = drive.state.global.nodes;
             const noteNodes = nodes.filter((n) => n.kind === "file" && n.documentType === "bai/knowledge-note");
-            const db = this.getDb(driveId);
+            const db = await this.getWritableDb(driveId);
             const now = new Date().toISOString();
             for (const node of noteNodes) {
                 try {
                     const doc = await this.reactorClient.get(node.id);
                     const state = doc.state;
                     const global = state.global;
+                    // Extract provenance
+                    const provenance = global.provenance;
                     await db
                         .insertInto("graph_nodes")
                         .values({
@@ -262,6 +441,10 @@ export class KnowledgeGraphSubgraph extends BaseSubgraph {
                         description: global.description ?? null,
                         note_type: global.noteType ?? null,
                         status: global.status ?? "DRAFT",
+                        content: global.content ?? null,
+                        author: provenance?.author ?? null,
+                        source_origin: provenance?.sourceOrigin ?? null,
+                        created_at: provenance?.createdAt ?? null,
                         updated_at: now,
                     })
                         .onConflict((oc) => oc.column("document_id").doUpdateSet({
@@ -269,10 +452,36 @@ export class KnowledgeGraphSubgraph extends BaseSubgraph {
                         description: global.description ?? null,
                         note_type: global.noteType ?? null,
                         status: global.status ?? "DRAFT",
+                        content: global.content ?? null,
+                        author: provenance?.author ?? null,
+                        source_origin: provenance?.sourceOrigin ?? null,
+                        created_at: provenance?.createdAt ?? null,
                         updated_at: now,
                     }))
                         .execute();
                     indexedNodes++;
+                    // Reconcile topics
+                    await db
+                        .deleteFrom("graph_topics")
+                        .where("document_id", "=", node.id)
+                        .execute();
+                    const topics = global.topics ?? [];
+                    if (topics.length > 0) {
+                        await db
+                            .insertInto("graph_topics")
+                            .values(topics.map((topic, idx) => {
+                            const name = typeof topic === "string"
+                                ? topic
+                                : (topic.name ?? "");
+                            return {
+                                id: `${node.id}-topic-${idx}`,
+                                document_id: node.id,
+                                name,
+                                updated_at: now,
+                            };
+                        }))
+                            .execute();
+                    }
                     // Reconcile edges
                     await db
                         .deleteFrom("graph_edges")
@@ -294,6 +503,19 @@ export class KnowledgeGraphSubgraph extends BaseSubgraph {
                             .execute();
                         indexedEdges += links.length;
                     }
+                    // Generate embedding for semantic search
+                    const text = [global.title, global.description, global.content]
+                        .filter(Boolean)
+                        .join(" ");
+                    if (text.length > 0) {
+                        try {
+                            const emb = await generateEmbedding(text);
+                            await upsertEmbedding(node.id, emb);
+                        }
+                        catch (embErr) {
+                            console.warn(`[KnowledgeGraphSubgraph] Embedding failed for ${node.id}:`, embErr);
+                        }
+                    }
                 }
                 catch (err) {
                     const msg = err instanceof Error ? err.message : String(err);
@@ -327,12 +549,12 @@ export class KnowledgeGraphSubgraph extends BaseSubgraph {
                 console.log(`[KnowledgeGraphSubgraph] Auto-created KnowledgeGraph in drive ${driveId}` +
                     (parentFolder
                         ? ` (folder: /self/)`
-                        : ` (drive root — /self/ folder not found)`));
+                        : ` (drive root -- /self/ folder not found)`));
             }
         }
         catch (err) {
             console.error(`[KnowledgeGraphSubgraph] Failed to ensure graph doc:`, err);
-            // Don't block queries if this fails — processor data still works
+            // Don't block queries if this fails -- processor data still works
         }
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@powerhousedao/knowledge-note",
   "description": "Knowledge Note document model package for Powerhouse",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "license": "AGPL-3.0-only",
   "type": "module",
   "files": [
@@ -107,6 +107,7 @@
   },
   "dependencies": {
     "@electric-sql/pglite": "0.3.15",
+    "@huggingface/transformers": "^4.0.1",
     "@powerhousedao/builder-tools": "6.0.0-dev.105",
     "@powerhousedao/common": "6.0.0-dev.105",
     "@powerhousedao/design-system": "6.0.0-dev.105",