@duytransipher/gitnexus 1.2.1 → 1.3.0

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 [
@@ -40,7 +41,17 @@ async function readUELogErrors(config) {
         const logPath = path.join(projectDir, 'Saved', 'Logs', `${projectName}.log`);
         const content = await fs.readFile(logPath, 'utf-8');
         const lines = content.split(/\r?\n/);
-        const errorLines = lines.filter(l => /\bError\b/i.test(l) && !/^LogWindows.*Failed to get driver/i.test(l.replace(/^\[.*?\]\[\s*\d+\]/, '')));
+        const stripped = (l) => l.replace(/^\[.*?\]\[\s*\d+\]/, '');
+        // Skip callstack lines, driver errors, and empty error lines
+        const isNoise = (l) => {
+            const s = stripped(l);
+            return /^LogWindows.*Failed to get driver/i.test(s)
+                || /\[Callstack\]/i.test(s)
+                || /^LogWindows: Error:\s*$/i.test(s)
+                || /^LogWindows: Error: ===/.test(s)
+                || /^LogWindows: Error: Fatal error!/i.test(s);
+        };
+        const errorLines = lines.filter(l => /\bError\b/i.test(l) && !isNoise(l));
         if (errorLines.length === 0)
             return '';
         return 'UE Log errors:\n' + errorLines.slice(-10).join('\n');
@@ -58,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);
@@ -75,6 +150,23 @@ export async function syncUnrealAssetManifest(storagePath, config) {
         };
     }
     catch (error) {
+        // UE may exit non-zero due to Blueprint compilation warnings even though
+        // the commandlet completed and wrote valid output. Try reading the file first.
+        try {
+            const stdout = error?.stdout ? String(error.stdout).trim() : '';
+            const manifest = await readOutputJson(outputPath, stdout);
+            if (manifest && Array.isArray(manifest.assets) && manifest.assets.length > 0) {
+                const manifestPath = await saveUnrealAssetManifest(storagePath, manifest);
+                return {
+                    status: 'success',
+                    manifest_path: manifestPath,
+                    asset_count: manifest.assets.length,
+                    generated_at: manifest.generated_at,
+                    warnings: ['UE exited with non-zero code (likely Blueprint compilation warnings)'],
+                };
+            }
+        }
+        catch { /* output file not readable, fall through to error */ }
         const stderr = error?.stderr ? String(error.stderr).trim() : '';
         const stdout = error?.stdout ? String(error.stdout).trim() : '';
         const msg = error instanceof Error ? error.message : String(error);

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.1",
+  "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",