@powerhousedao/knowledge-note 1.0.0

package/dist/subgraphs/index.d.ts

@@ -0,0 +1,2 @@
+export * as KnowledgeGraphSubgraph from "./knowledge-graph/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/subgraphs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../subgraphs/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,sBAAsB,MAAM,4BAA4B,CAAC"}

package/dist/subgraphs/index.js

@@ -0,0 +1 @@
+export * as KnowledgeGraphSubgraph from "./knowledge-graph/index.js";

package/dist/subgraphs/knowledge-graph/index.d.ts

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

package/dist/subgraphs/knowledge-graph/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../subgraphs/knowledge-graph/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC"}

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

@@ -0,0 +1 @@
+export { KnowledgeGraphSubgraph } from "./subgraph.js";

package/dist/subgraphs/knowledge-graph/subgraph.d.ts

@@ -0,0 +1,95 @@
+import { BaseSubgraph, type SubgraphArgs } from "@powerhousedao/reactor-api";
+export declare class KnowledgeGraphSubgraph extends BaseSubgraph {
+    name: string;
+    typeDefs: import("graphql").DocumentNode;
+    resolvers: {
+        Query: {
+            knowledgeGraphNodes: (_: unknown, args: {
+                driveId: string;
+            }) => Promise<import("../../processors/graph-indexer/query.js").GraphNodeResult[]>;
+            knowledgeGraphEdges: (_: unknown, args: {
+                driveId: string;
+            }) => Promise<import("../../processors/graph-indexer/query.js").GraphEdgeResult[]>;
+            knowledgeGraphStats: (_: unknown, args: {
+                driveId: string;
+            }) => Promise<import("../../processors/graph-indexer/query.js").GraphStatsResult>;
+            knowledgeGraphNodeByDocumentId: (_: unknown, args: {
+                driveId: string;
+                documentId: string;
+            }) => Promise<import("../../processors/graph-indexer/query.js").GraphNodeResult | undefined>;
+            knowledgeGraphOrphans: (_: unknown, args: {
+                driveId: string;
+            }) => Promise<import("../../processors/graph-indexer/query.js").GraphNodeResult[]>;
+            knowledgeGraphConnections: (_: unknown, args: {
+                driveId: string;
+                documentId: string;
+                depth?: number;
+            }) => Promise<import("../../processors/graph-indexer/query.js").ConnectionResult[]>;
+            knowledgeGraphNodesByStatus: (_: unknown, args: {
+                driveId: string;
+                status: string;
+            }) => Promise<import("../../processors/graph-indexer/query.js").GraphNodeResult[]>;
+            knowledgeGraphBacklinks: (_: unknown, args: {
+                driveId: string;
+                documentId: string;
+            }) => Promise<import("../../processors/graph-indexer/query.js").GraphEdgeResult[]>;
+            knowledgeGraphDensity: (_: unknown, args: {
+                driveId: string;
+            }) => Promise<number>;
+            knowledgeGraphSearch: (_: unknown, args: {
+                driveId: string;
+                query: string;
+                limit?: number;
+            }) => Promise<import("../../processors/graph-indexer/query.js").GraphNodeResult[]>;
+            knowledgeGraphTriangles: (_: unknown, args: {
+                driveId: string;
+                limit?: number;
+            }) => Promise<{
+                noteA: import("../../processors/graph-indexer/query.js").GraphNodeResult;
+                noteB: import("../../processors/graph-indexer/query.js").GraphNodeResult;
+                sharedTarget: import("../../processors/graph-indexer/query.js").GraphNodeResult;
+            }[]>;
+            knowledgeGraphBridges: (_: unknown, args: {
+                driveId: string;
+            }) => Promise<import("../../processors/graph-indexer/query.js").GraphNodeResult[]>;
+            knowledgeGraphForwardLinks: (_: unknown, args: {
+                driveId: string;
+                documentId: string;
+            }) => Promise<import("../../processors/graph-indexer/query.js").GraphEdgeResult[]>;
+            knowledgeGraphDebug: (_: unknown, args: {
+                driveId: string;
+            }) => Promise<{
+                rawNodeCount: number;
+                rawEdgeCount: number;
+                rawNodes: {
+                    id: any;
+                    documentId: any;
+                    title: any;
+                    description: any;
+                    noteType: any;
+                    status: any;
+                    updatedAt: any;
+                }[];
+                rawEdges: {
+                    id: any;
+                    sourceDocumentId: any;
+                    targetDocumentId: any;
+                    linkType: any;
+                    targetTitle: any;
+                    updatedAt: any;
+                }[];
+                processorNamespace: string;
+            }>;
+        };
+    };
+    constructor(args: SubgraphArgs);
+    private getQuery;
+    /**
+     * Ensures a bai/knowledge-graph document exists in the given drive.
+     * Called lazily on first query — supports API/plugin access without
+     * requiring the Connect UI to have initialized the drive first.
+     */
+    private ensuredDrives;
+    private ensureGraphDoc;
+}
+//# sourceMappingURL=subgraph.d.ts.map

package/dist/subgraphs/knowledge-graph/subgraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subgraph.d.ts","sourceRoot":"","sources":["../../../subgraphs/knowledge-graph/subgraph.ts"],"names":[],"mappings":"AACA,OAAO,EACL,YAAY,EACZ,KAAK,YAAY,EAElB,MAAM,4BAA4B,CAAC;AAMpC,qBAAa,sBAAuB,SAAQ,YAAY;IAC7C,IAAI,SAAoB;IAExB,QAAQ,iCAwEf;IAEO,SAAS;;qCAGT,OAAO,QACJ;gBAAE,OAAO,EAAE,MAAM,CAAA;aAAE;qCAQtB,OAAO,QACJ;gBAAE,OAAO,EAAE,MAAM,CAAA;aAAE;qCAQtB,OAAO,QACJ;gBAAE,OAAO,EAAE,MAAM,CAAA;aAAE;gDAQtB,OAAO,QACJ;gBAAE,OAAO,EAAE,MAAM,CAAC;gBAAC,UAAU,EAAE,MAAM,CAAA;aAAE;uCAO1C,OAAO,QACJ;gBAAE,OAAO,EAAE,MAAM,CAAA;aAAE;2CAOtB,OAAO,QACJ;gBAAE,OAAO,EAAE,MAAM,CAAC;gBAAC,UAAU,EAAE,MAAM,CAAC;gBAAC,KAAK,CAAC,EAAE,MAAM,CAAA;aAAE;6CAO1D,OAAO,QACJ;gBAAE,OAAO,EAAE,MAAM,CAAC;gBAAC,MAAM,EAAE,MAAM,CAAA;aAAE;yCAOtC,OAAO,QACJ;gBAAE,OAAO,EAAE,MAAM,CAAC;gBAAC,UAAU,EAAE,MAAM,CAAA;aAAE;uCAO1C,OAAO,QACJ;gBAAE,OAAO,EAAE,MAAM,CAAA;aAAE;sCAOtB,OAAO,QACJ;gBAAE,OAAO,EAAE,MAAM,CAAC;gBAAC,KAAK,EAAE,MAAM,CAAC;gBAAC,KAAK,CAAC,EAAE,MAAM,CAAA;aAAE;yCAOrD,OAAO,QACJ;gBAAE,OAAO,EAAE,MAAM,CAAC;gBAAC,KAAK,CAAC,EAAE,MAAM,CAAA;aAAE;;;;;uCAQtC,OAAO,QACJ;gBAAE,OAAO,EAAE,MAAM,CAAA;aAAE;4CAOtB,OAAO,QACJ;gBAAE,OAAO,EAAE,MAAM,CAAC;gBAAC,UAAU,EAAE,MAAM,CAAA;aAAE;qCAO1C,OAAO,QACJ;gBAAE,OAAO,EAAE,MAAM,CAAA;aAAE;;;;;;;;;;;;;;;;;;;;;;;MAqC7B;gBAEU,IAAI,EAAE,YAAY;IAI9B,OAAO,CAAC,QAAQ;IAOhB;;;;OAIG;IACH,OAAO,CAAC,aAAa,CAAqB;YAE5B,cAAc;CAmC7B"}

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

@@ -0,0 +1,216 @@
+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";
+export class KnowledgeGraphSubgraph extends BaseSubgraph {
+    name = "knowledgeGraph";
+    typeDefs = gql `
+    type KnowledgeGraphNode {
+      id: String!
+      documentId: String!
+      title: String
+      description: String
+      noteType: String
+      status: String
+      updatedAt: String!
+    }
+
+    type KnowledgeGraphEdge {
+      id: String!
+      sourceDocumentId: String!
+      targetDocumentId: String!
+      linkType: String
+      targetTitle: String
+      updatedAt: String!
+    }
+
+    type GraphStats {
+      nodeCount: Int!
+      edgeCount: Int!
+      orphanCount: Int!
+    }
+
+    type ConnectionResult {
+      node: KnowledgeGraphNode!
+      depth: Int!
+      viaLinkType: String
+    }
+
+    extend type Query {
+      knowledgeGraphNodes(driveId: ID!): [KnowledgeGraphNode!]!
+      knowledgeGraphEdges(driveId: ID!): [KnowledgeGraphEdge!]!
+      knowledgeGraphStats(driveId: ID!): GraphStats!
+      knowledgeGraphNodeByDocumentId(
+        driveId: ID!
+        documentId: String!
+      ): KnowledgeGraphNode
+      knowledgeGraphOrphans(driveId: ID!): [KnowledgeGraphNode!]!
+      knowledgeGraphConnections(
+        driveId: ID!
+        documentId: String!
+        depth: Int
+      ): [ConnectionResult!]!
+      knowledgeGraphNodesByStatus(driveId: ID!, status: String!): [KnowledgeGraphNode!]!
+      knowledgeGraphBacklinks(driveId: ID!, documentId: String!): [KnowledgeGraphEdge!]!
+      knowledgeGraphDensity(driveId: ID!): Float!
+
+      knowledgeGraphSearch(driveId: ID!, query: String!, limit: Int): [KnowledgeGraphNode!]!
+      knowledgeGraphTriangles(driveId: ID!, limit: Int): [Triangle!]!
+      knowledgeGraphBridges(driveId: ID!): [KnowledgeGraphNode!]!
+      knowledgeGraphForwardLinks(driveId: ID!, documentId: String!): [KnowledgeGraphEdge!]!
+
+      """Debug: raw processor DB tables"""
+      knowledgeGraphDebug(driveId: ID!): GraphDebugInfo!
+    }
+
+    type Triangle {
+      noteA: KnowledgeGraphNode!
+      noteB: KnowledgeGraphNode!
+      sharedTarget: KnowledgeGraphNode!
+    }
+
+    type GraphDebugInfo {
+      rawNodeCount: Int!
+      rawEdgeCount: Int!
+      rawNodes: [KnowledgeGraphNode!]!
+      rawEdges: [KnowledgeGraphEdge!]!
+      processorNamespace: String!
+    }
+  `;
+    resolvers = {
+        Query: {
+            knowledgeGraphNodes: async (_, args) => {
+                await this.ensureGraphDoc(args.driveId);
+                const query = this.getQuery(args.driveId);
+                return query.allNodes();
+            },
+            knowledgeGraphEdges: async (_, args) => {
+                await this.ensureGraphDoc(args.driveId);
+                const query = this.getQuery(args.driveId);
+                return query.allEdges();
+            },
+            knowledgeGraphStats: async (_, args) => {
+                await this.ensureGraphDoc(args.driveId);
+                const query = this.getQuery(args.driveId);
+                return query.stats();
+            },
+            knowledgeGraphNodeByDocumentId: async (_, args) => {
+                const query = this.getQuery(args.driveId);
+                return query.nodeByDocumentId(args.documentId) ?? null;
+            },
+            knowledgeGraphOrphans: async (_, args) => {
+                const query = this.getQuery(args.driveId);
+                return query.orphanNodes();
+            },
+            knowledgeGraphConnections: async (_, args) => {
+                const query = this.getQuery(args.driveId);
+                return query.connections(args.documentId, args.depth ?? 2);
+            },
+            knowledgeGraphNodesByStatus: async (_, args) => {
+                const query = this.getQuery(args.driveId);
+                return query.nodesByStatus(args.status);
+            },
+            knowledgeGraphBacklinks: async (_, args) => {
+                const query = this.getQuery(args.driveId);
+                return query.backlinks(args.documentId);
+            },
+            knowledgeGraphDensity: async (_, args) => {
+                const query = this.getQuery(args.driveId);
+                return query.density();
+            },
+            knowledgeGraphSearch: async (_, args) => {
+                const query = this.getQuery(args.driveId);
+                return query.searchNodes(args.query, args.limit ?? 50);
+            },
+            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 }));
+            },
+            knowledgeGraphBridges: async (_, args) => {
+                const query = this.getQuery(args.driveId);
+                return query.bridges();
+            },
+            knowledgeGraphForwardLinks: async (_, args) => {
+                const query = this.getQuery(args.driveId);
+                return query.forwardLinks(args.documentId);
+            },
+            knowledgeGraphDebug: async (_, args) => {
+                const namespace = GraphIndexerProcessor.getNamespace(args.driveId);
+                try {
+                    const rawNodes = await GraphIndexerProcessor.query(args.driveId, this.relationalDb)
+                        .selectFrom("graph_nodes")
+                        .selectAll()
+                        .execute();
+                    const rawEdges = await GraphIndexerProcessor.query(args.driveId, this.relationalDb)
+                        .selectFrom("graph_edges")
+                        .selectAll()
+                        .execute();
+                    return {
+                        rawNodeCount: rawNodes.length,
+                        rawEdgeCount: rawEdges.length,
+                        rawNodes: rawNodes.map((r) => ({
+                            id: r.id, documentId: r.document_id, title: r.title,
+                            description: r.description, noteType: r.note_type,
+                            status: r.status, updatedAt: r.updated_at,
+                        })),
+                        rawEdges: rawEdges.map((r) => ({
+                            id: r.id, sourceDocumentId: r.source_document_id,
+                            targetDocumentId: r.target_document_id, linkType: r.link_type,
+                            targetTitle: r.target_title, updatedAt: r.updated_at,
+                        })),
+                        processorNamespace: namespace,
+                    };
+                }
+                catch (err) {
+                    console.warn(`[KnowledgeGraphSubgraph] Debug query failed for ${namespace}:`, err);
+                    return {
+                        rawNodeCount: 0, rawEdgeCount: 0,
+                        rawNodes: [], rawEdges: [],
+                        processorNamespace: namespace,
+                    };
+                }
+            },
+        },
+    };
+    constructor(args) {
+        super(args);
+    }
+    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);
+    }
+    /**
+     * Ensures a bai/knowledge-graph document exists in the given drive.
+     * Called lazily on first query — supports API/plugin access without
+     * requiring the Connect UI to have initialized the drive first.
+     */
+    ensuredDrives = new Set();
+    async ensureGraphDoc(driveId) {
+        if (this.ensuredDrives.has(driveId))
+            return;
+        this.ensuredDrives.add(driveId);
+        try {
+            // Check if a knowledge-graph doc already exists anywhere in the drive
+            const drive = await this.reactorClient.get(driveId);
+            const nodes = drive.state.global.nodes;
+            const hasGraph = nodes.some((n) => n.kind === "file" && n.documentType === "bai/knowledge-graph");
+            if (!hasGraph) {
+                // Find the /self folder to place the graph doc in the correct location
+                const selfFolder = nodes.find((n) => n.kind === "folder" && n.name === "self" && n.parentFolder == null);
+                const parentFolder = selfFolder?.id;
+                await this.reactorClient.createEmpty("bai/knowledge-graph", {
+                    parentIdentifier: parentFolder ?? driveId,
+                });
+                console.log(`[KnowledgeGraphSubgraph] Auto-created KnowledgeGraph in drive ${driveId}` +
+                    (parentFolder ? ` (folder: /self/)` : ` (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
+        }
+    }
+}

package/dist/tests/helpers/create-test-db.d.ts

@@ -0,0 +1,9 @@
+import { Kysely } from "kysely";
+import { PGlite } from "@electric-sql/pglite";
+import type { DB } from "../../processors/graph-indexer/schema.js";
+export declare function createTestDb(): Promise<{
+    db: Kysely<DB>;
+    pglite: PGlite;
+    cleanup: () => Promise<void>;
+}>;
+//# sourceMappingURL=create-test-db.d.ts.map

package/dist/tests/helpers/create-test-db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-test-db.d.ts","sourceRoot":"","sources":["../../../tests/helpers/create-test-db.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAE9C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0CAA0C,CAAC;AAGnE,wBAAsB,YAAY;;;;GAYjC"}

package/dist/tests/helpers/create-test-db.js

@@ -0,0 +1,17 @@
+import { Kysely } from "kysely";
+import { PGlite } from "@electric-sql/pglite";
+import { PGliteDialect } from "kysely-pglite-dialect";
+import { up, down } from "../../processors/graph-indexer/migrations.js";
+export async function createTestDb() {
+    const pglite = new PGlite();
+    const db = new Kysely({ dialect: new PGliteDialect(pglite) });
+    await up(db);
+    return {
+        db,
+        pglite,
+        cleanup: async () => {
+            await down(db);
+            await db.destroy();
+        },
+    };
+}

package/dist/tests/helpers/make-op.d.ts

@@ -0,0 +1,10 @@
+import type { OperationWithContext } from "@powerhousedao/shared/document-model";
+export declare function makeOp(overrides?: {
+    documentId?: string;
+    documentType?: string;
+    actionType?: string;
+    actionInput?: Record<string, unknown>;
+    resultingState?: Record<string, unknown>;
+    index?: number;
+}): OperationWithContext;
+//# sourceMappingURL=make-op.d.ts.map

package/dist/tests/helpers/make-op.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-op.d.ts","sourceRoot":"","sources":["../../../tests/helpers/make-op.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAEjF,wBAAgB,MAAM,CAAC,SAAS,CAAC,EAAE;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GAAG,oBAAoB,CA4BvB"}

package/dist/tests/helpers/make-op.js

@@ -0,0 +1,29 @@
+export function makeOp(overrides) {
+    const ts = String(Date.now());
+    return {
+        operation: {
+            id: `op-${ts}`,
+            index: overrides?.index ?? 0,
+            skip: 0,
+            timestampUtcMs: ts,
+            hash: "test-hash",
+            action: {
+                id: `act-${ts}`,
+                type: overrides?.actionType ?? "SET_TITLE",
+                timestampUtcMs: ts,
+                input: overrides?.actionInput ?? {},
+                scope: "global",
+            },
+        },
+        context: {
+            documentId: overrides?.documentId ?? "test-doc-1",
+            documentType: overrides?.documentType ?? "bai/knowledge-note",
+            scope: "global",
+            branch: "main",
+            ordinal: 0,
+            resultingState: overrides?.resultingState
+                ? JSON.stringify({ global: overrides.resultingState })
+                : undefined,
+        },
+    };
+}

package/dist/tests/integration/remote-drive.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=remote-drive.test.d.ts.map

package/dist/tests/integration/remote-drive.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-drive.test.d.ts","sourceRoot":"","sources":["../../../tests/integration/remote-drive.test.ts"],"names":[],"mappings":""}

package/dist/tests/integration/remote-drive.test.js

@@ -0,0 +1,168 @@
+import { describe, it, expect } from "vitest";
+// The drive's REST endpoint — used to check liveliness and get the drive id
+const DRIVE_URL = "http://localhost:4001/d/remote-knowledge-vault";
+// The drive-level GraphQL endpoint (discovered from the drive REST response)
+const DRIVE_GRAPHQL_URL = "http://localhost:4001/graphql/r";
+async function isReactorRunning() {
+    try {
+        const res = await fetch(DRIVE_URL, { signal: AbortSignal.timeout(2000) });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+async function gql(query, variables) {
+    const res = await fetch(DRIVE_GRAPHQL_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ query, variables }),
+    });
+    return res.json();
+}
+const reactorAvailable = await isReactorRunning();
+describe.skipIf(!reactorAvailable)("Remote Drive Integration", () => {
+    // ── Test 1: drive accessibility ──────────────────────────────────────────────
+    it("drive exists and is accessible via REST endpoint", async () => {
+        const res = await fetch(DRIVE_URL, { signal: AbortSignal.timeout(5000) });
+        expect(res.ok).toBe(true);
+        const body = (await res.json());
+        expect(typeof body.id).toBe("string");
+        expect(body.slug).toBe("remote-knowledge-vault");
+    });
+    // ── Test 2: findDocuments for bai/knowledge-note returns results ─────────────
+    it("findDocuments for bai/knowledge-note returns results (array, may be empty)", async () => {
+        const result = await gql(`
+      query {
+        findDocuments(search: { type: "bai/knowledge-note" }) {
+          items {
+            id
+            documentType
+          }
+          totalCount
+        }
+      }
+    `);
+        expect(result.errors).toBeUndefined();
+        expect(result.data).toBeDefined();
+        const page = result.data?.findDocuments;
+        expect(page).toBeDefined();
+        expect(Array.isArray(page?.items)).toBe(true);
+        expect(typeof page?.totalCount).toBe("number");
+    });
+    // ── Test 3: bai/pipeline-queue — at least 1 (singleton) ─────────────────────
+    //
+    // NOTE: This test requires the remote drive to be seeded with at least one
+    // pipeline-queue singleton document. If the drive is empty, the test is
+    // skipped with a warning rather than failing.
+    it("findDocuments for bai/pipeline-queue returns at least 1 result", async () => {
+        const result = await gql(`
+      query {
+        findDocuments(search: { type: "bai/pipeline-queue" }) {
+          items {
+            id
+            documentType
+          }
+          totalCount
+        }
+      }
+    `);
+        expect(result.errors).toBeUndefined();
+        const page = result.data?.findDocuments;
+        expect(page).toBeDefined();
+        if (!page || page.totalCount === 0) {
+            console.warn("No bai/pipeline-queue documents found; drive may not be seeded yet.");
+            return;
+        }
+        expect(page.totalCount).toBeGreaterThanOrEqual(1);
+    });
+    // ── Test 4: bai/vault-config — at least 1 (singleton) ───────────────────────
+    //
+    // NOTE: Requires a seeded vault-config singleton. Skipped with warning when
+    // the drive contains no vault-config documents.
+    it("findDocuments for bai/vault-config returns at least 1 result", async () => {
+        const result = await gql(`
+      query {
+        findDocuments(search: { type: "bai/vault-config" }) {
+          items {
+            id
+            documentType
+          }
+          totalCount
+        }
+      }
+    `);
+        expect(result.errors).toBeUndefined();
+        const page = result.data?.findDocuments;
+        expect(page).toBeDefined();
+        if (!page || page.totalCount === 0) {
+            console.warn("No bai/vault-config documents found; drive may not be seeded yet.");
+            return;
+        }
+        expect(page.totalCount).toBeGreaterThanOrEqual(1);
+    });
+    // ── Test 5: bai/knowledge-graph — at least 1 ────────────────────────────────
+    //
+    // NOTE: Requires at least one knowledge-graph document. Skipped with warning
+    // when none exist.
+    it("findDocuments for bai/knowledge-graph returns at least 1 result", async () => {
+        const result = await gql(`
+      query {
+        findDocuments(search: { type: "bai/knowledge-graph" }) {
+          items {
+            id
+            documentType
+          }
+          totalCount
+        }
+      }
+    `);
+        expect(result.errors).toBeUndefined();
+        const page = result.data?.findDocuments;
+        expect(page).toBeDefined();
+        if (!page || page.totalCount === 0) {
+            console.warn("No bai/knowledge-graph documents found; drive may not be seeded yet.");
+            return;
+        }
+        expect(page.totalCount).toBeGreaterThanOrEqual(1);
+    });
+    // ── Test 6: document query by ID ─────────────────────────────────────────────
+    it("document query returns a document by ID (first note from findDocuments)", async () => {
+        // First, fetch note IDs
+        const listResult = await gql(`
+      query {
+        findDocuments(search: { type: "bai/knowledge-note" }) {
+          items {
+            id
+            documentType
+          }
+          totalCount
+        }
+      }
+    `);
+        expect(listResult.errors).toBeUndefined();
+        const page = listResult.data?.findDocuments;
+        expect(page).toBeDefined();
+        if (!page || page.items.length === 0) {
+            // No notes in the drive — skip gracefully with an informative log
+            console.warn("No bai/knowledge-note documents found in remote drive; skipping document-by-ID lookup.");
+            return;
+        }
+        const firstId = page.items[0].id;
+        expect(typeof firstId).toBe("string");
+        expect(firstId.length).toBeGreaterThan(0);
+        const docResult = await gql(`
+      query GetDocument($identifier: String!) {
+        document(identifier: $identifier) {
+          id
+          documentType
+        }
+      }
+    `, { identifier: firstId });
+        expect(docResult.errors).toBeUndefined();
+        const doc = docResult.data?.document;
+        expect(doc).toBeDefined();
+        expect(doc?.id).toBe(firstId);
+        expect(doc?.documentType).toBe("bai/knowledge-note");
+    });
+});

package/dist/tests/processor/graph-indexer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=graph-indexer.test.d.ts.map

package/dist/tests/processor/graph-indexer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-indexer.test.d.ts","sourceRoot":"","sources":["../../../tests/processor/graph-indexer.test.ts"],"names":[],"mappings":""}