@powerhousedao/knowledge-note 1.0.2 → 1.0.4

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

@@ -1,7 +1,9 @@
 import { gql } from "graphql-tag";
-import { BaseSubgraph, } from "@powerhousedao/reactor-api";
+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!
@@ -91,13 +154,44 @@ export class KnowledgeGraphSubgraph extends BaseSubgraph {
       rawEdges: [KnowledgeGraphEdge!]!
       processorNamespace: String!
     }
+
+    type ReindexResult {
+      indexedNodes: Int!
+      indexedEdges: Int!
+      errors: [String!]!
+    }
+
+    extend type Mutation {
+      """
+      Backfill the graph index by reading all bai/knowledge-note documents
+      in the drive. Use when the processor missed historical operations.
+      """
+      knowledgeGraphReindex(driveId: ID!): ReindexResult!
+    }
   `;
     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),
+        },
         Query: {
             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);
@@ -111,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);
@@ -135,33 +236,110 @@ 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 {
-                    const rawNodes = await GraphIndexerProcessor.query(args.driveId, this.relationalDb)
+                    const db = this.getDb(args.driveId);
+                    const rawNodes = await db
                         .selectFrom("graph_nodes")
                         .selectAll()
                         .execute();
-                    const rawEdges = await GraphIndexerProcessor.query(args.driveId, this.relationalDb)
+                    const rawEdges = await db
                         .selectFrom("graph_edges")
                         .selectAll()
                         .execute();
@@ -175,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,
@@ -204,18 +388,148 @@ export class KnowledgeGraphSubgraph extends BaseSubgraph {
     constructor(args) {
         super(args);
     }
+    /**
+     * Returns a Kysely<DB> instance scoped to the processor's namespace
+     * 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) {
-        // Use the processor's static query method for correct namespace scoping
-        // (same pattern as the working workstreams example)
-        const queryBuilder = GraphIndexerProcessor.query(driveId, this.relationalDb);
-        return createGraphQuery(queryBuilder);
+        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();
+    async reindexDrive(driveId) {
+        const errors = [];
+        let indexedNodes = 0;
+        let indexedEdges = 0;
+        try {
+            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 = 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({
+                        id: node.id,
+                        document_id: node.id,
+                        title: global.title ?? null,
+                        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({
+                        title: global.title ?? null,
+                        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")
+                        .where("source_document_id", "=", node.id)
+                        .execute();
+                    const links = global.links ?? [];
+                    if (links.length > 0) {
+                        await db
+                            .insertInto("graph_edges")
+                            .values(links.map((link) => ({
+                            id: link.id ??
+                                `${node.id}-${link.targetDocumentId}`,
+                            source_document_id: node.id,
+                            target_document_id: link.targetDocumentId ?? "",
+                            link_type: link.linkType ?? null,
+                            target_title: link.targetTitle ?? null,
+                            updated_at: now,
+                        })))
+                            .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);
+                    errors.push(`${node.id}: ${msg}`);
+                }
+            }
+            console.log(`[KnowledgeGraphSubgraph] Reindex complete: ${indexedNodes} nodes, ${indexedEdges} edges, ${errors.length} errors`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            errors.push(`Drive read failed: ${msg}`);
+        }
+        return { indexedNodes, indexedEdges, errors };
+    }
     async ensureGraphDoc(driveId) {
         if (this.ensuredDrives.has(driveId))
             return;
@@ -235,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,13 +1,13 @@
 {
   "name": "@powerhousedao/knowledge-note",
   "description": "Knowledge Note document model package for Powerhouse",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "license": "AGPL-3.0-only",
   "type": "module",
   "files": [
     "/dist"
   ],
-   "publishConfig": {
+  "publishConfig": {
     "access": "public"
   },
   "exports": {
@@ -107,13 +107,14 @@
   },
   "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",
     "@powerhousedao/document-engineering": "1.40.1",
     "@powerhousedao/vetra": "6.0.0-dev.105",
     "cytoscape": "^3.33.1",
-    "cytoscape-cose-bilkent": "^4.1.0",
+    "cytoscape-fcose": "^2.2.0",
     "document-model": "6.0.0-dev.105",
     "graphql": "16.12.0",
     "graphql-tag": "^2.12.6",

package/dist/processors/methodology-indexer/factory.d.ts

@@ -1,4 +0,0 @@
-import type { ProcessorRecord, IProcessorHostModule } from "@powerhousedao/reactor-browser";
-import type { PHDocumentHeader } from "document-model";
-export declare const methodologyIndexerProcessorFactory: (module: IProcessorHostModule) => (driveHeader: PHDocumentHeader) => Promise<ProcessorRecord[]>;
-//# sourceMappingURL=factory.d.ts.map

package/dist/processors/methodology-indexer/factory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../processors/methodology-indexer/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,oBAAoB,EACrB,MAAM,gCAAgC,CAAC;AAExC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAGvD,eAAO,MAAM,kCAAkC,GAC5C,QAAQ,oBAAoB,MACtB,aAAa,gBAAgB,KAAG,OAAO,CAAC,eAAe,EAAE,CAgC/D,CAAC"}

package/dist/processors/methodology-indexer/factory.js

@@ -1,23 +0,0 @@
-import {} from "@powerhousedao/shared/processors";
-import { MethodologyIndexerProcessor } from "./index.js";
-export const methodologyIndexerProcessorFactory = (module) => async (driveHeader) => {
-    const namespace = MethodologyIndexerProcessor.getNamespace(driveHeader.id);
-    console.log(`[MethodologyIndexer] Factory called for drive: ${driveHeader.id}, namespace: ${namespace}`);
-    const store = await module.relationalDb.createNamespace(namespace);
-    const filter = {
-        branch: ["main"],
-        documentId: ["*"],
-        documentType: ["bai/research-claim", "powerhouse/document-drive"],
-        scope: ["global"],
-    };
-    const processor = new MethodologyIndexerProcessor(namespace, filter, store);
-    await processor.initAndUpgrade();
-    console.log(`[MethodologyIndexer] Processor created for drive: ${driveHeader.id}`);
-    return [
-        {
-            processor,
-            filter,
-            startFrom: "beginning",
-        },
-    ];
-};

package/dist/processors/methodology-indexer/index.d.ts

@@ -1,11 +0,0 @@
-import { RelationalDbProcessor } from "@powerhousedao/shared/processors";
-import type { OperationWithContext } from "@powerhousedao/shared/document-model";
-import type { MethodologyDB } from "./schema.js";
-export declare class MethodologyIndexerProcessor extends RelationalDbProcessor<MethodologyDB> {
-    static getNamespace(driveId: string): string;
-    initAndUpgrade(): Promise<void>;
-    onOperations(operations: OperationWithContext[]): Promise<void>;
-    onDisconnect(): Promise<void>;
-    private deleteClaim;
-}
-//# sourceMappingURL=index.d.ts.map

package/dist/processors/methodology-indexer/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../processors/methodology-indexer/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAEjF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,qBAAa,2BAA4B,SAAQ,qBAAqB,CAAC,aAAa,CAAC;WACnE,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAItC,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAI/B,YAAY,CACzB,UAAU,EAAE,oBAAoB,EAAE,GACjC,OAAO,CAAC,IAAI,CAAC;IAsGV,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;YAYrB,WAAW;CAkB1B"}

package/dist/processors/methodology-indexer/index.js

@@ -1,116 +0,0 @@
-import { RelationalDbProcessor } from "@powerhousedao/shared/processors";
-import { up } from "./migrations.js";
-export class MethodologyIndexerProcessor extends RelationalDbProcessor {
-    static getNamespace(driveId) {
-        return super.getNamespace(driveId);
-    }
-    async initAndUpgrade() {
-        await up(this.relationalDb);
-    }
-    async onOperations(operations) {
-        if (operations.length === 0)
-            return;
-        const lastByDocument = new Map();
-        for (const entry of operations) {
-            const { operation, context } = entry;
-            const documentId = context.documentId;
-            // Handle deletion from drive
-            if (context.documentType === "powerhouse/document-drive" &&
-                operation.action.type === "DELETE_NODE") {
-                const deleteInput = operation.action.input;
-                await this.deleteClaim(deleteInput.id);
-                lastByDocument.delete(deleteInput.id);
-                continue;
-            }
-            // Only process research-claim documents
-            if (context.documentType !== "bai/research-claim")
-                continue;
-            if (context.resultingState) {
-                lastByDocument.set(documentId, entry);
-            }
-        }
-        for (const [documentId, entry] of lastByDocument) {
-            try {
-                const stateJson = entry.context.resultingState;
-                if (!stateJson)
-                    continue;
-                const parsed = JSON.parse(stateJson);
-                const global = (parsed.global ?? parsed);
-                const now = new Date().toISOString();
-                // Upsert claim
-                const topics = global.topics ?? [];
-                const methodology = global.methodology ?? [];
-                await this.relationalDb
-                    .insertInto("methodology_claims")
-                    .values({
-                    id: documentId,
-                    document_id: documentId,
-                    title: global.title ?? null,
-                    description: global.description ?? null,
-                    kind: global.kind ?? null,
-                    topics: JSON.stringify(topics),
-                    methodology: JSON.stringify(methodology),
-                    updated_at: now,
-                })
-                    .onConflict((oc) => oc.column("document_id").doUpdateSet({
-                    title: global.title ?? null,
-                    description: global.description ?? null,
-                    kind: global.kind ?? null,
-                    topics: JSON.stringify(topics),
-                    methodology: JSON.stringify(methodology),
-                    updated_at: now,
-                }))
-                    .execute();
-                // Reconcile connections
-                await this.relationalDb
-                    .deleteFrom("methodology_connections")
-                    .where("source_document_id", "=", documentId)
-                    .execute();
-                const connections = global.connections ?? [];
-                if (connections.length > 0) {
-                    await this.relationalDb
-                        .insertInto("methodology_connections")
-                        .values(connections.map((conn) => ({
-                        id: conn.id ??
-                            `${documentId}-${conn.targetRef}`,
-                        source_document_id: documentId,
-                        target_ref: conn.targetRef ?? "",
-                        context_phrase: conn.contextPhrase ?? null,
-                        updated_at: now,
-                    })))
-                        .execute();
-                }
-                console.log(`[MethodologyIndexer] Reconciled ${documentId}: ${connections.length} connections`);
-            }
-            catch (err) {
-                console.error(`[MethodologyIndexer] Error reconciling ${documentId}:`, err);
-            }
-        }
-    }
-    async onDisconnect() {
-        try {
-            await this.relationalDb.deleteFrom("methodology_connections").execute();
-            await this.relationalDb.deleteFrom("methodology_claims").execute();
-            console.log(`[MethodologyIndexer] Cleaned up namespace: ${this.namespace}`);
-        }
-        catch (err) {
-            console.error(`[MethodologyIndexer] Error cleaning up:`, err);
-        }
-    }
-    async deleteClaim(documentId) {
-        try {
-            await this.relationalDb
-                .deleteFrom("methodology_connections")
-                .where("source_document_id", "=", documentId)
-                .execute();
-            await this.relationalDb
-                .deleteFrom("methodology_claims")
-                .where("document_id", "=", documentId)
-                .execute();
-            console.log(`[MethodologyIndexer] Deleted claim ${documentId}`);
-        }
-        catch (err) {
-            console.error(`[MethodologyIndexer] Error deleting claim ${documentId}:`, err);
-        }
-    }
-}

package/dist/processors/methodology-indexer/migrations.d.ts

@@ -1,4 +0,0 @@
-import type { IRelationalDb } from "@powerhousedao/shared/processors";
-export declare function up(db: IRelationalDb<any>): Promise<void>;
-export declare function down(db: IRelationalDb<any>): Promise<void>;
-//# sourceMappingURL=migrations.d.ts.map