@vpxa/aikit 0.1.58 → 0.1.60

package/packages/store/dist/index.d.ts

@@ -1,6 +1,317 @@
-import { DepthGroupedResult, GraphEdge, GraphNode, GraphStats, GraphTraversalOptions, GraphTraversalResult, GraphValidationResult, IGraphStore, ProcessInfo, Symbol360 } from "./graph-store.interface.js";
-import { IKnowledgeStore, SearchOptions } from "./store.interface.js";
-import { LanceStore } from "./lance-store.js";
-import { SqliteGraphStore } from "./sqlite-graph-store.js";
-import { StoreBackend, StoreConfig, createStore } from "./store-factory.js";
+import { ContentType, IndexStats, KnowledgeOrigin, KnowledgeRecord, SearchResult, SourceType } from "../../core/dist/index.js";
+
+//#region packages/store/src/graph-store.interface.d.ts
+/**
+ * Knowledge graph store abstraction — typed nodes + edges for entity-relationship storage.
+ * Complements the vector store: vector search finds similar content,
+ * graph traversal finds connected concepts.
+ */
+/** A node in the knowledge graph (entity, concept, service, etc.) */
+interface GraphNode {
+  /** Unique identifier */
+  id: string;
+  /** Node type (e.g., 'entity', 'service', 'api', 'concept', 'decision') */
+  type: string;
+  /** Display name */
+  name: string;
+  /** Arbitrary properties */
+  properties: Record<string, unknown>;
+  /** Back-link to KnowledgeRecord.id that produced this node */
+  sourceRecordId?: string;
+  /** Source file path (for cleanup on re-index) */
+  sourcePath?: string;
+  /** ISO timestamp */
+  createdAt?: string;
+  /** Community/cluster label from community detection */
+  community?: string;
+}
+/** An edge connecting two nodes */
+interface GraphEdge {
+  /** Unique identifier */
+  id: string;
+  /** Source node ID */
+  fromId: string;
+  /** Target node ID */
+  toId: string;
+  /** Relationship type (e.g., 'depends-on', 'implements', 'calls', 'affects') */
+  type: string;
+  /** Optional weight (0-1) */
+  weight?: number;
+  /** Optional confidence score (0-1) for relationship certainty */
+  confidence?: number;
+  /** Arbitrary properties */
+  properties?: Record<string, unknown>;
+}
+/** Options for graph traversal */
+interface GraphTraversalOptions {
+  /** Relationship type filter */
+  edgeType?: string;
+  /** Max traversal depth (default: 2) */
+  maxDepth?: number;
+  /** Direction: outgoing from start, incoming to start, or both */
+  direction?: 'outgoing' | 'incoming' | 'both';
+  /** Max total nodes returned (default: 50) */
+  limit?: number;
+}
+/** Result of a graph traversal */
+interface GraphTraversalResult {
+  nodes: GraphNode[];
+  edges: GraphEdge[];
+}
+/** Graph statistics */
+interface GraphStats {
+  nodeCount: number;
+  edgeCount: number;
+  nodeTypes: Record<string, number>;
+  edgeTypes: Record<string, number>;
+}
+/** Result of graph validation */
+interface GraphValidationResult {
+  valid: boolean;
+  orphanNodes: string[];
+  danglingEdges: Array<{
+    edgeId: string;
+    missingNodeId: string;
+  }>;
+  stats: GraphStats;
+}
+/** Depth-grouped traversal result — nodes bucketed by distance from start */
+interface DepthGroupedResult {
+  [depth: number]: GraphNode[];
+}
+/** Execution flow / process info */
+interface ProcessInfo {
+  id: string;
+  entryNodeId: string;
+  label: string;
+  properties: Record<string, unknown>;
+  steps: string[];
+  createdAt?: string;
+}
+/** 360-degree symbol view — full context around a node */
+interface Symbol360 {
+  node: GraphNode;
+  incoming: GraphEdge[];
+  outgoing: GraphEdge[];
+  community: string | null;
+  processes: ProcessInfo[];
+}
+/** Knowledge graph store interface */
+interface IGraphStore {
+  /** Initialize the store (create tables, indices) */
+  initialize(): Promise<void>;
+  /** Add or update a single node */
+  upsertNode(node: GraphNode): Promise<void>;
+  /** Add or update a single edge */
+  upsertEdge(edge: GraphEdge): Promise<void>;
+  /** Batch add/update nodes */
+  upsertNodes(nodes: GraphNode[]): Promise<void>;
+  /** Batch add/update edges */
+  upsertEdges(edges: GraphEdge[]): Promise<void>;
+  /** Get a node by ID */
+  getNode(id: string): Promise<GraphNode | null>;
+  /** Get direct neighbors of a node */
+  getNeighbors(nodeId: string, options?: GraphTraversalOptions): Promise<GraphTraversalResult>;
+  /** Multi-hop traversal from a starting node */
+  traverse(startId: string, options?: GraphTraversalOptions): Promise<GraphTraversalResult>;
+  /** Find nodes by type and/or name pattern */
+  findNodes(filter: {
+    type?: string;
+    namePattern?: string;
+    sourcePath?: string;
+    limit?: number;
+  }): Promise<GraphNode[]>;
+  /** Find edges by type between optional node filters */
+  findEdges(filter: {
+    type?: string;
+    fromId?: string;
+    toId?: string;
+    limit?: number;
+  }): Promise<GraphEdge[]>;
+  /** Delete a node and all its edges */
+  deleteNode(id: string): Promise<void>;
+  /** Delete all nodes/edges originating from a source path */
+  deleteBySourcePath(sourcePath: string): Promise<number>;
+  /** Delete all nodes and edges (full reset) */
+  clear(): Promise<void>;
+  /** Get graph statistics */
+  getStats(): Promise<GraphStats>;
+  /** Validate graph integrity — check for orphan nodes and dangling edges */
+  validate(): Promise<GraphValidationResult>;
+  /** Set community label on a node */
+  setNodeCommunity(nodeId: string, community: string): Promise<void>;
+  /** Run label-propagation community detection, returns community -> nodeId[] map */
+  detectCommunities(): Promise<Record<string, string[]>>;
+  /** Trace execution flow from entry node via outgoing 'calls' edges, store as process */
+  traceProcess(entryNodeId: string, label: string): Promise<ProcessInfo>;
+  /** List processes, optionally filtered to those containing a specific node */
+  getProcesses(nodeId?: string): Promise<ProcessInfo[]>;
+  /** Delete a process and its steps */
+  deleteProcess(processId: string): Promise<void>;
+  /** Traverse with results grouped by depth: { 1: [...], 2: [...], 3: [...] } */
+  depthGroupedTraversal(startId: string, maxDepth?: number, options?: GraphTraversalOptions): Promise<DepthGroupedResult>;
+  /** Cohesion score for a community: internal edges / (internal + external edges) */
+  getCohesionScore(community: string): Promise<number>;
+  /** 360-degree view of a node: incoming, outgoing, community, processes */
+  getSymbol360(nodeId: string): Promise<Symbol360>;
+  /** Close the store */
+  close(): Promise<void>;
+}
+//#endregion
+//#region packages/store/src/store.interface.d.ts
+/** Options for searching the store */
+interface SearchOptions {
+  /** Maximum number of results to return */
+  limit?: number;
+  /** Minimum similarity score (0-1) */
+  minScore?: number;
+  /** Filter by content type */
+  contentType?: ContentType;
+  /** Filter by coarse source type (source, documentation, test, config, generated) */
+  sourceType?: SourceType;
+  /** Filter by origin */
+  origin?: KnowledgeOrigin;
+  /** Filter by category */
+  category?: string;
+  /** Filter by tags (any match) */
+  tags?: string[];
+}
+interface IKnowledgeStore {
+  /** Initialize the store (create tables, etc.) */
+  initialize(): Promise<void>;
+  /** Add or update records with their embedding vectors */
+  upsert(records: KnowledgeRecord[], vectors: Float32Array[]): Promise<void>;
+  /** Add or update records with priority over bulk indexing writes */
+  upsertInteractive(records: KnowledgeRecord[], vectors: Float32Array[]): Promise<void>;
+  /** Search by vector similarity */
+  search(queryVector: Float32Array, options?: SearchOptions): Promise<SearchResult[]>;
+  /** Get a specific record by ID */
+  getById(id: string): Promise<KnowledgeRecord | null>;
+  /** Delete records by source path (used during re-indexing) */
+  deleteBySourcePath(sourcePath: string): Promise<number>;
+  /** Delete a specific record by ID */
+  deleteById(id: string): Promise<boolean>;
+  /** Delete a specific record by ID with priority over bulk indexing writes */
+  deleteByIdInteractive(id: string): Promise<boolean>;
+  /** Get all records for a source path */
+  getBySourcePath(sourcePath: string): Promise<KnowledgeRecord[]>;
+  /** Get index statistics */
+  getStats(): Promise<IndexStats>;
+  /** List all unique source paths in the store */
+  listSourcePaths(): Promise<string[]>;
+  /** Create a full-text search index on the content column for keyword search */
+  createFtsIndex(): Promise<void>;
+  /** Full-text keyword search (requires FTS index) */
+  ftsSearch(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+  /** Drop the backing table entirely — used for hard resets (e.g. dimension changes) */
+  dropTable(): Promise<void>;
+  /** Close the store connection */
+  close(): Promise<void>;
+}
+//#endregion
+//#region packages/store/src/lance-store.d.ts
+declare class LanceStore implements IKnowledgeStore {
+  private db;
+  private table;
+  private readonly dbPath;
+  private readonly tableName;
+  private _draining;
+  private _priorityQueue;
+  private _normalQueue;
+  private _ftsReady;
+  private _ftsRecoveryAttemptAt;
+  private static readonly FTS_RECOVERY_COOLDOWN_MS;
+  private enqueueWrite;
+  private _drain;
+  constructor(options?: {
+    path?: string;
+    tableName?: string;
+  });
+  initialize(): Promise<void>;
+  upsert(records: KnowledgeRecord[], vectors: Float32Array[]): Promise<void>;
+  upsertInteractive(records: KnowledgeRecord[], vectors: Float32Array[]): Promise<void>;
+  private _upsertImpl;
+  search(queryVector: Float32Array, options?: SearchOptions): Promise<SearchResult[]>;
+  createFtsIndex(): Promise<void>;
+  private _createFtsIndexImpl;
+  ftsSearch(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+  getById(id: string): Promise<KnowledgeRecord | null>;
+  deleteBySourcePath(sourcePath: string): Promise<number>;
+  private _deleteBySourcePathImpl;
+  deleteById(id: string): Promise<boolean>;
+  deleteByIdInteractive(id: string): Promise<boolean>;
+  private _deleteByIdImpl;
+  getBySourcePath(sourcePath: string): Promise<KnowledgeRecord[]>;
+  getStats(): Promise<IndexStats>;
+  listSourcePaths(): Promise<string[]>;
+  dropTable(): Promise<void>;
+  private _dropTableImpl;
+  close(): Promise<void>;
+  private buildFilterString;
+  private fromLanceRecord;
+}
+//#endregion
+//#region packages/store/src/sqlite-graph-store.d.ts
+declare class SqliteGraphStore implements IGraphStore {
+  private db;
+  private readonly dbPath;
+  private sqlFactory;
+  private dirty;
+  constructor(options?: {
+    path?: string;
+  });
+  initialize(): Promise<void>;
+  private configureDb;
+  private createTables;
+  private migrateSchema;
+  private ensureDb;
+  private persist;
+  private markDirty;
+  private flushIfDirty;
+  private query;
+  private run;
+  upsertNode(node: GraphNode): Promise<void>;
+  upsertEdge(edge: GraphEdge): Promise<void>;
+  upsertNodes(nodes: GraphNode[]): Promise<void>;
+  upsertEdges(edges: GraphEdge[]): Promise<void>;
+  getNode(id: string): Promise<GraphNode | null>;
+  getNeighbors(nodeId: string, options?: GraphTraversalOptions): Promise<GraphTraversalResult>;
+  traverse(startId: string, options?: GraphTraversalOptions): Promise<GraphTraversalResult>;
+  findNodes(filter: {
+    type?: string;
+    namePattern?: string;
+    sourcePath?: string;
+    limit?: number;
+  }): Promise<GraphNode[]>;
+  findEdges(filter: {
+    type?: string;
+    fromId?: string;
+    toId?: string;
+    limit?: number;
+  }): Promise<GraphEdge[]>;
+  deleteNode(id: string): Promise<void>;
+  deleteBySourcePath(sourcePath: string): Promise<number>;
+  clear(): Promise<void>;
+  getStats(): Promise<GraphStats>;
+  validate(): Promise<GraphValidationResult>;
+  setNodeCommunity(nodeId: string, community: string): Promise<void>;
+  detectCommunities(): Promise<Record<string, string[]>>;
+  traceProcess(entryNodeId: string, label: string): Promise<ProcessInfo>;
+  getProcesses(nodeId?: string): Promise<ProcessInfo[]>;
+  deleteProcess(processId: string): Promise<void>;
+  depthGroupedTraversal(startId: string, maxDepth?: number, options?: GraphTraversalOptions): Promise<DepthGroupedResult>;
+  getCohesionScore(community: string): Promise<number>;
+  getSymbol360(nodeId: string): Promise<Symbol360>;
+  close(): Promise<void>;
+}
+//#endregion
+//#region packages/store/src/store-factory.d.ts
+type StoreBackend = 'lancedb' | 'sqlite-vec';
+interface StoreConfig {
+  backend: StoreBackend;
+  path: string;
+  options?: Record<string, unknown>;
+}
+declare function createStore(config: StoreConfig): Promise<IKnowledgeStore>;
+//#endregion
 export { type DepthGroupedResult, type GraphEdge, type GraphNode, type GraphStats, type GraphTraversalOptions, type GraphTraversalResult, type GraphValidationResult, type IGraphStore, type IKnowledgeStore, LanceStore, type ProcessInfo, type SearchOptions, SqliteGraphStore, type StoreBackend, type StoreConfig, type Symbol360, createStore };

package/packages/store/dist/index.js

@@ -1 +1,90 @@
-import{LanceStore as e}from"./lance-store.js";import{SqliteGraphStore as t}from"./sqlite-graph-store.js";import{createStore as n}from"./store-factory.js";export{e as LanceStore,t as SqliteGraphStore,n as createStore};
+import{t as e}from"./lance-store-jdHZp-V4.js";import{AIKIT_PATHS as t}from"../../core/dist/index.js";import{existsSync as n,mkdirSync as r,readFileSync as i,writeFileSync as a}from"node:fs";import{dirname as o,join as s}from"node:path";var c=class{db=null;dbPath;sqlFactory=null;dirty=!1;constructor(e){let n=e?.path??t.data;this.dbPath=s(n,`graph.db`)}async initialize(){let e=o(this.dbPath);n(e)||r(e,{recursive:!0});let t=(await import(`sql.js`)).default,a=await t();if(this.sqlFactory=a,n(this.dbPath)){let e=i(this.dbPath);this.db=new a.Database(e)}else this.db=new a.Database;this.configureDb(this.db),this.createTables(this.db),this.migrateSchema(this.db),this.persist()}configureDb(e){e.run(`PRAGMA journal_mode = WAL`),e.exec(`PRAGMA foreign_keys = ON;`)}createTables(e){e.run(`
+      CREATE TABLE IF NOT EXISTS nodes (
+        id TEXT PRIMARY KEY,
+        type TEXT NOT NULL,
+        name TEXT NOT NULL,
+        properties TEXT NOT NULL DEFAULT '{}',
+        source_record_id TEXT,
+        source_path TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        community TEXT
+      )
+    `),e.run(`
+      CREATE TABLE IF NOT EXISTS edges (
+        id TEXT PRIMARY KEY,
+        from_id TEXT NOT NULL,
+        to_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        weight REAL DEFAULT 1.0,
+        confidence REAL DEFAULT 1.0,
+        properties TEXT NOT NULL DEFAULT '{}',
+        FOREIGN KEY (from_id) REFERENCES nodes(id) ON DELETE CASCADE,
+        FOREIGN KEY (to_id) REFERENCES nodes(id) ON DELETE CASCADE
+      )
+    `),e.run(`CREATE INDEX IF NOT EXISTS idx_nodes_type ON nodes(type)`),e.run(`CREATE INDEX IF NOT EXISTS idx_nodes_name ON nodes(name)`),e.run(`CREATE INDEX IF NOT EXISTS idx_nodes_source_path ON nodes(source_path)`),e.run(`CREATE INDEX IF NOT EXISTS idx_edges_from ON edges(from_id)`),e.run(`CREATE INDEX IF NOT EXISTS idx_edges_to ON edges(to_id)`),e.run(`CREATE INDEX IF NOT EXISTS idx_edges_type ON edges(type)`),e.run(`
+      CREATE TABLE IF NOT EXISTS processes (
+        id TEXT PRIMARY KEY,
+        entry_node_id TEXT NOT NULL,
+        label TEXT NOT NULL,
+        properties TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        FOREIGN KEY (entry_node_id) REFERENCES nodes(id) ON DELETE CASCADE
+      )
+    `),e.run(`
+      CREATE TABLE IF NOT EXISTS process_steps (
+        process_id TEXT NOT NULL,
+        node_id TEXT NOT NULL,
+        step_order INTEGER NOT NULL,
+        PRIMARY KEY (process_id, node_id),
+        FOREIGN KEY (process_id) REFERENCES processes(id) ON DELETE CASCADE,
+        FOREIGN KEY (node_id) REFERENCES nodes(id) ON DELETE CASCADE
+      )
+    `),e.run(`CREATE INDEX IF NOT EXISTS idx_process_steps_node ON process_steps(node_id)`)}migrateSchema(e){for(let t of[`ALTER TABLE edges ADD COLUMN confidence REAL DEFAULT 1.0`,`ALTER TABLE nodes ADD COLUMN community TEXT`])try{e.run(t)}catch{}e.run(`CREATE INDEX IF NOT EXISTS idx_nodes_community ON nodes(community)`)}ensureDb(){if(!this.db){if(!this.sqlFactory)throw Error(`Graph store not initialized — call initialize() first`);this.db=n(this.dbPath)?new this.sqlFactory.Database(i(this.dbPath)):new this.sqlFactory.Database,this.configureDb(this.db),this.createTables(this.db),this.migrateSchema(this.db)}return this.db}persist(){if(!this.db)return;let e=this.db.export();try{a(this.dbPath,Buffer.from(e))}finally{this.db.exec(`PRAGMA foreign_keys = ON;`)}this.dirty=!1}markDirty(){this.dirty=!0}flushIfDirty(){this.dirty&&this.persist()}query(e,t=[]){let n=this.ensureDb().prepare(e);n.bind(t);let r=[];try{for(;n.step();)r.push(n.getAsObject())}finally{n.free()}return r}run(e,t=[]){this.ensureDb().run(e,t)}async upsertNode(e){this.run(`INSERT INTO nodes (id, type, name, properties, source_record_id, source_path, created_at, community)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         type = excluded.type, name = excluded.name, properties = excluded.properties,
+         source_record_id = excluded.source_record_id, source_path = excluded.source_path,
+         community = excluded.community`,[e.id,e.type,e.name,JSON.stringify(e.properties),e.sourceRecordId??null,e.sourcePath??null,e.createdAt??new Date().toISOString(),e.community??null]),this.markDirty(),this.flushIfDirty()}async upsertEdge(e){this.run(`INSERT INTO edges (id, from_id, to_id, type, weight, confidence, properties)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         from_id = excluded.from_id, to_id = excluded.to_id,
+         type = excluded.type, weight = excluded.weight, confidence = excluded.confidence, properties = excluded.properties`,[e.id,e.fromId,e.toId,e.type,e.weight??1,e.confidence??1,JSON.stringify(e.properties??{})]),this.markDirty(),this.flushIfDirty()}async upsertNodes(e){if(e.length===0)return;let t=this.ensureDb();t.run(`BEGIN TRANSACTION`);try{for(let t of e)this.run(`INSERT INTO nodes (id, type, name, properties, source_record_id, source_path, created_at, community)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET
+             type = excluded.type, name = excluded.name, properties = excluded.properties,
+             source_record_id = excluded.source_record_id, source_path = excluded.source_path,
+             community = excluded.community`,[t.id,t.type,t.name,JSON.stringify(t.properties),t.sourceRecordId??null,t.sourcePath??null,t.createdAt??new Date().toISOString(),t.community??null]);t.run(`COMMIT`)}catch(e){throw t.run(`ROLLBACK`),e}this.markDirty(),this.flushIfDirty()}async upsertEdges(e){if(e.length===0)return;let t=this.ensureDb();t.run(`PRAGMA foreign_keys = OFF`),t.run(`BEGIN TRANSACTION`);try{for(let t of e)this.run(`INSERT INTO edges (id, from_id, to_id, type, weight, confidence, properties)
+           VALUES (?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET
+             from_id = excluded.from_id, to_id = excluded.to_id,
+             type = excluded.type, weight = excluded.weight, confidence = excluded.confidence, properties = excluded.properties`,[t.id,t.fromId,t.toId,t.type,t.weight??1,t.confidence??1,JSON.stringify(t.properties??{})]);t.run(`COMMIT`)}catch(e){throw t.run(`ROLLBACK`),e}finally{t.run(`PRAGMA foreign_keys = ON`)}this.markDirty(),this.flushIfDirty()}async getNode(e){let t=this.query(`SELECT * FROM nodes WHERE id = ?`,[e]);return t.length>0?u(t[0]):null}async getNeighbors(e,t){let n=t?.direction??`both`,r=t?.edgeType,i=t?.limit??50,a=[],o=[],s=new Set;if(n===`outgoing`||n===`both`){let t=`
+          SELECT e.id AS edge_id, e.from_id, e.to_id, e.type AS edge_type, e.weight,
+            e.confidence AS edge_confidence, e.properties AS edge_props,
+             n.id AS node_id, n.type AS node_type, n.name AS node_name, n.properties AS node_props,
+            n.source_record_id AS node_src_rec, n.source_path AS node_src_path,
+            n.created_at AS node_created, n.community AS node_community
+      FROM edges e JOIN nodes n ON e.to_id = n.id WHERE e.from_id = ?`,n=[e];r&&(t+=` AND e.type = ?`,n.push(r)),t+=` LIMIT ?`,n.push(i);let c=this.query(t,n);for(let e of c)o.push(f(e)),s.has(e.node_id)||(s.add(e.node_id),a.push(p(e)))}if(n===`incoming`||n===`both`){let t=`
+          SELECT e.id AS edge_id, e.from_id, e.to_id, e.type AS edge_type, e.weight,
+            e.confidence AS edge_confidence, e.properties AS edge_props,
+             n.id AS node_id, n.type AS node_type, n.name AS node_name, n.properties AS node_props,
+            n.source_record_id AS node_src_rec, n.source_path AS node_src_path,
+            n.created_at AS node_created, n.community AS node_community
+      FROM edges e JOIN nodes n ON e.from_id = n.id WHERE e.to_id = ?`,n=[e];r&&(t+=` AND e.type = ?`,n.push(r)),t+=` LIMIT ?`,n.push(i);let c=this.query(t,n);for(let e of c)o.push(f(e)),s.has(e.node_id)||(s.add(e.node_id),a.push(p(e)))}return{nodes:a,edges:o}}async traverse(e,t){let n=t?.maxDepth??2,r=t?.direction??`both`,i=t?.edgeType,a=t?.limit??50,o=new Map,s=new Map,c=new Set,l=[{nodeId:e,depth:0}];for(;l.length>0&&o.size<a;){let e=l.shift();if(!e||c.has(e.nodeId)||e.depth>n)continue;c.add(e.nodeId);let t=await this.getNeighbors(e.nodeId,{direction:r,edgeType:i,limit:a-o.size});for(let r of t.nodes)o.has(r.id)||(o.set(r.id,r),e.depth+1<n&&l.push({nodeId:r.id,depth:e.depth+1}));for(let e of t.edges)s.set(e.id,e)}return{nodes:[...o.values()],edges:[...s.values()]}}async findNodes(e){let t=[],n=[];e.type&&(t.push(`type = ?`),n.push(e.type)),e.namePattern&&(t.push(`name LIKE ?`),n.push(`%${e.namePattern}%`)),e.sourcePath&&(t.push(`source_path = ?`),n.push(e.sourcePath));let r=t.length>0?`WHERE ${t.join(` AND `)}`:``,i=e.limit??100;return this.query(`SELECT * FROM nodes ${r} LIMIT ?`,[...n,i]).map(e=>u(e))}async findEdges(e){let t=[],n=[];e.type&&(t.push(`type = ?`),n.push(e.type)),e.fromId&&(t.push(`from_id = ?`),n.push(e.fromId)),e.toId&&(t.push(`to_id = ?`),n.push(e.toId));let r=t.length>0?`WHERE ${t.join(` AND `)}`:``,i=e.limit??100;return this.query(`SELECT * FROM edges ${r} LIMIT ?`,[...n,i]).map(e=>d(e))}async deleteNode(e){let t=this.ensureDb();t.run(`BEGIN TRANSACTION`);try{this.run(`DELETE FROM edges WHERE from_id = ? OR to_id = ?`,[e,e]),this.run(`DELETE FROM nodes WHERE id = ?`,[e]),t.run(`COMMIT`)}catch(e){throw t.run(`ROLLBACK`),e}this.markDirty(),this.flushIfDirty()}async deleteBySourcePath(e){let t=this.query(`SELECT id FROM nodes WHERE source_path = ?`,[e]);if(t.length===0)return 0;let n=this.ensureDb();n.run(`BEGIN TRANSACTION`);try{for(let e of t)this.run(`DELETE FROM edges WHERE from_id = ? OR to_id = ?`,[e.id,e.id]);this.run(`DELETE FROM nodes WHERE source_path = ?`,[e]),n.run(`COMMIT`)}catch(e){throw n.run(`ROLLBACK`),e}return this.markDirty(),this.flushIfDirty(),t.length}async clear(){this.run(`DELETE FROM process_steps`),this.run(`DELETE FROM processes`),this.run(`DELETE FROM edges`),this.run(`DELETE FROM nodes`),this.markDirty(),this.flushIfDirty()}async getStats(){let e=this.query(`SELECT COUNT(*) as count FROM nodes`)[0]?.count??0,t=this.query(`SELECT COUNT(*) as count FROM edges`)[0]?.count??0,n=this.query(`SELECT type, COUNT(*) as count FROM nodes GROUP BY type`),r={};for(let e of n)r[e.type]=e.count;let i=this.query(`SELECT type, COUNT(*) as count FROM edges GROUP BY type`),a={};for(let e of i)a[e.type]=e.count;return{nodeCount:e,edgeCount:t,nodeTypes:r,edgeTypes:a}}async validate(){let e=await this.getStats(),t=this.query(`SELECT e.id AS edgeId,
+              CASE
+                WHEN n1.id IS NULL THEN e.from_id
+                WHEN n2.id IS NULL THEN e.to_id
+              END AS missingNodeId
+       FROM edges e
+       LEFT JOIN nodes n1 ON e.from_id = n1.id
+       LEFT JOIN nodes n2 ON e.to_id = n2.id
+       WHERE n1.id IS NULL OR n2.id IS NULL`),n=this.query(`SELECT n.id AS id
+       FROM nodes n
+       LEFT JOIN edges e1 ON n.id = e1.from_id
+       LEFT JOIN edges e2 ON n.id = e2.to_id
+       WHERE e1.id IS NULL AND e2.id IS NULL`).map(e=>e.id);return{valid:t.length===0,orphanNodes:n,danglingEdges:t,stats:e}}async setNodeCommunity(e,t){this.run(`UPDATE nodes SET community = ? WHERE id = ?`,[t,e]),this.markDirty(),this.flushIfDirty()}async detectCommunities(){let e=this.query(`SELECT id FROM nodes`),t=new Map;for(let n of e)t.set(n.id,n.id);for(let n=0;n<10;n++){let n=!1,r=new Map(t);for(let i of e){let e=this.query(`SELECT to_id AS neighbor_id FROM edges WHERE from_id = ?
+           UNION
+           SELECT from_id AS neighbor_id FROM edges WHERE to_id = ?`,[i.id,i.id]),a=new Map,o=t.get(i.id)??i.id;a.set(o,1);for(let n of e){let e=t.get(n.neighbor_id)??n.neighbor_id;a.set(e,(a.get(e)??0)+1)}let s=o,c=0;for(let[e,t]of a)(t>c||t===c&&e<s)&&(c=t,s=e);o!==s&&(r.set(i.id,s),n=!0)}t.clear();for(let[e,n]of r)t.set(e,n);if(!n)break}let n=this.ensureDb();n.run(`BEGIN TRANSACTION`);try{for(let[e,n]of t)this.run(`UPDATE nodes SET community = ? WHERE id = ?`,[n,e]);n.run(`COMMIT`)}catch(e){throw n.run(`ROLLBACK`),e}this.markDirty(),this.flushIfDirty();let r={};for(let[e,n]of t)r[n]||(r[n]=[]),r[n].push(e);return r}async traceProcess(e,t){let n=[],r=new Set,i=[e];for(;i.length>0;){let e=i.shift();if(!e||r.has(e))continue;r.add(e),n.push(e);let t=this.query(`SELECT to_id FROM edges WHERE from_id = ? AND type = 'calls'`,[e]);for(let e of t)r.has(e.to_id)||i.push(e.to_id)}let a=`proc_${Date.now()}_${Math.random().toString(36).slice(2,8)}`,o=new Date().toISOString(),s=this.ensureDb();s.run(`BEGIN TRANSACTION`);try{this.run(`INSERT INTO processes (id, entry_node_id, label, properties, created_at)
+         VALUES (?, ?, ?, '{}', ?)`,[a,e,t,o]);for(let e=0;e<n.length;e++)this.run(`INSERT INTO process_steps (process_id, node_id, step_order) VALUES (?, ?, ?)`,[a,n[e],e]);s.run(`COMMIT`)}catch(e){throw s.run(`ROLLBACK`),e}return this.markDirty(),this.flushIfDirty(),{id:a,entryNodeId:e,label:t,properties:{},steps:n,createdAt:o}}async getProcesses(e){let t;t=e?this.query(`SELECT DISTINCT p.id, p.entry_node_id, p.label, p.properties, p.created_at
+         FROM processes p
+         JOIN process_steps ps ON p.id = ps.process_id
+         WHERE ps.node_id = ?`,[e]):this.query(`SELECT * FROM processes`);let n=[];for(let e of t){let t=this.query(`SELECT node_id FROM process_steps WHERE process_id = ? ORDER BY step_order`,[e.id]);n.push({id:e.id,entryNodeId:e.entry_node_id,label:e.label,properties:l(e.properties),steps:t.map(e=>e.node_id),createdAt:e.created_at})}return n}async deleteProcess(e){let t=this.ensureDb();t.run(`BEGIN TRANSACTION`);try{this.run(`DELETE FROM process_steps WHERE process_id = ?`,[e]),this.run(`DELETE FROM processes WHERE id = ?`,[e]),t.run(`COMMIT`)}catch(e){throw t.run(`ROLLBACK`),e}this.markDirty(),this.flushIfDirty()}async depthGroupedTraversal(e,t=3,n){let r=n?.direction??`both`,i=n?.edgeType,a=n?.limit??100,o={},s=new Set;s.add(e);let c=[e];for(let e=1;e<=t;e++){let t=[],n=[];for(let e of c){let o=await this.getNeighbors(e,{direction:r,edgeType:i,limit:a});for(let e of o.nodes)s.has(e.id)||(s.add(e.id),t.push(e.id),n.push(e))}if(n.length>0&&(o[e]=n),c=t,c.length===0||s.size>=a)break}return o}async getCohesionScore(e){let t=this.query(`SELECT id FROM nodes WHERE community = ?`,[e]);if(t.length===0)return 0;let n=new Set(t.map(e=>e.id)),r=t.map(()=>`?`).join(`,`),i=t.map(e=>e.id),a=this.query(`SELECT from_id, to_id FROM edges WHERE from_id IN (${r}) OR to_id IN (${r})`,[...i,...i]);if(a.length===0)return 0;let o=0;for(let e of a)n.has(e.from_id)&&n.has(e.to_id)&&o++;return o/a.length}async getSymbol360(e){let t=await this.getNode(e);if(!t)throw Error(`Node '${e}' not found`);let n=await this.findEdges({toId:e}),r=await this.findEdges({fromId:e}),i=await this.getProcesses(e);return{node:t,incoming:n,outgoing:r,community:t.community??null,processes:i}}async close(){this.db&&=(this.flushIfDirty(),this.db.close(),null)}};function l(e){if(!e)return{};try{return JSON.parse(e)}catch{return{}}}function u(e){return{id:e.id,type:e.type,name:e.name,properties:l(e.properties),sourceRecordId:e.source_record_id??void 0,sourcePath:e.source_path??void 0,createdAt:e.created_at,community:e.community??void 0}}function d(e){return{id:e.id,fromId:e.from_id,toId:e.to_id,type:e.type,weight:e.weight??1,confidence:e.confidence??1,properties:l(e.properties)}}function f(e){return{id:e.edge_id,fromId:e.from_id,toId:e.to_id,type:e.edge_type,weight:e.weight??1,confidence:e.edge_confidence??1,properties:l(e.edge_props??`{}`)}}function p(e){return{id:e.node_id,type:e.node_type,name:e.node_name,properties:l(e.node_props??`{}`),sourceRecordId:e.node_src_rec??void 0,sourcePath:e.node_src_path??void 0,createdAt:e.node_created,community:e.node_community??void 0}}async function m(e){switch(e.backend){case`lancedb`:{let{LanceStore:t}=await import(`./lance-store-jdHZp-V4.js`).then(e=>e.n);return new t({path:e.path})}default:throw Error(`Unknown store backend: "${e.backend}". Supported: lancedb`)}}export{e as LanceStore,c as SqliteGraphStore,m as createStore};

package/packages/store/dist/lance-store-jdHZp-V4.js

@@ -0,0 +1 @@
+import{EMBEDDING_DEFAULTS as e,SEARCH_DEFAULTS as t,STORE_DEFAULTS as n,createLogger as r,serializeError as i,sourceTypeContentTypes as a}from"../../core/dist/index.js";import{Index as o,connect as s}from"@lancedb/lancedb";var c=Object.defineProperty,l=((e,t)=>{let n={};for(var r in e)c(n,r,{get:e[r],enumerable:!0});return t||c(n,Symbol.toStringTag,{value:`Module`}),n})({LanceStore:()=>m});function u(e){if(!e)return[];try{let t=JSON.parse(e);return Array.isArray(t)?t:[]}catch{return[]}}const d=/^[\w.\-/ ]+$/,f=r(`store`);function p(e,t){if(!d.test(e))throw Error(`Invalid ${t} filter value: contains disallowed characters`);return e.replace(/'/g,`''`)}var m=class r{db=null;table=null;dbPath;tableName;_draining=!1;_priorityQueue=[];_normalQueue=[];_ftsReady=!1;_ftsRecoveryAttemptAt=0;static FTS_RECOVERY_COOLDOWN_MS=300*1e3;enqueueWrite(e,t=!1){return new Promise((n,r)=>{let i=async()=>{try{n(await e())}catch(e){r(e)}};t?this._priorityQueue.push(i):this._normalQueue.push(i),this._drain()})}async _drain(){if(!this._draining){this._draining=!0;try{for(;this._priorityQueue.length>0||this._normalQueue.length>0;){let e=this._priorityQueue.shift()??this._normalQueue.shift();e&&await e()}}finally{this._draining=!1}}}constructor(e){this.dbPath=e?.path??n.path,this.tableName=e?.tableName??n.tableName}async initialize(){this.db=await s(this.dbPath),(await this.db.tableNames()).includes(this.tableName)&&(this.table=await this.db.openTable(this.tableName),await this.createFtsIndex())}async upsert(e,t){if(e.length!==0){if(e.length!==t.length)throw Error(`Record count (${e.length}) does not match vector count (${t.length})`);return this.enqueueWrite(()=>this._upsertImpl(e,t))}}async upsertInteractive(e,t){if(e.length!==0){if(e.length!==t.length)throw Error(`Record count (${e.length}) does not match vector count (${t.length})`);return this.enqueueWrite(()=>this._upsertImpl(e,t),!0)}}async _upsertImpl(e,t){let n=e.map((e,n)=>({id:e.id,vector:Array.from(t[n]),content:e.content,sourcePath:e.sourcePath,contentType:e.contentType,headingPath:e.headingPath??``,chunkIndex:e.chunkIndex,totalChunks:e.totalChunks,startLine:e.startLine,endLine:e.endLine,fileHash:e.fileHash,indexedAt:e.indexedAt,origin:e.origin,tags:JSON.stringify(e.tags),category:e.category??``,version:e.version}));if(this.table){let t=[...new Set(e.map(e=>e.sourcePath))];for(let e of t)try{await this.table.delete(`sourcePath = '${p(e,`sourcePath`)}'`)}catch{}await this.table.add(n)}else try{this.table=await this.db?.createTable(this.tableName,n)??null}catch(e){if(String(e).includes(`already exists`)&&this.db)this.table=await this.db.openTable(this.tableName),await this.table.add(n);else throw e}}async search(e,n){if(!this.table)return[];let r=n?.limit??t.maxResults,i=n?.minScore??t.minScore,a=this.table.search(e).limit(r*2),o=this.buildFilterString(n);return o&&(a=a.where(o)),(await a.toArray()).map(e=>({record:this.fromLanceRecord(e),score:1-(e._distance??1)})).filter(e=>e.score>=i).slice(0,r)}async createFtsIndex(){return this.enqueueWrite(()=>this._createFtsIndexImpl())}async _createFtsIndexImpl(){if(this.table)try{await this.table.createIndex(`content`,{config:o.fts({withPosition:!0}),replace:!0}),this._ftsReady=!0,this._ftsRecoveryAttemptAt=0,f.info(`FTS index created/updated`,{column:`content`})}catch(e){f.warn(`FTS index creation failed`,i(e))}}async ftsSearch(e,n){if(!this.table)return[];if(!this._ftsReady){let e=Date.now();if(e-this._ftsRecoveryAttemptAt<r.FTS_RECOVERY_COOLDOWN_MS)return[];this._ftsRecoveryAttemptAt=e;try{await this.createFtsIndex()}catch{return[]}if(!this._ftsReady)return[]}let a=n?.limit??t.maxResults;try{let t=this.table.search(e).limit(a*2),r=this.buildFilterString(n);return r&&(t=t.where(r)),(await t.toArray()).map(e=>({record:this.fromLanceRecord(e),score:e._score??e._relevance_score??0}))}catch(e){return(e instanceof Error?e.message:String(e)).includes(`INVERTED index`)?(f.debug(`FTS search skipped — index not yet available`),this._ftsReady=!1):f.warn(`FTS search failed`,i(e)),[]}}async getById(e){if(!this.table)return null;let t=await this.table.query().where(`id = '${p(e,`id`)}'`).limit(1).toArray();return t.length===0?null:this.fromLanceRecord(t[0])}async deleteBySourcePath(e){return this.enqueueWrite(()=>this._deleteBySourcePathImpl(e))}async _deleteBySourcePathImpl(e){if(!this.table)return 0;let t=await this.getBySourcePath(e);return t.length===0?0:(await this.table.delete(`sourcePath = '${p(e,`sourcePath`)}'`),t.length)}async deleteById(e){return this.enqueueWrite(()=>this._deleteByIdImpl(e))}async deleteByIdInteractive(e){return this.enqueueWrite(()=>this._deleteByIdImpl(e),!0)}async _deleteByIdImpl(e){return!this.table||!await this.getById(e)?!1:(await this.table.delete(`id = '${p(e,`id`)}'`),!0)}async getBySourcePath(e){return this.table?(await this.table.query().where(`sourcePath = '${p(e,`sourcePath`)}'`).limit(1e3).toArray()).map(e=>this.fromLanceRecord(e)):[]}async getStats(){if(!this.table)return{totalRecords:0,totalFiles:0,contentTypeBreakdown:{},lastIndexedAt:null,storeBackend:`lancedb`,embeddingModel:e.model};let t=await this.table.countRows(),n=await this.table.query().select([`sourcePath`,`contentType`,`indexedAt`]).limit(1e5).toArray(),r={},i=new Set,a=null;for(let e of n){let t=e;r[t.contentType]=(r[t.contentType]??0)+1,i.add(t.sourcePath),(!a||t.indexedAt>a)&&(a=t.indexedAt)}return{totalRecords:t,totalFiles:i.size,contentTypeBreakdown:r,lastIndexedAt:a,storeBackend:`lancedb`,embeddingModel:e.model}}async listSourcePaths(){if(!this.table)return[];let e=await this.table.query().select([`sourcePath`]).limit(1e5).toArray();return[...new Set(e.map(e=>e.sourcePath))]}async dropTable(){return this.enqueueWrite(()=>this._dropTableImpl())}async _dropTableImpl(){if(this.db&&(await this.db.tableNames()).includes(this.tableName))for(let e=1;e<=3;e++)try{await this.db.dropTable(this.tableName);break}catch(t){if(e===3)throw t;let n=e*500;f.warn(`dropTable attempt failed, retrying`,{attempt:e,delayMs:n}),await new Promise(e=>setTimeout(e,n))}this.table=null}async close(){try{this.db&&typeof this.db.close==`function`&&await this.db.close()}catch{}this.table=null,this.db=null}buildFilterString(e){let t=[];if(e?.contentType&&t.push(`contentType = '${p(e.contentType,`contentType`)}'`),e?.sourceType){let n=a(e.sourceType);if(n.length>0){let e=n.map(e=>`'${p(e,`sourceType`)}'`).join(`, `);t.push(`contentType IN (${e})`)}}if(e?.origin&&t.push(`origin = '${p(e.origin,`origin`)}'`),e?.category&&t.push(`category = '${p(e.category,`category`)}'`),e?.tags&&e.tags.length>0){let n=e.tags.map(e=>`tags LIKE '%${p(e,`tag`)}%'`);t.push(`(${n.join(` OR `)})`)}return t.length>0?t.join(` AND `):null}fromLanceRecord(e){return{id:e.id,content:e.content,sourcePath:e.sourcePath,contentType:e.contentType,headingPath:e.headingPath||void 0,chunkIndex:e.chunkIndex,totalChunks:e.totalChunks,startLine:e.startLine,endLine:e.endLine,fileHash:e.fileHash,indexedAt:e.indexedAt,origin:e.origin,tags:u(e.tags),category:e.category||void 0,version:e.version}}};export{l as n,m as t};