@vpxa/kb 0.1.1

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

@@ -0,0 +1,258 @@
+import { EMBEDDING_DEFAULTS, SEARCH_DEFAULTS, STORE_DEFAULTS } from "@kb/core";
+import { connect, Index } from "@lancedb/lancedb";
+const SAFE_FILTER_VALUE = /^[\w.\-/ ]+$/;
+function sanitizeFilterValue(value, fieldName) {
+  if (!SAFE_FILTER_VALUE.test(value)) {
+    throw new Error(`Invalid ${fieldName} filter value: contains disallowed characters`);
+  }
+  return value.replace(/'/g, "''");
+}
+class LanceStore {
+  db = null;
+  table = null;
+  dbPath;
+  tableName;
+  constructor(options) {
+    this.dbPath = options?.path ?? STORE_DEFAULTS.path;
+    this.tableName = options?.tableName ?? STORE_DEFAULTS.tableName;
+  }
+  async initialize() {
+    this.db = await connect(this.dbPath);
+    const tableNames = await this.db.tableNames();
+    if (tableNames.includes(this.tableName)) {
+      this.table = await this.db.openTable(this.tableName);
+      await this.createFtsIndex();
+    }
+  }
+  async upsert(records, vectors) {
+    if (records.length === 0) return;
+    if (records.length !== vectors.length) {
+      throw new Error(
+        `Record count (${records.length}) does not match vector count (${vectors.length})`
+      );
+    }
+    const lanceRecords = records.map(
+      (r, i) => ({
+        id: r.id,
+        vector: Array.from(vectors[i]),
+        content: r.content,
+        sourcePath: r.sourcePath,
+        contentType: r.contentType,
+        headingPath: r.headingPath ?? "",
+        chunkIndex: r.chunkIndex,
+        totalChunks: r.totalChunks,
+        startLine: r.startLine,
+        endLine: r.endLine,
+        fileHash: r.fileHash,
+        indexedAt: r.indexedAt,
+        origin: r.origin,
+        tags: JSON.stringify(r.tags),
+        category: r.category ?? "",
+        version: r.version
+      })
+    );
+    if (!this.table) {
+      try {
+        this.table = await this.db?.createTable(this.tableName, lanceRecords) ?? null;
+      } catch (err) {
+        if (String(err).includes("already exists") && this.db) {
+          this.table = await this.db.openTable(this.tableName);
+          await this.table.add(lanceRecords);
+        } else {
+          throw err;
+        }
+      }
+    } else {
+      const sourcePaths = [...new Set(records.map((r) => r.sourcePath))];
+      for (const sp of sourcePaths) {
+        try {
+          await this.table.delete(`sourcePath = '${sanitizeFilterValue(sp, "sourcePath")}'`);
+        } catch {
+        }
+      }
+      await this.table.add(lanceRecords);
+    }
+  }
+  async search(queryVector, options) {
+    if (!this.table) return [];
+    const limit = options?.limit ?? SEARCH_DEFAULTS.maxResults;
+    const minScore = options?.minScore ?? SEARCH_DEFAULTS.minScore;
+    let query = this.table.search(queryVector).limit(limit * 2);
+    const filterStr = this.buildFilterString(options);
+    if (filterStr) {
+      query = query.where(filterStr);
+    }
+    const results = await query.toArray();
+    return results.map((row) => ({
+      record: this.fromLanceRecord(row),
+      score: 1 - (row._distance ?? 1)
+      // LanceDB returns L2 distance; convert to similarity
+    })).filter((r) => r.score >= minScore).slice(0, limit);
+  }
+  async createFtsIndex() {
+    if (!this.table) return;
+    try {
+      await this.table.createIndex("content", { config: Index.fts() });
+      console.error("[KB] FTS index created on content column");
+    } catch (err) {
+      if (!String(err).includes("already exists")) {
+        console.error("[KB] FTS index creation failed (non-fatal):", err);
+      }
+    }
+  }
+  async ftsSearch(query, options) {
+    if (!this.table) return [];
+    const limit = options?.limit ?? SEARCH_DEFAULTS.maxResults;
+    try {
+      let searchQuery = this.table.search(query).limit(limit * 2);
+      const filterStr = this.buildFilterString(options);
+      if (filterStr) {
+        searchQuery = searchQuery.where(filterStr);
+      }
+      const results = await searchQuery.toArray();
+      return results.map((row) => ({
+        record: this.fromLanceRecord(row),
+        score: row._score ?? row._relevance_score ?? 0
+      }));
+    } catch (err) {
+      console.error("[KB] FTS search failed (non-fatal):", err);
+      return [];
+    }
+  }
+  async getById(id) {
+    if (!this.table) return null;
+    const results = await this.table.query().where(`id = '${sanitizeFilterValue(id, "id")}'`).limit(1).toArray();
+    if (results.length === 0) return null;
+    return this.fromLanceRecord(results[0]);
+  }
+  async deleteBySourcePath(sourcePath) {
+    if (!this.table) return 0;
+    const existing = await this.getBySourcePath(sourcePath);
+    if (existing.length === 0) return 0;
+    await this.table.delete(`sourcePath = '${sanitizeFilterValue(sourcePath, "sourcePath")}'`);
+    return existing.length;
+  }
+  async deleteById(id) {
+    if (!this.table) return false;
+    const existing = await this.getById(id);
+    if (!existing) return false;
+    await this.table.delete(`id = '${sanitizeFilterValue(id, "id")}'`);
+    return true;
+  }
+  async getBySourcePath(sourcePath) {
+    if (!this.table) return [];
+    const results = await this.table.query().where(`sourcePath = '${sanitizeFilterValue(sourcePath, "sourcePath")}'`).limit(1e3).toArray();
+    return results.map((row) => this.fromLanceRecord(row));
+  }
+  async getStats() {
+    if (!this.table) {
+      return {
+        totalRecords: 0,
+        totalFiles: 0,
+        contentTypeBreakdown: {},
+        lastIndexedAt: null,
+        storeBackend: "lancedb",
+        embeddingModel: EMBEDDING_DEFAULTS.model
+      };
+    }
+    const allRows = await this.table.countRows();
+    const sample = await this.table.query().select(["sourcePath", "contentType", "indexedAt"]).limit(1e5).toArray();
+    const breakdown = {};
+    const uniquePaths = /* @__PURE__ */ new Set();
+    let lastIndexedAt = null;
+    for (const row of sample) {
+      const r = row;
+      breakdown[r.contentType] = (breakdown[r.contentType] ?? 0) + 1;
+      uniquePaths.add(r.sourcePath);
+      if (!lastIndexedAt || r.indexedAt > lastIndexedAt) {
+        lastIndexedAt = r.indexedAt;
+      }
+    }
+    return {
+      totalRecords: allRows,
+      totalFiles: uniquePaths.size,
+      contentTypeBreakdown: breakdown,
+      lastIndexedAt,
+      storeBackend: "lancedb",
+      embeddingModel: EMBEDDING_DEFAULTS.model
+    };
+  }
+  async listSourcePaths() {
+    if (!this.table) return [];
+    const results = await this.table.query().select(["sourcePath"]).limit(1e5).toArray();
+    return [
+      // biome-ignore lint/suspicious/noExplicitAny: LanceDB query returns untyped results
+      ...new Set(results.map((r) => r.sourcePath))
+    ];
+  }
+  async dropTable() {
+    if (this.db) {
+      const tableNames = await this.db.tableNames();
+      if (tableNames.includes(this.tableName)) {
+        const maxRetries = 3;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+          try {
+            await this.db.dropTable(this.tableName);
+            break;
+          } catch (err) {
+            if (attempt === maxRetries) throw err;
+            const delay = attempt * 500;
+            console.error(`[KB] dropTable attempt ${attempt} failed, retrying in ${delay}ms...`);
+            await new Promise((r) => setTimeout(r, delay));
+          }
+        }
+      }
+    }
+    this.table = null;
+  }
+  async close() {
+    try {
+      if (this.db && typeof this.db.close === "function") {
+        await this.db.close();
+      }
+    } catch {
+    }
+    this.table = null;
+    this.db = null;
+  }
+  buildFilterString(options) {
+    const filters = [];
+    if (options?.contentType) {
+      filters.push(`contentType = '${sanitizeFilterValue(options.contentType, "contentType")}'`);
+    }
+    if (options?.origin) {
+      filters.push(`origin = '${sanitizeFilterValue(options.origin, "origin")}'`);
+    }
+    if (options?.category) {
+      filters.push(`category = '${sanitizeFilterValue(options.category, "category")}'`);
+    }
+    if (options?.tags && options.tags.length > 0) {
+      const tagClauses = options.tags.map((t) => `tags LIKE '%${sanitizeFilterValue(t, "tag")}%'`);
+      filters.push(`(${tagClauses.join(" OR ")})`);
+    }
+    return filters.length > 0 ? filters.join(" AND ") : null;
+  }
+  fromLanceRecord(row) {
+    return {
+      id: row.id,
+      content: row.content,
+      sourcePath: row.sourcePath,
+      contentType: row.contentType,
+      headingPath: row.headingPath || void 0,
+      chunkIndex: row.chunkIndex,
+      totalChunks: row.totalChunks,
+      startLine: row.startLine,
+      endLine: row.endLine,
+      fileHash: row.fileHash,
+      indexedAt: row.indexedAt,
+      origin: row.origin,
+      tags: JSON.parse(row.tags || "[]"),
+      category: row.category || void 0,
+      version: row.version
+    };
+  }
+}
+export {
+  LanceStore
+};
+//# sourceMappingURL=lance-store.js.map

package/packages/store/dist/sqlite-graph-store.d.ts

@@ -0,0 +1,43 @@
+/**
+ * SQLite-backed knowledge graph store.
+ *
+ * Uses better-sqlite3 for a zero-config, embedded, single-file graph database.
+ * Stores nodes and edges with JSON properties, supports multi-hop traversal.
+ */
+import type { GraphEdge, GraphNode, GraphStats, GraphTraversalOptions, GraphTraversalResult, IGraphStore } from './graph-store.interface.js';
+export declare class SqliteGraphStore implements IGraphStore {
+    private db;
+    private readonly dbPath;
+    constructor(options?: {
+        path?: string;
+    });
+    initialize(): Promise<void>;
+    private ensureDb;
+    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>;
+    close(): Promise<void>;
+    private toGraphNode;
+    private toGraphEdge;
+}
+//# sourceMappingURL=sqlite-graph-store.d.ts.map

package/packages/store/dist/sqlite-graph-store.js

@@ -0,0 +1,374 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+class SqliteGraphStore {
+  db = null;
+  dbPath;
+  constructor(options) {
+    const basePath = options?.path ?? ".kb-data";
+    this.dbPath = join(basePath, "graph.db");
+  }
+  async initialize() {
+    const dir = dirname(this.dbPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    const BetterSqlite3 = (await import("better-sqlite3")).default;
+    this.db = new BetterSqlite3(this.dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.db.exec(`
+      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'))
+      );
+
+      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,
+        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
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_nodes_type ON nodes(type);
+      CREATE INDEX IF NOT EXISTS idx_nodes_name ON nodes(name);
+      CREATE INDEX IF NOT EXISTS idx_nodes_source_path ON nodes(source_path);
+      CREATE INDEX IF NOT EXISTS idx_edges_from ON edges(from_id);
+      CREATE INDEX IF NOT EXISTS idx_edges_to ON edges(to_id);
+      CREATE INDEX IF NOT EXISTS idx_edges_type ON edges(type);
+    `);
+  }
+  ensureDb() {
+    if (!this.db) throw new Error("Graph store not initialized \u2014 call initialize() first");
+    return this.db;
+  }
+  async upsertNode(node) {
+    const db = this.ensureDb();
+    db.prepare(`
+      INSERT INTO nodes (id, type, name, properties, source_record_id, source_path, created_at)
+      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
+    `).run(
+      node.id,
+      node.type,
+      node.name,
+      JSON.stringify(node.properties),
+      node.sourceRecordId ?? null,
+      node.sourcePath ?? null,
+      node.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    );
+  }
+  async upsertEdge(edge) {
+    const db = this.ensureDb();
+    db.prepare(`
+      INSERT INTO edges (id, from_id, to_id, type, weight, properties)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        from_id = excluded.from_id,
+        to_id = excluded.to_id,
+        type = excluded.type,
+        weight = excluded.weight,
+        properties = excluded.properties
+    `).run(
+      edge.id,
+      edge.fromId,
+      edge.toId,
+      edge.type,
+      edge.weight ?? 1,
+      JSON.stringify(edge.properties ?? {})
+    );
+  }
+  async upsertNodes(nodes) {
+    if (nodes.length === 0) return;
+    const db = this.ensureDb();
+    const stmt = db.prepare(`
+      INSERT INTO nodes (id, type, name, properties, source_record_id, source_path, created_at)
+      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
+    `);
+    const tx = db.transaction(() => {
+      for (const node of nodes) {
+        stmt.run(
+          node.id,
+          node.type,
+          node.name,
+          JSON.stringify(node.properties),
+          node.sourceRecordId ?? null,
+          node.sourcePath ?? null,
+          node.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+        );
+      }
+    });
+    tx();
+  }
+  async upsertEdges(edges) {
+    if (edges.length === 0) return;
+    const db = this.ensureDb();
+    const stmt = db.prepare(`
+      INSERT INTO edges (id, from_id, to_id, type, weight, properties)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        from_id = excluded.from_id,
+        to_id = excluded.to_id,
+        type = excluded.type,
+        weight = excluded.weight,
+        properties = excluded.properties
+    `);
+    const tx = db.transaction(() => {
+      for (const edge of edges) {
+        stmt.run(
+          edge.id,
+          edge.fromId,
+          edge.toId,
+          edge.type,
+          edge.weight ?? 1,
+          JSON.stringify(edge.properties ?? {})
+        );
+      }
+    });
+    tx();
+  }
+  async getNode(id) {
+    const db = this.ensureDb();
+    const row = db.prepare("SELECT * FROM nodes WHERE id = ?").get(id);
+    return row ? this.toGraphNode(row) : null;
+  }
+  async getNeighbors(nodeId, options) {
+    const db = this.ensureDb();
+    const direction = options?.direction ?? "both";
+    const edgeType = options?.edgeType;
+    const limit = options?.limit ?? 50;
+    const nodes = [];
+    const edges = [];
+    const seenNodeIds = /* @__PURE__ */ new Set();
+    const OUTGOING_SQL = `
+      SELECT e.id AS edge_id, e.from_id, e.to_id, e.type AS edge_type, e.weight, 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
+      FROM edges e JOIN nodes n ON e.to_id = n.id WHERE e.from_id = ?`;
+    const INCOMING_SQL = `
+      SELECT e.id AS edge_id, e.from_id, e.to_id, e.type AS edge_type, e.weight, 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
+      FROM edges e JOIN nodes n ON e.from_id = n.id WHERE e.to_id = ?`;
+    if (direction === "outgoing" || direction === "both") {
+      let sql = OUTGOING_SQL;
+      const params = [nodeId];
+      if (edgeType) {
+        sql += " AND e.type = ?";
+        params.push(edgeType);
+      }
+      sql += " LIMIT ?";
+      params.push(limit);
+      const rows = db.prepare(sql).all(...params);
+      for (const row of rows) {
+        edges.push(joinRowToEdge(row));
+        if (!seenNodeIds.has(row.node_id)) {
+          seenNodeIds.add(row.node_id);
+          nodes.push(joinRowToNode(row));
+        }
+      }
+    }
+    if (direction === "incoming" || direction === "both") {
+      let sql = INCOMING_SQL;
+      const params = [nodeId];
+      if (edgeType) {
+        sql += " AND e.type = ?";
+        params.push(edgeType);
+      }
+      sql += " LIMIT ?";
+      params.push(limit);
+      const rows = db.prepare(sql).all(...params);
+      for (const row of rows) {
+        edges.push(joinRowToEdge(row));
+        if (!seenNodeIds.has(row.node_id)) {
+          seenNodeIds.add(row.node_id);
+          nodes.push(joinRowToNode(row));
+        }
+      }
+    }
+    return { nodes, edges };
+  }
+  async traverse(startId, options) {
+    const maxDepth = options?.maxDepth ?? 2;
+    const direction = options?.direction ?? "both";
+    const edgeType = options?.edgeType;
+    const limit = options?.limit ?? 50;
+    const allNodes = /* @__PURE__ */ new Map();
+    const allEdges = /* @__PURE__ */ new Map();
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [{ nodeId: startId, depth: 0 }];
+    while (queue.length > 0 && allNodes.size < limit) {
+      const current = queue.shift();
+      if (!current || visited.has(current.nodeId)) continue;
+      if (current.depth > maxDepth) continue;
+      visited.add(current.nodeId);
+      const neighbors = await this.getNeighbors(current.nodeId, {
+        direction,
+        edgeType,
+        limit: limit - allNodes.size
+      });
+      for (const node of neighbors.nodes) {
+        if (!allNodes.has(node.id)) {
+          allNodes.set(node.id, node);
+          if (current.depth + 1 < maxDepth) {
+            queue.push({ nodeId: node.id, depth: current.depth + 1 });
+          }
+        }
+      }
+      for (const edge of neighbors.edges) {
+        allEdges.set(edge.id, edge);
+      }
+    }
+    return { nodes: [...allNodes.values()], edges: [...allEdges.values()] };
+  }
+  async findNodes(filter) {
+    const db = this.ensureDb();
+    const conditions = [];
+    const params = [];
+    if (filter.type) {
+      conditions.push("type = ?");
+      params.push(filter.type);
+    }
+    if (filter.namePattern) {
+      conditions.push("name LIKE ?");
+      params.push(`%${filter.namePattern}%`);
+    }
+    if (filter.sourcePath) {
+      conditions.push("source_path = ?");
+      params.push(filter.sourcePath);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const maxRows = filter.limit ?? 100;
+    const rows = db.prepare(`SELECT * FROM nodes ${where} LIMIT ?`).all(...params, maxRows);
+    return rows.map((r) => this.toGraphNode(r));
+  }
+  async findEdges(filter) {
+    const db = this.ensureDb();
+    const conditions = [];
+    const params = [];
+    if (filter.type) {
+      conditions.push("type = ?");
+      params.push(filter.type);
+    }
+    if (filter.fromId) {
+      conditions.push("from_id = ?");
+      params.push(filter.fromId);
+    }
+    if (filter.toId) {
+      conditions.push("to_id = ?");
+      params.push(filter.toId);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const maxRows = filter.limit ?? 100;
+    const rows = db.prepare(`SELECT * FROM edges ${where} LIMIT ?`).all(...params, maxRows);
+    return rows.map((r) => this.toGraphEdge(r));
+  }
+  async deleteNode(id) {
+    const db = this.ensureDb();
+    db.transaction(() => {
+      db.prepare("DELETE FROM edges WHERE from_id = ? OR to_id = ?").run(id, id);
+      db.prepare("DELETE FROM nodes WHERE id = ?").run(id);
+    })();
+  }
+  async deleteBySourcePath(sourcePath) {
+    const db = this.ensureDb();
+    const nodeIds = db.prepare("SELECT id FROM nodes WHERE source_path = ?").all(sourcePath);
+    if (nodeIds.length === 0) return 0;
+    const tx = db.transaction(() => {
+      for (const { id } of nodeIds) {
+        db.prepare("DELETE FROM edges WHERE from_id = ? OR to_id = ?").run(id, id);
+      }
+      db.prepare("DELETE FROM nodes WHERE source_path = ?").run(sourcePath);
+    });
+    tx();
+    return nodeIds.length;
+  }
+  async clear() {
+    const db = this.ensureDb();
+    db.exec("DELETE FROM edges; DELETE FROM nodes;");
+  }
+  async getStats() {
+    const db = this.ensureDb();
+    const nodeCount = db.prepare("SELECT COUNT(*) as count FROM nodes").get().count;
+    const edgeCount = db.prepare("SELECT COUNT(*) as count FROM edges").get().count;
+    const nodeTypeRows = db.prepare("SELECT type, COUNT(*) as count FROM nodes GROUP BY type").all();
+    const nodeTypes = {};
+    for (const row of nodeTypeRows) nodeTypes[row.type] = row.count;
+    const edgeTypeRows = db.prepare("SELECT type, COUNT(*) as count FROM edges GROUP BY type").all();
+    const edgeTypes = {};
+    for (const row of edgeTypeRows) edgeTypes[row.type] = row.count;
+    return { nodeCount, edgeCount, nodeTypes, edgeTypes };
+  }
+  async close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  // ── Private helpers ─────────────────────────────────────────────────
+  toGraphNode(row) {
+    return {
+      id: row.id,
+      type: row.type,
+      name: row.name,
+      properties: JSON.parse(row.properties),
+      sourceRecordId: row.source_record_id ?? void 0,
+      sourcePath: row.source_path ?? void 0,
+      createdAt: row.created_at
+    };
+  }
+  toGraphEdge(row) {
+    return {
+      id: row.id,
+      fromId: row.from_id,
+      toId: row.to_id,
+      type: row.type,
+      weight: row.weight ?? 1,
+      properties: JSON.parse(row.properties)
+    };
+  }
+}
+function joinRowToEdge(row) {
+  return {
+    id: row.edge_id,
+    fromId: row.from_id,
+    toId: row.to_id,
+    type: row.edge_type,
+    weight: row.weight ?? 1,
+    properties: JSON.parse(row.edge_props ?? "{}")
+  };
+}
+function joinRowToNode(row) {
+  return {
+    id: row.node_id,
+    type: row.node_type,
+    name: row.node_name,
+    properties: JSON.parse(row.node_props ?? "{}"),
+    sourceRecordId: row.node_src_rec ?? void 0,
+    sourcePath: row.node_src_path ?? void 0,
+    createdAt: row.node_created
+  };
+}
+export {
+  SqliteGraphStore
+};
+//# sourceMappingURL=sqlite-graph-store.js.map

package/packages/store/dist/store-factory.d.ts

@@ -0,0 +1,9 @@
+import type { IKnowledgeStore } from './store.interface.js';
+export type StoreBackend = 'lancedb' | 'sqlite-vec';
+export interface StoreConfig {
+    backend: StoreBackend;
+    path: string;
+    options?: Record<string, unknown>;
+}
+export declare function createStore(config: StoreConfig): Promise<IKnowledgeStore>;
+//# sourceMappingURL=store-factory.d.ts.map

package/packages/store/dist/store-factory.js

@@ -0,0 +1,14 @@
+async function createStore(config) {
+  switch (config.backend) {
+    case "lancedb": {
+      const { LanceStore } = await import("./lance-store.js");
+      return new LanceStore({ path: config.path });
+    }
+    default:
+      throw new Error(`Unknown store backend: "${config.backend}". Supported: lancedb`);
+  }
+}
+export {
+  createStore
+};
+//# sourceMappingURL=store-factory.js.map