gitnexus 1.4.10 → 1.5.0

package/dist/core/ingestion/workers/worker-pool.js

@@ -72,31 +72,26 @@ export const createWorkerPool = (workerUrl, poolSize) => {
                 const handler = (msg) => {
                     if (settled)
                         return;
-                    if (msg && msg.type === 'progress') {
+                    if (msg.type === 'progress') {
                         workerProgress[i] = msg.filesProcessed;
                         if (onProgress) {
                             const total = workerProgress.reduce((a, b) => a + b, 0);
                             onProgress(total);
                         }
                     }
-                    else if (msg && msg.type === 'sub-batch-done') {
+                    else if (msg.type === 'sub-batch-done') {
                         sendNextSubBatch();
                     }
-                    else if (msg && msg.type === 'error') {
+                    else if (msg.type === 'error') {
                         settled = true;
                         cleanup();
                         reject(new Error(`Worker ${i} error: ${msg.error}`));
                     }
-                    else if (msg && msg.type === 'result') {
+                    else if (msg.type === 'result') {
                         settled = true;
                         cleanup();
                         resolve(msg.data);
                     }
-                    else {
-                        settled = true;
-                        cleanup();
-                        resolve(msg);
-                    }
                 };
                 const errorHandler = (err) => {
                     if (!settled) {
@@ -121,7 +116,7 @@ export const createWorkerPool = (workerUrl, poolSize) => {
         return Promise.all(promises);
     };
     const terminate = async () => {
-        await Promise.all(workers.map(w => w.terminate()));
+        await Promise.all(workers.map((w) => w.terminate()));
         workers.length = 0;
     };
     return { dispatch, terminate, size };

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

@@ -49,10 +49,10 @@ export const isBinaryContent = (content) => {
     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)
+        if (code < 9 || (code > 13 && code < 32) || code === 127)
             nonPrintable++;
     }
-    return (nonPrintable / sample.length) > 0.1;
+    return nonPrintable / sample.length > 0.1;
 };
 /**
  * LRU content cache — avoids re-reading the same source file for every
@@ -216,17 +216,35 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
     const toolWriter = new BufferedCSVWriter(path.join(csvDir, 'tool.csv'), 'id,name,filePath,description');
     // Multi-language node types share the same CSV shape (no isExported column)
     const multiLangHeader = 'id,name,filePath,startLine,endLine,content,description';
-    const MULTI_LANG_TYPES = ['Struct', 'Enum', 'Macro', 'Typedef', 'Union', 'Namespace', 'Trait', 'Impl',
-        'TypeAlias', 'Const', 'Static', 'Property', 'Record', 'Delegate', 'Annotation', 'Constructor', 'Template', 'Module'];
+    const MULTI_LANG_TYPES = [
+        'Struct',
+        'Enum',
+        'Macro',
+        'Typedef',
+        'Union',
+        'Namespace',
+        'Trait',
+        'Impl',
+        'TypeAlias',
+        'Const',
+        'Static',
+        'Property',
+        'Record',
+        'Delegate',
+        'Annotation',
+        'Constructor',
+        'Template',
+        'Module',
+    ];
     const multiLangWriters = new Map();
     for (const t of MULTI_LANG_TYPES) {
         multiLangWriters.set(t, new BufferedCSVWriter(path.join(csvDir, `${t.toLowerCase()}.csv`), multiLangHeader));
     }
     const codeWriterMap = {
-        'Function': functionWriter,
-        'Class': classWriter,
-        'Interface': interfaceWriter,
-        'CodeElement': codeElemWriter,
+        Function: functionWriter,
+        Class: classWriter,
+        Interface: interfaceWriter,
+        CodeElement: codeElemWriter,
     };
     const seenFileIds = new Set();
     // --- SINGLE PASS over all nodes ---
@@ -376,8 +394,22 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
         }
     }
     // Finish all node writers
-    const allWriters = [fileWriter, folderWriter, functionWriter, classWriter, interfaceWriter, methodWriter, codeElemWriter, communityWriter, processWriter, sectionWriter, routeWriter, toolWriter, ...multiLangWriters.values()];
-    await Promise.all(allWriters.map(w => w.finish()));
+    const allWriters = [
+        fileWriter,
+        folderWriter,
+        functionWriter,
+        classWriter,
+        interfaceWriter,
+        methodWriter,
+        codeElemWriter,
+        communityWriter,
+        processWriter,
+        sectionWriter,
+        routeWriter,
+        toolWriter,
+        ...multiLangWriters.values(),
+    ];
+    await Promise.all(allWriters.map((w) => w.finish()));
     // --- Stream relationship CSV ---
     const relCsvPath = path.join(csvDir, 'relations.csv');
     const relWriter = new BufferedCSVWriter(relCsvPath, 'from,to,type,confidence,reason,step');
@@ -395,11 +427,15 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
     // Build result map — only include tables that have rows
     const nodeFiles = new Map();
     const tableMap = [
-        ['File', fileWriter], ['Folder', folderWriter],
-        ['Function', functionWriter], ['Class', classWriter],
-        ['Interface', interfaceWriter], ['Method', methodWriter],
+        ['File', fileWriter],
+        ['Folder', folderWriter],
+        ['Function', functionWriter],
+        ['Class', classWriter],
+        ['Interface', interfaceWriter],
+        ['Method', methodWriter],
         ['CodeElement', codeElemWriter],
-        ['Community', communityWriter], ['Process', processWriter],
+        ['Community', communityWriter],
+        ['Process', processWriter],
         ['Section', sectionWriter],
         ['Route', routeWriter],
         ['Tool', toolWriter],
@@ -407,7 +443,10 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
     ];
     for (const [name, writer] of tableMap) {
         if (writer.rows > 0) {
-            nodeFiles.set(name, { csvPath: path.join(csvDir, `${name.toLowerCase()}.csv`), rows: writer.rows });
+            nodeFiles.set(name, {
+                csvPath: path.join(csvDir, `${name.toLowerCase()}.csv`),
+                rows: writer.rows,
+            });
         }
     }
     // Restore original process listener limit

package/dist/core/lbug/lbug-adapter.d.ts

@@ -49,6 +49,11 @@ export declare const batchInsertNodesToLbug: (nodes: Array<{
     failed: number;
 }>;
 export declare const executeQuery: (cypher: string) => Promise<any[]>;
+/**
+ * Execute a single parameterized query (prepare/execute pattern).
+ * Prevents Cypher injection by binding values as parameters.
+ */
+export declare const executePrepared: (cypher: string, params: Record<string, any>) => Promise<any[]>;
 export declare const executeWithReusedStatement: (cypher: string, paramsList: Array<Record<string, any>>) => Promise<void>;
 export declare const getLbugStats: () => Promise<{
     nodes: number;

package/dist/core/lbug/lbug-adapter.js

@@ -25,15 +25,15 @@ const DB_LOCK_RETRY_DELAY_MS = 500;
  */
 export const isDbBusyError = (err) => {
     const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
-    return (msg.includes('busy')
-        || msg.includes('lock')
-        || msg.includes('already in use')
-        || msg.includes('could not set lock'));
+    return (msg.includes('busy') ||
+        msg.includes('lock') ||
+        msg.includes('already in use') ||
+        msg.includes('could not set lock'));
 };
 const runWithSessionLock = async (operation) => {
     const previous = sessionLock;
     let release = null;
-    sessionLock = new Promise(resolve => {
+    sessionLock = new Promise((resolve) => {
         release = resolve;
     });
     await previous;
@@ -77,19 +77,23 @@ export const withLbugDb = async (dbPath, operation) => {
                     if (conn)
                         await conn.close();
                 }
-                catch { /* best-effort */ }
+                catch {
+                    /* best-effort */
+                }
                 try {
                     if (db)
                         await db.close();
                 }
-                catch { /* best-effort */ }
+                catch {
+                    /* best-effort */
+                }
                 conn = null;
                 db = null;
                 currentDbPath = null;
                 ftsLoaded = false;
             });
             // Sleep outside the lock — no need to block others while waiting
-            await new Promise(resolve => setTimeout(resolve, DB_LOCK_RETRY_DELAY_MS * attempt));
+            await new Promise((resolve) => setTimeout(resolve, DB_LOCK_RETRY_DELAY_MS * attempt));
         }
     }
     // This line is unreachable — the loop either returns or throws inside,
@@ -212,7 +216,10 @@ export const loadGraphToLbug = async (graph, repoPath, storagePath, onProgress)
     let skippedRels = 0;
     let totalValidRels = 0;
     await new Promise((resolve, reject) => {
-        const rl = createInterface({ input: createReadStream(csvResult.relCsvPath, 'utf-8'), crlfDelay: Infinity });
+        const rl = createInterface({
+            input: createReadStream(csvResult.relCsvPath, 'utf-8'),
+            crlfDelay: Infinity,
+        });
         let isFirst = true;
         rl.on('line', (line) => {
             if (isFirst) {
@@ -322,9 +329,24 @@ const COPY_CSV_OPTS = `(HEADER=true, ESCAPE='"', DELIM=',', QUOTE='"', PARALLEL=
 // Multi-language table names that were created with backticks in CODE_ELEMENT_BASE
 // and must always be referenced with backticks in queries
 const BACKTICK_TABLES = new Set([
-    'Struct', 'Enum', 'Macro', 'Typedef', 'Union', 'Namespace', 'Trait', 'Impl',
-    'TypeAlias', 'Const', 'Static', 'Property', 'Record', 'Delegate', 'Annotation',
-    'Constructor', 'Template', 'Module',
+    'Struct',
+    'Enum',
+    'Macro',
+    'Typedef',
+    'Union',
+    'Namespace',
+    'Trait',
+    'Impl',
+    'TypeAlias',
+    'Const',
+    'Static',
+    'Property',
+    'Record',
+    'Delegate',
+    'Annotation',
+    'Constructor',
+    'Template',
+    'Module',
 ]);
 const escapeTableName = (table) => {
     return BACKTICK_TABLES.has(table) ? `\`${table}\`` : table;
@@ -362,7 +384,13 @@ const fallbackRelationshipInserts = async (validRelLines, validTables, getNodeLa
     }
 };
 /** Tables with isExported column (TypeScript/JS-native types) */
-const TABLES_WITH_EXPORTED = new Set(['Function', 'Class', 'Interface', 'Method', 'CodeElement']);
+const TABLES_WITH_EXPORTED = new Set([
+    'Function',
+    'Class',
+    'Interface',
+    'Method',
+    'CodeElement',
+]);
 const getCopyQuery = (table, filePath) => {
     const t = escapeTableName(table);
     if (table === 'File') {
@@ -427,16 +455,22 @@ export const insertNodeToLbug = async (label, properties, dbPath) => {
             query = `CREATE (n:Folder {id: ${escapeValue(properties.id)}, name: ${escapeValue(properties.name)}, filePath: ${escapeValue(properties.filePath)}})`;
         }
         else if (label === 'Section') {
-            const descPart = properties.description ? `, description: ${escapeValue(properties.description)}` : '';
+            const descPart = properties.description
+                ? `, description: ${escapeValue(properties.description)}`
+                : '';
             query = `CREATE (n:Section {id: ${escapeValue(properties.id)}, name: ${escapeValue(properties.name)}, filePath: ${escapeValue(properties.filePath)}, startLine: ${properties.startLine || 0}, endLine: ${properties.endLine || 0}, level: ${properties.level || 1}, content: ${escapeValue(properties.content || '')}${descPart}})`;
         }
         else if (TABLES_WITH_EXPORTED.has(label)) {
-            const descPart = properties.description ? `, description: ${escapeValue(properties.description)}` : '';
+            const descPart = properties.description
+                ? `, description: ${escapeValue(properties.description)}`
+                : '';
             query = `CREATE (n:${t} {id: ${escapeValue(properties.id)}, name: ${escapeValue(properties.name)}, filePath: ${escapeValue(properties.filePath)}, startLine: ${properties.startLine || 0}, endLine: ${properties.endLine || 0}, isExported: ${!!properties.isExported}, content: ${escapeValue(properties.content || '')}${descPart}})`;
         }
         else {
             // Multi-language tables (Struct, Impl, Trait, Macro, etc.) — no isExported
-            const descPart = properties.description ? `, description: ${escapeValue(properties.description)}` : '';
+            const descPart = properties.description
+                ? `, description: ${escapeValue(properties.description)}`
+                : '';
             query = `CREATE (n:${t} {id: ${escapeValue(properties.id)}, name: ${escapeValue(properties.name)}, filePath: ${escapeValue(properties.filePath)}, startLine: ${properties.startLine || 0}, endLine: ${properties.endLine || 0}, content: ${escapeValue(properties.content || '')}${descPart}})`;
         }
         // Use per-query connection if dbPath provided (avoids lock conflicts)
@@ -506,15 +540,21 @@ export const batchInsertNodesToLbug = async (nodes, dbPath) => {
                     query = `MERGE (n:Folder {id: ${escapeValue(properties.id)}}) SET n.name = ${escapeValue(properties.name)}, n.filePath = ${escapeValue(properties.filePath)}`;
                 }
                 else if (label === 'Section') {
-                    const descPart = properties.description ? `, n.description = ${escapeValue(properties.description)}` : '';
+                    const descPart = properties.description
+                        ? `, n.description = ${escapeValue(properties.description)}`
+                        : '';
                     query = `MERGE (n:Section {id: ${escapeValue(properties.id)}}) SET n.name = ${escapeValue(properties.name)}, n.filePath = ${escapeValue(properties.filePath)}, n.startLine = ${properties.startLine || 0}, n.endLine = ${properties.endLine || 0}, n.level = ${properties.level || 1}, n.content = ${escapeValue(properties.content || '')}${descPart}`;
                 }
                 else if (TABLES_WITH_EXPORTED.has(label)) {
-                    const descPart = properties.description ? `, n.description = ${escapeValue(properties.description)}` : '';
+                    const descPart = properties.description
+                        ? `, n.description = ${escapeValue(properties.description)}`
+                        : '';
                     query = `MERGE (n:${t} {id: ${escapeValue(properties.id)}}) SET n.name = ${escapeValue(properties.name)}, n.filePath = ${escapeValue(properties.filePath)}, n.startLine = ${properties.startLine || 0}, n.endLine = ${properties.endLine || 0}, n.isExported = ${!!properties.isExported}, n.content = ${escapeValue(properties.content || '')}${descPart}`;
                 }
                 else {
-                    const descPart = properties.description ? `, n.description = ${escapeValue(properties.description)}` : '';
+                    const descPart = properties.description
+                        ? `, n.description = ${escapeValue(properties.description)}`
+                        : '';
                     query = `MERGE (n:${t} {id: ${escapeValue(properties.id)}}) SET n.name = ${escapeValue(properties.name)}, n.filePath = ${escapeValue(properties.filePath)}, n.startLine = ${properties.startLine || 0}, n.endLine = ${properties.endLine || 0}, n.content = ${escapeValue(properties.content || '')}${descPart}`;
                 }
                 await tempConn.query(query);
@@ -549,6 +589,23 @@ export const executeQuery = async (cypher) => {
     const rows = await result.getAll();
     return rows;
 };
+/**
+ * Execute a single parameterized query (prepare/execute pattern).
+ * Prevents Cypher injection by binding values as parameters.
+ */
+export const executePrepared = async (cypher, params) => {
+    if (!conn) {
+        throw new Error('LadybugDB not initialized. Call initLbug first.');
+    }
+    const stmt = await conn.prepare(cypher);
+    if (!stmt.isSuccess()) {
+        const errMsg = await stmt.getErrorMessage();
+        throw new Error(`Prepare failed: ${errMsg}`);
+    }
+    const queryResult = await conn.execute(stmt, params);
+    const result = Array.isArray(queryResult) ? queryResult[0] : queryResult;
+    return await result.getAll();
+};
 export const executeWithReusedStatement = async (cypher, paramsList) => {
     if (!conn) {
         throw new Error('LadybugDB not initialized. Call initLbug first.');
@@ -629,12 +686,16 @@ export const loadCachedEmbeddings = async () => {
             if (embedding) {
                 embeddings.push({
                     nodeId,
-                    embedding: Array.isArray(embedding) ? embedding.map(Number) : Array.from(embedding).map(Number),
+                    embedding: Array.isArray(embedding)
+                        ? embedding.map(Number)
+                        : Array.from(embedding).map(Number),
                 });
             }
         }
     }
-    catch { /* embedding table may not exist */ }
+    catch {
+        /* embedding table may not exist */
+    }
     return { embeddingNodeIds, embeddings };
 };
 export const closeLbug = async () => {
@@ -748,7 +809,9 @@ export const loadFTSExtension = async () => {
     }
     catch (err) {
         const msg = err?.message || '';
-        if (msg.includes('already loaded') || msg.includes('already installed') || msg.includes('already exists')) {
+        if (msg.includes('already loaded') ||
+            msg.includes('already installed') ||
+            msg.includes('already exists')) {
             ftsLoaded = true;
         }
         else {
@@ -768,7 +831,7 @@ export const createFTSIndex = async (tableName, indexName, properties, stemmer =
         throw new Error('LadybugDB not initialized. Call initLbug first.');
     }
     await loadFTSExtension();
-    const propList = properties.map(p => `'${p}'`).join(', ');
+    const propList = properties.map((p) => `'${p}'`).join(', ');
     const query = `CALL CREATE_FTS_INDEX('${tableName}', '${indexName}', [${propList}], stemmer := '${stemmer}')`;
     try {
         await conn.query(query);

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

@@ -8,12 +8,9 @@
  * 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", "Section", "Struct", "Enum", "Macro", "Typedef", "Union", "Namespace", "Trait", "Impl", "TypeAlias", "Const", "Static", "Property", "Record", "Delegate", "Annotation", "Constructor", "Template", "Module", "Route", "Tool"];
-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", "HAS_PROPERTY", "ACCESSES", "OVERRIDES", "MEMBER_OF", "STEP_IN_PROCESS", "HANDLES_ROUTE", "FETCHES", "HANDLES_TOOL", "ENTRY_POINT_OF", "WRAPS", "QUERIES"];
-export type RelType = typeof REL_TYPES[number];
-export declare const EMBEDDING_TABLE_NAME = "CodeEmbedding";
+import { NODE_TABLES, REL_TABLE_NAME, REL_TYPES, EMBEDDING_TABLE_NAME } from 'gitnexus-shared';
+export { NODE_TABLES, REL_TABLE_NAME, REL_TYPES, EMBEDDING_TABLE_NAME };
+export type { NodeTableName, RelType } from 'gitnexus-shared';
 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)";

package/dist/core/lbug/schema.js

@@ -8,28 +8,10 @@
  * 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', 'Section',
-    // Multi-language support
-    'Struct', 'Enum', 'Macro', 'Typedef', 'Union', 'Namespace', 'Trait', 'Impl',
-    'TypeAlias', 'Const', 'Static', 'Property', 'Record', 'Delegate', 'Annotation', 'Constructor', 'Template', 'Module',
-    'Route',
-    'Tool'
-];
-// ============================================================================
-// RELATION TABLE
-// ============================================================================
-export const REL_TABLE_NAME = 'CodeRelation';
-// Valid relation types
-// Note: WRAPS is reserved for future middleware graph traversal (not yet emitted)
-export const REL_TYPES = ['CONTAINS', 'DEFINES', 'IMPORTS', 'CALLS', 'EXTENDS', 'IMPLEMENTS', 'HAS_METHOD', 'HAS_PROPERTY', 'ACCESSES', 'OVERRIDES', 'MEMBER_OF', 'STEP_IN_PROCESS', 'HANDLES_ROUTE', 'FETCHES', 'HANDLES_TOOL', 'ENTRY_POINT_OF', 'WRAPS', 'QUERIES'];
-// ============================================================================
-// EMBEDDING TABLE
-// ============================================================================
-export const EMBEDDING_TABLE_NAME = 'CodeEmbedding';
+// Import from shared package (single source of truth) — used in DDL templates below
+import { NODE_TABLES, REL_TABLE_NAME, REL_TYPES, EMBEDDING_TABLE_NAME } from 'gitnexus-shared';
+// Re-export so downstream consumers keep the same import path
+export { NODE_TABLES, REL_TABLE_NAME, REL_TYPES, EMBEDDING_TABLE_NAME };
 // ============================================================================
 // NODE TABLE SCHEMAS
 // ============================================================================
@@ -481,11 +463,5 @@ export const NODE_SCHEMA_QUERIES = [
     // MCP tools
     TOOL_SCHEMA,
 ];
-export const REL_SCHEMA_QUERIES = [
-    RELATION_SCHEMA,
-];
-export const SCHEMA_QUERIES = [
-    ...NODE_SCHEMA_QUERIES,
-    ...REL_SCHEMA_QUERIES,
-    EMBEDDING_SCHEMA,
-];
+export const REL_SCHEMA_QUERIES = [RELATION_SCHEMA];
+export const SCHEMA_QUERIES = [...NODE_SCHEMA_QUERIES, ...REL_SCHEMA_QUERIES, EMBEDDING_SCHEMA];

package/dist/core/run-analyze.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Shared Analysis Orchestrator
+ *
+ * Extracts the core analysis pipeline from the CLI analyze command into a
+ * reusable function that can be called from both the CLI and a server-side
+ * worker process.
+ *
+ * IMPORTANT: This module must NEVER call process.exit(). The caller (CLI
+ * wrapper or server worker) is responsible for process lifecycle.
+ */
+export interface AnalyzeCallbacks {
+    onProgress: (phase: string, percent: number, message: string) => void;
+    onLog?: (message: string) => void;
+}
+export interface AnalyzeOptions {
+    force?: boolean;
+    embeddings?: boolean;
+    skipGit?: boolean;
+    /** Skip AGENTS.md and CLAUDE.md gitnexus block updates. */
+    skipAgentsMd?: boolean;
+}
+export interface AnalyzeResult {
+    repoName: string;
+    repoPath: string;
+    stats: {
+        files?: number;
+        nodes?: number;
+        edges?: number;
+        communities?: number;
+        processes?: number;
+        embeddings?: number;
+    };
+    alreadyUpToDate?: boolean;
+    /** The raw pipeline result — only populated when needed by callers (e.g. skill generation). */
+    pipelineResult?: any;
+}
+export declare const PHASE_LABELS: Record<string, string>;
+/**
+ * Run the full GitNexus analysis pipeline.
+ *
+ * This is the shared core extracted from the CLI `analyze` command. It
+ * handles: pipeline execution, LadybugDB loading, FTS indexing, embedding
+ * generation, metadata persistence, and AI context file generation.
+ *
+ * The function communicates progress and log messages exclusively through
+ * the {@link AnalyzeCallbacks} interface — it never writes to stdout/stderr
+ * directly and never calls `process.exit()`.
+ */
+export declare function runFullAnalysis(repoPath: string, options: AnalyzeOptions, callbacks: AnalyzeCallbacks): Promise<AnalyzeResult>;