@zuvia-software-solutions/code-mapper 1.4.0

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

@@ -0,0 +1,46 @@
+/**
+ * @file schema.ts
+ * @description LadybugDB schema definitions for the hybrid node/relation model
+ *
+ * Separate node tables per code element type + single CodeRelation table,
+ * enabling natural Cypher like: MATCH (f:Function)-[:CodeRelation {type: 'CALLS'}]->(g:Function)
+ */
+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", "HAS_METHOD", "OVERRIDES", "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  description 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  description 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  description 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  description STRING,\n  parameterCount INT32,\n  returnType 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  description 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 Function TO `Const`,\n  FROM Function TO `Typedef`,\n  FROM Function TO `Union`,\n  FROM Function TO `Property`,\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 `Annotation`,\n  FROM Class TO `Constructor`,\n  FROM Class TO `Trait`,\n  FROM Class TO `Macro`,\n  FROM Class TO `Impl`,\n  FROM Class TO `Union`,\n  FROM Class TO `Namespace`,\n  FROM Class TO `Typedef`,\n  FROM Class TO `Property`,\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 Method TO `Property`,\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 Interface TO `Property`,\n  FROM `Struct` TO Community,\n  FROM `Struct` TO `Trait`,\n  FROM `Struct` TO `Struct`,\n  FROM `Struct` TO Class,\n  FROM `Struct` TO `Enum`,\n  FROM `Struct` TO Function,\n  FROM `Struct` TO Method,\n  FROM `Struct` TO Interface,\n  FROM `Struct` TO `Constructor`,\n  FROM `Struct` TO `Property`,\n  FROM `Enum` TO `Enum`,\n  FROM `Enum` TO Community,\n  FROM `Enum` TO Class,\n  FROM `Enum` TO Interface,\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 `Namespace` TO `Struct`,\n  FROM `Trait` TO Method,\n  FROM `Trait` TO `Constructor`,\n  FROM `Trait` TO `Property`,\n  FROM `Trait` TO Community,\n  FROM `Impl` TO Method,\n  FROM `Impl` TO `Constructor`,\n  FROM `Impl` TO `Property`,\n  FROM `Impl` TO Community,\n  FROM `Impl` TO `Trait`,\n  FROM `Impl` TO `Struct`,\n  FROM `Impl` TO `Impl`,\n  FROM `TypeAlias` TO Community,\n  FROM `TypeAlias` TO `Trait`,\n  FROM `TypeAlias` TO Class,\n  FROM `Const` TO Community,\n  FROM `Static` TO Community,\n  FROM `Property` TO Community,\n  FROM `Record` TO Method,\n  FROM `Record` TO `Constructor`,\n  FROM `Record` TO `Property`,\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 `Annotation`,\n  FROM `Constructor` TO `Impl`,\n  FROM `Constructor` TO `Namespace`,\n  FROM `Constructor` TO `Module`,\n  FROM `Constructor` TO `Property`,\n  FROM `Constructor` TO `Typedef`,\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  callLine INT32\n)";
+export declare const EMBEDDING_SCHEMA = "\nCREATE NODE TABLE CodeEmbedding (\n  nodeId STRING,\n  embedding FLOAT[256],\n  PRIMARY KEY (nodeId)\n)";
+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/lbug/schema.js

@@ -0,0 +1,402 @@
+// code-mapper/src/core/lbug/schema.ts
+/**
+ * @file schema.ts
+ * @description LadybugDB schema definitions for the hybrid node/relation model
+ *
+ * Separate node tables per code element type + single CodeRelation table,
+ * enabling natural Cypher like: MATCH (f:Function)-[:CodeRelation {type: 'CALLS'}]->(g:Function)
+ */
+// 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', 'HAS_METHOD', 'OVERRIDES', '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,
+  description 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,
+  description 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,
+  description 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,
+  description STRING,
+  parameterCount INT32,
+  returnType 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,
+  description STRING,
+  PRIMARY KEY (id)
+)`;
+// Community node table (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 (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#, etc
+const CODE_ELEMENT_BASE = (name) => `
+CREATE NODE TABLE \`${name}\` (
+  id STRING,
+  name STRING,
+  filePath STRING,
+  startLine INT64,
+  endLine INT64,
+  content STRING,
+  description 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 connecting 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 Function TO \`Const\`,
+  FROM Function TO \`Typedef\`,
+  FROM Function TO \`Union\`,
+  FROM Function TO \`Property\`,
+  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 \`Annotation\`,
+  FROM Class TO \`Constructor\`,
+  FROM Class TO \`Trait\`,
+  FROM Class TO \`Macro\`,
+  FROM Class TO \`Impl\`,
+  FROM Class TO \`Union\`,
+  FROM Class TO \`Namespace\`,
+  FROM Class TO \`Typedef\`,
+  FROM Class TO \`Property\`,
+  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 Method TO \`Property\`,
+  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 Interface TO \`Property\`,
+  FROM \`Struct\` TO Community,
+  FROM \`Struct\` TO \`Trait\`,
+  FROM \`Struct\` TO \`Struct\`,
+  FROM \`Struct\` TO Class,
+  FROM \`Struct\` TO \`Enum\`,
+  FROM \`Struct\` TO Function,
+  FROM \`Struct\` TO Method,
+  FROM \`Struct\` TO Interface,
+  FROM \`Struct\` TO \`Constructor\`,
+  FROM \`Struct\` TO \`Property\`,
+  FROM \`Enum\` TO \`Enum\`,
+  FROM \`Enum\` TO Community,
+  FROM \`Enum\` TO Class,
+  FROM \`Enum\` TO Interface,
+  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 \`Namespace\` TO \`Struct\`,
+  FROM \`Trait\` TO Method,
+  FROM \`Trait\` TO \`Constructor\`,
+  FROM \`Trait\` TO \`Property\`,
+  FROM \`Trait\` TO Community,
+  FROM \`Impl\` TO Method,
+  FROM \`Impl\` TO \`Constructor\`,
+  FROM \`Impl\` TO \`Property\`,
+  FROM \`Impl\` TO Community,
+  FROM \`Impl\` TO \`Trait\`,
+  FROM \`Impl\` TO \`Struct\`,
+  FROM \`Impl\` TO \`Impl\`,
+  FROM \`TypeAlias\` TO Community,
+  FROM \`TypeAlias\` TO \`Trait\`,
+  FROM \`TypeAlias\` TO Class,
+  FROM \`Const\` TO Community,
+  FROM \`Static\` TO Community,
+  FROM \`Property\` TO Community,
+  FROM \`Record\` TO Method,
+  FROM \`Record\` TO \`Constructor\`,
+  FROM \`Record\` TO \`Property\`,
+  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 \`Annotation\`,
+  FROM \`Constructor\` TO \`Impl\`,
+  FROM \`Constructor\` TO \`Namespace\`,
+  FROM \`Constructor\` TO \`Module\`,
+  FROM \`Constructor\` TO \`Property\`,
+  FROM \`Constructor\` TO \`Typedef\`,
+  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,
+  callLine INT32
+)`;
+// Embedding table schema (separate table to avoid COW overhead)
+export const EMBEDDING_SCHEMA = `
+CREATE NODE TABLE ${EMBEDDING_TABLE_NAME} (
+  nodeId STRING,
+  embedding FLOAT[256],
+  PRIMARY KEY (nodeId)
+)`;
+// HNSW vector index for semantic search (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 before relationship tables)
+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,20 @@
+/**
+ * @file bm25-index.ts
+ * @description Symbol-level full-text search via LadybugDB FTS indexes.
+ *
+ * Returns individual symbols (functions, classes, methods, interfaces, files)
+ * with their nodeId, name, type — NOT just filePaths.
+ * This gives the RRF merge symbol-level granularity for accurate ranking.
+ *
+ * All FTS tables are driven from FTS_TABLES in types.ts — single source of truth.
+ */
+import { type BM25SearchResult } from './types.js';
+export type { BM25SearchResult } from './types.js';
+/**
+ * Symbol-level BM25 search via LadybugDB FTS.
+ *
+ * Queries all FTS_TABLES in parallel. Returns individual symbols (not filePaths).
+ * Deduplicates by nodeId — if the same symbol matches in multiple indexes,
+ * take the highest score.
+ */
+export declare function searchFTSFromLbug(query: string, limit?: number, repoId?: string): Promise<BM25SearchResult[]>;

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

@@ -0,0 +1,123 @@
+// code-mapper/src/core/search/bm25-index.ts
+/**
+ * @file bm25-index.ts
+ * @description Symbol-level full-text search via LadybugDB FTS indexes.
+ *
+ * Returns individual symbols (functions, classes, methods, interfaces, files)
+ * with their nodeId, name, type — NOT just filePaths.
+ * This gives the RRF merge symbol-level granularity for accurate ranking.
+ *
+ * All FTS tables are driven from FTS_TABLES in types.ts — single source of truth.
+ */
+import { queryFTS } from '../lbug/lbug-adapter.js';
+import { FTS_TABLES } from './types.js';
+/**
+ * Execute a single FTS query returning symbol-level results.
+ * Each result has nodeId + name + type, not just filePath.
+ */
+async function queryFTSSymbols(executor, tableName, indexName, query, limit) {
+    const escapedQuery = query.replace(/\\/g, '\\\\').replace(/'/g, "''");
+    // Return node.id and node.name alongside filePath so we get symbol-level results
+    const isFile = tableName === 'File';
+    const returnFields = isFile
+        ? `node.id AS nodeId, node.name AS name, '${tableName}' AS type, node.filePath AS filePath, score`
+        : `node.id AS nodeId, node.name AS name, '${tableName}' AS type, node.filePath AS filePath, node.startLine AS startLine, node.endLine AS endLine, score`;
+    const cypher = `
+    CALL QUERY_FTS_INDEX('${tableName}', '${indexName}', '${escapedQuery}', conjunctive := false)
+    RETURN ${returnFields}
+    ORDER BY score DESC
+    LIMIT ${limit}
+  `;
+    try {
+        const rows = await executor(cypher);
+        return rows.map((row) => {
+            const r = row;
+            const rawScore = r.score ?? 0;
+            const score = typeof rawScore === 'number' ? rawScore : parseFloat(String(rawScore)) || 0;
+            return {
+                nodeId: String(r.nodeId ?? ''),
+                name: String(r.name ?? ''),
+                type: String(r.type ?? tableName),
+                filePath: String(r.filePath ?? ''),
+                score,
+                ...(!isFile && r.startLine != null ? { startLine: Number(r.startLine) } : {}),
+                ...(!isFile && r.endLine != null ? { endLine: Number(r.endLine) } : {}),
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+// ============================================================================
+// MAIN SEARCH FUNCTION
+// ============================================================================
+/**
+ * Symbol-level BM25 search via LadybugDB FTS.
+ *
+ * Queries all FTS_TABLES in parallel. Returns individual symbols (not filePaths).
+ * Deduplicates by nodeId — if the same symbol matches in multiple indexes,
+ * take the highest score.
+ */
+export async function searchFTSFromLbug(query, limit = 20, repoId) {
+    const queryAll = [];
+    if (repoId) {
+        const { executeQuery } = await import('../../mcp/core/lbug-adapter.js');
+        const executor = (cypher) => executeQuery(repoId, cypher);
+        for (const { table, index } of FTS_TABLES) {
+            queryAll.push(queryFTSSymbols(executor, table, index, query, limit));
+        }
+    }
+    else {
+        for (const { table, index } of FTS_TABLES) {
+            queryAll.push(queryFTS(table, index, query, limit, false)
+                .then((rows) => rows.map(r => ({
+                nodeId: String(r.nodeId ?? r.id ?? ''),
+                name: String(r.name ?? ''),
+                type: table,
+                filePath: String(r.filePath ?? ''),
+                score: typeof r.score === 'number' ? r.score : 0,
+                ...(r.startLine != null ? { startLine: Number(r.startLine) } : {}),
+                ...(r.endLine != null ? { endLine: Number(r.endLine) } : {}),
+            })))
+                .catch(() => []));
+        }
+    }
+    const allResults = await Promise.all(queryAll);
+    // Symbol-type weight multipliers: functions/methods are more actionable than files
+    const TYPE_WEIGHTS = {
+        Function: 1.5,
+        Method: 1.5,
+        Class: 1.3,
+        Interface: 1.3,
+        File: 1.0,
+    };
+    // Deduplicate by nodeId — keep highest score per symbol, apply type weighting
+    const byNodeId = new Map();
+    for (const tableResults of allResults) {
+        for (const r of tableResults) {
+            if (!r.nodeId)
+                continue;
+            const weight = TYPE_WEIGHTS[r.type] ?? 1.0;
+            const weighted = { ...r, score: r.score * weight };
+            const existing = byNodeId.get(r.nodeId);
+            if (!existing || weighted.score > existing.score) {
+                byNodeId.set(r.nodeId, weighted);
+            }
+        }
+    }
+    // Sort by score descending, assign rank
+    const sorted = Array.from(byNodeId.values())
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+    return sorted.map((r, index) => ({
+        nodeId: r.nodeId,
+        name: r.name,
+        type: r.type,
+        filePath: r.filePath,
+        score: r.score,
+        rank: index + 1,
+        ...(r.startLine != null ? { startLine: r.startLine } : {}),
+        ...(r.endLine != null ? { endLine: r.endLine } : {}),
+    }));
+}

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

@@ -0,0 +1,32 @@
+/**
+ * @file hybrid-search.ts
+ * @description Combines BM25 (keyword) and semantic (embedding) search using
+ * weighted Reciprocal Rank Fusion (RRF) to merge rankings without score normalization
+ *
+ * All constants come from types.ts (single source of truth)
+ * This is the ONLY RRF implementation — local-backend.ts must import this, never reimplement
+ */
+import { type BM25SearchResult, type SemanticSearchResult, type HybridSearchResult, type RRFConfig } from './types.js';
+export type { HybridSearchResult, RRFConfig } from './types.js';
+/**
+ * Merge BM25 and semantic results using weighted Reciprocal Rank Fusion
+ *
+ * Formula: rrfScore = weight * (1 / (k + rank))
+ * Results found by both methods get both scores summed (consensus boost)
+ *
+ * @param bm25Results - BM25 keyword search results (pre-sorted by score desc)
+ * @param semanticResults - Semantic embedding search results (pre-sorted by distance asc)
+ * @param config - RRF configuration (weights, k, limit)
+ */
+export declare function mergeWithRRF(bm25Results: readonly BM25SearchResult[], semanticResults: readonly SemanticSearchResult[], config?: Partial<RRFConfig>): HybridSearchResult[];
+/** Check if hybrid search is available (FTS always available when DB is open) */
+export declare function isHybridSearchReady(): boolean;
+/** Format hybrid results for LLM consumption */
+export declare function formatHybridResults(results: readonly HybridSearchResult[]): string;
+/**
+ * Execute BM25 + semantic search and merge with weighted RRF
+ *
+ * Uses LadybugDB FTS for always-fresh BM25 results
+ * The semanticSearch function is injected to keep this module environment-agnostic
+ */
+export declare function hybridSearch(query: string, limit: number, executeQuery: (cypher: string) => Promise<unknown[]>, semanticSearchFn: (executeQuery: (cypher: string) => Promise<unknown[]>, query: string, k?: number) => Promise<SemanticSearchResult[]>): Promise<HybridSearchResult[]>;