@duytransipher/gitnexus 1.2.2 → 1.3.0

package/dist/cli/analyze.js

@@ -185,7 +185,7 @@ export const analyzeCommand = async (inputPath, options) => {
     // ── Phase 1.5: Blueprint Ingestion (optional) ────────────────────────
     try {
         const { ingestBlueprintsIntoGraph } = await import('../unreal/blueprint-ingestion.js');
-        const bpResult = await ingestBlueprintsIntoGraph(pipelineResult.graph, storagePath);
+        const bpResult = await ingestBlueprintsIntoGraph(pipelineResult.graph, storagePath, repoPath);
         if (bpResult.nodesAdded > 0) {
             updateBar(61, `Indexed ${bpResult.nodesAdded} Blueprints (${bpResult.edgesAdded} edges)`);
         }

package/dist/cli/index.js

@@ -106,6 +106,7 @@ program
     .command('unreal-sync')
     .description('Refresh the Unreal Blueprint asset manifest for the current indexed repo')
     .option('-r, --repo <name>', 'Target repository')
+    .option('--deep', 'Deep mode: load Blueprints fully for native_function_refs (slower, higher memory)')
     .action(createLazyAction(() => import('./tool.js'), 'syncUnrealAssetManifestCommand'));
 program
     .command('unreal-find-refs [functionName]')

package/dist/cli/tool.d.ts

@@ -39,6 +39,7 @@ export declare function cypherCommand(query: string, options?: {
 }): Promise<void>;
 export declare function syncUnrealAssetManifestCommand(options?: {
     repo?: string;
+    deep?: boolean;
 }): Promise<void>;
 export declare function findNativeBlueprintReferencesCommand(functionName: string, options?: {
     repo?: string;

package/dist/cli/tool.js

@@ -129,13 +129,14 @@ export async function cypherCommand(query, options) {
 }
 export async function syncUnrealAssetManifestCommand(options) {
     const backend = await getBackend();
-    const result = await withUnrealProgress(() => backend.callTool('sync_unreal_asset_manifest', { repo: options?.repo }), { phaseLabel: 'Syncing Unreal asset manifest', successLabel: 'Manifest synced', failLabel: 'Manifest sync failed', isError: isUnrealError });
+    const mode = options?.deep ? 'deep' : 'metadata';
+    const result = await withUnrealProgress(() => backend.callTool('sync_unreal_asset_manifest', { repo: options?.repo, deep: options?.deep }), { phaseLabel: `Syncing Unreal asset manifest (${mode} mode)`, successLabel: 'Manifest synced', failLabel: 'Manifest sync failed', isError: isUnrealError });
     if (result?.status === 'error') {
         console.error(`\n  Error: ${result.error}\n`);
         process.exit(1);
     }
     if (result?.asset_count != null) {
-        console.log(`  ${result.asset_count.toLocaleString()} Blueprint assets indexed`);
+        console.log(`  ${result.asset_count.toLocaleString()} Blueprint assets indexed (${mode} mode)`);
         if (result.manifest_path)
             console.log(`  ${result.manifest_path}`);
     }

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

@@ -276,7 +276,7 @@ export class LocalBackend {
             case 'rename':
                 return this.rename(repo, params);
             case 'sync_unreal_asset_manifest':
-                return this.syncUnrealAssetManifestTool(repo);
+                return this.syncUnrealAssetManifestTool(repo, params);
             case 'find_native_blueprint_references':
                 return this.findNativeBlueprintReferencesTool(repo, params);
             case 'expand_blueprint_chain':
@@ -426,7 +426,7 @@ export class LocalBackend {
         let manifest = refreshManifest ? null : await loadUnrealAssetManifest(repo.storagePath);
         let manifestRefreshed = false;
         if (!manifest) {
-            const syncResult = await syncUnrealAssetManifest(repo.storagePath, config);
+            const syncResult = await syncUnrealAssetManifest(repo.storagePath, config, repo.repoPath);
             if (syncResult.status === 'error') {
                 return { error: syncResult.error || 'Failed to build Unreal asset manifest.' };
             }
@@ -443,7 +443,7 @@ export class LocalBackend {
             manifestRefreshed,
         };
     }
-    async syncUnrealAssetManifestTool(repo) {
+    async syncUnrealAssetManifestTool(repo, params) {
         const config = await loadUnrealConfig(repo.storagePath);
         if (!config) {
             const paths = getUnrealStoragePaths(repo.storagePath);
@@ -451,7 +451,7 @@ export class LocalBackend {
                 error: `Unreal analyzer is not configured for this repo. Create ${paths.config_path} with editor_cmd and project_path.`,
             };
         }
-        return syncUnrealAssetManifest(repo.storagePath, config);
+        return syncUnrealAssetManifest(repo.storagePath, config, repo.repoPath, params?.deep);
     }
     async findNativeBlueprintReferencesTool(repo, params) {
         const targetResult = await this.resolveNativeFunctionTarget(repo, params);

package/dist/mcp/tools.js

@@ -7,14 +7,14 @@
 export const GITNEXUS_TOOLS = [
     {
         name: 'list_repos',
-        description: `List all indexed repositories available to GitNexus.
-
-Returns each repo's name, path, indexed date, last commit, and stats.
-
-WHEN TO USE: First step when multiple repos are indexed, or to discover available repos.
-AFTER THIS: READ gitnexus://repo/{name}/context for the repo you want to work with.
-
-When multiple repos are indexed, you MUST specify the "repo" parameter
+        description: `List all indexed repositories available to GitNexus.
+
+Returns each repo's name, path, indexed date, last commit, and stats.
+
+WHEN TO USE: First step when multiple repos are indexed, or to discover available repos.
+AFTER THIS: READ gitnexus://repo/{name}/context for the repo you want to work with.
+
+When multiple repos are indexed, you MUST specify the "repo" parameter
 on other tools (query, context, impact, etc.) to target the correct one.`,
         inputSchema: {
             type: 'object',
@@ -29,6 +29,10 @@ on other tools (query, context, impact, etc.) to target the correct one.`,
 Uses the configured Unreal Editor commandlet to enumerate Blueprint assets and
 store a manifest under .gitnexus/unreal/asset-manifest.json.
 
+Two modes:
+- metadata (default): Uses AssetRegistry only — zero Blueprint loading, fast and safe for large projects.
+- deep: Loads each Blueprint fully to extract native_function_refs and graph data. Uses batch GC. Pass deep=true.
+
 WHEN TO USE: Before Blueprint-reference queries, after large Blueprint changes, or
 to validate Unreal analyzer configuration.
 AFTER THIS: Use find_native_blueprint_references() or find_blueprints_derived_from_native_class().`,
@@ -36,6 +40,7 @@ AFTER THIS: Use find_native_blueprint_references() or find_blueprints_derived_fr
             type: 'object',
             properties: {
                 repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
+                deep: { type: 'boolean', description: 'Deep mode: fully load Blueprints for native_function_refs (slower, higher memory). Default: false (metadata-only).' },
             },
             required: [],
         },
@@ -106,15 +111,15 @@ AFTER THIS: Use find_native_blueprint_references() for function-level graph refe
         name: 'query',
         description: `Query the code knowledge graph for execution flows related to a concept.
 Returns processes (call chains) ranked by relevance, each with its symbols and file locations.
-
-WHEN TO USE: Understanding how code works together. Use this when you need execution flows and relationships, not just file matches. Complements grep/IDE search.
-AFTER THIS: Use context() on a specific symbol for 360-degree view (callers, callees, categorized refs).
-
-Returns results grouped by process (execution flow):
-- processes: ranked execution flows with relevance priority
-- process_symbols: all symbols in those flows with file locations and module (functional area)
-- definitions: standalone types/interfaces not in any process
-
+
+WHEN TO USE: Understanding how code works together. Use this when you need execution flows and relationships, not just file matches. Complements grep/IDE search.
+AFTER THIS: Use context() on a specific symbol for 360-degree view (callers, callees, categorized refs).
+
+Returns results grouped by process (execution flow):
+- processes: ranked execution flows with relevance priority
+- process_symbols: all symbols in those flows with file locations and module (functional area)
+- definitions: standalone types/interfaces not in any process
+
 Hybrid ranking: BM25 keyword + semantic vector search, ranked by Reciprocal Rank Fusion.`,
         inputSchema: {
             type: 'object',
@@ -132,49 +137,49 @@ Hybrid ranking: BM25 keyword + semantic vector search, ranked by Reciprocal Rank
     },
     {
         name: 'cypher',
-        description: `Execute Cypher query against the code knowledge graph.
-
-WHEN TO USE: Complex structural queries that search/explore can't answer. READ gitnexus://repo/{name}/schema first for the full schema.
-AFTER THIS: Use context() on result symbols for deeper context.
-
-SCHEMA:
-- Nodes: File, Folder, Function, Class, Interface, Method, CodeElement, Community, Process
-- Multi-language nodes (use backticks): \`Struct\`, \`Enum\`, \`Trait\`, \`Impl\`, etc.
-- All edges via single CodeRelation table with 'type' property
-- Edge types: CONTAINS, DEFINES, CALLS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_METHOD, HAS_PROPERTY, ACCESSES, OVERRIDES, MEMBER_OF, STEP_IN_PROCESS
-- Edge properties: type (STRING), confidence (DOUBLE), reason (STRING), step (INT32)
-
-EXAMPLES:
-• Find callers of a function:
-  MATCH (a)-[:CodeRelation {type: 'CALLS'}]->(b:Function {name: "validateUser"}) RETURN a.name, a.filePath
-
-• Find community members:
-  MATCH (f)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community) WHERE c.heuristicLabel = "Auth" RETURN f.name
-
-• Trace a process:
-  MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process) WHERE p.heuristicLabel = "UserLogin" RETURN s.name, r.step ORDER BY r.step
-
-• Find all methods of a class:
-  MATCH (c:Class {name: "UserService"})-[r:CodeRelation {type: 'HAS_METHOD'}]->(m:Method) RETURN m.name, m.parameterCount, m.returnType
-
-• Find all properties of a class:
-  MATCH (c:Class {name: "User"})-[r:CodeRelation {type: 'HAS_PROPERTY'}]->(p:Property) RETURN p.name, p.description
-
-• Find all writers of a field:
-  MATCH (f:Function)-[r:CodeRelation {type: 'ACCESSES', reason: 'write'}]->(p:Property) WHERE p.name = "address" RETURN f.name, f.filePath
-
-• Find method overrides (MRO resolution):
-  MATCH (winner:Method)-[r:CodeRelation {type: 'OVERRIDES'}]->(loser:Method) RETURN winner.name, winner.filePath, loser.filePath, r.reason
-
-• Detect diamond inheritance:
-  MATCH (d:Class)-[:CodeRelation {type: 'EXTENDS'}]->(b1), (d)-[:CodeRelation {type: 'EXTENDS'}]->(b2), (b1)-[:CodeRelation {type: 'EXTENDS'}]->(a), (b2)-[:CodeRelation {type: 'EXTENDS'}]->(a) WHERE b1 <> b2 RETURN d.name, b1.name, b2.name, a.name
-
-OUTPUT: Returns { markdown, row_count } — results formatted as a Markdown table for easy reading.
-
-TIPS:
-- All relationships use single CodeRelation table — filter with {type: 'CALLS'} etc.
-- Community = auto-detected functional area (Leiden algorithm)
-- Process = execution flow trace from entry point to terminal
+        description: `Execute Cypher query against the code knowledge graph.
+
+WHEN TO USE: Complex structural queries that search/explore can't answer. READ gitnexus://repo/{name}/schema first for the full schema.
+AFTER THIS: Use context() on result symbols for deeper context.
+
+SCHEMA:
+- Nodes: File, Folder, Function, Class, Interface, Method, CodeElement, Community, Process
+- Multi-language nodes (use backticks): \`Struct\`, \`Enum\`, \`Trait\`, \`Impl\`, etc.
+- All edges via single CodeRelation table with 'type' property
+- Edge types: CONTAINS, DEFINES, CALLS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_METHOD, HAS_PROPERTY, ACCESSES, OVERRIDES, MEMBER_OF, STEP_IN_PROCESS
+- Edge properties: type (STRING), confidence (DOUBLE), reason (STRING), step (INT32)
+
+EXAMPLES:
+• Find callers of a function:
+  MATCH (a)-[:CodeRelation {type: 'CALLS'}]->(b:Function {name: "validateUser"}) RETURN a.name, a.filePath
+
+• Find community members:
+  MATCH (f)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community) WHERE c.heuristicLabel = "Auth" RETURN f.name
+
+• Trace a process:
+  MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process) WHERE p.heuristicLabel = "UserLogin" RETURN s.name, r.step ORDER BY r.step
+
+• Find all methods of a class:
+  MATCH (c:Class {name: "UserService"})-[r:CodeRelation {type: 'HAS_METHOD'}]->(m:Method) RETURN m.name, m.parameterCount, m.returnType
+
+• Find all properties of a class:
+  MATCH (c:Class {name: "User"})-[r:CodeRelation {type: 'HAS_PROPERTY'}]->(p:Property) RETURN p.name, p.description
+
+• Find all writers of a field:
+  MATCH (f:Function)-[r:CodeRelation {type: 'ACCESSES', reason: 'write'}]->(p:Property) WHERE p.name = "address" RETURN f.name, f.filePath
+
+• Find method overrides (MRO resolution):
+  MATCH (winner:Method)-[r:CodeRelation {type: 'OVERRIDES'}]->(loser:Method) RETURN winner.name, winner.filePath, loser.filePath, r.reason
+
+• Detect diamond inheritance:
+  MATCH (d:Class)-[:CodeRelation {type: 'EXTENDS'}]->(b1), (d)-[:CodeRelation {type: 'EXTENDS'}]->(b2), (b1)-[:CodeRelation {type: 'EXTENDS'}]->(a), (b2)-[:CodeRelation {type: 'EXTENDS'}]->(a) WHERE b1 <> b2 RETURN d.name, b1.name, b2.name, a.name
+
+OUTPUT: Returns { markdown, row_count } — results formatted as a Markdown table for easy reading.
+
+TIPS:
+- All relationships use single CodeRelation table — filter with {type: 'CALLS'} etc.
+- Community = auto-detected functional area (Leiden algorithm)
+- Process = execution flow trace from entry point to terminal
 - Use heuristicLabel (not label) for human-readable community/process names`,
         inputSchema: {
             type: 'object',
@@ -187,14 +192,14 @@ TIPS:
     },
     {
         name: 'context',
-        description: `360-degree view of a single code symbol.
-Shows categorized incoming/outgoing references (calls, imports, extends, implements, methods, properties, overrides), process participation, and file location.
-
-WHEN TO USE: After query() to understand a specific symbol in depth. When you need to know all callers, callees, and what execution flows a symbol participates in.
-AFTER THIS: Use impact() if planning changes, or READ gitnexus://repo/{name}/process/{processName} for full execution trace.
-
-Handles disambiguation: if multiple symbols share the same name, returns candidates for you to pick from. Use uid param for zero-ambiguity lookup from prior results.
-
+        description: `360-degree view of a single code symbol.
+Shows categorized incoming/outgoing references (calls, imports, extends, implements, methods, properties, overrides), process participation, and file location.
+
+WHEN TO USE: After query() to understand a specific symbol in depth. When you need to know all callers, callees, and what execution flows a symbol participates in.
+AFTER THIS: Use impact() if planning changes, or READ gitnexus://repo/{name}/process/{processName} for full execution trace.
+
+Handles disambiguation: if multiple symbols share the same name, returns candidates for you to pick from. Use uid param for zero-ambiguity lookup from prior results.
+
 NOTE: ACCESSES edges (field read/write tracking) are included in context results. Coverage: reads detected during call chain resolution (e.g., user.address.save() emits a read on 'address'). Standalone reads and writes require Phase 2.`,
         inputSchema: {
             type: 'object',
@@ -210,12 +215,12 @@ NOTE: ACCESSES edges (field read/write tracking) are included in context results
     },
     {
         name: 'detect_changes',
-        description: `Analyze uncommitted git changes and find affected execution flows.
-Maps git diff hunks to indexed symbols, then traces which processes are impacted.
-
-WHEN TO USE: Before committing — to understand what your changes affect. Pre-commit review, PR preparation.
-AFTER THIS: Review affected processes. Use context() on high-risk symbols. READ gitnexus://repo/{name}/process/{name} for full traces.
-
+        description: `Analyze uncommitted git changes and find affected execution flows.
+Maps git diff hunks to indexed symbols, then traces which processes are impacted.
+
+WHEN TO USE: Before committing — to understand what your changes affect. Pre-commit review, PR preparation.
+AFTER THIS: Review affected processes. Use context() on high-risk symbols. READ gitnexus://repo/{name}/process/{name} for full traces.
+
 Returns: changed symbols, affected processes, and a risk summary.`,
         inputSchema: {
             type: 'object',
@@ -229,14 +234,14 @@ Returns: changed symbols, affected processes, and a risk summary.`,
     },
     {
         name: 'rename',
-        description: `Multi-file coordinated rename using the knowledge graph + text search.
-Finds all references via graph (high confidence) and regex text search (lower confidence). Preview by default.
-
-WHEN TO USE: Renaming a function, class, method, or variable across the codebase. Safer than find-and-replace.
-AFTER THIS: Run detect_changes() to verify no unexpected side effects.
-
-Each edit is tagged with confidence:
-- "graph": found via knowledge graph relationships (high confidence, safe to accept)
+        description: `Multi-file coordinated rename using the knowledge graph + text search.
+Finds all references via graph (high confidence) and regex text search (lower confidence). Preview by default.
+
+WHEN TO USE: Renaming a function, class, method, or variable across the codebase. Safer than find-and-replace.
+AFTER THIS: Run detect_changes() to verify no unexpected side effects.
+
+Each edit is tagged with confidence:
+- "graph": found via knowledge graph relationships (high confidence, safe to accept)
 - "text_search": found via regex text search (lower confidence, review carefully)`,
         inputSchema: {
             type: 'object',
@@ -253,27 +258,27 @@ Each edit is tagged with confidence:
     },
     {
         name: 'impact',
-        description: `Analyze the blast radius of changing a code symbol.
-Returns affected symbols grouped by depth, plus risk assessment, affected execution flows, and affected modules.
-
-WHEN TO USE: Before making code changes — especially refactoring, renaming, or modifying shared code. Shows what would break.
-AFTER THIS: Review d=1 items (WILL BREAK). Use context() on high-risk symbols.
-
-Output includes:
-- risk: LOW / MEDIUM / HIGH / CRITICAL
-- summary: direct callers, processes affected, modules affected
-- affected_processes: which execution flows break and at which step
-- affected_modules: which functional areas are hit (direct vs indirect)
-- byDepth: all affected symbols grouped by traversal depth
-
-Depth groups:
-- d=1: WILL BREAK (direct callers/importers)
-- d=2: LIKELY AFFECTED (indirect)
-- d=3: MAY NEED TESTING (transitive)
-
-TIP: Default traversal uses CALLS/IMPORTS/EXTENDS/IMPLEMENTS. For class members, include HAS_METHOD and HAS_PROPERTY in relationTypes. For field access analysis, include ACCESSES in relationTypes.
-
-EdgeType: CALLS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_METHOD, HAS_PROPERTY, OVERRIDES, ACCESSES
+        description: `Analyze the blast radius of changing a code symbol.
+Returns affected symbols grouped by depth, plus risk assessment, affected execution flows, and affected modules.
+
+WHEN TO USE: Before making code changes — especially refactoring, renaming, or modifying shared code. Shows what would break.
+AFTER THIS: Review d=1 items (WILL BREAK). Use context() on high-risk symbols.
+
+Output includes:
+- risk: LOW / MEDIUM / HIGH / CRITICAL
+- summary: direct callers, processes affected, modules affected
+- affected_processes: which execution flows break and at which step
+- affected_modules: which functional areas are hit (direct vs indirect)
+- byDepth: all affected symbols grouped by traversal depth
+
+Depth groups:
+- d=1: WILL BREAK (direct callers/importers)
+- d=2: LIKELY AFFECTED (indirect)
+- d=3: MAY NEED TESTING (transitive)
+
+TIP: Default traversal uses CALLS/IMPORTS/EXTENDS/IMPLEMENTS. For class members, include HAS_METHOD and HAS_PROPERTY in relationTypes. For field access analysis, include ACCESSES in relationTypes.
+
+EdgeType: CALLS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_METHOD, HAS_PROPERTY, OVERRIDES, ACCESSES
 Confidence: 1.0 = certain, <0.8 = fuzzy match`,
         inputSchema: {
             type: 'object',

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

@@ -10,9 +10,16 @@ export interface BlueprintIngestionResult {
     nodesAdded: number;
     edgesAdded: number;
 }
+/**
+ * Convert an Unreal asset path to a filesystem-relative path for ignore matching.
+ * "/Game/Characters/BP_Hero"       → "Content/Characters/BP_Hero"
+ * "/MyPlugin/Maps/TestMap"         → "Plugins/MyPlugin/Content/Maps/TestMap"
+ * "/Engine/BasicShapes/Cube"       → "Engine/Content/BasicShapes/Cube"
+ */
+export declare const assetPathToRelative: (assetPath: string) => string;
 /**
  * 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>;
+export declare const ingestBlueprintsIntoGraph: (graph: KnowledgeGraph, storagePath: string, repoPath?: string) => Promise<BlueprintIngestionResult>;

package/dist/unreal/blueprint-ingestion.js

@@ -8,6 +8,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { generateId } from '../lib/utils.js';
+import { shouldIgnorePath, loadIgnoreRules } from '../config/ignore-service.js';
 /** Extract a display name from an Unreal asset path (last segment). */
 const extractAssetName = (assetPath) => {
     // "/Game/Characters/BP_Hero" → "BP_Hero"
@@ -29,12 +30,33 @@ const extractClassName = (unrealPath) => {
     const slashIdx = unrealPath.lastIndexOf('/');
     return slashIdx >= 0 ? unrealPath.slice(slashIdx + 1) : unrealPath;
 };
+/**
+ * Convert an Unreal asset path to a filesystem-relative path for ignore matching.
+ * "/Game/Characters/BP_Hero"       → "Content/Characters/BP_Hero"
+ * "/MyPlugin/Maps/TestMap"         → "Plugins/MyPlugin/Content/Maps/TestMap"
+ * "/Engine/BasicShapes/Cube"       → "Engine/Content/BasicShapes/Cube"
+ */
+export const assetPathToRelative = (assetPath) => {
+    // Strip leading slash
+    const trimmed = assetPath.startsWith('/') ? assetPath.slice(1) : assetPath;
+    const slashIdx = trimmed.indexOf('/');
+    if (slashIdx < 0)
+        return trimmed;
+    const mount = trimmed.slice(0, slashIdx);
+    const rest = trimmed.slice(slashIdx + 1);
+    if (mount === 'Game')
+        return `Content/${rest}`;
+    if (mount === 'Engine')
+        return `Engine/Content/${rest}`;
+    // Plugin mounts: /PluginName/X → Plugins/PluginName/Content/X
+    return `Plugins/${mount}/Content/${rest}`;
+};
 /**
  * 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) => {
+export const ingestBlueprintsIntoGraph = async (graph, storagePath, repoPath) => {
     const manifestPath = path.join(storagePath, 'unreal', 'asset-manifest.json');
     let manifest;
     try {
@@ -47,6 +69,16 @@ export const ingestBlueprintsIntoGraph = async (graph, storagePath) => {
     if (!manifest.assets || manifest.assets.length === 0) {
         return { nodesAdded: 0, edgesAdded: 0 };
     }
+    // ── Filter assets through ignore rules ─────────────────────────────
+    const ig = repoPath ? await loadIgnoreRules(repoPath) : null;
+    const assets = manifest.assets.filter(asset => {
+        const relPath = assetPathToRelative(asset.asset_path);
+        if (shouldIgnorePath(relPath))
+            return false;
+        if (ig && ig.ignores(relPath))
+            return false;
+        return true;
+    });
     // ── Build lookup indexes from existing graph nodes ──────────────────
     // Class/Struct nodes keyed by name (for parent class matching)
     const classByName = new Map();
@@ -101,7 +133,7 @@ export const ingestBlueprintsIntoGraph = async (graph, storagePath) => {
     let edgeCounter = 0;
     // Track created Blueprint IDs for second-pass dependency edges
     const blueprintIdByAssetPath = new Map();
-    for (const asset of manifest.assets) {
+    for (const asset of assets) {
         const bpId = generateId('Blueprint', asset.asset_path);
         const bpName = extractAssetName(asset.asset_path);
         graph.addNode({
@@ -174,7 +206,7 @@ export const ingestBlueprintsIntoGraph = async (graph, storagePath) => {
         }
     }
     // ── Second pass: Blueprint-to-Blueprint IMPORTS edges ───────────────
-    for (const asset of manifest.assets) {
+    for (const asset of assets) {
         const deps = asset.dependencies || [];
         if (deps.length === 0)
             continue;

package/dist/unreal/bridge.d.ts

@@ -1,4 +1,4 @@
 import type { ExpandBlueprintChainResult, FindNativeBlueprintReferencesResult, NativeFunctionTarget, SyncUnrealAssetManifestResult, UnrealBlueprintCandidate, UnrealConfig } from './types.js';
-export declare function syncUnrealAssetManifest(storagePath: string, config: UnrealConfig): Promise<SyncUnrealAssetManifestResult>;
+export declare function syncUnrealAssetManifest(storagePath: string, config: UnrealConfig, repoPath?: string, deep?: boolean): Promise<SyncUnrealAssetManifestResult>;
 export declare function findNativeBlueprintReferences(storagePath: string, config: UnrealConfig, target: NativeFunctionTarget, candidateAssets: UnrealBlueprintCandidate[], manifestPath?: string): Promise<FindNativeBlueprintReferencesResult>;
 export declare function expandBlueprintChain(storagePath: string, config: UnrealConfig, assetPath: string, chainAnchorId: string, direction: 'upstream' | 'downstream', maxDepth: number): Promise<ExpandBlueprintChainResult>;

package/dist/unreal/bridge.js

@@ -4,6 +4,7 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { randomUUID } from 'node:crypto';
 import { ensureUnrealStorage, saveUnrealAssetManifest } from './config.js';
+import { loadIgnoreRules } from '../config/ignore-service.js';
 const execFileAsync = promisify(execFile);
 function buildBaseArgs(config, operation, outputPath) {
     return [
@@ -68,10 +69,74 @@ async function readOutputJson(outputPath, stdout) {
         return JSON.parse(stdout);
     }
 }
-export async function syncUnrealAssetManifest(storagePath, config) {
+/**
+ * Build include/exclude prefix filters for the Unreal commandlet.
+ * Merges config `include_paths`/`exclude_paths` with .gitnexusignore patterns,
+ * mapping filesystem patterns to Unreal asset path prefixes.
+ */
+async function buildFilterPrefixes(repoPath, config) {
+    const include_prefixes = [];
+    const exclude_prefixes = [];
+    // Add explicit include_paths (whitelist) from unreal config
+    if (config.include_paths && Array.isArray(config.include_paths)) {
+        for (const p of config.include_paths) {
+            include_prefixes.push(p);
+        }
+    }
+    // Add explicit exclude_paths from unreal config
+    if (config.exclude_paths && Array.isArray(config.exclude_paths)) {
+        for (const p of config.exclude_paths) {
+            exclude_prefixes.push(p);
+        }
+    }
+    // Derive exclude prefixes from .gitnexusignore patterns
+    if (repoPath) {
+        const ig = await loadIgnoreRules(repoPath);
+        if (ig) {
+            const projectDir = path.dirname(config.project_path);
+            try {
+                const contentDir = path.join(projectDir, 'Content');
+                const entries = await fs.readdir(contentDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.isDirectory()) {
+                        const relPath = `Content/${entry.name}`;
+                        if (ig.ignores(relPath) || ig.ignores(relPath + '/')) {
+                            exclude_prefixes.push(`/Game/${entry.name}`);
+                        }
+                    }
+                }
+            }
+            catch { /* Content dir might not exist */ }
+            try {
+                const pluginsDir = path.join(projectDir, 'Plugins');
+                const entries = await fs.readdir(pluginsDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.isDirectory()) {
+                        const relPath = `Plugins/${entry.name}`;
+                        if (ig.ignores(relPath) || ig.ignores(relPath + '/')) {
+                            exclude_prefixes.push(`/${entry.name}`);
+                        }
+                    }
+                }
+            }
+            catch { /* Plugins dir might not exist */ }
+        }
+    }
+    return { include_prefixes, exclude_prefixes };
+}
+export async function syncUnrealAssetManifest(storagePath, config, repoPath, deep) {
     const unrealPaths = await ensureUnrealStorage(storagePath);
     const { outputPath } = requestPaths(unrealPaths);
     const args = buildBaseArgs(config, 'SyncAssets', outputPath);
+    // Pass scan mode: metadata (default, zero loading) or deep (full Blueprint loading)
+    args.push(`-Mode=${deep ? 'deep' : 'metadata'}`);
+    // Build and pass filter prefixes (include + exclude)
+    const filters = await buildFilterPrefixes(repoPath, config);
+    if (filters.include_prefixes.length > 0 || filters.exclude_prefixes.length > 0) {
+        const filterJsonPath = path.join(unrealPaths.requests_dir, `filter-${randomUUID()}.json`);
+        await fs.writeFile(filterJsonPath, JSON.stringify(filters), 'utf-8');
+        args.push(`-FilterJson=${filterJsonPath}`);
+    }
     try {
         const { stdout } = await runCommand(config, 'SyncAssets', args);
         const manifest = await readOutputJson(outputPath, stdout);

package/dist/unreal/types.d.ts

@@ -19,6 +19,10 @@ export interface UnrealConfig {
     timeout_ms?: number;
     working_directory?: string;
     extra_args?: string[];
+    /** Unreal package path prefixes to exclude from sync (e.g., "/Game/ThirdParty", "/SomePlugin") */
+    exclude_paths?: string[];
+    /** Unreal package path prefixes to include (whitelist). If set, ONLY assets under these prefixes are scanned. */
+    include_paths?: string[];
 }
 export interface UnrealStoragePaths {
     root_dir: string;

package/package.json

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