gitnexus 1.0.0

package/dist/core/ingestion/tree-sitter-queries.js

@@ -0,0 +1,319 @@
+import { SupportedLanguages } from '../../config/supported-languages.js';
+/*
+ * Tree-sitter queries for extracting code definitions.
+ *
+ * Note: Different grammars (typescript vs tsx vs javascript) may have
+ * slightly different node types. These queries are designed to be
+ * compatible with the standard tree-sitter grammars.
+ */
+// TypeScript queries - works with tree-sitter-typescript
+export const TYPESCRIPT_QUERIES = `
+(class_declaration
+  name: (type_identifier) @name) @definition.class
+
+(interface_declaration
+  name: (type_identifier) @name) @definition.interface
+
+(function_declaration
+  name: (identifier) @name) @definition.function
+
+(method_definition
+  name: (property_identifier) @name) @definition.method
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @name
+    value: (arrow_function))) @definition.function
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @name
+    value: (function_expression))) @definition.function
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (arrow_function)))) @definition.function
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (function_expression)))) @definition.function
+
+(import_statement
+  source: (string) @import.source) @import
+
+(call_expression
+  function: (identifier) @call.name) @call
+
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @call.name)) @call
+
+; Heritage queries - class extends
+(class_declaration
+  name: (type_identifier) @heritage.class
+  (class_heritage
+    (extends_clause
+      value: (identifier) @heritage.extends))) @heritage
+
+; Heritage queries - class implements interface
+(class_declaration
+  name: (type_identifier) @heritage.class
+  (class_heritage
+    (implements_clause
+      (type_identifier) @heritage.implements))) @heritage.impl
+`;
+// JavaScript queries - works with tree-sitter-javascript  
+export const JAVASCRIPT_QUERIES = `
+(class_declaration
+  name: (identifier) @name) @definition.class
+
+(function_declaration
+  name: (identifier) @name) @definition.function
+
+(method_definition
+  name: (property_identifier) @name) @definition.method
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @name
+    value: (arrow_function))) @definition.function
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @name
+    value: (function_expression))) @definition.function
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (arrow_function)))) @definition.function
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (function_expression)))) @definition.function
+
+(import_statement
+  source: (string) @import.source) @import
+
+(call_expression
+  function: (identifier) @call.name) @call
+
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @call.name)) @call
+
+; Heritage queries - class extends (JavaScript uses different AST than TypeScript)
+; In tree-sitter-javascript, class_heritage directly contains the parent identifier
+(class_declaration
+  name: (identifier) @heritage.class
+  (class_heritage
+    (identifier) @heritage.extends)) @heritage
+`;
+// Python queries - works with tree-sitter-python
+export const PYTHON_QUERIES = `
+(class_definition
+  name: (identifier) @name) @definition.class
+
+(function_definition
+  name: (identifier) @name) @definition.function
+
+(import_statement
+  name: (dotted_name) @import.source) @import
+
+(import_from_statement
+  module_name: (dotted_name) @import.source) @import
+
+(call
+  function: (identifier) @call.name) @call
+
+(call
+  function: (attribute
+    attribute: (identifier) @call.name)) @call
+
+; Heritage queries - Python class inheritance
+(class_definition
+  name: (identifier) @heritage.class
+  superclasses: (argument_list
+    (identifier) @heritage.extends)) @heritage
+`;
+// Java queries - works with tree-sitter-java
+export const JAVA_QUERIES = `
+; Classes, Interfaces, Enums, Annotations
+(class_declaration name: (identifier) @name) @definition.class
+(interface_declaration name: (identifier) @name) @definition.interface
+(enum_declaration name: (identifier) @name) @definition.enum
+(annotation_type_declaration name: (identifier) @name) @definition.annotation
+
+; Methods & Constructors
+(method_declaration name: (identifier) @name) @definition.method
+(constructor_declaration name: (identifier) @name) @definition.constructor
+
+; Imports - capture any import declaration child as source
+(import_declaration (_) @import.source) @import
+
+; Calls
+(method_invocation name: (identifier) @call.name) @call
+(method_invocation object: (_) name: (identifier) @call.name) @call
+
+; Heritage - extends class
+(class_declaration name: (identifier) @heritage.class
+  (superclass (type_identifier) @heritage.extends)) @heritage
+
+; Heritage - implements interfaces
+(class_declaration name: (identifier) @heritage.class
+  (super_interfaces (type_list (type_identifier) @heritage.implements))) @heritage.impl
+`;
+// C queries - works with tree-sitter-c
+export const C_QUERIES = `
+; Functions
+(function_definition declarator: (function_declarator declarator: (identifier) @name)) @definition.function
+(declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.function
+
+; Structs, Unions, Enums, Typedefs
+(struct_specifier name: (type_identifier) @name) @definition.struct
+(union_specifier name: (type_identifier) @name) @definition.union
+(enum_specifier name: (type_identifier) @name) @definition.enum
+(type_definition declarator: (type_identifier) @name) @definition.typedef
+
+; Macros
+(preproc_function_def name: (identifier) @name) @definition.macro
+(preproc_def name: (identifier) @name) @definition.macro
+
+; Includes
+(preproc_include path: (_) @import.source) @import
+
+; Calls
+(call_expression function: (identifier) @call.name) @call
+(call_expression function: (field_expression field: (field_identifier) @call.name)) @call
+`;
+// Go queries - works with tree-sitter-go
+export const GO_QUERIES = `
+; Functions & Methods
+(function_declaration name: (identifier) @name) @definition.function
+(method_declaration name: (field_identifier) @name) @definition.method
+
+; Types
+(type_declaration (type_spec name: (type_identifier) @name type: (struct_type))) @definition.struct
+(type_declaration (type_spec name: (type_identifier) @name type: (interface_type))) @definition.interface
+(type_declaration (type_spec name: (type_identifier) @name)) @definition.type
+
+; Imports
+(import_declaration (import_spec path: (interpreted_string_literal) @import.source)) @import
+(import_declaration (import_spec_list (import_spec path: (interpreted_string_literal) @import.source))) @import
+
+; Calls
+(call_expression function: (identifier) @call.name) @call
+(call_expression function: (selector_expression field: (field_identifier) @call.name)) @call
+`;
+// C++ queries - works with tree-sitter-cpp
+export const CPP_QUERIES = `
+; Classes, Structs, Namespaces
+(class_specifier name: (type_identifier) @name) @definition.class
+(struct_specifier name: (type_identifier) @name) @definition.struct
+(namespace_definition name: (namespace_identifier) @name) @definition.namespace
+(enum_specifier name: (type_identifier) @name) @definition.enum
+
+; Functions & Methods
+(function_definition declarator: (function_declarator declarator: (identifier) @name)) @definition.function
+(function_definition declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name))) @definition.method
+
+; Templates
+(template_declaration (class_specifier name: (type_identifier) @name)) @definition.template
+(template_declaration (function_definition declarator: (function_declarator declarator: (identifier) @name))) @definition.template
+
+; Includes
+(preproc_include path: (_) @import.source) @import
+
+; Calls
+(call_expression function: (identifier) @call.name) @call
+(call_expression function: (field_expression field: (field_identifier) @call.name)) @call
+(call_expression function: (qualified_identifier name: (identifier) @call.name)) @call
+(call_expression function: (template_function name: (identifier) @call.name)) @call
+
+; Heritage
+(class_specifier name: (type_identifier) @heritage.class
+  (base_class_clause (type_identifier) @heritage.extends)) @heritage
+(class_specifier name: (type_identifier) @heritage.class
+  (base_class_clause (access_specifier) (type_identifier) @heritage.extends)) @heritage
+`;
+// C# queries - works with tree-sitter-c-sharp
+export const CSHARP_QUERIES = `
+; Types
+(class_declaration name: (identifier) @name) @definition.class
+(interface_declaration name: (identifier) @name) @definition.interface
+(struct_declaration name: (identifier) @name) @definition.struct
+(enum_declaration name: (identifier) @name) @definition.enum
+(record_declaration name: (identifier) @name) @definition.record
+(delegate_declaration name: (identifier) @name) @definition.delegate
+
+; Namespaces
+(namespace_declaration name: (identifier) @name) @definition.namespace
+(namespace_declaration name: (qualified_name) @name) @definition.namespace
+
+; Methods & Properties
+(method_declaration name: (identifier) @name) @definition.method
+(local_function_statement name: (identifier) @name) @definition.function
+(constructor_declaration name: (identifier) @name) @definition.constructor
+(property_declaration name: (identifier) @name) @definition.property
+
+; Using
+(using_directive (qualified_name) @import.source) @import
+(using_directive (identifier) @import.source) @import
+
+; Calls
+(invocation_expression function: (identifier) @call.name) @call
+(invocation_expression function: (member_access_expression name: (identifier) @call.name)) @call
+
+; Heritage
+(class_declaration name: (identifier) @heritage.class
+  (base_list (simple_base_type (identifier) @heritage.extends))) @heritage
+(class_declaration name: (identifier) @heritage.class
+  (base_list (simple_base_type (generic_name (identifier) @heritage.extends)))) @heritage
+`;
+// Rust queries - works with tree-sitter-rust
+export const RUST_QUERIES = `
+; Functions & Items
+(function_item name: (identifier) @name) @definition.function
+(struct_item name: (type_identifier) @name) @definition.struct
+(enum_item name: (type_identifier) @name) @definition.enum
+(trait_item name: (type_identifier) @name) @definition.trait
+(impl_item type: (type_identifier) @name) @definition.impl
+(mod_item name: (identifier) @name) @definition.module
+
+; Type aliases, const, static, macros
+(type_item name: (type_identifier) @name) @definition.type
+(const_item name: (identifier) @name) @definition.const
+(static_item name: (identifier) @name) @definition.static
+(macro_definition name: (identifier) @name) @definition.macro
+
+; Use statements
+(use_declaration argument: (_) @import.source) @import
+
+; Calls
+(call_expression function: (identifier) @call.name) @call
+(call_expression function: (field_expression field: (field_identifier) @call.name)) @call
+(call_expression function: (scoped_identifier name: (identifier) @call.name)) @call
+(call_expression function: (generic_function function: (identifier) @call.name)) @call
+
+; Heritage (trait implementation)
+(impl_item trait: (type_identifier) @heritage.trait type: (type_identifier) @heritage.class) @heritage
+(impl_item trait: (generic_type type: (type_identifier) @heritage.trait) type: (type_identifier) @heritage.class) @heritage
+`;
+export const LANGUAGE_QUERIES = {
+    [SupportedLanguages.TypeScript]: TYPESCRIPT_QUERIES,
+    [SupportedLanguages.JavaScript]: JAVASCRIPT_QUERIES,
+    [SupportedLanguages.Python]: PYTHON_QUERIES,
+    [SupportedLanguages.Java]: JAVA_QUERIES,
+    [SupportedLanguages.C]: C_QUERIES,
+    [SupportedLanguages.Go]: GO_QUERIES,
+    [SupportedLanguages.CPlusPlus]: CPP_QUERIES,
+    [SupportedLanguages.CSharp]: CSHARP_QUERIES,
+    [SupportedLanguages.Rust]: RUST_QUERIES,
+};

package/dist/core/ingestion/utils.d.ts

@@ -0,0 +1,10 @@
+import { SupportedLanguages } from '../../config/supported-languages.js';
+/**
+ * Yield control to the event loop so spinners/progress can render.
+ * Call periodically in hot loops to prevent UI freezes.
+ */
+export declare const yieldToEventLoop: () => Promise<void>;
+/**
+ * Map file extension to SupportedLanguage enum
+ */
+export declare const getLanguageFromFilename: (filename: string) => SupportedLanguages | null;

package/dist/core/ingestion/utils.js

@@ -0,0 +1,44 @@
+import { SupportedLanguages } from '../../config/supported-languages.js';
+/**
+ * Yield control to the event loop so spinners/progress can render.
+ * Call periodically in hot loops to prevent UI freezes.
+ */
+export const yieldToEventLoop = () => new Promise(resolve => setImmediate(resolve));
+/**
+ * Map file extension to SupportedLanguage enum
+ */
+export const getLanguageFromFilename = (filename) => {
+    // TypeScript (including TSX)
+    if (filename.endsWith('.tsx'))
+        return SupportedLanguages.TypeScript;
+    if (filename.endsWith('.ts'))
+        return SupportedLanguages.TypeScript;
+    // JavaScript (including JSX)
+    if (filename.endsWith('.jsx'))
+        return SupportedLanguages.JavaScript;
+    if (filename.endsWith('.js'))
+        return SupportedLanguages.JavaScript;
+    // Python
+    if (filename.endsWith('.py'))
+        return SupportedLanguages.Python;
+    // Java
+    if (filename.endsWith('.java'))
+        return SupportedLanguages.Java;
+    // C (source and headers)
+    if (filename.endsWith('.c') || filename.endsWith('.h'))
+        return SupportedLanguages.C;
+    // C++ (all common extensions)
+    if (filename.endsWith('.cpp') || filename.endsWith('.cc') || filename.endsWith('.cxx') ||
+        filename.endsWith('.hpp') || filename.endsWith('.hxx') || filename.endsWith('.hh'))
+        return SupportedLanguages.CPlusPlus;
+    // C#
+    if (filename.endsWith('.cs'))
+        return SupportedLanguages.CSharp;
+    // Go
+    if (filename.endsWith('.go'))
+        return SupportedLanguages.Go;
+    // Rust
+    if (filename.endsWith('.rs'))
+        return SupportedLanguages.Rust;
+    return null;
+};

package/dist/core/kuzu/csv-generator.d.ts

@@ -0,0 +1,22 @@
+/**
+ * CSV Generator for KuzuDB Hybrid Schema
+ *
+ * Generates separate CSV files for each node table and one relation CSV.
+ * This enables efficient bulk loading via COPY FROM for hybrid schema.
+ *
+ * RFC 4180 Compliant:
+ * - Fields containing commas, double quotes, or newlines are enclosed in double quotes
+ * - Double quotes within fields are escaped by doubling them ("")
+ * - All fields are consistently quoted for safety with code content
+ */
+import { KnowledgeGraph } from '../graph/types.js';
+import { NodeTableName } from './schema.js';
+export interface CSVData {
+    nodes: Map<NodeTableName, string>;
+    relCSV: string;
+}
+/**
+ * Generate all CSV data for hybrid schema bulk loading
+ * Returns Maps of node table name -> CSV content, and single relation CSV
+ */
+export declare const generateAllCSVs: (graph: KnowledgeGraph, fileContents: Map<string, string>) => CSVData;

package/dist/core/kuzu/csv-generator.js

@@ -0,0 +1,272 @@
+/**
+ * CSV Generator for KuzuDB Hybrid Schema
+ *
+ * Generates separate CSV files for each node table and one relation CSV.
+ * This enables efficient bulk loading via COPY FROM for hybrid schema.
+ *
+ * RFC 4180 Compliant:
+ * - Fields containing commas, double quotes, or newlines are enclosed in double quotes
+ * - Double quotes within fields are escaped by doubling them ("")
+ * - All fields are consistently quoted for safety with code content
+ */
+// ============================================================================
+// CSV ESCAPE UTILITIES
+// ============================================================================
+/**
+ * Sanitize string to ensure valid UTF-8 and safe CSV content for KuzuDB
+ * Removes or replaces invalid characters that would break CSV parsing.
+ *
+ * Critical: KuzuDB's native CSV parser on Windows can misinterpret \r\n
+ * inside quoted fields. We normalize all line endings to \n only.
+ */
+const sanitizeUTF8 = (str) => {
+    return str
+        .replace(/\r\n/g, '\n') // Normalize Windows line endings first
+        .replace(/\r/g, '\n') // Normalize remaining \r to \n
+        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '') // Remove control chars except \t \n
+        .replace(/[\uD800-\uDFFF]/g, '') // Remove surrogate pairs (invalid standalone)
+        .replace(/[\uFFFE\uFFFF]/g, ''); // Remove BOM and special chars
+};
+/**
+ * RFC 4180 compliant CSV field escaping
+ * ALWAYS wraps in double quotes for safety with code content
+ */
+const escapeCSVField = (value) => {
+    if (value === undefined || value === null) {
+        return '""';
+    }
+    let str = String(value);
+    str = sanitizeUTF8(str);
+    return `"${str.replace(/"/g, '""')}"`;
+};
+/**
+ * Escape a numeric value (no quotes needed for numbers)
+ */
+const escapeCSVNumber = (value, defaultValue = -1) => {
+    if (value === undefined || value === null) {
+        return String(defaultValue);
+    }
+    return String(value);
+};
+// ============================================================================
+// CONTENT EXTRACTION
+// ============================================================================
+/**
+ * Check if content looks like binary data
+ */
+const isBinaryContent = (content) => {
+    if (!content || content.length === 0)
+        return false;
+    const sample = content.slice(0, 1000);
+    let nonPrintable = 0;
+    for (let i = 0; i < sample.length; i++) {
+        const code = sample.charCodeAt(i);
+        if ((code < 9) || (code > 13 && code < 32) || code === 127) {
+            nonPrintable++;
+        }
+    }
+    return (nonPrintable / sample.length) > 0.1;
+};
+/**
+ * Extract code content for a node
+ */
+const extractContent = (node, fileContents) => {
+    const filePath = node.properties.filePath;
+    const content = fileContents.get(filePath);
+    if (!content)
+        return '';
+    if (node.label === 'Folder')
+        return '';
+    if (isBinaryContent(content))
+        return '[Binary file - content not stored]';
+    // For File nodes, return content (limited)
+    if (node.label === 'File') {
+        const MAX_FILE_CONTENT = 10000;
+        if (content.length > MAX_FILE_CONTENT) {
+            return content.slice(0, MAX_FILE_CONTENT) + '\n... [truncated]';
+        }
+        return content;
+    }
+    // For code elements, extract the relevant lines with context
+    const startLine = node.properties.startLine;
+    const endLine = node.properties.endLine;
+    if (startLine === undefined || endLine === undefined)
+        return '';
+    const lines = content.split('\n');
+    const contextLines = 2;
+    const start = Math.max(0, startLine - contextLines);
+    const end = Math.min(lines.length - 1, endLine + contextLines);
+    const snippet = lines.slice(start, end + 1).join('\n');
+    const MAX_SNIPPET = 5000;
+    if (snippet.length > MAX_SNIPPET) {
+        return snippet.slice(0, MAX_SNIPPET) + '\n... [truncated]';
+    }
+    return snippet;
+};
+// ============================================================================
+// NODE CSV GENERATORS
+// ============================================================================
+/**
+ * Generate CSV for File nodes
+ * Headers: id,name,filePath,content
+ */
+const generateFileCSV = (nodes, fileContents) => {
+    const headers = ['id', 'name', 'filePath', 'content'];
+    const rows = [headers.join(',')];
+    const seenIds = new Set();
+    for (const node of nodes) {
+        if (node.label !== 'File')
+            continue;
+        // Skip duplicates
+        if (seenIds.has(node.id))
+            continue;
+        seenIds.add(node.id);
+        const content = extractContent(node, fileContents);
+        rows.push([
+            escapeCSVField(node.id),
+            escapeCSVField(node.properties.name || ''),
+            escapeCSVField(node.properties.filePath || ''),
+            escapeCSVField(content),
+        ].join(','));
+    }
+    return rows.join('\n');
+};
+/**
+ * Generate CSV for Folder nodes
+ * Headers: id,name,filePath
+ */
+const generateFolderCSV = (nodes) => {
+    const headers = ['id', 'name', 'filePath'];
+    const rows = [headers.join(',')];
+    for (const node of nodes) {
+        if (node.label !== 'Folder')
+            continue;
+        rows.push([
+            escapeCSVField(node.id),
+            escapeCSVField(node.properties.name || ''),
+            escapeCSVField(node.properties.filePath || ''),
+        ].join(','));
+    }
+    return rows.join('\n');
+};
+/**
+ * Generate CSV for code element nodes (Function, Class, Interface, Method, CodeElement)
+ * Headers: id,name,filePath,startLine,endLine,isExported,content
+ */
+const generateCodeElementCSV = (nodes, label, fileContents) => {
+    const headers = ['id', 'name', 'filePath', 'startLine', 'endLine', 'isExported', 'content'];
+    const rows = [headers.join(',')];
+    for (const node of nodes) {
+        if (node.label !== label)
+            continue;
+        const content = extractContent(node, fileContents);
+        rows.push([
+            escapeCSVField(node.id),
+            escapeCSVField(node.properties.name || ''),
+            escapeCSVField(node.properties.filePath || ''),
+            escapeCSVNumber(node.properties.startLine, -1),
+            escapeCSVNumber(node.properties.endLine, -1),
+            node.properties.isExported ? 'true' : 'false',
+            escapeCSVField(content),
+        ].join(','));
+    }
+    return rows.join('\n');
+};
+/**
+ * Generate CSV for Community nodes (from Leiden algorithm)
+ * Headers: id,label,heuristicLabel,keywords,description,enrichedBy,cohesion,symbolCount
+ */
+const generateCommunityCSV = (nodes) => {
+    const headers = ['id', 'label', 'heuristicLabel', 'keywords', 'description', 'enrichedBy', 'cohesion', 'symbolCount'];
+    const rows = [headers.join(',')];
+    for (const node of nodes) {
+        if (node.label !== 'Community')
+            continue;
+        // Handle keywords array - convert to KuzuDB array format
+        const keywords = node.properties.keywords || [];
+        const keywordsStr = `[${keywords.map((k) => `'${k.replace(/'/g, "''")}'`).join(',')}]`;
+        rows.push([
+            escapeCSVField(node.id),
+            escapeCSVField(node.properties.name || ''), // label is stored in name
+            escapeCSVField(node.properties.heuristicLabel || ''),
+            keywordsStr, // Array format for KuzuDB
+            escapeCSVField(node.properties.description || ''),
+            escapeCSVField(node.properties.enrichedBy || 'heuristic'),
+            escapeCSVNumber(node.properties.cohesion, 0),
+            escapeCSVNumber(node.properties.symbolCount, 0),
+        ].join(','));
+    }
+    return rows.join('\n');
+};
+/**
+ * Generate CSV for Process nodes
+ * Headers: id,label,heuristicLabel,processType,stepCount,communities,entryPointId,terminalId
+ */
+const generateProcessCSV = (nodes) => {
+    const headers = ['id', 'label', 'heuristicLabel', 'processType', 'stepCount', 'communities', 'entryPointId', 'terminalId'];
+    const rows = [headers.join(',')];
+    for (const node of nodes) {
+        if (node.label !== 'Process')
+            continue;
+        // Handle communities array (string[])
+        const communities = node.properties.communities || [];
+        const communitiesStr = `[${communities.map((c) => `'${c.replace(/'/g, "''")}'`).join(',')}]`;
+        rows.push([
+            escapeCSVField(node.id),
+            escapeCSVField(node.properties.name || ''), // label stores name
+            escapeCSVField(node.properties.heuristicLabel || ''),
+            escapeCSVField(node.properties.processType || ''),
+            escapeCSVNumber(node.properties.stepCount, 0),
+            escapeCSVField(communitiesStr), // Needs CSV escaping because it contains commas!
+            escapeCSVField(node.properties.entryPointId || ''),
+            escapeCSVField(node.properties.terminalId || ''),
+        ].join(','));
+    }
+    return rows.join('\n');
+};
+/**
+ * Generate CSV for the single CodeRelation table
+ * Headers: from,to,type,confidence,reason
+ *
+ * confidence: 0-1 score for CALLS edges (how sure are we about the target?)
+ * reason: 'import-resolved' | 'same-file' | 'fuzzy-global' (or empty for non-CALLS)
+ */
+const generateRelationCSV = (graph) => {
+    const headers = ['from', 'to', 'type', 'confidence', 'reason', 'step'];
+    const rows = [headers.join(',')];
+    for (const rel of graph.relationships) {
+        rows.push([
+            escapeCSVField(rel.sourceId),
+            escapeCSVField(rel.targetId),
+            escapeCSVField(rel.type),
+            escapeCSVNumber(rel.confidence, 1.0),
+            escapeCSVField(rel.reason),
+            escapeCSVNumber(rel.step, 0),
+        ].join(','));
+    }
+    return rows.join('\n');
+};
+// ============================================================================
+// MAIN CSV GENERATION FUNCTION
+// ============================================================================
+/**
+ * Generate all CSV data for hybrid schema bulk loading
+ * Returns Maps of node table name -> CSV content, and single relation CSV
+ */
+export const generateAllCSVs = (graph, fileContents) => {
+    const nodes = Array.from(graph.nodes);
+    // Generate node CSVs
+    const nodeCSVs = new Map();
+    nodeCSVs.set('File', generateFileCSV(nodes, fileContents));
+    nodeCSVs.set('Folder', generateFolderCSV(nodes));
+    nodeCSVs.set('Function', generateCodeElementCSV(nodes, 'Function', fileContents));
+    nodeCSVs.set('Class', generateCodeElementCSV(nodes, 'Class', fileContents));
+    nodeCSVs.set('Interface', generateCodeElementCSV(nodes, 'Interface', fileContents));
+    nodeCSVs.set('Method', generateCodeElementCSV(nodes, 'Method', fileContents));
+    nodeCSVs.set('CodeElement', generateCodeElementCSV(nodes, 'CodeElement', fileContents));
+    nodeCSVs.set('Community', generateCommunityCSV(nodes));
+    nodeCSVs.set('Process', generateProcessCSV(nodes));
+    // Generate single relation CSV
+    const relCSV = generateRelationCSV(graph);
+    return { nodes: nodeCSVs, relCSV };
+};