@duytransipher/gitnexus 1.2.1 → 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

@@ -17,6 +17,8 @@
  */
 import { writeSync } from 'node:fs';
 import { LocalBackend } from '../mcp/local/local-backend.js';
+import { withUnrealProgress } from './unreal-progress.js';
+const isUnrealError = (r) => r?.status === 'error' || r?.error != null;
 let _backend = null;
 async function getBackend() {
     if (_backend)
@@ -127,9 +129,17 @@ export async function cypherCommand(query, options) {
 }
 export async function syncUnrealAssetManifestCommand(options) {
     const backend = await getBackend();
-    const result = await backend.callTool('sync_unreal_asset_manifest', {
-        repo: options?.repo,
-    });
+    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 (${mode} mode)`);
+        if (result.manifest_path)
+            console.log(`  ${result.manifest_path}`);
+    }
     output(result);
 }
 export async function findNativeBlueprintReferencesCommand(functionName, options) {
@@ -138,7 +148,7 @@ export async function findNativeBlueprintReferencesCommand(functionName, options
         process.exit(1);
     }
     const backend = await getBackend();
-    const result = await backend.callTool('find_native_blueprint_references', {
+    const result = await withUnrealProgress(() => backend.callTool('find_native_blueprint_references', {
         function: functionName || undefined,
         symbol_uid: options?.uid,
         class_name: options?.className,
@@ -146,7 +156,11 @@ export async function findNativeBlueprintReferencesCommand(functionName, options
         refresh_manifest: options?.refreshManifest ?? false,
         max_candidates: options?.maxCandidates ? parseInt(options.maxCandidates, 10) : undefined,
         repo: options?.repo,
-    });
+    }), { phaseLabel: 'Scanning Blueprints for native references', successLabel: 'Blueprint scan complete', failLabel: 'Blueprint scan failed', isError: isUnrealError });
+    if (result?.status === 'error') {
+        console.error(`\n  Error: ${result.error}\n`);
+        process.exit(1);
+    }
     output(result);
 }
 export async function expandBlueprintChainCommand(assetPath, chainAnchorId, options) {
@@ -155,13 +169,17 @@ export async function expandBlueprintChainCommand(assetPath, chainAnchorId, opti
         process.exit(1);
     }
     const backend = await getBackend();
-    const result = await backend.callTool('expand_blueprint_chain', {
+    const result = await withUnrealProgress(() => backend.callTool('expand_blueprint_chain', {
         asset_path: assetPath,
         chain_anchor_id: chainAnchorId,
         direction: options?.direction || 'downstream',
         max_depth: options?.depth ? parseInt(options.depth, 10) : undefined,
         repo: options?.repo,
-    });
+    }), { phaseLabel: 'Expanding Blueprint chain', successLabel: 'Chain expanded', failLabel: 'Chain expansion failed', isError: isUnrealError });
+    if (result?.status === 'error') {
+        console.error(`\n  Error: ${result.error}\n`);
+        process.exit(1);
+    }
     output(result);
 }
 export async function findBlueprintsDerivedFromNativeClassCommand(className, options) {
@@ -170,11 +188,15 @@ export async function findBlueprintsDerivedFromNativeClassCommand(className, opt
         process.exit(1);
     }
     const backend = await getBackend();
-    const result = await backend.callTool('find_blueprints_derived_from_native_class', {
+    const result = await withUnrealProgress(() => backend.callTool('find_blueprints_derived_from_native_class', {
         class_name: className,
         refresh_manifest: options?.refreshManifest ?? false,
         max_results: options?.maxResults ? parseInt(options.maxResults, 10) : undefined,
         repo: options?.repo,
-    });
+    }), { phaseLabel: 'Finding derived Blueprints', successLabel: 'Derived Blueprint search complete', failLabel: 'Derived Blueprint search failed', isError: isUnrealError });
+    if (result?.status === 'error') {
+        console.error(`\n  Error: ${result.error}\n`);
+        process.exit(1);
+    }
     output(result);
 }

package/dist/cli/unreal-progress.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Spinner helper for long-running Unreal CLI commands.
+ * Uses braille-dot animation with elapsed time — CLI layer only.
+ */
+export interface SpinnerOptions {
+    phaseLabel: string;
+    successLabel?: string;
+    failLabel?: string;
+    /** Check if the result indicates an error (for non-throwing error returns). */
+    isError?: (result: any) => boolean;
+}
+export declare function withUnrealProgress<T>(operation: () => Promise<T>, opts: SpinnerOptions): Promise<T>;

package/dist/cli/unreal-progress.js

@@ -0,0 +1,66 @@
+/**
+ * Spinner helper for long-running Unreal CLI commands.
+ * Uses braille-dot animation with elapsed time — CLI layer only.
+ */
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const GREEN = '\x1b[92m';
+const RED = '\x1b[91m';
+const YELLOW = '\x1b[93m';
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+export async function withUnrealProgress(operation, opts) {
+    const start = Date.now();
+    let frame = 0;
+    let aborted = false;
+    const clearLine = () => process.stdout.write('\r\x1b[2K');
+    const render = () => {
+        const elapsed = Math.round((Date.now() - start) / 1000);
+        const spinner = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
+        const time = elapsed > 0 ? ` ${DIM}(${elapsed}s)${RESET}` : '';
+        clearLine();
+        process.stdout.write(`  ${YELLOW}${spinner}${RESET} ${opts.phaseLabel}...${time}`);
+        frame++;
+    };
+    // Initial render + tick every 80ms for smooth animation
+    render();
+    const timer = setInterval(render, 80);
+    const sigintHandler = () => {
+        if (aborted)
+            process.exit(1);
+        aborted = true;
+        clearInterval(timer);
+        clearLine();
+        process.stdout.write(`  ${RED}✗${RESET} Interrupted\n`);
+        process.exit(130);
+    };
+    process.on('SIGINT', sigintHandler);
+    const cleanup = () => {
+        clearInterval(timer);
+        process.removeListener('SIGINT', sigintHandler);
+    };
+    try {
+        const result = await operation();
+        cleanup();
+        const totalSec = ((Date.now() - start) / 1000).toFixed(1);
+        if (opts.isError?.(result)) {
+            const label = opts.failLabel || 'Failed';
+            clearLine();
+            process.stdout.write(`  ${RED}${BOLD}✗${RESET} ${label} ${DIM}(${totalSec}s)${RESET}\n`);
+        }
+        else {
+            const label = opts.successLabel || 'Done';
+            clearLine();
+            process.stdout.write(`  ${GREEN}${BOLD}✓${RESET} ${label} ${DIM}(${totalSec}s)${RESET}\n`);
+        }
+        return result;
+    }
+    catch (error) {
+        cleanup();
+        const totalSec = ((Date.now() - start) / 1000).toFixed(1);
+        const label = opts.failLabel || 'Failed';
+        clearLine();
+        process.stdout.write(`  ${RED}${BOLD}✗${RESET} ${label} ${DIM}(${totalSec}s)${RESET}\n`);
+        throw error;
+    }
+}

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

@@ -199,7 +199,13 @@ export class LocalBackend {
         if (this.repos.size === 1) {
             return this.repos.values().next().value;
         }
-        return null; // Multiple repos, no param — ambiguous
+        // Multiple repos — try to match by current working directory
+        const cwd = process.cwd();
+        for (const handle of this.repos.values()) {
+            if (cwd.startsWith(handle.repoPath))
+                return handle;
+        }
+        return null; // Multiple repos, no CWD match — ambiguous
     }
     // ─── Lazy LadybugDB Init ────────────────────────────────────────────
     async ensureInitialized(repoId) {
@@ -270,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':
@@ -420,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.' };
             }
@@ -437,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);
@@ -445,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>;