gitnexus 1.3.11 → 1.4.1

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

@@ -29,6 +29,30 @@ 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.
  */
@@ -60,6 +84,11 @@ 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.
@@ -78,3 +107,16 @@ 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

@@ -10,7 +10,7 @@ const REPO_ID = '__wiki__';
  * Initialize the KuzuDB connection for wiki generation.
  */
 export async function initWikiDb(kuzuPath) {
-    await initKuzu(REPO_ID, kuzuPath);
+    await initKuzu(REPO_ID, kuzuPath, { pinned: true });
 }
 /**
  * Close the KuzuDB connection.
@@ -22,11 +22,11 @@ export async function closeWikiDb() {
  * 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,6 +126,50 @@ 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.
@@ -134,78 +178,57 @@ export async function getProcessesForFiles(filePaths, limit = 5) {
     if (filePaths.length === 0)
         return [];
     const fileList = filePaths.map(f => `'${f.replace(/'/g, "''")}'`).join(', ');
-    // 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}
+    // 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}
   `);
-    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;
+    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);
 }
 /**
  * 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}
+    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}
   `);
-    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;
+    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
+  `);
+    return groupStepsByProcess(procRows, stepRows);
 }
 /**
  * Get inter-module edges for overview architecture diagram.
@@ -236,3 +259,159 @@ 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,
+        };
+    });
+}