@veewo/gitnexus 1.4.8 → 1.4.9

package/dist/core/unity/ui-asset-ref-scanner.js

@@ -0,0 +1,213 @@
+import { createReadStream } from 'node:fs';
+import path from 'node:path';
+import { createInterface } from 'node:readline';
+import { glob } from 'glob';
+const YAML_INLINE_GUID_PATTERN = /\bguid\s*:\s*([0-9a-f]{32})\b/i;
+const YAML_FIELD_OPEN_PATTERN = /^\s*([A-Za-z0-9_]+)\s*:\s*\{/;
+const YAML_INLINE_FIELD_PATTERN = /^\s*([A-Za-z0-9_]+)\s*:\s*\{[^}]*\bguid\s*:\s*([0-9a-f]{32})\b[^}]*\}/i;
+const SCAN_CONCURRENCY = 8;
+export async function scanUiAssetRefs(input) {
+    const resourceFiles = await resolveFiles(input.repoRoot, input.scopedPaths);
+    const guidFilter = toGuidFilter(input.targetGuids);
+    const candidateFiles = guidFilter && guidFilter.size > 0
+        ? await findCandidateFilesByGuid(input.repoRoot, resourceFiles, guidFilter)
+        : resourceFiles;
+    const perFile = await mapWithConcurrency(candidateFiles, SCAN_CONCURRENCY, async (resourcePath) => {
+        const sourceType = resourcePath.endsWith('.prefab') ? 'prefab' : 'asset';
+        return scanResourceFileForGuidRefs(input.repoRoot, resourcePath, sourceType, guidFilter);
+    });
+    const all = [];
+    for (const entries of perFile) {
+        all.push(...entries);
+    }
+    return all;
+}
+async function findCandidateFilesByGuid(repoRoot, resourceFiles, guidFilter) {
+    const candidates = await mapWithConcurrency(resourceFiles, SCAN_CONCURRENCY, async (resourcePath) => {
+        const absolutePath = path.join(repoRoot, resourcePath);
+        const stream = createReadStream(absolutePath, { encoding: 'utf-8' });
+        const reader = createInterface({ input: stream, crlfDelay: Infinity });
+        try {
+            for await (const line of reader) {
+                const lower = line.toLowerCase();
+                for (const guid of guidFilter) {
+                    if (lower.includes(guid))
+                        return resourcePath;
+                }
+            }
+            return null;
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'ENOENT' || code === 'EISDIR')
+                return null;
+            throw error;
+        }
+        finally {
+            reader.close();
+            stream.destroy();
+        }
+    });
+    return candidates
+        .filter((value) => Boolean(value))
+        .sort((left, right) => left.localeCompare(right));
+}
+async function scanResourceFileForGuidRefs(repoRoot, resourcePath, sourceType, guidFilter) {
+    const absolutePath = path.join(repoRoot, resourcePath);
+    const stream = createReadStream(absolutePath, { encoding: 'utf-8' });
+    const reader = createInterface({ input: stream, crlfDelay: Infinity });
+    const out = [];
+    let lineNumber = 0;
+    let currentField = '';
+    let currentStartLine = 0;
+    let currentLines = [];
+    let currentGuidLine = 0;
+    let braceDepth = 0;
+    const flushCurrentBlock = () => {
+        if (!currentField || currentLines.length === 0) {
+            resetCurrentBlock();
+            return;
+        }
+        const combined = currentLines.join('\n');
+        const guidMatch = combined.match(YAML_INLINE_GUID_PATTERN);
+        if (!guidMatch) {
+            resetCurrentBlock();
+            return;
+        }
+        const guid = guidMatch[1].toLowerCase();
+        if (guidFilter && !guidFilter.has(guid)) {
+            resetCurrentBlock();
+            return;
+        }
+        out.push({
+            sourceType,
+            sourcePath: resourcePath,
+            line: currentGuidLine || currentStartLine || 1,
+            fieldName: currentField,
+            guid,
+            snippet: currentLines[0].trim(),
+        });
+        resetCurrentBlock();
+    };
+    const resetCurrentBlock = () => {
+        currentField = '';
+        currentStartLine = 0;
+        currentLines = [];
+        currentGuidLine = 0;
+        braceDepth = 0;
+    };
+    try {
+        for await (const line of reader) {
+            lineNumber += 1;
+            const inlineMatch = line.match(YAML_INLINE_FIELD_PATTERN);
+            if (inlineMatch) {
+                const guid = inlineMatch[2].toLowerCase();
+                if (!guidFilter || guidFilter.has(guid)) {
+                    out.push({
+                        sourceType,
+                        sourcePath: resourcePath,
+                        line: lineNumber,
+                        fieldName: inlineMatch[1],
+                        guid,
+                        snippet: line.trim(),
+                    });
+                }
+                continue;
+            }
+            if (currentField) {
+                currentLines.push(line);
+                if (!currentGuidLine && YAML_INLINE_GUID_PATTERN.test(line)) {
+                    currentGuidLine = lineNumber;
+                }
+                braceDepth += countChar(line, '{');
+                braceDepth -= countChar(line, '}');
+                if (braceDepth <= 0 || line.includes('}')) {
+                    flushCurrentBlock();
+                }
+                continue;
+            }
+            const openMatch = line.match(YAML_FIELD_OPEN_PATTERN);
+            if (!openMatch)
+                continue;
+            currentField = openMatch[1];
+            currentStartLine = lineNumber;
+            currentLines = [line];
+            currentGuidLine = YAML_INLINE_GUID_PATTERN.test(line) ? lineNumber : 0;
+            braceDepth = Math.max(1, countChar(line, '{') - countChar(line, '}'));
+            if (line.includes('}') || braceDepth <= 0) {
+                flushCurrentBlock();
+            }
+        }
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT' || code === 'EISDIR') {
+            return [];
+        }
+        throw error;
+    }
+    finally {
+        reader.close();
+        stream.destroy();
+    }
+    if (currentField) {
+        flushCurrentBlock();
+    }
+    return out;
+}
+async function resolveFiles(repoRoot, scopedPaths) {
+    if (!scopedPaths || scopedPaths.length === 0) {
+        return (await glob(['**/*.prefab', '**/*.asset'], {
+            cwd: repoRoot,
+            nodir: true,
+            dot: false,
+        })).sort((left, right) => left.localeCompare(right));
+    }
+    const normalized = scopedPaths
+        .filter((value) => value.endsWith('.prefab') || value.endsWith('.asset'))
+        .map((value) => normalizeRelativePath(repoRoot, value))
+        .filter((value) => value !== null)
+        .sort((left, right) => left.localeCompare(right));
+    return [...new Set(normalized)];
+}
+function normalizeRelativePath(repoRoot, filePath) {
+    const relativePath = path.isAbsolute(filePath) ? path.relative(repoRoot, filePath) : filePath;
+    const normalized = relativePath.replace(/\\/g, '/');
+    if (normalized.startsWith('../'))
+        return null;
+    return normalized;
+}
+function toGuidFilter(guidInputs) {
+    if (!guidInputs || guidInputs.length === 0)
+        return null;
+    const normalized = guidInputs
+        .map((value) => String(value || '').trim().toLowerCase())
+        .filter((value) => /^[0-9a-f]{32}$/.test(value));
+    if (normalized.length === 0)
+        return null;
+    return new Set(normalized);
+}
+function countChar(input, char) {
+    let count = 0;
+    for (let i = 0; i < input.length; i += 1) {
+        if (input[i] === char)
+            count += 1;
+    }
+    return count;
+}
+async function mapWithConcurrency(items, concurrency, mapper) {
+    const safeConcurrency = Math.max(1, Math.min(concurrency, items.length || 1));
+    const results = new Array(items.length);
+    let cursor = 0;
+    const workers = Array.from({ length: safeConcurrency }, async () => {
+        while (true) {
+            const index = cursor;
+            cursor += 1;
+            if (index >= items.length)
+                break;
+            results[index] = await mapper(items[index], index);
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}

package/dist/core/unity/ui-asset-ref-scanner.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/unity/ui-asset-ref-scanner.test.js

@@ -0,0 +1,44 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { scanUiAssetRefs } from './ui-asset-ref-scanner.js';
+const here = path.dirname(fileURLToPath(import.meta.url));
+const fixtureRoot = path.resolve(here, '../../../src/core/unity/__fixtures__/mini-unity-ui');
+test('scans prefab and asset VisualTreeAsset refs with evidence lines', async () => {
+    const refs = await scanUiAssetRefs({ repoRoot: fixtureRoot });
+    assert.ok(refs.some((entry) => entry.sourceType === 'prefab'
+        && entry.sourcePath === 'Assets/Prefabs/EliteBossScreen.prefab'
+        && entry.guid === 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
+        && entry.line > 0));
+    assert.ok(refs.some((entry) => entry.sourceType === 'asset'
+        && entry.sourcePath === 'Assets/Config/DressUpScreenConfig.asset'
+        && entry.guid === 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
+        && entry.line > 0));
+});
+test('parses multiline YAML object refs and supports target guid prefilter', async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-ui-asset-scan-'));
+    await fs.mkdir(path.join(tempRoot, 'Assets/Prefabs'), { recursive: true });
+    await fs.writeFile(path.join(tempRoot, 'Assets/Prefabs/MultiLine.prefab'), [
+        '%YAML 1.1',
+        '--- !u!114 &11400000',
+        'MonoBehaviour:',
+        '  m_ObjectHideFlags: 0',
+        '  m_VisualTreeAsset: {',
+        '    fileID: 9197481965408888,',
+        '    guid: abcdefabcdefabcdefabcdefabcdefab,',
+        '    type: 3',
+        '  }',
+    ].join('\n'), 'utf-8');
+    const refs = await scanUiAssetRefs({
+        repoRoot: tempRoot,
+        targetGuids: ['abcdefabcdefabcdefabcdefabcdefab'],
+    });
+    assert.equal(refs.length, 1);
+    assert.equal(refs[0].sourcePath, 'Assets/Prefabs/MultiLine.prefab');
+    assert.equal(refs[0].fieldName, 'm_VisualTreeAsset');
+    assert.equal(refs[0].guid, 'abcdefabcdefabcdefabcdefabcdefab');
+    await fs.rm(tempRoot, { recursive: true, force: true });
+});

package/dist/core/unity/ui-meta-index.d.ts

@@ -0,0 +1,8 @@
+export interface UnityUiMetaIndex {
+    uxmlGuidToPath: Map<string, string>;
+    ussGuidToPath: Map<string, string>;
+}
+export interface BuildUnityUiMetaIndexOptions {
+    scopedPaths?: string[];
+}
+export declare function buildUnityUiMetaIndex(repoRoot: string, options?: BuildUnityUiMetaIndexOptions): Promise<UnityUiMetaIndex>;

package/dist/core/unity/ui-meta-index.js

@@ -0,0 +1,60 @@
+import path from 'node:path';
+import { glob } from 'glob';
+import { buildAssetMetaIndex } from './meta-index.js';
+export async function buildUnityUiMetaIndex(repoRoot, options = {}) {
+    const metaFiles = await resolveUiMetaFiles(repoRoot, options.scopedPaths);
+    if (metaFiles.length === 0) {
+        return {
+            uxmlGuidToPath: new Map(),
+            ussGuidToPath: new Map(),
+        };
+    }
+    const guidToAssetPath = await buildAssetMetaIndex(repoRoot, { metaFiles });
+    const uxmlGuidToPath = new Map();
+    const ussGuidToPath = new Map();
+    for (const [guid, assetPath] of guidToAssetPath.entries()) {
+        const normalizedPath = assetPath.replace(/\\/g, '/');
+        if (normalizedPath.endsWith('.uxml')) {
+            uxmlGuidToPath.set(guid, normalizedPath);
+            uxmlGuidToPath.set(guid.toLowerCase(), normalizedPath);
+        }
+        if (normalizedPath.endsWith('.uss')) {
+            ussGuidToPath.set(guid, normalizedPath);
+            ussGuidToPath.set(guid.toLowerCase(), normalizedPath);
+        }
+    }
+    return {
+        uxmlGuidToPath,
+        ussGuidToPath,
+    };
+}
+async function resolveUiMetaFiles(repoRoot, scopedPaths) {
+    if (!scopedPaths || scopedPaths.length === 0) {
+        return (await glob(['**/*.uxml.meta', '**/*.uss.meta'], {
+            cwd: repoRoot,
+            nodir: true,
+            dot: false,
+        })).sort((left, right) => left.localeCompare(right));
+    }
+    const out = new Set();
+    for (const scopedPath of scopedPaths) {
+        const normalized = normalizeRelativePath(repoRoot, scopedPath);
+        if (!normalized)
+            continue;
+        if (normalized.endsWith('.uxml.meta') || normalized.endsWith('.uss.meta')) {
+            out.add(normalized);
+            continue;
+        }
+        if (normalized.endsWith('.uxml') || normalized.endsWith('.uss')) {
+            out.add(`${normalized}.meta`);
+        }
+    }
+    return [...out].sort((left, right) => left.localeCompare(right));
+}
+function normalizeRelativePath(repoRoot, filePath) {
+    const relativePath = path.isAbsolute(filePath) ? path.relative(repoRoot, filePath) : filePath;
+    const normalized = relativePath.replace(/\\/g, '/');
+    if (normalized.startsWith('../'))
+        return null;
+    return normalized;
+}

package/dist/core/unity/ui-meta-index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/unity/ui-meta-index.test.js

@@ -0,0 +1,18 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { buildUnityUiMetaIndex } from './ui-meta-index.js';
+import { buildUnityScanContext } from './scan-context.js';
+const here = path.dirname(fileURLToPath(import.meta.url));
+const fixtureRoot = path.resolve(here, '../../../src/core/unity/__fixtures__/mini-unity-ui');
+test('builds *.uxml.meta/*.uss.meta guid indexes', async () => {
+    const index = await buildUnityUiMetaIndex(fixtureRoot);
+    assert.equal(index.uxmlGuidToPath.get('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'), 'Assets/UI/Screens/EliteBossScreenNew.uxml');
+    assert.equal(index.ussGuidToPath.get('dddddddddddddddddddddddddddddddd'), 'Assets/UI/Styles/EliteBossScreenNew.uss');
+});
+test('buildUnityScanContext exposes uxml/uss guid indexes', async () => {
+    const context = await buildUnityScanContext({ repoRoot: fixtureRoot });
+    assert.equal(context.uxmlGuidToPath?.get('bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'), 'Assets/UI/Screens/DressUpScreenNew.uxml');
+    assert.equal(context.ussGuidToPath?.get('eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'), 'Assets/UI/Styles/DressUpScreenNew.uss');
+});

package/dist/core/unity/ui-trace-storage-guard.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/unity/ui-trace-storage-guard.test.js

@@ -0,0 +1,10 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { NODE_TABLES, REL_TYPES } from '../lbug/schema.js';
+test('v1 ui trace does not require schema migration', () => {
+    assert.equal(NODE_TABLES.includes('Uxml'), false);
+    assert.equal(NODE_TABLES.includes('Uss'), false);
+    assert.equal(REL_TYPES.includes('UNITY_UI_TEMPLATE_REF'), false);
+    assert.equal(REL_TYPES.includes('UNITY_UI_STYLE_REF'), false);
+    assert.equal(REL_TYPES.includes('UNITY_UI_SELECTOR_BINDS'), false);
+});

package/dist/core/unity/ui-trace.acceptance.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/unity/ui-trace.acceptance.test.js

@@ -0,0 +1,38 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runUnityUiTrace } from './ui-trace.js';
+const here = path.dirname(fileURLToPath(import.meta.url));
+const fixtureRoot = path.resolve(here, '../../../src/core/unity/__fixtures__/mini-unity-ui');
+test('Q1: EliteBossScreenNew TooltipBox layout file trace', async () => {
+    const out = await runUnityUiTrace({
+        repoRoot: fixtureRoot,
+        target: 'Assets/UI/Screens/EliteBossScreenNew.uxml',
+        goal: 'template_refs',
+    });
+    assert.equal(out.results.length, 1);
+    assert.equal(out.results[0].evidence_chain[1].path, 'Assets/UI/Components/TooltipBox.uxml');
+});
+test('Q2: DressUpScreenNew template refs trace', async () => {
+    const out = await runUnityUiTrace({
+        repoRoot: fixtureRoot,
+        target: 'Assets/UI/Screens/DressUpScreenNew.uxml',
+        goal: 'template_refs',
+    });
+    assert.equal(out.results.length, 1);
+    assert.equal(out.results[0].evidence_chain[1].path, 'Assets/UI/Components/TooltipBox.uxml');
+});
+test('csharp target and uxml target resolve identical answers for asset_refs', async () => {
+    const outByClass = await runUnityUiTrace({
+        repoRoot: fixtureRoot,
+        target: 'EliteBossScreenController',
+        goal: 'asset_refs',
+    });
+    const outByUxml = await runUnityUiTrace({
+        repoRoot: fixtureRoot,
+        target: 'Assets/UI/Screens/EliteBossScreenNew.uxml',
+        goal: 'asset_refs',
+    });
+    assert.deepEqual(outByClass.results, outByUxml.results);
+});

package/dist/core/unity/ui-trace.d.ts

@@ -0,0 +1,31 @@
+export type UnityUiTraceGoal = 'asset_refs' | 'template_refs' | 'selector_bindings';
+export type UnityUiSelectorMode = 'strict' | 'balanced';
+export interface UnityUiTraceEvidenceHop {
+    path: string;
+    line: number;
+    snippet: string;
+}
+export interface UnityUiTraceResult {
+    key: string;
+    evidence_chain: UnityUiTraceEvidenceHop[];
+    score?: number;
+    confidence?: 'high' | 'medium' | 'low';
+}
+export interface UnityUiTraceDiagnostic {
+    code: 'ambiguous' | 'not_found';
+    message: string;
+    candidates: UnityUiTraceEvidenceHop[];
+}
+export interface UnityUiTraceOutput {
+    goal: UnityUiTraceGoal;
+    target: string;
+    results: UnityUiTraceResult[];
+    diagnostics: UnityUiTraceDiagnostic[];
+}
+export interface UnityUiTraceInput {
+    repoRoot: string;
+    target: string;
+    goal: UnityUiTraceGoal;
+    selectorMode?: UnityUiSelectorMode;
+}
+export declare function runUnityUiTrace(input: UnityUiTraceInput): Promise<UnityUiTraceOutput>;