@duytransipher/gitnexus 1.0.0 → 1.1.0

package/dist/cli/index.js

@@ -14,6 +14,10 @@ program
 program
     .command('setup')
     .description('One-time setup: configure MCP for Cursor, Claude Code, OpenCode')
+    .option('--unreal', 'Also install the GitNexus Unreal Engine plugin into a UE project')
+    .option('--project <path>', 'UE project root (default: current directory, used with --unreal)')
+    .option('--editor-cmd <path>', 'Path to UnrealEditor-Cmd.exe (auto-detected if omitted)')
+    .option('--force', 'Overwrite existing Unreal plugin/config if present')
     .action(createLazyAction(() => import('./setup.js'), 'setupCommand'));
 program
     .command('analyze [path]')

package/dist/cli/setup.d.ts

@@ -5,4 +5,9 @@
  * Detects installed AI editors and writes the appropriate MCP config
  * so the GitNexus MCP server is available in all projects.
  */
-export declare const setupCommand: () => Promise<void>;
+export declare const setupCommand: (options: {
+    unreal?: boolean;
+    project?: string;
+    editorCmd?: string;
+    force?: boolean;
+}) => Promise<void>;

package/dist/cli/setup.js

@@ -6,8 +6,10 @@
  * so the GitNexus MCP server is available in all projects.
  */
 import fs from 'fs/promises';
+import fsSync from 'fs';
 import path from 'path';
 import os from 'os';
+import { execSync } from 'child_process';
 import { fileURLToPath } from 'url';
 import { glob } from 'glob';
 import { getGlobalDir } from '../storage/repo-manager.js';
@@ -310,8 +312,164 @@ async function installOpenCodeSkills(result) {
         result.errors.push(`OpenCode skills: ${err.message}`);
     }
 }
+async function findUProjectFile(projectRoot) {
+    const entries = await fs.readdir(projectRoot);
+    const uprojects = entries.filter(e => e.endsWith('.uproject'));
+    if (uprojects.length === 0) {
+        throw new Error(`No .uproject file found in ${projectRoot}. Use --project to specify the UE project root.`);
+    }
+    if (uprojects.length > 1) {
+        throw new Error(`Multiple .uproject files in ${projectRoot}: ${uprojects.join(', ')}. Move into the correct project directory or use --project.`);
+    }
+    return path.join(projectRoot, uprojects[0]);
+}
+function resolveEditorCmd(explicitPath, engineAssociation) {
+    if (explicitPath) {
+        const resolved = path.resolve(explicitPath);
+        try {
+            fsSync.accessSync(resolved);
+        }
+        catch {
+            throw new Error(`Editor command not found: ${resolved}`);
+        }
+        return resolved;
+    }
+    if (process.platform !== 'win32') {
+        throw new Error('Auto-detection of UnrealEditor-Cmd is only supported on Windows. Use --editor-cmd.');
+    }
+    const tryCandidates = (rootOrExe) => {
+        const candidates = [
+            rootOrExe,
+            path.join(rootOrExe, 'Engine', 'Binaries', 'Win64', 'UnrealEditor-Cmd.exe'),
+            path.join(rootOrExe, 'Engine', 'Windows', 'Engine', 'Binaries', 'Win64', 'UnrealEditor-Cmd.exe'),
+        ];
+        for (const c of candidates) {
+            try {
+                const stat = fsSync.statSync(c);
+                if (stat.isFile())
+                    return c;
+            }
+            catch { /* next */ }
+        }
+        return null;
+    };
+    // Try registry lookup for source builds (GUID engine association)
+    if (engineAssociation) {
+        try {
+            const regQuery = `reg query "HKCU\\Software\\Epic Games\\Unreal Engine\\Builds" /v "${engineAssociation}" 2>nul`;
+            const output = execSync(regQuery, { encoding: 'utf-8' });
+            const match = output.match(/REG_SZ\s+(.+)/);
+            if (match) {
+                const found = tryCandidates(match[1].trim());
+                if (found)
+                    return found;
+            }
+        }
+        catch { /* registry key not found */ }
+        // Try standard install path
+        const found = tryCandidates(path.join('C:\\Program Files\\Epic Games', `UE_${engineAssociation}`));
+        if (found)
+            return found;
+    }
+    throw new Error(`Could not auto-detect UnrealEditor-Cmd.exe for EngineAssociation '${engineAssociation}'. Use --editor-cmd to specify it.`);
+}
+async function setupUnreal(options, result) {
+    const projectRoot = path.resolve(options.project || process.cwd());
+    try {
+        const stat = await fs.stat(projectRoot);
+        if (!stat.isDirectory())
+            throw new Error('not a directory');
+    }
+    catch {
+        result.errors.push(`Unreal: project root not found: ${projectRoot}`);
+        return;
+    }
+    let uprojectPath;
+    try {
+        uprojectPath = await findUProjectFile(projectRoot);
+    }
+    catch (err) {
+        result.errors.push(`Unreal: ${err.message}`);
+        return;
+    }
+    // Read engine association from .uproject
+    let engineAssociation = '';
+    try {
+        const uproject = JSON.parse(await fs.readFile(uprojectPath, 'utf-8'));
+        engineAssociation = uproject.EngineAssociation || '';
+    }
+    catch (err) {
+        result.errors.push(`Unreal: failed to read ${path.basename(uprojectPath)}: ${err.message}`);
+        return;
+    }
+    // Resolve editor command
+    let editorCmd;
+    try {
+        editorCmd = resolveEditorCmd(options.editorCmd, engineAssociation);
+    }
+    catch (err) {
+        result.errors.push(`Unreal: ${err.message}`);
+        return;
+    }
+    // Paths
+    const pluginDest = path.join(projectRoot, 'Plugins', 'GitNexusUnreal');
+    const gitnexusDir = path.join(projectRoot, '.gitnexus');
+    const unrealDir = path.join(gitnexusDir, 'unreal');
+    const configPath = path.join(unrealDir, 'config.json');
+    // Check existing installation
+    const pluginExists = await dirExists(pluginDest);
+    const configExists = await fileExists(configPath);
+    if ((pluginExists || configExists) && !options.force) {
+        result.errors.push(`Unreal: plugin or config already exists in ${projectRoot}. Use --force to overwrite.`);
+        return;
+    }
+    // Copy bundled plugin
+    const bundledPlugin = path.join(__dirname, '..', '..', 'vendor', 'GitNexusUnreal');
+    if (!(await dirExists(bundledPlugin))) {
+        result.errors.push('Unreal: bundled plugin not found in vendor/GitNexusUnreal');
+        return;
+    }
+    try {
+        if (pluginExists) {
+            await fs.rm(pluginDest, { recursive: true, force: true });
+        }
+        await fs.mkdir(path.join(projectRoot, 'Plugins'), { recursive: true });
+        await copyDirRecursive(bundledPlugin, pluginDest);
+    }
+    catch (err) {
+        result.errors.push(`Unreal: failed to copy plugin: ${err.message}`);
+        return;
+    }
+    // Write config
+    try {
+        await fs.mkdir(unrealDir, { recursive: true });
+        const config = {
+            editor_cmd: editorCmd.replace(/\\/g, '/'),
+            project_path: uprojectPath.replace(/\\/g, '/'),
+            commandlet: 'GitNexusBlueprintAnalyzer',
+            timeout_ms: 300000,
+        };
+        await fs.writeFile(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+    }
+    catch (err) {
+        result.errors.push(`Unreal: failed to write config: ${err.message}`);
+        return;
+    }
+    result.configured.push(`Unreal plugin → ${pluginDest}`);
+    result.configured.push(`Unreal config → ${configPath}`);
+    console.log(`    Editor: ${editorCmd}`);
+}
+async function fileExists(filePath) {
+    try {
+        const stat = await fs.stat(filePath);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
 // ─── Main command ──────────────────────────────────────────────────
-export const setupCommand = async () => {
+export const setupCommand = async (options) => {
     console.log('');
     console.log('  GitNexus Setup');
     console.log('  ==============');
@@ -333,6 +491,12 @@ export const setupCommand = async () => {
     await installClaudeCodeHooks(result);
     await installCursorSkills(result);
     await installOpenCodeSkills(result);
+    // Unreal Engine plugin setup (optional)
+    if (options.unreal) {
+        console.log('  Unreal Engine Setup');
+        console.log('  -------------------');
+        await setupUnreal({ project: options.project, editorCmd: options.editorCmd, force: options.force }, result);
+    }
     // Print results
     if (result.configured.length > 0) {
         console.log('  Configured:');
@@ -363,5 +527,12 @@ export const setupCommand = async () => {
     console.log('    1. cd into any git repo');
     console.log('    2. Run: gitnexus analyze');
     console.log('    3. Open the repo in your editor — MCP is ready!');
+    if (options.unreal) {
+        console.log('');
+        console.log('  Unreal next steps:');
+        console.log('    1. Build your Unreal editor target (so the commandlet compiles)');
+        console.log('    2. Run: gitnexus analyze     (index the C++ codebase)');
+        console.log('    3. Run: gitnexus unreal-sync  (scan Blueprint assets)');
+    }
     console.log('');
 };

package/package.json

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