@duytransipher/gitnexus 1.1.2 → 1.2.1

package/dist/cli/analyze.js

@@ -182,6 +182,15 @@ export const analyzeCommand = async (inputPath, options) => {
         const scaled = Math.round(progress.percent * 0.6);
         updateBar(scaled, phaseLabel);
     });
+    // ── Phase 1.5: Blueprint Ingestion (optional) ────────────────────────
+    try {
+        const { ingestBlueprintsIntoGraph } = await import('../unreal/blueprint-ingestion.js');
+        const bpResult = await ingestBlueprintsIntoGraph(pipelineResult.graph, storagePath);
+        if (bpResult.nodesAdded > 0) {
+            updateBar(61, `Indexed ${bpResult.nodesAdded} Blueprints (${bpResult.edgesAdded} edges)`);
+        }
+    }
+    catch { /* non-fatal — Unreal integration is optional */ }
     // ── Phase 2: LadybugDB (60–85%) ──────────────────────────────────────
     updateBar(60, 'Loading into LadybugDB...');
     await closeLbug();

package/dist/cli/setup.js

@@ -366,6 +366,21 @@ function resolveEditorCmd(explicitPath, engineAssociation) {
             }
         }
         catch { /* registry key not found */ }
+        // Try LauncherInstalled.dat (Epic Games Launcher writes this for all engine installs)
+        try {
+            const launcherDat = path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'EpicGames', 'UnrealEngineLauncher', 'LauncherInstalled.dat');
+            const launcher = JSON.parse(fsSync.readFileSync(launcherDat, 'utf-8'));
+            if (Array.isArray(launcher.InstallationList)) {
+                for (const entry of launcher.InstallationList) {
+                    if (entry.AppName === `UE_${engineAssociation}` || entry.AppName === engineAssociation) {
+                        const found = tryCandidates(entry.InstallLocation);
+                        if (found)
+                            return found;
+                    }
+                }
+            }
+        }
+        catch { /* LauncherInstalled.dat not found or unparseable */ }
         // Try standard install path
         const found = tryCandidates(path.join('C:\\Program Files\\Epic Games', `UE_${engineAssociation}`));
         if (found)

package/dist/core/augmentation/engine.js

@@ -95,20 +95,21 @@ export async function augment(pattern, cwd) {
             return '';
         // Step 2: Map BM25 file results to symbols
         const symbolMatches = [];
+        const extractLabel = (v) => Array.isArray(v) ? v[0] : typeof v === 'string' ? v : undefined;
         for (const result of bm25Results.slice(0, 5)) {
             const escaped = result.filePath.replace(/'/g, "''");
             try {
                 const symbols = await executeQuery(repoId, `
           MATCH (n) WHERE n.filePath = '${escaped}'
           AND n.name CONTAINS '${pattern.replace(/'/g, "''").split(/\s+/)[0]}'
-          RETURN n.id AS id, n.name AS name, labels(n)[0] AS type, n.filePath AS filePath
+          RETURN n.id AS id, n.name AS name, labels(n) AS type, n.filePath AS filePath
           LIMIT 3
         `);
                 for (const sym of symbols) {
                     symbolMatches.push({
                         nodeId: sym.id || sym[0],
                         name: sym.name || sym[1],
-                        type: sym.type || sym[2],
+                        type: extractLabel(sym.type || sym[2]),
                         filePath: sym.filePath || sym[3],
                         score: result.score,
                     });

package/dist/core/graph/types.d.ts

@@ -1,4 +1,4 @@
-export type NodeLabel = 'Project' | 'Package' | 'Module' | 'Folder' | 'File' | 'Class' | 'Function' | 'Method' | 'Variable' | 'Interface' | 'Enum' | 'Decorator' | 'Import' | 'Type' | 'CodeElement' | 'Community' | 'Process' | 'Struct' | 'Macro' | 'Typedef' | 'Union' | 'Namespace' | 'Trait' | 'Impl' | 'TypeAlias' | 'Const' | 'Static' | 'Property' | 'Record' | 'Delegate' | 'Annotation' | 'Constructor' | 'Template';
+export type NodeLabel = 'Project' | 'Package' | 'Module' | 'Folder' | 'File' | 'Class' | 'Function' | 'Method' | 'Variable' | 'Interface' | 'Enum' | 'Decorator' | 'Import' | 'Type' | 'CodeElement' | 'Community' | 'Process' | 'Struct' | 'Macro' | 'Typedef' | 'Union' | 'Namespace' | 'Trait' | 'Impl' | 'TypeAlias' | 'Const' | 'Static' | 'Property' | 'Record' | 'Delegate' | 'Annotation' | 'Constructor' | 'Template' | 'Blueprint';
 import { SupportedLanguages } from '../../config/supported-languages.js';
 export type NodeProperties = {
     name: string;

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

@@ -1024,7 +1024,37 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             // Compute enclosing class for Method/Constructor/Property/Function — used for both ownerId and HAS_METHOD
             // Function is included because Kotlin/Rust/Python capture class methods as Function nodes
             const needsOwner = nodeLabel === 'Method' || nodeLabel === 'Constructor' || nodeLabel === 'Property' || nodeLabel === 'Function';
-            const enclosingClassId = needsOwner ? findEnclosingClassId(nameNode || definitionNode, file.path) : null;
+            let enclosingClassId = needsOwner ? findEnclosingClassId(nameNode || definitionNode, file.path) : null;
+            // C/C++ out-of-line methods: extract class from qualified_identifier scope.
+            // e.g. void Duck::speak() → scope class "Duck". Since the class is declared
+            // in a header (different file), AST walk can't find it. Search accumulated
+            // batch nodes for a matching Class node instead.
+            if (!enclosingClassId && needsOwner && nodeLabel === 'Method'
+                && (language === SupportedLanguages.CPlusPlus || language === SupportedLanguages.C)) {
+                const qualifiedId = nameNode?.parent;
+                if (qualifiedId?.type === 'qualified_identifier') {
+                    const scopeNode = qualifiedId.childForFieldName?.('scope')
+                        ?? qualifiedId.children?.find((c) => (c.type === 'namespace_identifier' || c.type === 'identifier' || c.type === 'type_identifier')
+                            && c !== nameNode);
+                    const scopeClassName = scopeNode?.text;
+                    if (scopeClassName) {
+                        // Prefer the Class node defined in the canonical header (ClassName.h)
+                        const matchingClasses = result.nodes.filter(n => n.label === 'Class' && n.properties.name === scopeClassName);
+                        if (matchingClasses.length === 1) {
+                            enclosingClassId = matchingClasses[0].id;
+                        }
+                        else if (matchingClasses.length > 1) {
+                            // Prefer the class in a header whose base name matches the class name
+                            const preferred = matchingClasses.find(n => {
+                                const fp = (n.properties.filePath || '').toLowerCase();
+                                return fp.endsWith(`${scopeClassName.toLowerCase()}.h`)
+                                    || fp.endsWith(`${scopeClassName.toLowerCase()}.hpp`);
+                            });
+                            enclosingClassId = (preferred || matchingClasses[0]).id;
+                        }
+                    }
+                }
+            }
             result.symbols.push({
                 filePath: file.path,
                 name: nodeName,

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

@@ -211,7 +211,7 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
     // 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'];
+        'TypeAlias', 'Const', 'Static', 'Property', 'Record', 'Delegate', 'Annotation', 'Constructor', 'Template', 'Module', 'Blueprint'];
     const multiLangWriters = new Map();
     for (const t of MULTI_LANG_TYPES) {
         multiLangWriters.set(t, new BufferedCSVWriter(path.join(csvDir, `${t.toLowerCase()}.csv`), multiLangHeader));

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

@@ -270,7 +270,7 @@ const COPY_CSV_OPTS = `(HEADER=true, ESCAPE='"', DELIM=',', QUOTE='"', PARALLEL=
 const BACKTICK_TABLES = new Set([
     'Struct', 'Enum', 'Macro', 'Typedef', 'Union', 'Namespace', 'Trait', 'Impl',
     'TypeAlias', 'Const', 'Static', 'Property', 'Record', 'Delegate', 'Annotation',
-    'Constructor', 'Template', 'Module',
+    'Constructor', 'Template', 'Module', 'Blueprint',
 ]);
 const escapeTableName = (table) => {
     return BACKTICK_TABLES.has(table) ? `\`${table}\`` : table;

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

@@ -8,7 +8,7 @@
  * 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", "Struct", "Enum", "Macro", "Typedef", "Union", "Namespace", "Trait", "Impl", "TypeAlias", "Const", "Static", "Property", "Record", "Delegate", "Annotation", "Constructor", "Template", "Module"];
+export declare const NODE_TABLES: readonly ["File", "Folder", "Function", "Class", "Interface", "Method", "CodeElement", "Community", "Process", "Struct", "Enum", "Macro", "Typedef", "Union", "Namespace", "Trait", "Impl", "TypeAlias", "Const", "Static", "Property", "Record", "Delegate", "Annotation", "Constructor", "Template", "Module", "Blueprint"];
 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"];
@@ -41,7 +41,8 @@ export declare const ANNOTATION_SCHEMA: string;
 export declare const CONSTRUCTOR_SCHEMA: string;
 export declare const TEMPLATE_SCHEMA: string;
 export declare const MODULE_SCHEMA: string;
-export declare const RELATION_SCHEMA = "\nCREATE REL TABLE CodeRelation (\n  FROM File TO File,\n  FROM File TO Folder,\n  FROM File TO Function,\n  FROM File TO Class,\n  FROM File TO Interface,\n  FROM File TO Method,\n  FROM File TO CodeElement,\n  FROM File TO `Struct`,\n  FROM File TO `Enum`,\n  FROM File TO `Macro`,\n  FROM File TO `Typedef`,\n  FROM File TO `Union`,\n  FROM File TO `Namespace`,\n  FROM File TO `Trait`,\n  FROM File TO `Impl`,\n  FROM File TO `TypeAlias`,\n  FROM File TO `Const`,\n  FROM File TO `Static`,\n  FROM File TO `Property`,\n  FROM File TO `Record`,\n  FROM File TO `Delegate`,\n  FROM File TO `Annotation`,\n  FROM File TO `Constructor`,\n  FROM File TO `Template`,\n  FROM File TO `Module`,\n  FROM Folder TO Folder,\n  FROM Folder TO File,\n  FROM Function TO Function,\n  FROM Function TO Method,\n  FROM Function TO Class,\n  FROM Function TO Community,\n  FROM Function TO `Macro`,\n  FROM Function TO `Struct`,\n  FROM Function TO `Template`,\n  FROM Function TO `Enum`,\n  FROM Function TO `Namespace`,\n  FROM Function TO `TypeAlias`,\n  FROM Function TO `Module`,\n  FROM Function TO `Impl`,\n  FROM Function TO Interface,\n  FROM Function TO `Constructor`,\n  FROM Function TO `Const`,\n  FROM Function TO `Typedef`,\n  FROM Function TO `Union`,\n  FROM Function TO `Property`,\n  FROM Class TO Method,\n  FROM Class TO Function,\n  FROM Class TO Class,\n  FROM Class TO Interface,\n  FROM Class TO Community,\n  FROM Class TO `Template`,\n  FROM Class TO `TypeAlias`,\n  FROM Class TO `Struct`,\n  FROM Class TO `Enum`,\n  FROM Class TO `Annotation`,\n  FROM Class TO `Constructor`,\n  FROM Class TO `Trait`,\n  FROM Class TO `Macro`,\n  FROM Class TO `Impl`,\n  FROM Class TO `Union`,\n  FROM Class TO `Namespace`,\n  FROM Class TO `Typedef`,\n  FROM Class TO `Property`,\n  FROM Method TO Function,\n  FROM Method TO Method,\n  FROM Method TO Class,\n  FROM Method TO Community,\n  FROM Method TO `Template`,\n  FROM Method TO `Struct`,\n  FROM Method TO `TypeAlias`,\n  FROM Method TO `Enum`,\n  FROM Method TO `Macro`,\n  FROM Method TO `Namespace`,\n  FROM Method TO `Module`,\n  FROM Method TO `Impl`,\n  FROM Method TO Interface,\n  FROM Method TO `Constructor`,\n  FROM Method TO `Property`,\n  FROM `Template` TO `Template`,\n  FROM `Template` TO Function,\n  FROM `Template` TO Method,\n  FROM `Template` TO Class,\n  FROM `Template` TO `Struct`,\n  FROM `Template` TO `TypeAlias`,\n  FROM `Template` TO `Enum`,\n  FROM `Template` TO `Macro`,\n  FROM `Template` TO Interface,\n  FROM `Template` TO `Constructor`,\n  FROM `Module` TO `Module`,\n  FROM CodeElement TO Community,\n  FROM Interface TO Community,\n  FROM Interface TO Function,\n  FROM Interface TO Method,\n  FROM Interface TO Class,\n  FROM Interface TO Interface,\n  FROM Interface TO `TypeAlias`,\n  FROM Interface TO `Struct`,\n  FROM Interface TO `Constructor`,\n  FROM Interface TO `Property`,\n  FROM `Struct` TO Community,\n  FROM `Struct` TO `Trait`,\n  FROM `Struct` TO `Struct`,\n  FROM `Struct` TO Class,\n  FROM `Struct` TO `Enum`,\n  FROM `Struct` TO Function,\n  FROM `Struct` TO Method,\n  FROM `Struct` TO Interface,\n  FROM `Struct` TO `Constructor`,\n  FROM `Struct` TO `Property`,\n  FROM `Enum` TO `Enum`,\n  FROM `Enum` TO Community,\n  FROM `Enum` TO Class,\n  FROM `Enum` TO Interface,\n  FROM `Macro` TO Community,\n  FROM `Macro` TO Function,\n  FROM `Macro` TO Method,\n  FROM `Module` TO Function,\n  FROM `Module` TO Method,\n  FROM `Typedef` TO Community,\n  FROM `Union` TO Community,\n  FROM `Namespace` TO Community,\n  FROM `Namespace` TO `Struct`,\n  FROM `Trait` TO Method,\n  FROM `Trait` TO `Constructor`,\n  FROM `Trait` TO `Property`,\n  FROM `Trait` TO Community,\n  FROM `Impl` TO Method,\n  FROM `Impl` TO `Constructor`,\n  FROM `Impl` TO `Property`,\n  FROM `Impl` TO Community,\n  FROM `Impl` TO `Trait`,\n  FROM `Impl` TO `Struct`,\n  FROM `Impl` TO `Impl`,\n  FROM `TypeAlias` TO Community,\n  FROM `TypeAlias` TO `Trait`,\n  FROM `TypeAlias` TO Class,\n  FROM `Const` TO Community,\n  FROM `Static` TO Community,\n  FROM `Property` TO Community,\n  FROM `Record` TO Method,\n  FROM `Record` TO `Constructor`,\n  FROM `Record` TO `Property`,\n  FROM `Record` TO Community,\n  FROM `Delegate` TO Community,\n  FROM `Annotation` TO Community,\n  FROM `Constructor` TO Community,\n  FROM `Constructor` TO Interface,\n  FROM `Constructor` TO Class,\n  FROM `Constructor` TO Method,\n  FROM `Constructor` TO Function,\n  FROM `Constructor` TO `Constructor`,\n  FROM `Constructor` TO `Struct`,\n  FROM `Constructor` TO `Macro`,\n  FROM `Constructor` TO `Template`,\n  FROM `Constructor` TO `TypeAlias`,\n  FROM `Constructor` TO `Enum`,\n  FROM `Constructor` TO `Annotation`,\n  FROM `Constructor` TO `Impl`,\n  FROM `Constructor` TO `Namespace`,\n  FROM `Constructor` TO `Module`,\n  FROM `Constructor` TO `Property`,\n  FROM `Constructor` TO `Typedef`,\n  FROM `Template` TO Community,\n  FROM `Module` TO Community,\n  FROM Function TO Process,\n  FROM Method TO Process,\n  FROM Class TO Process,\n  FROM Interface TO Process,\n  FROM `Struct` TO Process,\n  FROM `Constructor` TO Process,\n  FROM `Module` TO Process,\n  FROM `Macro` TO Process,\n  FROM `Impl` TO Process,\n  FROM `Typedef` TO Process,\n  FROM `TypeAlias` TO Process,\n  FROM `Enum` TO Process,\n  FROM `Union` TO Process,\n  FROM `Namespace` TO Process,\n  FROM `Trait` TO Process,\n  FROM `Const` TO Process,\n  FROM `Static` TO Process,\n  FROM `Property` TO Process,\n  FROM `Record` TO Process,\n  FROM `Delegate` TO Process,\n  FROM `Annotation` TO Process,\n  FROM `Template` TO Process,\n  FROM CodeElement TO Process,\n  type STRING,\n  confidence DOUBLE,\n  reason STRING,\n  step INT32\n)";
+export declare const BLUEPRINT_SCHEMA: string;
+export declare const RELATION_SCHEMA = "\nCREATE REL TABLE CodeRelation (\n  FROM File TO File,\n  FROM File TO Folder,\n  FROM File TO Function,\n  FROM File TO Class,\n  FROM File TO Interface,\n  FROM File TO Method,\n  FROM File TO CodeElement,\n  FROM File TO `Struct`,\n  FROM File TO `Enum`,\n  FROM File TO `Macro`,\n  FROM File TO `Typedef`,\n  FROM File TO `Union`,\n  FROM File TO `Namespace`,\n  FROM File TO `Trait`,\n  FROM File TO `Impl`,\n  FROM File TO `TypeAlias`,\n  FROM File TO `Const`,\n  FROM File TO `Static`,\n  FROM File TO `Property`,\n  FROM File TO `Record`,\n  FROM File TO `Delegate`,\n  FROM File TO `Annotation`,\n  FROM File TO `Constructor`,\n  FROM File TO `Template`,\n  FROM File TO `Module`,\n  FROM Folder TO Folder,\n  FROM Folder TO File,\n  FROM Function TO Function,\n  FROM Function TO Method,\n  FROM Function TO Class,\n  FROM Function TO Community,\n  FROM Function TO `Macro`,\n  FROM Function TO `Struct`,\n  FROM Function TO `Template`,\n  FROM Function TO `Enum`,\n  FROM Function TO `Namespace`,\n  FROM Function TO `TypeAlias`,\n  FROM Function TO `Module`,\n  FROM Function TO `Impl`,\n  FROM Function TO Interface,\n  FROM Function TO `Constructor`,\n  FROM Function TO `Const`,\n  FROM Function TO `Typedef`,\n  FROM Function TO `Union`,\n  FROM Function TO `Property`,\n  FROM Class TO Method,\n  FROM Class TO Function,\n  FROM Class TO Class,\n  FROM Class TO Interface,\n  FROM Class TO Community,\n  FROM Class TO `Template`,\n  FROM Class TO `TypeAlias`,\n  FROM Class TO `Struct`,\n  FROM Class TO `Enum`,\n  FROM Class TO `Annotation`,\n  FROM Class TO `Constructor`,\n  FROM Class TO `Trait`,\n  FROM Class TO `Macro`,\n  FROM Class TO `Impl`,\n  FROM Class TO `Union`,\n  FROM Class TO `Namespace`,\n  FROM Class TO `Typedef`,\n  FROM Class TO `Property`,\n  FROM Method TO Function,\n  FROM Method TO Method,\n  FROM Method TO Class,\n  FROM Method TO Community,\n  FROM Method TO `Template`,\n  FROM Method TO `Struct`,\n  FROM Method TO `TypeAlias`,\n  FROM Method TO `Enum`,\n  FROM Method TO `Macro`,\n  FROM Method TO `Namespace`,\n  FROM Method TO `Module`,\n  FROM Method TO `Impl`,\n  FROM Method TO Interface,\n  FROM Method TO `Constructor`,\n  FROM Method TO `Property`,\n  FROM `Template` TO `Template`,\n  FROM `Template` TO Function,\n  FROM `Template` TO Method,\n  FROM `Template` TO Class,\n  FROM `Template` TO `Struct`,\n  FROM `Template` TO `TypeAlias`,\n  FROM `Template` TO `Enum`,\n  FROM `Template` TO `Macro`,\n  FROM `Template` TO Interface,\n  FROM `Template` TO `Constructor`,\n  FROM `Module` TO `Module`,\n  FROM CodeElement TO Community,\n  FROM Interface TO Community,\n  FROM Interface TO Function,\n  FROM Interface TO Method,\n  FROM Interface TO Class,\n  FROM Interface TO Interface,\n  FROM Interface TO `TypeAlias`,\n  FROM Interface TO `Struct`,\n  FROM Interface TO `Constructor`,\n  FROM Interface TO `Property`,\n  FROM `Struct` TO Community,\n  FROM `Struct` TO `Trait`,\n  FROM `Struct` TO `Struct`,\n  FROM `Struct` TO Class,\n  FROM `Struct` TO `Enum`,\n  FROM `Struct` TO Function,\n  FROM `Struct` TO Method,\n  FROM `Struct` TO Interface,\n  FROM `Struct` TO `Constructor`,\n  FROM `Struct` TO `Property`,\n  FROM `Enum` TO `Enum`,\n  FROM `Enum` TO Community,\n  FROM `Enum` TO Class,\n  FROM `Enum` TO Interface,\n  FROM `Macro` TO Community,\n  FROM `Macro` TO Function,\n  FROM `Macro` TO Method,\n  FROM `Module` TO Function,\n  FROM `Module` TO Method,\n  FROM `Typedef` TO Community,\n  FROM `Union` TO Community,\n  FROM `Namespace` TO Community,\n  FROM `Namespace` TO `Struct`,\n  FROM `Trait` TO Method,\n  FROM `Trait` TO `Constructor`,\n  FROM `Trait` TO `Property`,\n  FROM `Trait` TO Community,\n  FROM `Impl` TO Method,\n  FROM `Impl` TO `Constructor`,\n  FROM `Impl` TO `Property`,\n  FROM `Impl` TO Community,\n  FROM `Impl` TO `Trait`,\n  FROM `Impl` TO `Struct`,\n  FROM `Impl` TO `Impl`,\n  FROM `TypeAlias` TO Community,\n  FROM `TypeAlias` TO `Trait`,\n  FROM `TypeAlias` TO Class,\n  FROM `Const` TO Community,\n  FROM `Static` TO Community,\n  FROM `Property` TO Community,\n  FROM `Record` TO Method,\n  FROM `Record` TO `Constructor`,\n  FROM `Record` TO `Property`,\n  FROM `Record` TO Community,\n  FROM `Delegate` TO Community,\n  FROM `Annotation` TO Community,\n  FROM `Constructor` TO Community,\n  FROM `Constructor` TO Interface,\n  FROM `Constructor` TO Class,\n  FROM `Constructor` TO Method,\n  FROM `Constructor` TO Function,\n  FROM `Constructor` TO `Constructor`,\n  FROM `Constructor` TO `Struct`,\n  FROM `Constructor` TO `Macro`,\n  FROM `Constructor` TO `Template`,\n  FROM `Constructor` TO `TypeAlias`,\n  FROM `Constructor` TO `Enum`,\n  FROM `Constructor` TO `Annotation`,\n  FROM `Constructor` TO `Impl`,\n  FROM `Constructor` TO `Namespace`,\n  FROM `Constructor` TO `Module`,\n  FROM `Constructor` TO `Property`,\n  FROM `Constructor` TO `Typedef`,\n  FROM `Template` TO Community,\n  FROM `Module` TO Community,\n  FROM Function TO Process,\n  FROM Method TO Process,\n  FROM Class TO Process,\n  FROM Interface TO Process,\n  FROM `Struct` TO Process,\n  FROM `Constructor` TO Process,\n  FROM `Module` TO Process,\n  FROM `Macro` TO Process,\n  FROM `Impl` TO Process,\n  FROM `Typedef` TO Process,\n  FROM `TypeAlias` TO Process,\n  FROM `Enum` TO Process,\n  FROM `Union` TO Process,\n  FROM `Namespace` TO Process,\n  FROM `Trait` TO Process,\n  FROM `Const` TO Process,\n  FROM `Static` TO Process,\n  FROM `Property` TO Process,\n  FROM `Record` TO Process,\n  FROM `Delegate` TO Process,\n  FROM `Annotation` TO Process,\n  FROM `Template` TO Process,\n  FROM CodeElement TO Process,\n  FROM `Blueprint` TO Class,\n  FROM `Blueprint` TO `Struct`,\n  FROM `Blueprint` TO Method,\n  FROM `Blueprint` TO Function,\n  FROM `Blueprint` TO `Blueprint`,\n  FROM `Blueprint` TO Community,\n  FROM `Blueprint` TO Process,\n  type STRING,\n  confidence DOUBLE,\n  reason STRING,\n  step INT32\n)";
 export declare const EMBEDDING_SCHEMA = "\nCREATE NODE TABLE CodeEmbedding (\n  nodeId STRING,\n  embedding FLOAT[384],\n  PRIMARY KEY (nodeId)\n)";
 /**
  * Create vector index for semantic search

package/dist/core/lbug/schema.js

@@ -15,7 +15,9 @@ export const NODE_TABLES = [
     'File', 'Folder', 'Function', 'Class', 'Interface', 'Method', 'CodeElement', 'Community', 'Process',
     // Multi-language support
     'Struct', 'Enum', 'Macro', 'Typedef', 'Union', 'Namespace', 'Trait', 'Impl',
-    'TypeAlias', 'Const', 'Static', 'Property', 'Record', 'Delegate', 'Annotation', 'Constructor', 'Template', 'Module'
+    'TypeAlias', 'Const', 'Static', 'Property', 'Record', 'Delegate', 'Annotation', 'Constructor', 'Template', 'Module',
+    // Unreal Engine Blueprint assets
+    'Blueprint'
 ];
 // ============================================================================
 // RELATION TABLE
@@ -171,6 +173,8 @@ export const ANNOTATION_SCHEMA = CODE_ELEMENT_BASE('Annotation');
 export const CONSTRUCTOR_SCHEMA = CODE_ELEMENT_BASE('Constructor');
 export const TEMPLATE_SCHEMA = CODE_ELEMENT_BASE('Template');
 export const MODULE_SCHEMA = CODE_ELEMENT_BASE('Module');
+// Unreal Engine Blueprint assets
+export const BLUEPRINT_SCHEMA = CODE_ELEMENT_BASE('Blueprint');
 // ============================================================================
 // RELATION TABLE SCHEMA
 // Single table with 'type' property - connects all node tables
@@ -364,6 +368,13 @@ CREATE REL TABLE ${REL_TABLE_NAME} (
   FROM \`Annotation\` TO Process,
   FROM \`Template\` TO Process,
   FROM CodeElement TO Process,
+  FROM \`Blueprint\` TO Class,
+  FROM \`Blueprint\` TO \`Struct\`,
+  FROM \`Blueprint\` TO Method,
+  FROM \`Blueprint\` TO Function,
+  FROM \`Blueprint\` TO \`Blueprint\`,
+  FROM \`Blueprint\` TO Community,
+  FROM \`Blueprint\` TO Process,
   type STRING,
   confidence DOUBLE,
   reason STRING,
@@ -419,6 +430,7 @@ export const NODE_SCHEMA_QUERIES = [
     CONSTRUCTOR_SCHEMA,
     TEMPLATE_SCHEMA,
     MODULE_SCHEMA,
+    BLUEPRINT_SCHEMA,
 ];
 export const REL_SCHEMA_QUERIES = [
     RELATION_SCHEMA,

package/dist/core/wiki/generator.d.ts

@@ -25,6 +25,7 @@ export interface WikiMeta {
     model: string;
     moduleFiles: Record<string, string[]>;
     moduleTree: ModuleTreeNode[];
+    failedModules?: string[];
 }
 export interface ModuleTreeNode {
     name: string;
@@ -67,6 +68,11 @@ export declare class WikiGenerator {
     }>;
     private ensureHTMLViewer;
     private fullGeneration;
+    /**
+     * Retry only the modules that failed in a previous run.
+     * Finds them in the saved module tree and regenerates their pages.
+     */
+    private retryFailedModules;
     private buildModuleTree;
     /**
      * Parse LLM grouping response. Validates all files are assigned.

package/dist/core/wiki/generator.js

@@ -121,6 +121,20 @@ export class WikiGenerator {
         const forceMode = this.options.force;
         // Up-to-date check (skip if --force)
         if (!forceMode && existingMeta && existingMeta.fromCommit === currentCommit) {
+            // If previous run had failed modules, retry them instead of skipping
+            if (existingMeta.failedModules?.length) {
+                this.onProgress('init', 2, 'Retrying previously failed modules...');
+                await initWikiDb(this.lbugPath);
+                let retryResult;
+                try {
+                    retryResult = await this.retryFailedModules(existingMeta, currentCommit);
+                }
+                finally {
+                    await closeWikiDb();
+                }
+                await this.ensureHTMLViewer();
+                return retryResult;
+            }
             // Still regenerate the HTML viewer in case it's missing
             await this.ensureHTMLViewer();
             return { pagesGenerated: 0, mode: 'up-to-date', failedModules: [] };
@@ -246,7 +260,7 @@ export class WikiGenerator {
         this.onProgress('overview', 88, 'Generating overview page...');
         await this.generateOverview(moduleTree);
         pagesGenerated++;
-        // Save metadata
+        // Save metadata (include failed modules so retry can find them)
         this.onProgress('finalize', 95, 'Saving metadata...');
         const moduleFiles = this.extractModuleFiles(moduleTree);
         await this.saveModuleTree(moduleTree);
@@ -256,10 +270,87 @@ export class WikiGenerator {
             model: this.llmConfig.model,
             moduleFiles,
             moduleTree,
+            failedModules: this.failedModules.length > 0 ? [...this.failedModules] : undefined,
         });
         this.onProgress('done', 100, 'Wiki generation complete');
         return { pagesGenerated, mode: 'full', failedModules: [...this.failedModules] };
     }
+    // ─── Retry Failed Modules ──────────────────────────────────────────
+    /**
+     * Retry only the modules that failed in a previous run.
+     * Finds them in the saved module tree and regenerates their pages.
+     */
+    async retryFailedModules(existingMeta, currentCommit) {
+        const failedNames = new Set(existingMeta.failedModules ?? []);
+        const moduleTree = existingMeta.moduleTree;
+        const { leaves, parents } = this.flattenModuleTree(moduleTree);
+        const failedLeaves = leaves.filter(n => failedNames.has(n.name));
+        const failedParents = parents.filter(n => failedNames.has(n.name));
+        const totalRetries = failedLeaves.length + failedParents.length;
+        let processed = 0;
+        let pagesGenerated = 0;
+        const reportProgress = (moduleName) => {
+            processed++;
+            const percent = 10 + Math.round((processed / totalRetries) * 75);
+            const detail = moduleName
+                ? `Retry ${processed}/${totalRetries} — ${moduleName}`
+                : `Retry ${processed}/${totalRetries}`;
+            this.onProgress('retry', percent, detail);
+        };
+        // Delete existing failed pages so they get regenerated
+        for (const name of failedNames) {
+            const node = [...leaves, ...parents].find(n => n.name === name);
+            if (node) {
+                try {
+                    await fs.unlink(path.join(this.wikiDir, `${node.slug}.md`));
+                }
+                catch { }
+            }
+        }
+        // Retry leaf modules in parallel
+        pagesGenerated += await this.runParallel(failedLeaves, async (node) => {
+            try {
+                await this.generateLeafPage(node);
+                reportProgress(node.name);
+                return 1;
+            }
+            catch {
+                this.failedModules.push(node.name);
+                reportProgress(`Failed: ${node.name}`);
+                return 0;
+            }
+        });
+        // Retry parent modules sequentially
+        for (const node of failedParents) {
+            try {
+                await this.generateParentPage(node);
+                pagesGenerated++;
+                reportProgress(node.name);
+            }
+            catch {
+                this.failedModules.push(node.name);
+                reportProgress(`Failed: ${node.name}`);
+            }
+        }
+        // Regenerate overview if any pages were recovered
+        if (pagesGenerated > 0) {
+            this.onProgress('overview', 88, 'Regenerating overview page...');
+            await this.generateOverview(moduleTree);
+        }
+        // Update metadata
+        this.onProgress('finalize', 95, 'Saving metadata...');
+        const moduleFiles = this.extractModuleFiles(moduleTree);
+        await this.saveWikiMeta({
+            fromCommit: currentCommit,
+            generatedAt: new Date().toISOString(),
+            model: this.llmConfig.model,
+            moduleFiles,
+            moduleTree,
+            failedModules: this.failedModules.length > 0 ? [...this.failedModules] : undefined,
+        });
+        this.onProgress('done', 100, 'Retry complete');
+        return { pagesGenerated, mode: 'full', failedModules: [...this.failedModules] };
+    }
     // ─── Phase 1: Build Module Tree ────────────────────────────────────
     async buildModuleTree(files) {
         // Check for existing immutable snapshot (resumability)
@@ -620,6 +711,7 @@ export class WikiGenerator {
             fromCommit: currentCommit,
             generatedAt: new Date().toISOString(),
             model: this.llmConfig.model,
+            failedModules: this.failedModules.length > 0 ? [...this.failedModules] : undefined,
         });
         this.onProgress('done', 100, 'Incremental update complete');
         return { pagesGenerated, mode: 'incremental', failedModules: [...this.failedModules] };

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

@@ -6,6 +6,7 @@
  */
 import { initLbug, executeQuery, closeLbug } from '../../mcp/core/lbug-adapter.js';
 const REPO_ID = '__wiki__';
+const extractLabel = (v) => Array.isArray(v) ? v[0] : typeof v === 'string' ? v : undefined;
 /**
  * Initialize the LadybugDB connection for wiki generation.
  */
@@ -25,14 +26,14 @@ 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
+    RETURN f.filePath AS filePath, n.name AS name, labels(n) AS type
     ORDER BY f.filePath
   `);
     const fileMap = new Map();
     for (const row of rows) {
         const fp = row.filePath || row[0];
         const name = row.name || row[1];
-        const type = row.type || row[2];
+        const type = extractLabel(row.type || row[2]);
         let entry = fileMap.get(fp);
         if (!entry) {
             entry = { filePath: fp, symbols: [] };
@@ -152,7 +153,7 @@ export async function getProcessesForFiles(filePaths, limit = 5) {
         // 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
+      RETURN s.name AS name, s.filePath AS filePath, labels(s) AS type, r.step AS step
       ORDER BY r.step
     `);
         processes.push({
@@ -164,7 +165,7 @@ export async function getProcessesForFiles(filePaths, limit = 5) {
                 step: s.step || s[3] || 0,
                 name: s.name || s[0],
                 filePath: s.filePath || s[1],
-                type: s.type || s[2],
+                type: extractLabel(s.type || s[2]),
             })),
         });
     }
@@ -189,7 +190,7 @@ export async function getAllProcesses(limit = 20) {
         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
+      RETURN s.name AS name, s.filePath AS filePath, labels(s) AS type, r.step AS step
       ORDER BY r.step
     `);
         processes.push({
@@ -201,7 +202,7 @@ export async function getAllProcesses(limit = 20) {
                 step: s.step || s[3] || 0,
                 name: s.name || s[0],
                 filePath: s.filePath || s[1],
-                type: s.type || s[2],
+                type: extractLabel(s.type || s[2]),
             })),
         });
     }

package/dist/core/wiki/llm-client.d.ts

@@ -39,5 +39,7 @@ export interface CallLLMOptions {
  * Call an OpenAI-compatible LLM API.
  * Uses streaming when onChunk callback is provided for real-time progress.
  * Retries up to 3 times on transient failures (429, 5xx, network errors).
+ *
+ * Automatically detects Anthropic API URLs and routes to the Messages API.
  */
 export declare function callLLM(prompt: string, config: LLMConfig, systemPrompt?: string, options?: CallLLMOptions): Promise<LLMResponse>;

package/dist/core/wiki/llm-client.js

@@ -51,12 +51,164 @@ function isGatewayStreamStartFailure(status, errorText) {
     return normalized.includes('empty_stream')
         || normalized.includes('upstream stream closed before first payload');
 }
+/**
+ * Detect whether a base URL points to the Anthropic Messages API.
+ */
+function isAnthropicAPI(baseUrl) {
+    return /anthropic\.com/i.test(baseUrl);
+}
+/**
+ * Resolve the API key for Anthropic, preferring Anthropic-specific sources.
+ * Priority: ANTHROPIC_API_KEY env > saved config key (if Anthropic-shaped) > config.apiKey
+ */
+async function resolveAnthropicApiKey(configApiKey) {
+    // 1. Dedicated Anthropic env var
+    if (process.env.ANTHROPIC_API_KEY)
+        return process.env.ANTHROPIC_API_KEY;
+    // 2. If the resolved key looks like an Anthropic key, use it
+    if (configApiKey.startsWith('sk-ant-'))
+        return configApiKey;
+    // 3. Fall back to saved config key (may differ from resolved key when env vars override)
+    const { loadCLIConfig } = await import('../../storage/repo-manager.js');
+    const saved = await loadCLIConfig();
+    if (saved.apiKey?.startsWith('sk-ant-'))
+        return saved.apiKey;
+    // 4. Use whatever was resolved
+    return configApiKey;
+}
+/**
+ * Call the Anthropic Messages API (/v1/messages).
+ * Handles both streaming and non-streaming modes.
+ */
+async function callAnthropicLLM(prompt, config, systemPrompt, options) {
+    const apiKey = await resolveAnthropicApiKey(config.apiKey);
+    const url = `${config.baseUrl.replace(/\/+$/, '')}/v1/messages`;
+    const useStream = !!options?.onChunk;
+    const body = {
+        model: config.model,
+        max_tokens: config.maxTokens,
+        temperature: config.temperature,
+        messages: [{ role: 'user', content: prompt }],
+    };
+    if (systemPrompt) {
+        body.system = systemPrompt;
+    }
+    if (useStream) {
+        body.stream = true;
+    }
+    const headers = {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+    };
+    const MAX_RETRIES = 3;
+    let lastError = null;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => 'unknown error');
+                if (response.status === 429 && attempt < MAX_RETRIES - 1) {
+                    const retryAfter = parseInt(response.headers.get('retry-after') || '0', 10);
+                    const delay = retryAfter > 0 ? retryAfter * 1000 : (2 ** attempt) * 3000;
+                    await sleep(delay);
+                    continue;
+                }
+                if (response.status >= 500 && attempt < MAX_RETRIES - 1) {
+                    await sleep((attempt + 1) * 2000);
+                    continue;
+                }
+                throw new Error(`LLM API error (${response.status}): ${errorText.slice(0, 500)}`);
+            }
+            if (useStream && response.body) {
+                return await readAnthropicSSEStream(response.body, options.onChunk);
+            }
+            const json = await response.json();
+            const text = json.content?.find((b) => b.type === 'text')?.text;
+            if (!text) {
+                throw new Error('LLM returned empty response');
+            }
+            return {
+                content: text,
+                promptTokens: json.usage?.input_tokens,
+                completionTokens: json.usage?.output_tokens,
+            };
+        }
+        catch (err) {
+            lastError = err;
+            if (attempt < MAX_RETRIES - 1 && (err.code === 'ECONNREFUSED' || err.code === 'ETIMEDOUT' || err.message?.includes('fetch'))) {
+                await sleep((attempt + 1) * 3000);
+                continue;
+            }
+            throw err;
+        }
+    }
+    throw lastError || new Error('LLM call failed after retries');
+}
+/**
+ * Read an SSE stream from the Anthropic Messages API.
+ * Anthropic uses event types: content_block_delta with delta.text.
+ */
+async function readAnthropicSSEStream(body, onChunk) {
+    const decoder = new TextDecoder();
+    const reader = body.getReader();
+    let content = '';
+    let buffer = '';
+    let promptTokens;
+    let completionTokens;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || !trimmed.startsWith('data: '))
+                continue;
+            const data = trimmed.slice(6);
+            if (data === '[DONE]')
+                continue;
+            try {
+                const parsed = JSON.parse(data);
+                if (parsed.type === 'content_block_delta' && parsed.delta?.text) {
+                    content += parsed.delta.text;
+                    onChunk(content.length);
+                }
+                else if (parsed.type === 'message_delta' && parsed.usage) {
+                    completionTokens = parsed.usage.output_tokens;
+                }
+                else if (parsed.type === 'message_start' && parsed.message?.usage) {
+                    promptTokens = parsed.message.usage.input_tokens;
+                }
+            }
+            catch {
+                // Skip malformed SSE chunks
+            }
+        }
+    }
+    if (!content) {
+        throw new Error('LLM returned empty streaming response');
+    }
+    return { content, promptTokens, completionTokens };
+}
 /**
  * Call an OpenAI-compatible LLM API.
  * Uses streaming when onChunk callback is provided for real-time progress.
  * Retries up to 3 times on transient failures (429, 5xx, network errors).
+ *
+ * Automatically detects Anthropic API URLs and routes to the Messages API.
  */
 export async function callLLM(prompt, config, systemPrompt, options) {
+    // Route to Anthropic Messages API when baseUrl points to anthropic.com
+    if (isAnthropicAPI(config.baseUrl)) {
+        return callAnthropicLLM(prompt, config, systemPrompt, options);
+    }
     const messages = [];
     if (systemPrompt) {
         messages.push({ role: 'system', content: systemPrompt });

package/dist/mcp/local/local-backend.js

@@ -42,6 +42,12 @@ export const VALID_NODE_LABELS = new Set([
 export const VALID_RELATION_TYPES = new Set(['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS', 'HAS_METHOD', 'HAS_PROPERTY', 'OVERRIDES', 'ACCESSES']);
 /** Regex to detect write operations in user-supplied Cypher queries */
 export const CYPHER_WRITE_RE = /\b(CREATE|DELETE|SET|MERGE|REMOVE|DROP|ALTER|COPY|DETACH)\b/i;
+/**
+ * Extract the primary label from a KùzuDB labels() result.
+ * KùzuDB returns labels() as a string[] but does not support array indexing [0]
+ * in Cypher, so we return the full array from queries and extract here.
+ */
+const extractLabel = (v) => Array.isArray(v) ? v[0] : typeof v === 'string' ? v : undefined;
 /** Check if a Cypher query contains write operations */
 export function isWriteQuery(query) {
     return CYPHER_WRITE_RE.test(query);
@@ -294,21 +300,21 @@ export class LocalBackend {
         if (!params.symbol_uid && !symbolName) {
             return { error: 'Either "function" or "symbol_uid" is required.' };
         }
-        const rows = await executeParameterized(repo.id, `
-      MATCH (n)
-      WHERE labels(n)[0] IN ['Function', 'Method']
-        AND (($symbolId = '') OR n.id = $symbolId)
-        AND (($symbolName = '') OR n.name = $symbolName)
-        AND (($filePath = '') OR n.filePath = $filePath)
-      OPTIONAL MATCH (owner)-[:CodeRelation {type: 'HAS_METHOD'}]->(n)
-      RETURN
-        n.id AS symbolId,
-        n.name AS symbolName,
-        labels(n)[0] AS symbolType,
-        n.filePath AS filePath,
-        n.startLine AS startLine,
-        owner.name AS ownerClass
-      LIMIT 25
+        const rows = await executeParameterized(repo.id, `
+      MATCH (n)
+      WHERE labels(n) IN ['Function', 'Method']
+        AND (($symbolId = '') OR n.id = $symbolId)
+        AND (($symbolName = '') OR n.name = $symbolName)
+        AND (($filePath = '') OR n.filePath = $filePath)
+      OPTIONAL MATCH (owner)-[:CodeRelation {type: 'HAS_METHOD'}]->(n)
+      RETURN
+        n.id AS symbolId,
+        n.name AS symbolName,
+        labels(n) AS symbolType,
+        n.filePath AS filePath,
+        n.startLine AS startLine,
+        owner.name AS ownerClass
+      LIMIT 25
     `, {
             symbolId: params.symbol_uid || '',
             symbolName,
@@ -322,7 +328,7 @@ export class LocalBackend {
             return {
                 symbol_id: row.symbolId || row[0],
                 symbol_name: row.symbolName || row[1],
-                symbol_type: row.symbolType || row[2],
+                symbol_type: extractLabel(row.symbolType || row[2]),
                 class_name: ownerClass,
                 file_path: row.filePath || row[3],
                 start_line: row.startLine || row[4],
@@ -706,7 +712,7 @@ export class LocalBackend {
                 const symbols = await executeParameterized(repo.id, `
           MATCH (n)
           WHERE n.filePath = $filePath
-          RETURN n.id AS id, n.name AS name, labels(n)[0] AS type, n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine
+          RETURN n.id AS id, n.name AS name, labels(n) AS type, n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine
           LIMIT 3
         `, { filePath: fullPath });
                 if (symbols.length > 0) {
@@ -714,7 +720,7 @@ export class LocalBackend {
                         results.push({
                             nodeId: sym.id || sym[0],
                             name: sym.name || sym[1],
-                            type: sym.type || sym[2],
+                            type: extractLabel(sym.type || sym[2]),
                             filePath: sym.filePath || sym[3],
                             startLine: sym.startLine || sym[4],
                             endLine: sym.endLine || sym[5],
@@ -961,7 +967,7 @@ export class LocalBackend {
         if (uid) {
             symbols = await executeParameterized(repo.id, `
         MATCH (n {id: $uid})
-        RETURN n.id AS id, n.name AS name, labels(n)[0] AS type, n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine${include_content ? ', n.content AS content' : ''}
+        RETURN n.id AS id, n.name AS name, labels(n) AS type, n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine${include_content ? ', n.content AS content' : ''}
         LIMIT 1
       `, { uid });
         }
@@ -983,7 +989,7 @@ export class LocalBackend {
             }
             symbols = await executeParameterized(repo.id, `
         MATCH (n) ${whereClause}
-        RETURN n.id AS id, n.name AS name, labels(n)[0] AS type, n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine${include_content ? ', n.content AS content' : ''}
+        RETURN n.id AS id, n.name AS name, labels(n) AS type, n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine${include_content ? ', n.content AS content' : ''}
         LIMIT 10
       `, queryParams);
         }
@@ -998,7 +1004,7 @@ export class LocalBackend {
                 candidates: symbols.map((s) => ({
                     uid: s.id || s[0],
                     name: s.name || s[1],
-                    kind: s.type || s[2],
+                    kind: extractLabel(s.type || s[2]),
                     filePath: s.filePath || s[3],
                     line: s.startLine || s[4],
                 })),
@@ -1011,14 +1017,14 @@ export class LocalBackend {
         const incomingRows = await executeParameterized(repo.id, `
       MATCH (caller)-[r:CodeRelation]->(n {id: $symId})
       WHERE r.type IN ['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS', 'HAS_METHOD', 'HAS_PROPERTY', 'OVERRIDES', 'ACCESSES']
-      RETURN r.type AS relType, caller.id AS uid, caller.name AS name, caller.filePath AS filePath, labels(caller)[0] AS kind
+      RETURN r.type AS relType, caller.id AS uid, caller.name AS name, caller.filePath AS filePath, labels(caller) AS kind
       LIMIT 30
     `, { symId });
         // Categorized outgoing refs
         const outgoingRows = await executeParameterized(repo.id, `
       MATCH (n {id: $symId})-[r:CodeRelation]->(target)
       WHERE r.type IN ['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS', 'HAS_METHOD', 'HAS_PROPERTY', 'OVERRIDES', 'ACCESSES']
-      RETURN r.type AS relType, target.id AS uid, target.name AS name, target.filePath AS filePath, labels(target)[0] AS kind
+      RETURN r.type AS relType, target.id AS uid, target.name AS name, target.filePath AS filePath, labels(target) AS kind
       LIMIT 30
     `, { symId });
         // Process participation
@@ -1041,7 +1047,7 @@ export class LocalBackend {
                     uid: row.uid || row[1],
                     name: row.name || row[2],
                     filePath: row.filePath || row[3],
-                    kind: row.kind || row[4],
+                    kind: extractLabel(row.kind || row[4]),
                 };
                 if (!cats[relType])
                     cats[relType] = [];
@@ -1054,7 +1060,7 @@ export class LocalBackend {
             symbol: {
                 uid: sym.id || sym[0],
                 name: sym.name || sym[1],
-                kind: sym.type || sym[2],
+                kind: extractLabel(sym.type || sym[2]),
                 filePath: sym.filePath || sym[3],
                 startLine: sym.startLine || sym[4],
                 endLine: sym.endLine || sym[5],
@@ -1101,7 +1107,7 @@ export class LocalBackend {
             const members = await executeParameterized(repo.id, `
         MATCH (n)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
         WHERE c.label = $clusterName OR c.heuristicLabel = $clusterName
-        RETURN DISTINCT n.name AS name, labels(n)[0] AS type, n.filePath AS filePath
+        RETURN DISTINCT n.name AS name, labels(n) AS type, n.filePath AS filePath
         LIMIT 30
       `, { clusterName: name });
             return {
@@ -1114,7 +1120,7 @@ export class LocalBackend {
                     subCommunities: rawClusters.length,
                 },
                 members: members.map((m) => ({
-                    name: m.name || m[0], type: m.type || m[1], filePath: m.filePath || m[2],
+                    name: m.name || m[0], type: extractLabel(m.type || m[1]), filePath: m.filePath || m[2],
                 })),
             };
         }
@@ -1131,7 +1137,7 @@ export class LocalBackend {
             const procId = proc.id || proc[0];
             const steps = await executeParameterized(repo.id, `
         MATCH (n)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p {id: $procId})
-        RETURN n.name AS name, labels(n)[0] AS type, n.filePath AS filePath, r.step AS step
+        RETURN n.name AS name, labels(n) AS type, n.filePath AS filePath, r.step AS step
         ORDER BY r.step
       `, { procId });
             return {
@@ -1140,7 +1146,7 @@ export class LocalBackend {
                     processType: proc.processType || proc[3], stepCount: proc.stepCount || proc[4],
                 },
                 steps: steps.map((s) => ({
-                    step: s.step || s[3], name: s.name || s[0], type: s.type || s[1], filePath: s.filePath || s[2],
+                    step: s.step || s[3], name: s.name || s[0], type: extractLabel(s.type || s[1]), filePath: s.filePath || s[2],
                 })),
             };
         }
@@ -1195,14 +1201,14 @@ export class LocalBackend {
             try {
                 const symbols = await executeParameterized(repo.id, `
           MATCH (n) WHERE n.filePath CONTAINS $filePath
-          RETURN n.id AS id, n.name AS name, labels(n)[0] AS type, n.filePath AS filePath
+          RETURN n.id AS id, n.name AS name, labels(n) AS type, n.filePath AS filePath
           LIMIT 20
         `, { filePath: normalizedFile });
                 for (const sym of symbols) {
                     changedSymbols.push({
                         id: sym.id || sym[0],
                         name: sym.name || sym[1],
-                        type: sym.type || sym[2],
+                        type: extractLabel(sym.type || sym[2]),
                         filePath: sym.filePath || sym[3],
                         change_type: 'Modified',
                     });
@@ -1441,7 +1447,7 @@ export class LocalBackend {
         const targets = await executeParameterized(repo.id, `
       MATCH (n)
       WHERE n.name = $targetName
-      RETURN n.id AS id, n.name AS name, labels(n)[0] AS type, n.filePath AS filePath
+      RETURN n.id AS id, n.name AS name, labels(n) AS type, n.filePath AS filePath
       LIMIT 1
     `, { targetName: target });
         if (targets.length === 0)
@@ -1457,8 +1463,8 @@ export class LocalBackend {
             // Batch frontier nodes into a single Cypher query per depth level
             const idList = frontier.map(id => `'${id.replace(/'/g, "''")}'`).join(', ');
             const query = direction === 'upstream'
-                ? `MATCH (caller)-[r:CodeRelation]->(n) WHERE n.id IN [${idList}] AND r.type IN [${relTypeFilter}]${confidenceFilter} RETURN n.id AS sourceId, caller.id AS id, caller.name AS name, labels(caller)[0] AS type, caller.filePath AS filePath, r.type AS relType, r.confidence AS confidence`
-                : `MATCH (n)-[r:CodeRelation]->(callee) WHERE n.id IN [${idList}] AND r.type IN [${relTypeFilter}]${confidenceFilter} RETURN n.id AS sourceId, callee.id AS id, callee.name AS name, labels(callee)[0] AS type, callee.filePath AS filePath, r.type AS relType, r.confidence AS confidence`;
+                ? `MATCH (caller)-[r:CodeRelation]->(n) WHERE n.id IN [${idList}] AND r.type IN [${relTypeFilter}]${confidenceFilter} RETURN n.id AS sourceId, caller.id AS id, caller.name AS name, labels(caller) AS type, caller.filePath AS filePath, r.type AS relType, r.confidence AS confidence`
+                : `MATCH (n)-[r:CodeRelation]->(callee) WHERE n.id IN [${idList}] AND r.type IN [${relTypeFilter}]${confidenceFilter} RETURN n.id AS sourceId, callee.id AS id, callee.name AS name, labels(callee) AS type, callee.filePath AS filePath, r.type AS relType, r.confidence AS confidence`;
             try {
                 const related = await executeQuery(repo.id, query);
                 for (const rel of related) {
@@ -1473,7 +1479,7 @@ export class LocalBackend {
                             depth,
                             id: relId,
                             name: rel.name || rel[2],
-                            type: rel.type || rel[3],
+                            type: extractLabel(rel.type || rel[3]),
                             filePath,
                             relationType: rel.relType || rel[5],
                             confidence: rel.confidence || rel[6] || 1.0,
@@ -1558,7 +1564,7 @@ export class LocalBackend {
             target: {
                 id: symId,
                 name: sym.name || sym[1],
-                type: sym.type || sym[2],
+                type: extractLabel(sym.type || sym[2]),
                 filePath: sym.filePath || sym[3],
             },
             direction,
@@ -1659,7 +1665,7 @@ export class LocalBackend {
         const members = await executeParameterized(repo.id, `
       MATCH (n)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
       WHERE c.label = $clusterName OR c.heuristicLabel = $clusterName
-      RETURN DISTINCT n.name AS name, labels(n)[0] AS type, n.filePath AS filePath
+      RETURN DISTINCT n.name AS name, labels(n) AS type, n.filePath AS filePath
       LIMIT 30
     `, { clusterName: name });
         return {
@@ -1672,7 +1678,7 @@ export class LocalBackend {
                 subCommunities: rawClusters.length,
             },
             members: members.map((m) => ({
-                name: m.name || m[0], type: m.type || m[1], filePath: m.filePath || m[2],
+                name: m.name || m[0], type: extractLabel(m.type || m[1]), filePath: m.filePath || m[2],
             })),
         };
     }
@@ -1695,7 +1701,7 @@ export class LocalBackend {
         const procId = proc.id || proc[0];
         const steps = await executeParameterized(repo.id, `
       MATCH (n)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p {id: $procId})
-      RETURN n.name AS name, labels(n)[0] AS type, n.filePath AS filePath, r.step AS step
+      RETURN n.name AS name, labels(n) AS type, n.filePath AS filePath, r.step AS step
       ORDER BY r.step
     `, { procId });
         return {
@@ -1704,7 +1710,7 @@ export class LocalBackend {
                 processType: proc.processType || proc[3], stepCount: proc.stepCount || proc[4],
             },
             steps: steps.map((s) => ({
-                step: s.step || s[3], name: s.name || s[0], type: s.type || s[1], filePath: s.filePath || s[2],
+                step: s.step || s[3], name: s.name || s[0], type: extractLabel(s.type || s[1]), filePath: s.filePath || s[2],
             })),
         };
     }

package/dist/mcp/resources.js

@@ -295,7 +295,7 @@ example_queries:
   find_community_members: |
     MATCH (s)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
     WHERE c.heuristicLabel = "Auth"
-    RETURN s.name, labels(s)[0] AS type
+    RETURN s.name, labels(s) AS type
   
   trace_process: |
     MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)

package/dist/unreal/blueprint-ingestion.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Blueprint Ingestion — adds Unreal Blueprint assets to the knowledge graph
+ *
+ * Reads the asset manifest (produced by `gitnexus unreal-sync`) and creates
+ * Blueprint nodes plus edges to C++ classes and functions already in the graph.
+ * Runs as a post-pipeline step before LadybugDB loading.
+ */
+import { KnowledgeGraph } from '../core/graph/types.js';
+export interface BlueprintIngestionResult {
+    nodesAdded: number;
+    edgesAdded: number;
+}
+/**
+ * Ingest Blueprint assets from the Unreal asset manifest into the knowledge graph.
+ * Creates Blueprint nodes and edges (EXTENDS, CALLS, IMPORTS) linking them to
+ * existing C++ symbols in the graph.
+ */
+export declare const ingestBlueprintsIntoGraph: (graph: KnowledgeGraph, storagePath: string) => Promise<BlueprintIngestionResult>;

package/dist/unreal/blueprint-ingestion.js

@@ -0,0 +1,200 @@
+/**
+ * Blueprint Ingestion — adds Unreal Blueprint assets to the knowledge graph
+ *
+ * Reads the asset manifest (produced by `gitnexus unreal-sync`) and creates
+ * Blueprint nodes plus edges to C++ classes and functions already in the graph.
+ * Runs as a post-pipeline step before LadybugDB loading.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { generateId } from '../lib/utils.js';
+/** Extract a display name from an Unreal asset path (last segment). */
+const extractAssetName = (assetPath) => {
+    // "/Game/Characters/BP_Hero" → "BP_Hero"
+    // "/Game/Characters/BP_Hero.BP_Hero_C" → "BP_Hero"
+    const lastSlash = assetPath.lastIndexOf('/');
+    const segment = lastSlash >= 0 ? assetPath.slice(lastSlash + 1) : assetPath;
+    const dotIdx = segment.indexOf('.');
+    return dotIdx >= 0 ? segment.slice(0, dotIdx) : segment;
+};
+/** Extract a C++ class name from an Unreal class path.
+ *  "/Script/Engine.Character" → "Character"
+ *  "/Script/Engine.ACharacter" → "ACharacter"
+ *  "ACharacter" → "ACharacter" (already plain)
+ */
+const extractClassName = (unrealPath) => {
+    const dotIdx = unrealPath.lastIndexOf('.');
+    if (dotIdx >= 0)
+        return unrealPath.slice(dotIdx + 1);
+    const slashIdx = unrealPath.lastIndexOf('/');
+    return slashIdx >= 0 ? unrealPath.slice(slashIdx + 1) : unrealPath;
+};
+/**
+ * Ingest Blueprint assets from the Unreal asset manifest into the knowledge graph.
+ * Creates Blueprint nodes and edges (EXTENDS, CALLS, IMPORTS) linking them to
+ * existing C++ symbols in the graph.
+ */
+export const ingestBlueprintsIntoGraph = async (graph, storagePath) => {
+    const manifestPath = path.join(storagePath, 'unreal', 'asset-manifest.json');
+    let manifest;
+    try {
+        const raw = await fs.readFile(manifestPath, 'utf-8');
+        manifest = JSON.parse(raw);
+    }
+    catch {
+        return { nodesAdded: 0, edgesAdded: 0 };
+    }
+    if (!manifest.assets || manifest.assets.length === 0) {
+        return { nodesAdded: 0, edgesAdded: 0 };
+    }
+    // ── Build lookup indexes from existing graph nodes ──────────────────
+    // Class/Struct nodes keyed by name (for parent class matching)
+    const classByName = new Map();
+    // Method/Function nodes keyed by name (for native_function_refs matching)
+    const symbolByName = new Map();
+    // Class ID → set of Method IDs (via HAS_METHOD edges)
+    const classMethodIds = new Map();
+    // Build class→method map from HAS_METHOD edges
+    for (const rel of graph.iterRelationships()) {
+        if (rel.type === 'HAS_METHOD') {
+            let methods = classMethodIds.get(rel.sourceId);
+            if (!methods) {
+                methods = new Set();
+                classMethodIds.set(rel.sourceId, methods);
+            }
+            methods.add(rel.targetId);
+        }
+    }
+    for (const node of graph.iterNodes()) {
+        if (node.label === 'Class' || node.label === 'Struct') {
+            const name = node.properties.name;
+            let list = classByName.get(name);
+            if (!list) {
+                list = [];
+                classByName.set(name, list);
+            }
+            list.push(node);
+        }
+        if (node.label === 'Method' || node.label === 'Function') {
+            const name = node.properties.name;
+            let list = symbolByName.get(name);
+            if (!list) {
+                list = [];
+                symbolByName.set(name, list);
+            }
+            list.push(node);
+        }
+    }
+    // Reverse map: method ID → owning class name (for disambiguation)
+    const methodOwnerName = new Map();
+    for (const [classId, methodIds] of classMethodIds) {
+        const classNode = graph.getNode(classId);
+        if (!classNode)
+            continue;
+        for (const methodId of methodIds) {
+            methodOwnerName.set(methodId, classNode.properties.name);
+        }
+    }
+    // ── Create Blueprint nodes and edges ────────────────────────────────
+    let nodesAdded = 0;
+    let edgesAdded = 0;
+    let edgeCounter = 0;
+    // Track created Blueprint IDs for second-pass dependency edges
+    const blueprintIdByAssetPath = new Map();
+    for (const asset of manifest.assets) {
+        const bpId = generateId('Blueprint', asset.asset_path);
+        const bpName = extractAssetName(asset.asset_path);
+        graph.addNode({
+            id: bpId,
+            label: 'Blueprint',
+            properties: {
+                name: bpName,
+                filePath: asset.asset_path,
+                startLine: -1,
+                endLine: -1,
+                description: asset.generated_class || '',
+            },
+        });
+        nodesAdded++;
+        blueprintIdByAssetPath.set(asset.asset_path, bpId);
+        // ── EXTENDS edge to nearest native parent class ──────────────
+        const nativeParents = asset.native_parents || [];
+        if (nativeParents.length > 0) {
+            const parentClassName = extractClassName(nativeParents[0]);
+            const candidates = classByName.get(parentClassName);
+            if (candidates && candidates.length > 0) {
+                const target = candidates[0]; // pick first match
+                graph.addRelationship({
+                    id: generateId('EXTENDS', `${bpId}->${target.id}:${edgeCounter++}`),
+                    sourceId: bpId,
+                    targetId: target.id,
+                    type: 'EXTENDS',
+                    confidence: 0.9,
+                    reason: 'blueprint-manifest',
+                });
+                edgesAdded++;
+            }
+        }
+        // ── CALLS edges for native function references ───────────────
+        const funcRefs = asset.native_function_refs || [];
+        for (const ref of funcRefs) {
+            const colonIdx = ref.lastIndexOf('::');
+            let targetClassName;
+            let funcName;
+            if (colonIdx >= 0) {
+                targetClassName = ref.slice(0, colonIdx);
+                funcName = ref.slice(colonIdx + 2);
+            }
+            else {
+                funcName = ref;
+            }
+            const candidates = symbolByName.get(funcName);
+            if (!candidates || candidates.length === 0)
+                continue;
+            // If we have a class name, prefer methods owned by that class
+            let matched;
+            if (targetClassName) {
+                matched = candidates.find(c => {
+                    const owner = methodOwnerName.get(c.id);
+                    return owner === targetClassName;
+                });
+            }
+            // Fallback: first candidate
+            if (!matched)
+                matched = candidates[0];
+            graph.addRelationship({
+                id: generateId('CALLS', `${bpId}->${matched.id}:${edgeCounter++}`),
+                sourceId: bpId,
+                targetId: matched.id,
+                type: 'CALLS',
+                confidence: 0.8,
+                reason: 'blueprint-manifest',
+            });
+            edgesAdded++;
+        }
+    }
+    // ── Second pass: Blueprint-to-Blueprint IMPORTS edges ───────────────
+    for (const asset of manifest.assets) {
+        const deps = asset.dependencies || [];
+        if (deps.length === 0)
+            continue;
+        const sourceBpId = blueprintIdByAssetPath.get(asset.asset_path);
+        if (!sourceBpId)
+            continue;
+        for (const dep of deps) {
+            const targetBpId = blueprintIdByAssetPath.get(dep);
+            if (!targetBpId || targetBpId === sourceBpId)
+                continue;
+            graph.addRelationship({
+                id: generateId('IMPORTS', `${sourceBpId}->${targetBpId}:${edgeCounter++}`),
+                sourceId: sourceBpId,
+                targetId: targetBpId,
+                type: 'IMPORTS',
+                confidence: 0.7,
+                reason: 'blueprint-manifest',
+            });
+            edgesAdded++;
+        }
+    }
+    return { nodesAdded, edgesAdded };
+};

package/dist/unreal/types.d.ts

@@ -52,12 +52,39 @@ export interface UnrealConfirmedReference {
     chain_anchor_id: string;
     source: 'editor_confirmed';
 }
+export interface UnrealChainNodePin {
+    name: string;
+    direction: 'input' | 'output';
+    type: string;
+    sub_type?: string;
+    default_value?: string;
+    connected_to?: string[];
+    connected_to_title?: string[];
+}
+export interface UnrealChainNodePins {
+    exec_pins: UnrealChainNodePin[];
+    data_pins: UnrealChainNodePin[];
+}
+export interface UnrealChainNodeDetails {
+    is_pure?: boolean;
+    target_class?: string;
+    function_name?: string;
+    variable_name?: string;
+    node_role?: 'variable_get' | 'variable_set';
+    branch_type?: 'if_then_else' | 'switch';
+}
 export interface UnrealChainNode {
     node_id: string;
     graph_name?: string;
     node_kind: string;
     node_title?: string;
     depth: number;
+    is_enabled?: boolean;
+    comment?: string;
+    traversed_from_pin?: string;
+    traversed_from_node?: string;
+    pins?: UnrealChainNodePins;
+    details?: UnrealChainNodeDetails;
 }
 export interface SyncUnrealAssetManifestResult {
     status: 'success' | 'error';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duytransipher/gitnexus",
-  "version": "1.1.2",
+  "version": "1.2.1",
   "description": "Sipher-maintained fork of GitNexus for graph-powered code intelligence via MCP and CLI.",
   "author": "DuyTranSipher",
   "license": "PolyForm-Noncommercial-1.0.0",

package/scripts/setup-unreal-gitnexus.ps1

@@ -108,6 +108,20 @@ function Resolve-UnrealEditorCmd {
         } catch {
         }
 
+        # Try LauncherInstalled.dat (Epic Games Launcher writes this for all engine installs)
+        try {
+            $launcherDat = Join-Path $env:LOCALAPPDATA 'EpicGames\UnrealEngineLauncher\LauncherInstalled.dat'
+            if (Test-Path -LiteralPath $launcherDat -PathType Leaf) {
+                $launcher = Get-Content -LiteralPath $launcherDat -Raw | ConvertFrom-Json
+                foreach ($entry in $launcher.InstallationList) {
+                    if ($entry.AppName -eq "UE_$EngineAssociation" -or $entry.AppName -eq $EngineAssociation) {
+                        Add-EditorCmdCandidates -Candidates $candidates -RootOrExe $entry.InstallLocation
+                    }
+                }
+            }
+        } catch {
+        }
+
         Add-EditorCmdCandidates -Candidates $candidates -RootOrExe "C:\Program Files\Epic Games\UE_$EngineAssociation"
     }