gitnexus 1.0.0

package/dist/core/kuzu/schema.d.ts

@@ -0,0 +1,53 @@
+/**
+ * KuzuDB Schema Definitions
+ *
+ * Hybrid Schema:
+ * - Separate node tables for each code element type (File, Function, Class, etc.)
+ * - Single CodeRelation table with 'type' property for all relationships
+ *
+ * This allows LLMs to write natural Cypher queries like:
+ *   MATCH (f:Function)-[r:CodeRelation {type: 'CALLS'}]->(g:Function) RETURN f, g
+ */
+export declare const NODE_TABLES: readonly ["File", "Folder", "Function", "Class", "Interface", "Method", "CodeElement", "Community", "Process", "Struct", "Enum", "Macro", "Typedef", "Union", "Namespace", "Trait", "Impl", "TypeAlias", "Const", "Static", "Property", "Record", "Delegate", "Annotation", "Constructor", "Template", "Module"];
+export type NodeTableName = typeof NODE_TABLES[number];
+export declare const REL_TABLE_NAME = "CodeRelation";
+export declare const REL_TYPES: readonly ["CONTAINS", "DEFINES", "IMPORTS", "CALLS", "EXTENDS", "IMPLEMENTS", "MEMBER_OF", "STEP_IN_PROCESS"];
+export type RelType = typeof REL_TYPES[number];
+export declare const EMBEDDING_TABLE_NAME = "CodeEmbedding";
+export declare const FILE_SCHEMA = "\nCREATE NODE TABLE File (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  content STRING,\n  PRIMARY KEY (id)\n)";
+export declare const FOLDER_SCHEMA = "\nCREATE NODE TABLE Folder (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  PRIMARY KEY (id)\n)";
+export declare const FUNCTION_SCHEMA = "\nCREATE NODE TABLE Function (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  isExported BOOLEAN,\n  content STRING,\n  PRIMARY KEY (id)\n)";
+export declare const CLASS_SCHEMA = "\nCREATE NODE TABLE Class (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  isExported BOOLEAN,\n  content STRING,\n  PRIMARY KEY (id)\n)";
+export declare const INTERFACE_SCHEMA = "\nCREATE NODE TABLE Interface (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  isExported BOOLEAN,\n  content STRING,\n  PRIMARY KEY (id)\n)";
+export declare const METHOD_SCHEMA = "\nCREATE NODE TABLE Method (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  isExported BOOLEAN,\n  content STRING,\n  PRIMARY KEY (id)\n)";
+export declare const CODE_ELEMENT_SCHEMA = "\nCREATE NODE TABLE CodeElement (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  isExported BOOLEAN,\n  content STRING,\n  PRIMARY KEY (id)\n)";
+export declare const COMMUNITY_SCHEMA = "\nCREATE NODE TABLE Community (\n  id STRING,\n  label STRING,\n  heuristicLabel STRING,\n  keywords STRING[],\n  description STRING,\n  enrichedBy STRING,\n  cohesion DOUBLE,\n  symbolCount INT32,\n  PRIMARY KEY (id)\n)";
+export declare const PROCESS_SCHEMA = "\nCREATE NODE TABLE Process (\n  id STRING,\n  label STRING,\n  heuristicLabel STRING,\n  processType STRING,\n  stepCount INT32,\n  communities STRING[],\n  entryPointId STRING,\n  terminalId STRING,\n  PRIMARY KEY (id)\n)";
+export declare const STRUCT_SCHEMA: string;
+export declare const ENUM_SCHEMA: string;
+export declare const MACRO_SCHEMA: string;
+export declare const TYPEDEF_SCHEMA: string;
+export declare const UNION_SCHEMA: string;
+export declare const NAMESPACE_SCHEMA: string;
+export declare const TRAIT_SCHEMA: string;
+export declare const IMPL_SCHEMA: string;
+export declare const TYPE_ALIAS_SCHEMA: string;
+export declare const CONST_SCHEMA: string;
+export declare const STATIC_SCHEMA: string;
+export declare const PROPERTY_SCHEMA: string;
+export declare const RECORD_SCHEMA: string;
+export declare const DELEGATE_SCHEMA: string;
+export declare const ANNOTATION_SCHEMA: string;
+export declare const CONSTRUCTOR_SCHEMA: string;
+export declare const TEMPLATE_SCHEMA: string;
+export declare const MODULE_SCHEMA: string;
+export declare const RELATION_SCHEMA = "\nCREATE REL TABLE CodeRelation (\n  FROM File TO File,\n  FROM File TO Folder,\n  FROM File TO Function,\n  FROM File TO Class,\n  FROM File TO Interface,\n  FROM File TO Method,\n  FROM File TO CodeElement,\n  FROM File TO `Struct`,\n  FROM File TO `Enum`,\n  FROM File TO `Macro`,\n  FROM File TO `Typedef`,\n  FROM File TO `Union`,\n  FROM File TO `Namespace`,\n  FROM File TO `Trait`,\n  FROM File TO `Impl`,\n  FROM File TO `TypeAlias`,\n  FROM File TO `Const`,\n  FROM File TO `Static`,\n  FROM File TO `Property`,\n  FROM File TO `Record`,\n  FROM File TO `Delegate`,\n  FROM File TO `Annotation`,\n  FROM File TO `Constructor`,\n  FROM File TO `Template`,\n  FROM File TO `Module`,\n  FROM Folder TO Folder,\n  FROM Folder TO File,\n  FROM Function TO Function,\n  FROM Function TO Method,\n  FROM Function TO Class,\n  FROM Function TO Community,\n  FROM Function TO `Macro`,\n  FROM Function TO `Struct`,\n  FROM Function TO `Template`,\n  FROM Function TO `Enum`,\n  FROM Function TO `Namespace`,\n  FROM Function TO `TypeAlias`,\n  FROM Function TO `Module`,\n  FROM Function TO `Impl`,\n  FROM Function TO Interface,\n  FROM Function TO `Constructor`,\n  FROM Class TO Method,\n  FROM Class TO Function,\n  FROM Class TO Class,\n  FROM Class TO Interface,\n  FROM Class TO Community,\n  FROM Class TO `Template`,\n  FROM Class TO `TypeAlias`,\n  FROM Class TO `Struct`,\n  FROM Class TO `Enum`,\n  FROM Class TO `Constructor`,\n  FROM Method TO Function,\n  FROM Method TO Method,\n  FROM Method TO Class,\n  FROM Method TO Community,\n  FROM Method TO `Template`,\n  FROM Method TO `Struct`,\n  FROM Method TO `TypeAlias`,\n  FROM Method TO `Enum`,\n  FROM Method TO `Macro`,\n  FROM Method TO `Namespace`,\n  FROM Method TO `Module`,\n  FROM Method TO `Impl`,\n  FROM Method TO Interface,\n  FROM Method TO `Constructor`,\n  FROM `Template` TO `Template`,\n  FROM `Template` TO Function,\n  FROM `Template` TO Method,\n  FROM `Template` TO Class,\n  FROM `Template` TO `Struct`,\n  FROM `Template` TO `TypeAlias`,\n  FROM `Template` TO `Enum`,\n  FROM `Template` TO `Macro`,\n  FROM `Template` TO Interface,\n  FROM `Template` TO `Constructor`,\n  FROM `Module` TO `Module`,\n  FROM CodeElement TO Community,\n  FROM Interface TO Community,\n  FROM Interface TO Function,\n  FROM Interface TO Method,\n  FROM Interface TO Class,\n  FROM Interface TO Interface,\n  FROM Interface TO `TypeAlias`,\n  FROM Interface TO `Struct`,\n  FROM Interface TO `Constructor`,\n  FROM `Struct` TO Community,\n  FROM `Struct` TO `Trait`,\n  FROM `Struct` TO Function,\n  FROM `Struct` TO Method,\n  FROM `Enum` TO Community,\n  FROM `Macro` TO Community,\n  FROM `Macro` TO Function,\n  FROM `Macro` TO Method,\n  FROM `Module` TO Function,\n  FROM `Module` TO Method,\n  FROM `Typedef` TO Community,\n  FROM `Union` TO Community,\n  FROM `Namespace` TO Community,\n  FROM `Trait` TO Community,\n  FROM `Impl` TO Community,\n  FROM `Impl` TO `Trait`,\n  FROM `TypeAlias` TO Community,\n  FROM `Const` TO Community,\n  FROM `Static` TO Community,\n  FROM `Property` TO Community,\n  FROM `Record` TO Community,\n  FROM `Delegate` TO Community,\n  FROM `Annotation` TO Community,\n  FROM `Constructor` TO Community,\n  FROM `Constructor` TO Interface,\n  FROM `Constructor` TO Class,\n  FROM `Constructor` TO Method,\n  FROM `Constructor` TO Function,\n  FROM `Constructor` TO `Constructor`,\n  FROM `Constructor` TO `Struct`,\n  FROM `Constructor` TO `Macro`,\n  FROM `Constructor` TO `Template`,\n  FROM `Constructor` TO `TypeAlias`,\n  FROM `Constructor` TO `Enum`,\n  FROM `Constructor` TO `Impl`,\n  FROM `Constructor` TO `Namespace`,\n  FROM `Template` TO Community,\n  FROM `Module` TO Community,\n  FROM Function TO Process,\n  FROM Method TO Process,\n  FROM Class TO Process,\n  FROM Interface TO Process,\n  FROM `Struct` TO Process,\n  FROM `Constructor` TO Process,\n  FROM `Module` TO Process,\n  FROM `Macro` TO Process,\n  FROM `Impl` TO Process,\n  FROM `Typedef` TO Process,\n  FROM `TypeAlias` TO Process,\n  FROM `Enum` TO Process,\n  FROM `Union` TO Process,\n  FROM `Namespace` TO Process,\n  FROM `Trait` TO Process,\n  FROM `Const` TO Process,\n  FROM `Static` TO Process,\n  FROM `Property` TO Process,\n  FROM `Record` TO Process,\n  FROM `Delegate` TO Process,\n  FROM `Annotation` TO Process,\n  FROM `Template` TO Process,\n  FROM CodeElement TO Process,\n  type STRING,\n  confidence DOUBLE,\n  reason STRING,\n  step INT32\n)";
+export declare const EMBEDDING_SCHEMA = "\nCREATE NODE TABLE CodeEmbedding (\n  nodeId STRING,\n  embedding FLOAT[384],\n  PRIMARY KEY (nodeId)\n)";
+/**
+ * Create vector index for semantic search
+ * Uses HNSW (Hierarchical Navigable Small World) algorithm with cosine similarity
+ */
+export declare const CREATE_VECTOR_INDEX_QUERY = "\nCALL CREATE_VECTOR_INDEX('CodeEmbedding', 'code_embedding_idx', 'embedding', metric := 'cosine')\n";
+export declare const NODE_SCHEMA_QUERIES: string[];
+export declare const REL_SCHEMA_QUERIES: string[];
+export declare const SCHEMA_QUERIES: string[];

package/dist/core/kuzu/schema.js

@@ -0,0 +1,380 @@
+/**
+ * KuzuDB Schema Definitions
+ *
+ * Hybrid Schema:
+ * - Separate node tables for each code element type (File, Function, Class, etc.)
+ * - Single CodeRelation table with 'type' property for all relationships
+ *
+ * This allows LLMs to write natural Cypher queries like:
+ *   MATCH (f:Function)-[r:CodeRelation {type: 'CALLS'}]->(g:Function) RETURN f, g
+ */
+// ============================================================================
+// NODE TABLE NAMES
+// ============================================================================
+export const NODE_TABLES = [
+    'File', 'Folder', 'Function', 'Class', 'Interface', 'Method', 'CodeElement', 'Community', 'Process',
+    // Multi-language support
+    'Struct', 'Enum', 'Macro', 'Typedef', 'Union', 'Namespace', 'Trait', 'Impl',
+    'TypeAlias', 'Const', 'Static', 'Property', 'Record', 'Delegate', 'Annotation', 'Constructor', 'Template', 'Module'
+];
+// ============================================================================
+// RELATION TABLE
+// ============================================================================
+export const REL_TABLE_NAME = 'CodeRelation';
+// Valid relation types
+export const REL_TYPES = ['CONTAINS', 'DEFINES', 'IMPORTS', 'CALLS', 'EXTENDS', 'IMPLEMENTS', 'MEMBER_OF', 'STEP_IN_PROCESS'];
+// ============================================================================
+// EMBEDDING TABLE
+// ============================================================================
+export const EMBEDDING_TABLE_NAME = 'CodeEmbedding';
+// ============================================================================
+// NODE TABLE SCHEMAS
+// ============================================================================
+export const FILE_SCHEMA = `
+CREATE NODE TABLE File (
+  id STRING,
+  name STRING,
+  filePath STRING,
+  content STRING,
+  PRIMARY KEY (id)
+)`;
+export const FOLDER_SCHEMA = `
+CREATE NODE TABLE Folder (
+  id STRING,
+  name STRING,
+  filePath STRING,
+  PRIMARY KEY (id)
+)`;
+export const FUNCTION_SCHEMA = `
+CREATE NODE TABLE Function (
+  id STRING,
+  name STRING,
+  filePath STRING,
+  startLine INT64,
+  endLine INT64,
+  isExported BOOLEAN,
+  content STRING,
+  PRIMARY KEY (id)
+)`;
+export const CLASS_SCHEMA = `
+CREATE NODE TABLE Class (
+  id STRING,
+  name STRING,
+  filePath STRING,
+  startLine INT64,
+  endLine INT64,
+  isExported BOOLEAN,
+  content STRING,
+  PRIMARY KEY (id)
+)`;
+export const INTERFACE_SCHEMA = `
+CREATE NODE TABLE Interface (
+  id STRING,
+  name STRING,
+  filePath STRING,
+  startLine INT64,
+  endLine INT64,
+  isExported BOOLEAN,
+  content STRING,
+  PRIMARY KEY (id)
+)`;
+export const METHOD_SCHEMA = `
+CREATE NODE TABLE Method (
+  id STRING,
+  name STRING,
+  filePath STRING,
+  startLine INT64,
+  endLine INT64,
+  isExported BOOLEAN,
+  content STRING,
+  PRIMARY KEY (id)
+)`;
+export const CODE_ELEMENT_SCHEMA = `
+CREATE NODE TABLE CodeElement (
+  id STRING,
+  name STRING,
+  filePath STRING,
+  startLine INT64,
+  endLine INT64,
+  isExported BOOLEAN,
+  content STRING,
+  PRIMARY KEY (id)
+)`;
+// ============================================================================
+// COMMUNITY NODE TABLE (for Leiden algorithm clusters)
+// ============================================================================
+export const COMMUNITY_SCHEMA = `
+CREATE NODE TABLE Community (
+  id STRING,
+  label STRING,
+  heuristicLabel STRING,
+  keywords STRING[],
+  description STRING,
+  enrichedBy STRING,
+  cohesion DOUBLE,
+  symbolCount INT32,
+  PRIMARY KEY (id)
+)`;
+// ============================================================================
+// PROCESS NODE TABLE (for execution flow detection)
+// ============================================================================
+export const PROCESS_SCHEMA = `
+CREATE NODE TABLE Process (
+  id STRING,
+  label STRING,
+  heuristicLabel STRING,
+  processType STRING,
+  stepCount INT32,
+  communities STRING[],
+  entryPointId STRING,
+  terminalId STRING,
+  PRIMARY KEY (id)
+)`;
+// ============================================================================
+// MULTI-LANGUAGE NODE TABLE SCHEMAS
+// ============================================================================
+// Generic code element with startLine/endLine for C, C++, Rust, Go, Java, C#
+const CODE_ELEMENT_BASE = (name) => `
+CREATE NODE TABLE \`${name}\` (
+  id STRING,
+  name STRING,
+  filePath STRING,
+  startLine INT64,
+  endLine INT64,
+  content STRING,
+  PRIMARY KEY (id)
+)`;
+export const STRUCT_SCHEMA = CODE_ELEMENT_BASE('Struct');
+export const ENUM_SCHEMA = CODE_ELEMENT_BASE('Enum');
+export const MACRO_SCHEMA = CODE_ELEMENT_BASE('Macro');
+export const TYPEDEF_SCHEMA = CODE_ELEMENT_BASE('Typedef');
+export const UNION_SCHEMA = CODE_ELEMENT_BASE('Union');
+export const NAMESPACE_SCHEMA = CODE_ELEMENT_BASE('Namespace');
+export const TRAIT_SCHEMA = CODE_ELEMENT_BASE('Trait');
+export const IMPL_SCHEMA = CODE_ELEMENT_BASE('Impl');
+export const TYPE_ALIAS_SCHEMA = CODE_ELEMENT_BASE('TypeAlias');
+export const CONST_SCHEMA = CODE_ELEMENT_BASE('Const');
+export const STATIC_SCHEMA = CODE_ELEMENT_BASE('Static');
+export const PROPERTY_SCHEMA = CODE_ELEMENT_BASE('Property');
+export const RECORD_SCHEMA = CODE_ELEMENT_BASE('Record');
+export const DELEGATE_SCHEMA = CODE_ELEMENT_BASE('Delegate');
+export const ANNOTATION_SCHEMA = CODE_ELEMENT_BASE('Annotation');
+export const CONSTRUCTOR_SCHEMA = CODE_ELEMENT_BASE('Constructor');
+export const TEMPLATE_SCHEMA = CODE_ELEMENT_BASE('Template');
+export const MODULE_SCHEMA = CODE_ELEMENT_BASE('Module');
+// ============================================================================
+// RELATION TABLE SCHEMA
+// Single table with 'type' property - connects all node tables
+// ============================================================================
+export const RELATION_SCHEMA = `
+CREATE REL TABLE ${REL_TABLE_NAME} (
+  FROM File TO File,
+  FROM File TO Folder,
+  FROM File TO Function,
+  FROM File TO Class,
+  FROM File TO Interface,
+  FROM File TO Method,
+  FROM File TO CodeElement,
+  FROM File TO \`Struct\`,
+  FROM File TO \`Enum\`,
+  FROM File TO \`Macro\`,
+  FROM File TO \`Typedef\`,
+  FROM File TO \`Union\`,
+  FROM File TO \`Namespace\`,
+  FROM File TO \`Trait\`,
+  FROM File TO \`Impl\`,
+  FROM File TO \`TypeAlias\`,
+  FROM File TO \`Const\`,
+  FROM File TO \`Static\`,
+  FROM File TO \`Property\`,
+  FROM File TO \`Record\`,
+  FROM File TO \`Delegate\`,
+  FROM File TO \`Annotation\`,
+  FROM File TO \`Constructor\`,
+  FROM File TO \`Template\`,
+  FROM File TO \`Module\`,
+  FROM Folder TO Folder,
+  FROM Folder TO File,
+  FROM Function TO Function,
+  FROM Function TO Method,
+  FROM Function TO Class,
+  FROM Function TO Community,
+  FROM Function TO \`Macro\`,
+  FROM Function TO \`Struct\`,
+  FROM Function TO \`Template\`,
+  FROM Function TO \`Enum\`,
+  FROM Function TO \`Namespace\`,
+  FROM Function TO \`TypeAlias\`,
+  FROM Function TO \`Module\`,
+  FROM Function TO \`Impl\`,
+  FROM Function TO Interface,
+  FROM Function TO \`Constructor\`,
+  FROM Class TO Method,
+  FROM Class TO Function,
+  FROM Class TO Class,
+  FROM Class TO Interface,
+  FROM Class TO Community,
+  FROM Class TO \`Template\`,
+  FROM Class TO \`TypeAlias\`,
+  FROM Class TO \`Struct\`,
+  FROM Class TO \`Enum\`,
+  FROM Class TO \`Constructor\`,
+  FROM Method TO Function,
+  FROM Method TO Method,
+  FROM Method TO Class,
+  FROM Method TO Community,
+  FROM Method TO \`Template\`,
+  FROM Method TO \`Struct\`,
+  FROM Method TO \`TypeAlias\`,
+  FROM Method TO \`Enum\`,
+  FROM Method TO \`Macro\`,
+  FROM Method TO \`Namespace\`,
+  FROM Method TO \`Module\`,
+  FROM Method TO \`Impl\`,
+  FROM Method TO Interface,
+  FROM Method TO \`Constructor\`,
+  FROM \`Template\` TO \`Template\`,
+  FROM \`Template\` TO Function,
+  FROM \`Template\` TO Method,
+  FROM \`Template\` TO Class,
+  FROM \`Template\` TO \`Struct\`,
+  FROM \`Template\` TO \`TypeAlias\`,
+  FROM \`Template\` TO \`Enum\`,
+  FROM \`Template\` TO \`Macro\`,
+  FROM \`Template\` TO Interface,
+  FROM \`Template\` TO \`Constructor\`,
+  FROM \`Module\` TO \`Module\`,
+  FROM CodeElement TO Community,
+  FROM Interface TO Community,
+  FROM Interface TO Function,
+  FROM Interface TO Method,
+  FROM Interface TO Class,
+  FROM Interface TO Interface,
+  FROM Interface TO \`TypeAlias\`,
+  FROM Interface TO \`Struct\`,
+  FROM Interface TO \`Constructor\`,
+  FROM \`Struct\` TO Community,
+  FROM \`Struct\` TO \`Trait\`,
+  FROM \`Struct\` TO Function,
+  FROM \`Struct\` TO Method,
+  FROM \`Enum\` TO Community,
+  FROM \`Macro\` TO Community,
+  FROM \`Macro\` TO Function,
+  FROM \`Macro\` TO Method,
+  FROM \`Module\` TO Function,
+  FROM \`Module\` TO Method,
+  FROM \`Typedef\` TO Community,
+  FROM \`Union\` TO Community,
+  FROM \`Namespace\` TO Community,
+  FROM \`Trait\` TO Community,
+  FROM \`Impl\` TO Community,
+  FROM \`Impl\` TO \`Trait\`,
+  FROM \`TypeAlias\` TO Community,
+  FROM \`Const\` TO Community,
+  FROM \`Static\` TO Community,
+  FROM \`Property\` TO Community,
+  FROM \`Record\` TO Community,
+  FROM \`Delegate\` TO Community,
+  FROM \`Annotation\` TO Community,
+  FROM \`Constructor\` TO Community,
+  FROM \`Constructor\` TO Interface,
+  FROM \`Constructor\` TO Class,
+  FROM \`Constructor\` TO Method,
+  FROM \`Constructor\` TO Function,
+  FROM \`Constructor\` TO \`Constructor\`,
+  FROM \`Constructor\` TO \`Struct\`,
+  FROM \`Constructor\` TO \`Macro\`,
+  FROM \`Constructor\` TO \`Template\`,
+  FROM \`Constructor\` TO \`TypeAlias\`,
+  FROM \`Constructor\` TO \`Enum\`,
+  FROM \`Constructor\` TO \`Impl\`,
+  FROM \`Constructor\` TO \`Namespace\`,
+  FROM \`Template\` TO Community,
+  FROM \`Module\` TO Community,
+  FROM Function TO Process,
+  FROM Method TO Process,
+  FROM Class TO Process,
+  FROM Interface TO Process,
+  FROM \`Struct\` TO Process,
+  FROM \`Constructor\` TO Process,
+  FROM \`Module\` TO Process,
+  FROM \`Macro\` TO Process,
+  FROM \`Impl\` TO Process,
+  FROM \`Typedef\` TO Process,
+  FROM \`TypeAlias\` TO Process,
+  FROM \`Enum\` TO Process,
+  FROM \`Union\` TO Process,
+  FROM \`Namespace\` TO Process,
+  FROM \`Trait\` TO Process,
+  FROM \`Const\` TO Process,
+  FROM \`Static\` TO Process,
+  FROM \`Property\` TO Process,
+  FROM \`Record\` TO Process,
+  FROM \`Delegate\` TO Process,
+  FROM \`Annotation\` TO Process,
+  FROM \`Template\` TO Process,
+  FROM CodeElement TO Process,
+  type STRING,
+  confidence DOUBLE,
+  reason STRING,
+  step INT32
+)`;
+// ============================================================================
+// EMBEDDING TABLE SCHEMA
+// Separate table for vector storage to avoid copy-on-write overhead
+// ============================================================================
+export const EMBEDDING_SCHEMA = `
+CREATE NODE TABLE ${EMBEDDING_TABLE_NAME} (
+  nodeId STRING,
+  embedding FLOAT[384],
+  PRIMARY KEY (nodeId)
+)`;
+/**
+ * Create vector index for semantic search
+ * Uses HNSW (Hierarchical Navigable Small World) algorithm with cosine similarity
+ */
+export const CREATE_VECTOR_INDEX_QUERY = `
+CALL CREATE_VECTOR_INDEX('${EMBEDDING_TABLE_NAME}', 'code_embedding_idx', 'embedding', metric := 'cosine')
+`;
+// ============================================================================
+// ALL SCHEMA QUERIES IN ORDER
+// Node tables must be created before relationship tables that reference them
+// ============================================================================
+export const NODE_SCHEMA_QUERIES = [
+    FILE_SCHEMA,
+    FOLDER_SCHEMA,
+    FUNCTION_SCHEMA,
+    CLASS_SCHEMA,
+    INTERFACE_SCHEMA,
+    METHOD_SCHEMA,
+    CODE_ELEMENT_SCHEMA,
+    COMMUNITY_SCHEMA,
+    PROCESS_SCHEMA,
+    // Multi-language support
+    STRUCT_SCHEMA,
+    ENUM_SCHEMA,
+    MACRO_SCHEMA,
+    TYPEDEF_SCHEMA,
+    UNION_SCHEMA,
+    NAMESPACE_SCHEMA,
+    TRAIT_SCHEMA,
+    IMPL_SCHEMA,
+    TYPE_ALIAS_SCHEMA,
+    CONST_SCHEMA,
+    STATIC_SCHEMA,
+    PROPERTY_SCHEMA,
+    RECORD_SCHEMA,
+    DELEGATE_SCHEMA,
+    ANNOTATION_SCHEMA,
+    CONSTRUCTOR_SCHEMA,
+    TEMPLATE_SCHEMA,
+    MODULE_SCHEMA,
+];
+export const REL_SCHEMA_QUERIES = [
+    RELATION_SCHEMA,
+];
+export const SCHEMA_QUERIES = [
+    ...NODE_SCHEMA_QUERIES,
+    ...REL_SCHEMA_QUERIES,
+    EMBEDDING_SCHEMA,
+];

package/dist/core/search/bm25-index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Full-Text Search via KuzuDB FTS
+ *
+ * Uses KuzuDB's built-in full-text search indexes for keyword-based search.
+ * Always reads from the database (no cached state to drift).
+ */
+export interface BM25SearchResult {
+    filePath: string;
+    score: number;
+    rank: number;
+}
+/**
+ * Search using KuzuDB's built-in FTS (always fresh, reads from disk)
+ *
+ * Queries multiple node tables (File, Function, Class, Method) in parallel
+ * and merges results by filePath, summing scores for the same file.
+ *
+ * @param query - Search query string
+ * @param limit - Maximum results
+ * @returns Ranked search results from FTS indexes
+ */
+export declare const searchFTSFromKuzu: (query: string, limit?: number) => Promise<BM25SearchResult[]>;

package/dist/core/search/bm25-index.js

@@ -0,0 +1,52 @@
+/**
+ * Full-Text Search via KuzuDB FTS
+ *
+ * Uses KuzuDB's built-in full-text search indexes for keyword-based search.
+ * Always reads from the database (no cached state to drift).
+ */
+import { queryFTS } from '../kuzu/kuzu-adapter.js';
+/**
+ * Search using KuzuDB's built-in FTS (always fresh, reads from disk)
+ *
+ * Queries multiple node tables (File, Function, Class, Method) in parallel
+ * and merges results by filePath, summing scores for the same file.
+ *
+ * @param query - Search query string
+ * @param limit - Maximum results
+ * @returns Ranked search results from FTS indexes
+ */
+export const searchFTSFromKuzu = async (query, limit = 20) => {
+    // Search multiple tables with searchable content
+    const [fileResults, functionResults, classResults, methodResults] = await Promise.all([
+        queryFTS('File', 'file_fts', query, limit, false).catch(() => []),
+        queryFTS('Function', 'function_fts', query, limit, false).catch(() => []),
+        queryFTS('Class', 'class_fts', query, limit, false).catch(() => []),
+        queryFTS('Method', 'method_fts', query, limit, false).catch(() => []),
+    ]);
+    // Merge results by filePath, summing scores for same file
+    const merged = new Map();
+    const addResults = (results) => {
+        for (const r of results) {
+            const existing = merged.get(r.filePath);
+            if (existing) {
+                existing.score += r.score;
+            }
+            else {
+                merged.set(r.filePath, { filePath: r.filePath, score: r.score });
+            }
+        }
+    };
+    addResults(fileResults);
+    addResults(functionResults);
+    addResults(classResults);
+    addResults(methodResults);
+    // Sort by score descending and add rank
+    const sorted = Array.from(merged.values())
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+    return sorted.map((r, index) => ({
+        filePath: r.filePath,
+        score: r.score,
+        rank: index + 1,
+    }));
+};

package/dist/core/search/hybrid-search.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Hybrid Search with Reciprocal Rank Fusion (RRF)
+ *
+ * Combines BM25 (keyword) and semantic (embedding) search results.
+ * Uses RRF to merge rankings without needing score normalization.
+ *
+ * This is the same approach used by Elasticsearch, Pinecone, and other
+ * production search systems.
+ */
+import { type BM25SearchResult } from './bm25-index.js';
+import type { SemanticSearchResult } from '../embeddings/types.js';
+export interface HybridSearchResult {
+    filePath: string;
+    score: number;
+    rank: number;
+    sources: ('bm25' | 'semantic')[];
+    nodeId?: string;
+    name?: string;
+    label?: string;
+    startLine?: number;
+    endLine?: number;
+    bm25Score?: number;
+    semanticScore?: number;
+}
+/**
+ * Perform hybrid search combining BM25 and semantic results
+ *
+ * @param bm25Results - Results from BM25 keyword search
+ * @param semanticResults - Results from semantic/embedding search
+ * @param limit - Maximum results to return
+ * @returns Merged and re-ranked results
+ */
+export declare const mergeWithRRF: (bm25Results: BM25SearchResult[], semanticResults: SemanticSearchResult[], limit?: number) => HybridSearchResult[];
+/**
+ * Check if hybrid search is available
+ * KuzuDB FTS is always available once the database is initialized.
+ * Semantic search is optional - hybrid works with just FTS if embeddings aren't ready.
+ */
+export declare const isHybridSearchReady: () => boolean;
+/**
+ * Format hybrid results for LLM consumption
+ */
+export declare const formatHybridResults: (results: HybridSearchResult[]) => string;
+/**
+ * Execute BM25 + semantic search and merge with RRF.
+ * Uses KuzuDB FTS for always-fresh BM25 results (no cached data).
+ * The semanticSearch function is injected to keep this module environment-agnostic.
+ */
+export declare const hybridSearch: (query: string, limit: number, executeQuery: (cypher: string) => Promise<any[]>, semanticSearch: (executeQuery: (cypher: string) => Promise<any[]>, query: string, k?: number) => Promise<SemanticSearchResult[]>) => Promise<HybridSearchResult[]>;

package/dist/core/search/hybrid-search.js

@@ -0,0 +1,118 @@
+/**
+ * Hybrid Search with Reciprocal Rank Fusion (RRF)
+ *
+ * Combines BM25 (keyword) and semantic (embedding) search results.
+ * Uses RRF to merge rankings without needing score normalization.
+ *
+ * This is the same approach used by Elasticsearch, Pinecone, and other
+ * production search systems.
+ */
+import { searchFTSFromKuzu } from './bm25-index.js';
+/**
+ * RRF constant - standard value used in the literature
+ * Higher values give more weight to lower-ranked results
+ */
+const RRF_K = 60;
+/**
+ * Perform hybrid search combining BM25 and semantic results
+ *
+ * @param bm25Results - Results from BM25 keyword search
+ * @param semanticResults - Results from semantic/embedding search
+ * @param limit - Maximum results to return
+ * @returns Merged and re-ranked results
+ */
+export const mergeWithRRF = (bm25Results, semanticResults, limit = 10) => {
+    const merged = new Map();
+    // Process BM25 results
+    for (let i = 0; i < bm25Results.length; i++) {
+        const r = bm25Results[i];
+        const rrfScore = 1 / (RRF_K + i + 1); // i+1 because rank starts at 1
+        merged.set(r.filePath, {
+            filePath: r.filePath,
+            score: rrfScore,
+            rank: 0, // Will be set after sorting
+            sources: ['bm25'],
+            bm25Score: r.score,
+        });
+    }
+    // Process semantic results and merge
+    for (let i = 0; i < semanticResults.length; i++) {
+        const r = semanticResults[i];
+        const rrfScore = 1 / (RRF_K + i + 1);
+        const existing = merged.get(r.filePath);
+        if (existing) {
+            // Found by both methods - add scores
+            existing.score += rrfScore;
+            existing.sources.push('semantic');
+            existing.semanticScore = 1 - r.distance;
+            // Add semantic metadata
+            existing.nodeId = r.nodeId;
+            existing.name = r.name;
+            existing.label = r.label;
+            existing.startLine = r.startLine;
+            existing.endLine = r.endLine;
+        }
+        else {
+            // Only found by semantic
+            merged.set(r.filePath, {
+                filePath: r.filePath,
+                score: rrfScore,
+                rank: 0,
+                sources: ['semantic'],
+                semanticScore: 1 - r.distance,
+                nodeId: r.nodeId,
+                name: r.name,
+                label: r.label,
+                startLine: r.startLine,
+                endLine: r.endLine,
+            });
+        }
+    }
+    // Sort by RRF score descending
+    const sorted = Array.from(merged.values())
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+    // Assign final ranks
+    sorted.forEach((r, i) => {
+        r.rank = i + 1;
+    });
+    return sorted;
+};
+/**
+ * Check if hybrid search is available
+ * KuzuDB FTS is always available once the database is initialized.
+ * Semantic search is optional - hybrid works with just FTS if embeddings aren't ready.
+ */
+export const isHybridSearchReady = () => {
+    return true; // FTS is always available via KuzuDB when DB is open
+};
+/**
+ * Format hybrid results for LLM consumption
+ */
+export const formatHybridResults = (results) => {
+    if (results.length === 0) {
+        return 'No results found.';
+    }
+    const formatted = results.map((r, i) => {
+        const sources = r.sources.join(' + ');
+        const location = r.startLine ? ` (lines ${r.startLine}-${r.endLine})` : '';
+        const label = r.label ? `${r.label}: ` : 'File: ';
+        const name = r.name || r.filePath.split('/').pop() || r.filePath;
+        return `[${i + 1}] ${label}${name}
+    File: ${r.filePath}${location}
+    Found by: ${sources}
+    Relevance: ${r.score.toFixed(4)}`;
+    });
+    return `Found ${results.length} results:\n\n${formatted.join('\n\n')}`;
+};
+/**
+ * Execute BM25 + semantic search and merge with RRF.
+ * Uses KuzuDB FTS for always-fresh BM25 results (no cached data).
+ * The semanticSearch function is injected to keep this module environment-agnostic.
+ */
+export const hybridSearch = async (query, limit, executeQuery, semanticSearch) => {
+    // Use KuzuDB FTS for always-fresh BM25 results
+    const bm25Results = await searchFTSFromKuzu(query, limit);
+    const semanticResults = await semanticSearch(executeQuery, query, limit);
+    return mergeWithRRF(bm25Results, semanticResults, limit);
+};

package/dist/core/tree-sitter/parser-loader.d.ts

@@ -0,0 +1,4 @@
+import Parser from 'tree-sitter';
+import { SupportedLanguages } from '../../config/supported-languages.js';
+export declare const loadParser: () => Promise<Parser>;
+export declare const loadLanguage: (language: SupportedLanguages, filePath?: string) => Promise<void>;