@leanlabsinnov/codegraph 0.1.0

package/dist/chunk-F5QKPRNW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../graph-db/src/client.ts","../../graph-db/src/schema.ts"],"sourcesContent":["import { mkdir } from \"node:fs/promises\";\nimport { homedir } from \"node:os\";\nimport { dirname, resolve } from \"node:path\";\nimport { EDGE_KINDS, NODE_KINDS, type EdgeKind } from \"@codegraph/shared\";\nimport * as kuzu from \"kuzu\";\nimport {\n  DEFAULT_EMBEDDING_DIMENSION,\n  SYMBOL_COLUMNS,\n  buildSchemaStatements,\n  buildVectorIndexStatements,\n} from \"./schema.js\";\nimport type { QueryResult, UpsertEdgeInput, UpsertNodeInput } from \"./types.js\";\n\nexport interface GraphDbOptions {\n  /** Directory where Kuzu stores its on-disk database files. Defaults to `~/.codegraph/graph`. */\n  dbPath?: string;\n  /**\n   * Legacy `url` option kept for back-compat with Phase-1 callers. Ignored at runtime -\n   * Kuzu is embedded - but accepted so existing call sites compile while the rest of the\n   * codebase migrates to `dbPath`.\n   */\n  url?: string;\n  /** Vector dimension for the `Symbol.embedding` column. Baked into the schema at create time. */\n  embeddingDimension?: number;\n}\n\n/** Default on-disk location for the embedded graph. */\nexport function defaultDbPath(): string {\n  return resolve(homedir(), \".codegraph\", \"graph\");\n}\n\n/**\n * Thin, typed wrapper around the embedded Kuzu database.\n *\n * Public surface (intentionally identical to the Phase-1 FalkorDB client so callers don't\n * change): connect / close / migrate / query / upsertNodes / upsertEdges / deleteByRepo /\n * stats. Internals are pure Kuzu.\n */\nexport class GraphDb {\n  private readonly dbPath: string;\n  private readonly embeddingDimension: number;\n  private db: kuzu.Database | null = null;\n  private conn: kuzu.Connection | null = null;\n  private vectorIndexReady = false;\n  /**\n   * Cache of `conn.prepare()` results keyed by Cypher source. Kuzu's Node SDK requires a\n   * prepared statement for any parameterized query - reusing the prepared object keeps\n   * UNWIND-batched upserts fast.\n   */\n  private preparedCache = new Map<string, kuzu.PreparedStatement>();\n\n  constructor(opts: GraphDbOptions = {}) {\n    this.dbPath = opts.dbPath ?? defaultDbPath();\n    this.embeddingDimension = opts.embeddingDimension ?? DEFAULT_EMBEDDING_DIMENSION;\n  }\n\n  async connect(): Promise<void> {\n    if (this.conn) return;\n    await mkdir(dirname(this.dbPath), { recursive: true });\n    this.db = new kuzu.Database(this.dbPath);\n    this.conn = new kuzu.Connection(this.db);\n  }\n\n  async close(): Promise<void> {\n    this.preparedCache.clear();\n    // Kuzu 0.11+ exposes explicit close on Connection and Database; call them so file\n    // handles release deterministically before the GC otherwise reclaims native handles.\n    try {\n      this.conn?.close?.();\n    } catch {\n      // Best-effort: an already-closed connection throws synchronously on some versions.\n    }\n    try {\n      this.db?.close?.();\n    } catch {\n      // ditto\n    }\n    this.conn = null;\n    this.db = null;\n    this.vectorIndexReady = false;\n  }\n\n  private requireConn(): kuzu.Connection {\n    if (!this.conn) {\n      throw new Error(\"GraphDb not connected. Call connect() first.\");\n    }\n    return this.conn;\n  }\n\n  /**\n   * Idempotent migration. Runs all DDL through `IF NOT EXISTS` guards and tolerates the\n   * vector-index \"already exists\" error from re-runs.\n   */\n  async migrate(): Promise<void> {\n    await this.connect();\n    const schemaStmts = buildSchemaStatements({ embeddingDimension: this.embeddingDimension });\n    for (const stmt of schemaStmts) {\n      await this.exec(stmt);\n    }\n    for (const stmt of buildVectorIndexStatements()) {\n      try {\n        await this.exec(stmt);\n      } catch (err) {\n        const message = err instanceof Error ? err.message : String(err);\n        if (isAlreadyExistsError(message)) continue;\n        // Vector extension not available is a soft failure - we still get all the other\n        // functionality, just no semantic search. Warn and continue.\n        if (/extension/i.test(message) && /(not found|missing|unsupported|disabled)/i.test(message)) {\n          // eslint-disable-next-line no-console\n          console.warn(\n            `[codegraph] vector extension unavailable; semantic search disabled. Underlying: ${message}`,\n          );\n          return;\n        }\n        throw new Error(`migrate failed on \\`${stmt}\\`: ${message}`);\n      }\n    }\n    this.vectorIndexReady = true;\n  }\n\n  /**\n   * Typed Cypher escape hatch.\n   *\n   * Kuzu returns BIGINT columns as native BigInt; we coerce to plain `number` when safe so\n   * downstream JSON serialization (MCP responses, snapshot tests) does not need bespoke\n   * handling.\n   */\n  async query<T = Record<string, unknown>>(\n    cypher: string,\n    params: Record<string, unknown> = {},\n  ): Promise<QueryResult<T>> {\n    const result = await this.runQuery(cypher, params);\n    const raw = await collectAll(result);\n    const data = raw.map((row) => normalizeRow(row)) as T[];\n    const headers = raw.length > 0 ? Object.keys(raw[0] ?? {}) : [];\n    return { data, headers, metadata: [] };\n  }\n\n  /** Fire-and-forget DDL/exec. */\n  private async exec(cypher: string, params: Record<string, unknown> = {}): Promise<void> {\n    await this.runQuery(cypher, params);\n  }\n\n  /**\n   * Bridge to Kuzu's two execution paths:\n   * - `conn.query(stmt)` for unparameterized statements (the second positional arg is a\n   *   `progressCallback`, NOT params - mistaking that is the #1 way to confuse the API).\n   * - `conn.prepare(stmt) + conn.execute(prepared, params)` for anything with `$name`\n   *   placeholders. We cache the prepared statement so UNWIND batches reuse it.\n   */\n  private async runQuery(cypher: string, params: Record<string, unknown>): Promise<unknown> {\n    const conn = this.requireConn();\n    if (Object.keys(params).length === 0) {\n      return conn.query(cypher);\n    }\n    let prepared = this.preparedCache.get(cypher);\n    if (!prepared) {\n      prepared = await conn.prepare(cypher);\n      if (!prepared.isSuccess()) {\n        throw new Error(prepared.getErrorMessage());\n      }\n      this.preparedCache.set(cypher, prepared);\n    }\n    // Cast through `unknown`: Kuzu's bindings advertise a strict `KuzuValue` union, but\n    // we can pass through any JSON-serializable value the embedded engine accepts (nested\n    // structs and lists are converted at the native layer).\n    return conn.execute(prepared, params as unknown as Parameters<kuzu.Connection[\"execute\"]>[1]);\n  }\n\n  /**\n   * Upserts nodes via batched UNWIND + MERGE. Kuzu requires every column we SET to exist\n   * in the schema, so each row is normalized to include every `SYMBOL_COLUMNS` field (NULL\n   * for fields not present).\n   */\n  async upsertNodes(nodes: UpsertNodeInput[]): Promise<void> {\n    if (nodes.length === 0) return;\n    await this.connect();\n    const BATCH = 200;\n    const setClause = SYMBOL_COLUMNS.filter((c) => c !== \"id\")\n      .map((c) => `n.${c} = r.${c}`)\n      .join(\", \");\n    const cypher = `UNWIND $batch AS r MERGE (n:Symbol {id: r.id}) SET ${setClause}`;\n    for (let i = 0; i < nodes.length; i += BATCH) {\n      const slice = nodes.slice(i, i + BATCH);\n      const payload = slice.map(buildSymbolRow);\n      await this.exec(cypher, { batch: payload });\n    }\n  }\n\n  /**\n   * Upserts edges. Both endpoints must already exist as `Symbol` nodes; rows where the\n   * MATCH fails are silently dropped, matching Cypher semantics.\n   *\n   * Uses CREATE because the orchestrator wipes the repo's slice before writing, so\n   * duplicates can't pre-exist within a single index pass.\n   */\n  async upsertEdges(edges: UpsertEdgeInput[]): Promise<void> {\n    if (edges.length === 0) return;\n    await this.connect();\n    const byKind = new Map<EdgeKind, UpsertEdgeInput[]>();\n    for (const e of edges) {\n      const bucket = byKind.get(e.kind);\n      if (bucket) bucket.push(e);\n      else byKind.set(e.kind, [e]);\n    }\n    const BATCH = 500;\n    for (const [kind, batch] of byKind) {\n      const cypher = `UNWIND $batch AS r MATCH (a:Symbol {id: r.fromId}) MATCH (b:Symbol {id: r.toId}) CREATE (a)-[e:${kind} {line: r.line}]->(b)`;\n      for (let i = 0; i < batch.length; i += BATCH) {\n        const slice = batch.slice(i, i + BATCH);\n        const payload = slice.map((e) => ({\n          fromId: e.fromId,\n          toId: e.toId,\n          line: typeof e.line === \"number\" ? e.line : null,\n        }));\n        await this.exec(cypher, { batch: payload });\n      }\n    }\n  }\n\n  /**\n   * Deletes all nodes (and incident edges via DETACH DELETE) for a repo. If `paths` is\n   * provided, restricts the delete to nodes whose `path` is in the list - used by\n   * incremental re-indexing.\n   */\n  async deleteByRepo(repoId: string, paths?: string[]): Promise<void> {\n    await this.connect();\n    if (paths && paths.length > 0) {\n      await this.exec(\n        \"MATCH (n:Symbol) WHERE n.repoId = $repoId AND n.path IN $paths DETACH DELETE n\",\n        { repoId, paths },\n      );\n      return;\n    }\n    await this.exec(\"MATCH (n:Symbol) WHERE n.repoId = $repoId DETACH DELETE n\", { repoId });\n  }\n\n  /**\n   * Returns counts of nodes (per kind) and edges (per kind) for a repo, plus the share of\n   * non-File nodes that carry an embedding.\n   */\n  async stats(repoId: string): Promise<{\n    nodes: Record<string, number>;\n    edges: Record<string, number>;\n    embeddingCoverage: number;\n  }> {\n    await this.connect();\n    const nodes: Record<string, number> = {};\n    for (const kind of NODE_KINDS) {\n      const r = await this.query<{ count: number }>(\n        \"MATCH (n:Symbol) WHERE n.repoId = $repoId AND n.kind = $kind RETURN count(n) AS count\",\n        { repoId, kind },\n      );\n      nodes[kind] = Number(r.data[0]?.count ?? 0);\n    }\n    const edges: Record<string, number> = {};\n    for (const kind of EDGE_KINDS) {\n      const r = await this.query<{ count: number }>(\n        `MATCH (a:Symbol)-[r:${kind}]->(b:Symbol)\n           WHERE a.repoId = $repoId AND b.repoId = $repoId\n           RETURN count(r) AS count`,\n        { repoId },\n      );\n      edges[kind] = Number(r.data[0]?.count ?? 0);\n    }\n    const cov = await this.query<{ total: number | bigint; embedded: number | bigint }>(\n      `MATCH (n:Symbol)\n         WHERE n.repoId = $repoId AND n.kind <> 'File'\n         RETURN count(n) AS total,\n                count(n.embedding) AS embedded`,\n      { repoId },\n    );\n    const row = cov.data[0];\n    const total = Number(row?.total ?? 0);\n    const embedded = Number(row?.embedded ?? 0);\n    const coverage = total === 0 ? 0 : embedded / total;\n    return { nodes, edges, embeddingCoverage: coverage };\n  }\n\n  /** True once `migrate()` confirmed the vector extension is loaded. */\n  hasVectorIndex(): boolean {\n    return this.vectorIndexReady;\n  }\n}\n\n/**\n * Build a fully-populated row for a Kuzu UNWIND batch. Every column in `SYMBOL_COLUMNS`\n * is present (NULL when missing) so Kuzu can infer a homogeneous struct schema for the\n * batch parameter.\n */\nfunction buildSymbolRow(node: UpsertNodeInput): Record<string, unknown> {\n  const src = node as unknown as Record<string, unknown>;\n  const row: Record<string, unknown> = {};\n  for (const col of SYMBOL_COLUMNS) {\n    const value = src[col];\n    row[col] = value === undefined ? null : value;\n  }\n  // Reinforce the discriminated-union fields so callers passing partial bags still produce\n  // a complete row.\n  row.id = node.id;\n  row.kind = node.kind;\n  return row;\n}\n\n/** Convert Kuzu's row representation (Map or plain object) into a plain JSON object. */\nfunction normalizeRow(row: unknown): Record<string, unknown> {\n  if (row instanceof Map) {\n    const out: Record<string, unknown> = {};\n    for (const [k, v] of row) {\n      out[String(k)] = coerceValue(v);\n    }\n    return out;\n  }\n  if (row && typeof row === \"object\") {\n    const src = row as Record<string, unknown>;\n    const out: Record<string, unknown> = {};\n    for (const k of Object.keys(src)) {\n      out[k] = coerceValue(src[k]);\n    }\n    return out;\n  }\n  return { value: coerceValue(row) };\n}\n\n/**\n * Kuzu returns BIGINT columns as JS BigInt. Coerce to `number` when within Number.MAX_SAFE\n * for JSON-friendly downstream consumption.\n */\nfunction coerceValue(value: unknown): unknown {\n  if (typeof value === \"bigint\") {\n    if (value <= BigInt(Number.MAX_SAFE_INTEGER) && value >= BigInt(Number.MIN_SAFE_INTEGER)) {\n      return Number(value);\n    }\n    return value.toString();\n  }\n  if (Array.isArray(value)) return value.map(coerceValue);\n  return value;\n}\n\n/** Drain a Kuzu QueryResult (or array of them) into an array of row objects. */\nasync function collectAll(result: unknown): Promise<unknown[]> {\n  // Multi-statement queries return an array; we keep only the last one (matches how the\n  // final statement is the one that carries a `RETURN`).\n  const target = Array.isArray(result) ? result[result.length - 1] : result;\n  if (!target) return [];\n  const getAll = (target as { getAll?: () => Promise<unknown[]> }).getAll;\n  if (typeof getAll !== \"function\") return [];\n  return getAll.call(target);\n}\n\nfunction isAlreadyExistsError(message: string): boolean {\n  return (\n    /already exists/i.test(message) ||\n    /already loaded/i.test(message) ||\n    /already installed/i.test(message) ||\n    /duplicate (table|index)/i.test(message)\n  );\n}\n","import { EDGE_KINDS } from \"@codegraph/shared\";\n\n/**\n * Kuzu is schema-first. Unlike FalkorDB which is schema-less, every column we ever want to\n * SET on a node must exist up-front. We use ONE `Symbol` node table with a `kind` column\n * (Kuzu does not support multi-labels), and one REL table per `EdgeKind`.\n *\n * Columns are the union of every field across the `GraphNode` discriminated union in\n * `@codegraph/shared` plus the two embedding-namespace fields. Fields that are not\n * relevant to a given kind stay NULL.\n */\n\n/** Explicit list of columns the upserter knows how to SET. Order is not significant. */\nexport const SYMBOL_COLUMNS = [\n  \"id\",\n  \"kind\",\n  \"repoId\",\n  \"name\",\n  \"path\",\n  \"lineStart\",\n  \"lineEnd\",\n  \"signature\",\n  \"leadingComment\",\n  \"isExported\",\n  // File-specific\n  \"language\",\n  \"sizeBytes\",\n  \"contentHash\",\n  // Function-specific\n  \"isAsync\",\n  \"isArrow\",\n  // Route-specific\n  \"method\",\n  \"routePath\",\n  \"framework\",\n  // Embedding\n  \"embeddingNamespace\",\n] as const;\n\nexport type SymbolColumn = (typeof SYMBOL_COLUMNS)[number];\n\n/** Optional per-edge metadata. Currently only `line`. */\nexport const EDGE_COLUMNS = [\"line\"] as const;\n\nexport type EdgeColumn = (typeof EDGE_COLUMNS)[number];\n\n/**\n * DDL statements that bring an empty Kuzu database to the codegraph schema.\n * `IF NOT EXISTS` makes `migrate()` idempotent so it can run on every connect.\n *\n * `embedding` is a fixed-dimension column - dimension is configured at migrate time and\n * baked into the schema. If a user later switches to an embedding provider with a\n * different dimension they must delete the on-disk graph directory to recreate it. The\n * embedding-namespace tag ensures we never silently mix dimensions.\n */\nexport function buildSchemaStatements(opts: { embeddingDimension: number }): string[] {\n  const columnDefs = [\n    \"id STRING\",\n    \"kind STRING\",\n    \"repoId STRING\",\n    \"name STRING\",\n    \"path STRING\",\n    \"lineStart INT64\",\n    \"lineEnd INT64\",\n    \"signature STRING\",\n    \"leadingComment STRING\",\n    \"isExported BOOLEAN\",\n    \"language STRING\",\n    \"sizeBytes INT64\",\n    \"contentHash STRING\",\n    \"isAsync BOOLEAN\",\n    \"isArrow BOOLEAN\",\n    \"method STRING\",\n    \"routePath STRING\",\n    \"framework STRING\",\n    \"embeddingNamespace STRING\",\n    `embedding FLOAT[${opts.embeddingDimension}]`,\n    \"PRIMARY KEY (id)\",\n  ];\n  const statements: string[] = [\n    `CREATE NODE TABLE IF NOT EXISTS Symbol(${columnDefs.join(\", \")})`,\n  ];\n  for (const kind of EDGE_KINDS) {\n    statements.push(\n      `CREATE REL TABLE IF NOT EXISTS ${kind}(FROM Symbol TO Symbol, line INT64)`,\n    );\n  }\n  return statements;\n}\n\n/**\n * The vector extension is bundled but not auto-loaded. We install + load on every connect\n * (both no-op if already done) and create the HNSW index if it does not already exist.\n *\n * Kuzu's `CALL CREATE_VECTOR_INDEX` errors out with a stable \"already exists\" message\n * when re-run, so the client's `migrate()` swallows that specific error.\n */\nexport function buildVectorIndexStatements(): string[] {\n  return [\n    \"INSTALL VECTOR\",\n    \"LOAD EXTENSION VECTOR\",\n    \"CALL CREATE_VECTOR_INDEX('Symbol', 'embedding_idx', 'embedding', metric := 'cosine')\",\n  ];\n}\n\n/** Default embedding dimension when none is supplied. Matches `text-embedding-3-small`. */\nexport const DEFAULT_EMBEDDING_DIMENSION = 1536;\n"],"mappings":"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","names":[]}