gitnexus 1.4.1 → 1.4.6

package/dist/core/wiki/graph-queries.d.ts

@@ -2,7 +2,7 @@
  * Graph Queries for Wiki Generation
  *
  * Encapsulated Cypher queries against the GitNexus knowledge graph.
- * Uses the MCP-style pooled kuzu-adapter for connection management.
+ * Uses the MCP-style pooled lbug-adapter for connection management.
  */
 export interface FileWithExports {
     filePath: string;
@@ -29,36 +29,12 @@ export interface ProcessInfo {
         type: string;
     }>;
 }
-export interface CommunityFileGroup {
-    communityId: string;
-    label: string;
-    keywords: string[];
-    description: string;
-    cohesion: number;
-    symbolCount: number;
-    files: string[];
-    secondaryFiles: string[];
-}
-export interface InterCommunityEdge {
-    fromLabel: string;
-    toLabel: string;
-    callCount: number;
-    sampleCalls: Array<{
-        fromName: string;
-        toName: string;
-    }>;
-}
-export interface CrossCommunityProcess {
-    label: string;
-    communities: string[];
-    stepCount: number;
-}
 /**
- * Initialize the KuzuDB connection for wiki generation.
+ * Initialize the LadybugDB connection for wiki generation.
  */
-export declare function initWikiDb(kuzuPath: string): Promise<void>;
+export declare function initWikiDb(lbugPath: string): Promise<void>;
 /**
- * Close the KuzuDB connection.
+ * Close the LadybugDB connection.
  */
 export declare function closeWikiDb(): Promise<void>;
 /**
@@ -84,11 +60,6 @@ export declare function getInterModuleCallEdges(filePaths: string[]): Promise<{
     outgoing: CallEdge[];
     incoming: CallEdge[];
 }>;
-/**
- * Get files that are call-graph neighbors of the given files but not in the set.
- * Used to assign new files to existing modules during incremental updates.
- */
-export declare function getCallGraphNeighborFiles(filePaths: string[]): Promise<string[]>;
 /**
  * Get processes (execution flows) that pass through a set of files.
  * Returns top N by step count.
@@ -107,16 +78,3 @@ export declare function getInterModuleEdgesForOverview(moduleFiles: Record<strin
     to: string;
     count: number;
 }>>;
-/**
- * Get community-to-file mapping from Leiden-detected clusters.
- * Each file is assigned to its majority community; secondary memberships tracked separately.
- */
-export declare function getCommunityFileMapping(): Promise<CommunityFileGroup[]>;
-/**
- * Get call edges between communities for inter-module coupling analysis.
- */
-export declare function getInterCommunityCallEdges(): Promise<InterCommunityEdge[]>;
-/**
- * Get cross-community execution flows.
- */
-export declare function getCrossCommunityProcesses(): Promise<CrossCommunityProcess[]>;

package/dist/core/wiki/graph-queries.js

@@ -2,31 +2,31 @@
  * Graph Queries for Wiki Generation
  *
  * Encapsulated Cypher queries against the GitNexus knowledge graph.
- * Uses the MCP-style pooled kuzu-adapter for connection management.
+ * Uses the MCP-style pooled lbug-adapter for connection management.
  */
-import { initKuzu, executeQuery, closeKuzu } from '../../mcp/core/kuzu-adapter.js';
+import { initLbug, executeQuery, closeLbug } from '../../mcp/core/lbug-adapter.js';
 const REPO_ID = '__wiki__';
 /**
- * Initialize the KuzuDB connection for wiki generation.
+ * Initialize the LadybugDB connection for wiki generation.
  */
-export async function initWikiDb(kuzuPath) {
-    await initKuzu(REPO_ID, kuzuPath, { pinned: true });
+export async function initWikiDb(lbugPath) {
+    await initLbug(REPO_ID, lbugPath);
 }
 /**
- * Close the KuzuDB connection.
+ * Close the LadybugDB connection.
  */
 export async function closeWikiDb() {
-    await closeKuzu(REPO_ID);
+    await closeLbug(REPO_ID);
 }
 /**
  * Get all source files with their exported symbol names and types.
  */
 export async function getFilesWithExports() {
-    const rows = await executeQuery(REPO_ID, `
-    MATCH (f:File)-[:CodeRelation {type: 'DEFINES'}]->(n)
-    WHERE n.isExported = true
-    RETURN f.filePath AS filePath, n.name AS name, labels(n)[0] AS type
-    ORDER BY f.filePath
+    const rows = await executeQuery(REPO_ID, `
+    MATCH (f:File)-[:CodeRelation {type: 'DEFINES'}]->(n)
+    WHERE n.isExported = true
+    RETURN f.filePath AS filePath, n.name AS name, labels(n)[0] AS type
+    ORDER BY f.filePath
   `);
     const fileMap = new Map();
     for (const row of rows) {
@@ -46,10 +46,10 @@ export async function getFilesWithExports() {
  * Get all files tracked in the graph (including those with no exports).
  */
 export async function getAllFiles() {
-    const rows = await executeQuery(REPO_ID, `
-    MATCH (f:File)
-    RETURN f.filePath AS filePath
-    ORDER BY f.filePath
+    const rows = await executeQuery(REPO_ID, `
+    MATCH (f:File)
+    RETURN f.filePath AS filePath
+    ORDER BY f.filePath
   `);
     return rows.map(r => r.filePath || r[0]);
 }
@@ -57,11 +57,11 @@ export async function getAllFiles() {
  * Get inter-file call edges (calls between different files).
  */
 export async function getInterFileCallEdges() {
-    const rows = await executeQuery(REPO_ID, `
-    MATCH (a)-[:CodeRelation {type: 'CALLS'}]->(b)
-    WHERE a.filePath <> b.filePath
-    RETURN DISTINCT a.filePath AS fromFile, a.name AS fromName,
-           b.filePath AS toFile, b.name AS toName
+    const rows = await executeQuery(REPO_ID, `
+    MATCH (a)-[:CodeRelation {type: 'CALLS'}]->(b)
+    WHERE a.filePath <> b.filePath
+    RETURN DISTINCT a.filePath AS fromFile, a.name AS fromName,
+           b.filePath AS toFile, b.name AS toName
   `);
     return rows.map(r => ({
         fromFile: r.fromFile || r[0],
@@ -77,11 +77,11 @@ export async function getIntraModuleCallEdges(filePaths) {
     if (filePaths.length === 0)
         return [];
     const fileList = filePaths.map(f => `'${f.replace(/'/g, "''")}'`).join(', ');
-    const rows = await executeQuery(REPO_ID, `
-    MATCH (a)-[:CodeRelation {type: 'CALLS'}]->(b)
-    WHERE a.filePath IN [${fileList}] AND b.filePath IN [${fileList}]
-    RETURN DISTINCT a.filePath AS fromFile, a.name AS fromName,
-           b.filePath AS toFile, b.name AS toName
+    const rows = await executeQuery(REPO_ID, `
+    MATCH (a)-[:CodeRelation {type: 'CALLS'}]->(b)
+    WHERE a.filePath IN [${fileList}] AND b.filePath IN [${fileList}]
+    RETURN DISTINCT a.filePath AS fromFile, a.name AS fromName,
+           b.filePath AS toFile, b.name AS toName
   `);
     return rows.map(r => ({
         fromFile: r.fromFile || r[0],
@@ -97,19 +97,19 @@ export async function getInterModuleCallEdges(filePaths) {
     if (filePaths.length === 0)
         return { outgoing: [], incoming: [] };
     const fileList = filePaths.map(f => `'${f.replace(/'/g, "''")}'`).join(', ');
-    const outRows = await executeQuery(REPO_ID, `
-    MATCH (a)-[:CodeRelation {type: 'CALLS'}]->(b)
-    WHERE a.filePath IN [${fileList}] AND NOT b.filePath IN [${fileList}]
-    RETURN DISTINCT a.filePath AS fromFile, a.name AS fromName,
-           b.filePath AS toFile, b.name AS toName
-    LIMIT 30
+    const outRows = await executeQuery(REPO_ID, `
+    MATCH (a)-[:CodeRelation {type: 'CALLS'}]->(b)
+    WHERE a.filePath IN [${fileList}] AND NOT b.filePath IN [${fileList}]
+    RETURN DISTINCT a.filePath AS fromFile, a.name AS fromName,
+           b.filePath AS toFile, b.name AS toName
+    LIMIT 30
   `);
-    const inRows = await executeQuery(REPO_ID, `
-    MATCH (a)-[:CodeRelation {type: 'CALLS'}]->(b)
-    WHERE NOT a.filePath IN [${fileList}] AND b.filePath IN [${fileList}]
-    RETURN DISTINCT a.filePath AS fromFile, a.name AS fromName,
-           b.filePath AS toFile, b.name AS toName
-    LIMIT 30
+    const inRows = await executeQuery(REPO_ID, `
+    MATCH (a)-[:CodeRelation {type: 'CALLS'}]->(b)
+    WHERE NOT a.filePath IN [${fileList}] AND b.filePath IN [${fileList}]
+    RETURN DISTINCT a.filePath AS fromFile, a.name AS fromName,
+           b.filePath AS toFile, b.name AS toName
+    LIMIT 30
   `);
     return {
         outgoing: outRows.map(r => ({
@@ -126,50 +126,6 @@ export async function getInterModuleCallEdges(filePaths) {
         })),
     };
 }
-/**
- * Get files that are call-graph neighbors of the given files but not in the set.
- * Used to assign new files to existing modules during incremental updates.
- */
-export async function getCallGraphNeighborFiles(filePaths) {
-    if (filePaths.length === 0)
-        return [];
-    const fileList = filePaths.map(f => `'${f.replace(/'/g, "''")}'`).join(', ');
-    const rows = await executeQuery(REPO_ID, `
-    MATCH (a)-[:CodeRelation {type: 'CALLS'}]-(b)
-    WHERE a.filePath IN [${fileList}] AND NOT b.filePath IN [${fileList}]
-    RETURN DISTINCT b.filePath AS neighborFile
-  `);
-    return rows.map(r => r.neighborFile || r[0]);
-}
-/**
- * Shared helper: group step rows by process ID.
- */
-function groupStepsByProcess(procRows, stepRows) {
-    const stepsByProc = new Map();
-    for (const s of stepRows) {
-        const procId = s.processId || s[4];
-        if (!stepsByProc.has(procId))
-            stepsByProc.set(procId, []);
-        stepsByProc.get(procId).push({
-            step: s.step || s[3] || 0,
-            name: s.name || s[0],
-            filePath: s.filePath || s[1],
-            type: s.type || s[2],
-        });
-    }
-    return procRows.map(row => {
-        const procId = row.id || row[0];
-        const steps = stepsByProc.get(procId) || [];
-        steps.sort((a, b) => a.step - b.step);
-        return {
-            id: procId,
-            label: row.label || row[1] || procId,
-            type: row.type || row[2] || 'unknown',
-            stepCount: row.stepCount || row[3] || 0,
-            steps,
-        };
-    });
-}
 /**
  * Get processes (execution flows) that pass through a set of files.
  * Returns top N by step count.
@@ -178,57 +134,78 @@ export async function getProcessesForFiles(filePaths, limit = 5) {
     if (filePaths.length === 0)
         return [];
     const fileList = filePaths.map(f => `'${f.replace(/'/g, "''")}'`).join(', ');
-    // Query 1: Find processes that have steps in the given files
-    const procRows = await executeQuery(REPO_ID, `
-    MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
-    WHERE s.filePath IN [${fileList}]
-    RETURN DISTINCT p.id AS id, p.heuristicLabel AS label,
-           p.processType AS type, p.stepCount AS stepCount
-    ORDER BY stepCount DESC
-    LIMIT ${limit}
+    // Find processes that have steps in the given files
+    const procRows = await executeQuery(REPO_ID, `
+    MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
+    WHERE s.filePath IN [${fileList}]
+    RETURN DISTINCT p.id AS id, p.heuristicLabel AS label,
+           p.processType AS type, p.stepCount AS stepCount
+    ORDER BY stepCount DESC
+    LIMIT ${limit}
   `);
-    if (procRows.length === 0)
-        return [];
-    // Query 2: Fetch ALL steps for ALL matched processes in one query
-    const procIdList = procRows.map(r => {
-        const id = r.id || r[0];
-        return `'${id.replace(/'/g, "''")}'`;
-    }).join(', ');
-    const stepRows = await executeQuery(REPO_ID, `
-    MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
-    WHERE p.id IN [${procIdList}]
-    RETURN s.name AS name, s.filePath AS filePath, labels(s)[0] AS type,
-           r.step AS step, p.id AS processId
-    ORDER BY p.id, r.step
-  `);
-    return groupStepsByProcess(procRows, stepRows);
+    const processes = [];
+    for (const row of procRows) {
+        const procId = row.id || row[0];
+        const label = row.label || row[1] || procId;
+        const type = row.type || row[2] || 'unknown';
+        const stepCount = row.stepCount || row[3] || 0;
+        // Get the full step trace for this process
+        const stepRows = await executeQuery(REPO_ID, `
+      MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process {id: '${procId.replace(/'/g, "''")}'})
+      RETURN s.name AS name, s.filePath AS filePath, labels(s)[0] AS type, r.step AS step
+      ORDER BY r.step
+    `);
+        processes.push({
+            id: procId,
+            label,
+            type,
+            stepCount,
+            steps: stepRows.map(s => ({
+                step: s.step || s[3] || 0,
+                name: s.name || s[0],
+                filePath: s.filePath || s[1],
+                type: s.type || s[2],
+            })),
+        });
+    }
+    return processes;
 }
 /**
  * Get all processes in the graph (for overview page).
  */
 export async function getAllProcesses(limit = 20) {
-    const procRows = await executeQuery(REPO_ID, `
-    MATCH (p:Process)
-    RETURN p.id AS id, p.heuristicLabel AS label,
-           p.processType AS type, p.stepCount AS stepCount
-    ORDER BY stepCount DESC
-    LIMIT ${limit}
-  `);
-    if (procRows.length === 0)
-        return [];
-    // Batch fetch all steps for all matched processes
-    const procIdList = procRows.map(r => {
-        const id = r.id || r[0];
-        return `'${id.replace(/'/g, "''")}'`;
-    }).join(', ');
-    const stepRows = await executeQuery(REPO_ID, `
-    MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
-    WHERE p.id IN [${procIdList}]
-    RETURN s.name AS name, s.filePath AS filePath, labels(s)[0] AS type,
-           r.step AS step, p.id AS processId
-    ORDER BY p.id, r.step
+    const procRows = await executeQuery(REPO_ID, `
+    MATCH (p:Process)
+    RETURN p.id AS id, p.heuristicLabel AS label,
+           p.processType AS type, p.stepCount AS stepCount
+    ORDER BY stepCount DESC
+    LIMIT ${limit}
   `);
-    return groupStepsByProcess(procRows, stepRows);
+    const processes = [];
+    for (const row of procRows) {
+        const procId = row.id || row[0];
+        const label = row.label || row[1] || procId;
+        const type = row.type || row[2] || 'unknown';
+        const stepCount = row.stepCount || row[3] || 0;
+        const stepRows = await executeQuery(REPO_ID, `
+      MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process {id: '${procId.replace(/'/g, "''")}'})
+      RETURN s.name AS name, s.filePath AS filePath, labels(s)[0] AS type, r.step AS step
+      ORDER BY r.step
+    `);
+        processes.push({
+            id: procId,
+            label,
+            type,
+            stepCount,
+            steps: stepRows.map(s => ({
+                step: s.step || s[3] || 0,
+                name: s.name || s[0],
+                filePath: s.filePath || s[1],
+                type: s.type || s[2],
+            })),
+        });
+    }
+    return processes;
 }
 /**
  * Get inter-module edges for overview architecture diagram.
@@ -259,159 +236,3 @@ export async function getInterModuleEdgesForOverview(moduleFiles) {
     })
         .sort((a, b) => b.count - a.count);
 }
-/**
- * Get community-to-file mapping from Leiden-detected clusters.
- * Each file is assigned to its majority community; secondary memberships tracked separately.
- */
-export async function getCommunityFileMapping() {
-    // Query 1: Fetch all Community nodes
-    const communityRows = await executeQuery(REPO_ID, `
-    MATCH (c:Community)
-    RETURN c.id AS id, c.heuristicLabel AS label, c.keywords AS keywords,
-           c.description AS description, c.cohesion AS cohesion,
-           c.symbolCount AS symbolCount
-    ORDER BY c.symbolCount DESC
-  `);
-    if (communityRows.length === 0)
-        return [];
-    // Query 2: Fetch all MEMBER_OF edges with file paths
-    const memberRows = await executeQuery(REPO_ID, `
-    MATCH (n)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
-    WHERE n.filePath IS NOT NULL
-    RETURN n.filePath AS filePath, c.id AS communityId
-  `);
-    // Build file -> community count map
-    const fileCommunityCount = new Map();
-    for (const row of memberRows) {
-        const fp = row.filePath || row[0];
-        const cId = row.communityId || row[1];
-        if (!fileCommunityCount.has(fp))
-            fileCommunityCount.set(fp, new Map());
-        const counts = fileCommunityCount.get(fp);
-        counts.set(cId, (counts.get(cId) || 0) + 1);
-    }
-    // Assign each file to majority community
-    const communityFiles = new Map();
-    for (const row of communityRows) {
-        const cId = row.id || row[0];
-        communityFiles.set(cId, { primary: [], secondary: [] });
-    }
-    for (const [fp, counts] of fileCommunityCount) {
-        let maxCount = 0;
-        let maxCommunity = '';
-        for (const [cId, count] of counts) {
-            if (count > maxCount) {
-                maxCount = count;
-                maxCommunity = cId;
-            }
-        }
-        if (maxCommunity && communityFiles.has(maxCommunity)) {
-            communityFiles.get(maxCommunity).primary.push(fp);
-        }
-        // Track secondary memberships
-        for (const [cId] of counts) {
-            if (cId !== maxCommunity && communityFiles.has(cId)) {
-                communityFiles.get(cId).secondary.push(fp);
-            }
-        }
-    }
-    // Build result, merge tiny communities into "Other"
-    const results = [];
-    const otherFiles = [];
-    const otherSecondary = [];
-    for (const row of communityRows) {
-        const cId = row.id || row[0];
-        const entry = communityFiles.get(cId);
-        if (!entry)
-            continue;
-        if (entry.primary.length < 2) {
-            otherFiles.push(...entry.primary);
-            otherSecondary.push(...entry.secondary);
-            continue;
-        }
-        const keywords = row.keywords || row[2];
-        results.push({
-            communityId: cId,
-            label: row.label || row[1] || cId,
-            keywords: Array.isArray(keywords) ? keywords : typeof keywords === 'string' ? keywords.split(',').map((k) => k.trim()) : [],
-            description: row.description || row[3] || '',
-            cohesion: row.cohesion || row[4] || 0,
-            symbolCount: row.symbolCount || row[5] || 0,
-            files: entry.primary,
-            secondaryFiles: entry.secondary,
-        });
-    }
-    // Add "Other" bucket if non-empty
-    if (otherFiles.length > 0) {
-        results.push({
-            communityId: '__other__',
-            label: 'Other small clusters',
-            keywords: [],
-            description: 'Files from small communities merged together',
-            cohesion: 0,
-            symbolCount: 0,
-            files: otherFiles,
-            secondaryFiles: otherSecondary,
-        });
-    }
-    // Cap at 30 communities
-    return results.slice(0, 30);
-}
-/**
- * Get call edges between communities for inter-module coupling analysis.
- */
-export async function getInterCommunityCallEdges() {
-    const rows = await executeQuery(REPO_ID, `
-    MATCH (a)-[:CodeRelation {type: 'CALLS'}]->(b),
-          (a)-[:CodeRelation {type: 'MEMBER_OF'}]->(ca:Community),
-          (b)-[:CodeRelation {type: 'MEMBER_OF'}]->(cb:Community)
-    WHERE ca.id <> cb.id
-    RETURN ca.heuristicLabel AS fromLabel, cb.heuristicLabel AS toLabel,
-           a.name AS fromName, b.name AS toName
-  `);
-    // Aggregate in JS
-    const edgeMap = new Map();
-    for (const row of rows) {
-        const from = row.fromLabel || row[0];
-        const to = row.toLabel || row[1];
-        const key = `${from}|||${to}`;
-        if (!edgeMap.has(key))
-            edgeMap.set(key, { count: 0, samples: [] });
-        const entry = edgeMap.get(key);
-        entry.count++;
-        if (entry.samples.length < 3) {
-            entry.samples.push({
-                fromName: row.fromName || row[2],
-                toName: row.toName || row[3],
-            });
-        }
-    }
-    const results = [];
-    for (const [key, val] of edgeMap) {
-        const [fromLabel, toLabel] = key.split('|||');
-        results.push({ fromLabel, toLabel, callCount: val.count, sampleCalls: val.samples });
-    }
-    return results
-        .sort((a, b) => b.callCount - a.callCount)
-        .slice(0, 40);
-}
-/**
- * Get cross-community execution flows.
- */
-export async function getCrossCommunityProcesses() {
-    const rows = await executeQuery(REPO_ID, `
-    MATCH (p:Process)
-    WHERE p.processType = 'cross_community'
-    RETURN p.heuristicLabel AS label, p.communities AS communities, p.stepCount AS stepCount
-    ORDER BY p.stepCount DESC
-    LIMIT 15
-  `);
-    return rows.map(r => {
-        const communities = r.communities || r[1];
-        return {
-            label: r.label || r[0] || 'Unknown',
-            communities: Array.isArray(communities) ? communities : typeof communities === 'string' ? communities.split(',').map((c) => c.trim()) : [],
-            stepCount: r.stepCount || r[2] || 0,
-        };
-    });
-}