@veewo/gitnexus 1.4.8 → 1.4.9-rc

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>;

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

@@ -0,0 +1,363 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { glob } from 'glob';
+import { scanUiAssetRefs } from './ui-asset-ref-scanner.js';
+import { parseUxmlRefs } from './uxml-ref-parser.js';
+import { parseUssSelectors } from './uss-selector-parser.js';
+import { extractCsharpSelectorBindings } from './csharp-selector-binding.js';
+import { buildUnityUiMetaIndex } from './ui-meta-index.js';
+import { buildMetaIndex } from './meta-index.js';
+export async function runUnityUiTrace(input) {
+    const target = String(input.target || '').trim();
+    const goal = input.goal;
+    const selectorMode = input.selectorMode || 'balanced';
+    const key = canonicalKey(target);
+    const uiMeta = await buildUnityUiMetaIndex(input.repoRoot);
+    const uxmlCandidates = resolveTargetUxmlCandidates(input.repoRoot, target, key, uiMeta.uxmlGuidToPath);
+    const diagnostics = [];
+    if (uxmlCandidates.length === 0) {
+        return {
+            goal,
+            target,
+            results: [],
+            diagnostics: [
+                {
+                    code: 'not_found',
+                    message: 'No matching UXML target found.',
+                    candidates: [],
+                },
+            ],
+        };
+    }
+    if (uxmlCandidates.length > 1) {
+        return {
+            goal,
+            target,
+            results: [],
+            diagnostics: [
+                {
+                    code: 'ambiguous',
+                    message: 'Target resolves to multiple UXML files.',
+                    candidates: uxmlCandidates.map((candidate) => ({ path: candidate, line: 1, snippet: 'target-candidate' })),
+                },
+            ],
+        };
+    }
+    const targetUxmlPath = uxmlCandidates[0];
+    const results = await resolveGoal({
+        repoRoot: input.repoRoot,
+        goal,
+        selectorMode,
+        target,
+        targetKey: key,
+        targetUxmlPath,
+        uiMeta,
+    });
+    if (results.length === 0) {
+        diagnostics.push({
+            code: 'not_found',
+            message: 'No evidence chain found.',
+            candidates: [],
+        });
+        return { goal, target, results: [], diagnostics };
+    }
+    return { goal, target, results, diagnostics };
+}
+async function resolveGoal(input) {
+    if (input.goal === 'asset_refs') {
+        const targetUxmlGuid = findGuidForUxmlPath(input.targetUxmlPath, input.uiMeta.uxmlGuidToPath);
+        if (!targetUxmlGuid)
+            return [];
+        const refs = await scanUiAssetRefs({
+            repoRoot: input.repoRoot,
+            targetGuids: [targetUxmlGuid],
+        });
+        return refs
+            .filter((row) => row.guid === targetUxmlGuid)
+            .map((row, index) => ({
+            key: `${row.sourcePath}:${row.line}:${index}`,
+            evidence_chain: [
+                { path: row.sourcePath, line: row.line, snippet: row.snippet },
+                { path: input.targetUxmlPath, line: 1, snippet: 'resolved-by-guid' },
+            ],
+        }));
+    }
+    if (input.goal === 'template_refs') {
+        const source = await safeRead(path.join(input.repoRoot, input.targetUxmlPath));
+        const parsed = parseUxmlRefs(source);
+        const templates = parsed.templates
+            .map((template) => ({
+            template,
+            resolvedPath: input.uiMeta.uxmlGuidToPath.get(template.guid),
+        }))
+            .filter((row) => Boolean(row.resolvedPath));
+        return templates.map((row, index) => ({
+            key: `${row.resolvedPath}:${row.template.line}:${index}`,
+            evidence_chain: [
+                { path: input.targetUxmlPath, line: row.template.line, snippet: row.template.snippet },
+                { path: row.resolvedPath, line: 1, snippet: 'template-target' },
+            ],
+        }));
+    }
+    const scriptPaths = await resolveScriptPathsForSelectorTarget(input.repoRoot, input.target, input.targetUxmlPath, input.targetKey, input.uiMeta);
+    const csharpBindings = await scanCsharpBindings(input.repoRoot, input.targetKey, scriptPaths);
+    const styles = await resolveStyleSelectorsForUxml(input.repoRoot, input.targetUxmlPath, input.uiMeta);
+    const styleSelectorTokenIndex = buildStyleSelectorTokenIndex(styles, input.selectorMode);
+    const selectorMatches = [];
+    for (const binding of csharpBindings) {
+        const normalizedClass = normalizeClassToken(binding.className);
+        if (!normalizedClass)
+            continue;
+        const styleEvidenceList = styleSelectorTokenIndex.get(normalizedClass) || [];
+        for (const styleEvidence of styleEvidenceList) {
+            const score = scoreSelectorBindingMatch(binding, styleEvidence, input.targetKey);
+            selectorMatches.push({
+                key: `${binding.path}:${binding.line}:${styleEvidence.path}:${styleEvidence.line}:${normalizedClass}`,
+                score,
+                evidence_chain: [
+                    { path: binding.path, line: binding.line, snippet: binding.snippet },
+                    { path: styleEvidence.path, line: styleEvidence.line, snippet: styleEvidence.snippet },
+                ],
+            });
+        }
+    }
+    selectorMatches.sort((left, right) => {
+        const scoreDiff = (right.score || 0) - (left.score || 0);
+        if (scoreDiff !== 0)
+            return scoreDiff;
+        const leftHop = left.evidence_chain[0];
+        const rightHop = right.evidence_chain[0];
+        const pathDiff = leftHop.path.localeCompare(rightHop.path);
+        if (pathDiff !== 0)
+            return pathDiff;
+        return leftHop.line - rightHop.line;
+    });
+    return dedupeTraceResults(selectorMatches);
+}
+function resolveTargetUxmlCandidates(repoRoot, target, targetKey, uxmlGuidToPath) {
+    const normalizedTarget = normalizeUxmlTargetPath(repoRoot, target);
+    if (normalizedTarget) {
+        const exactPath = findExactUxmlPath(normalizedTarget, uxmlGuidToPath);
+        if (exactPath) {
+            return [exactPath];
+        }
+    }
+    const set = new Set();
+    for (const p of uxmlGuidToPath.values()) {
+        if (canonicalKey(path.basename(p, '.uxml')) === targetKey) {
+            set.add(p);
+        }
+    }
+    return [...set];
+}
+function canonicalKey(input) {
+    return String(input || '')
+        .replace(/\\/g, '/')
+        .split('/')
+        .pop()
+        .replace(/\.uxml$/i, '')
+        .replace(/controller$/i, '')
+        .replace(/new$/i, '')
+        .replace(/[^a-z0-9]/gi, '')
+        .toLowerCase();
+}
+async function scanCsharpBindings(repoRoot, targetKey, preferredScriptPaths = []) {
+    const preferredSet = new Set(preferredScriptPaths);
+    const fallbackScriptPaths = (await glob('**/*.cs', { cwd: repoRoot, nodir: true, dot: false }))
+        .filter((scriptPath) => canonicalKey(path.basename(scriptPath, '.cs')) === targetKey);
+    const scriptPaths = [...new Set([...preferredScriptPaths, ...fallbackScriptPaths])]
+        .sort((left, right) => left.localeCompare(right));
+    const out = [];
+    for (const scriptPath of scriptPaths) {
+        const source = await safeRead(path.join(repoRoot, scriptPath));
+        const bindings = extractCsharpSelectorBindings(source);
+        for (const binding of bindings) {
+            out.push({
+                path: scriptPath.replace(/\\/g, '/'),
+                line: binding.line,
+                snippet: binding.snippet,
+                className: binding.className,
+                source: preferredSet.has(scriptPath) ? 'resource_chain' : 'name_fallback',
+            });
+        }
+    }
+    return out;
+}
+async function resolveScriptPathsForSelectorTarget(repoRoot, target, targetUxmlPath, targetKey, uiMeta) {
+    const normalizedTarget = normalizeUxmlTargetPath(repoRoot, target);
+    const isPathTarget = Boolean(normalizedTarget && findExactUxmlPath(normalizedTarget, uiMeta.uxmlGuidToPath));
+    if (!isPathTarget) {
+        return [];
+    }
+    const targetUxmlGuid = findGuidForUxmlPath(targetUxmlPath, uiMeta.uxmlGuidToPath);
+    if (!targetUxmlGuid)
+        return [];
+    const assetRefs = await scanUiAssetRefs({
+        repoRoot,
+        targetGuids: [targetUxmlGuid],
+    });
+    const sourcePaths = [...new Set(assetRefs.map((row) => row.sourcePath))];
+    if (sourcePaths.length === 0)
+        return [];
+    const scopedRefs = await scanUiAssetRefs({
+        repoRoot,
+        scopedPaths: sourcePaths,
+    });
+    const scriptGuids = [...new Set(scopedRefs
+            .filter((row) => row.fieldName === 'm_Script')
+            .map((row) => row.guid.toLowerCase()))];
+    if (scriptGuids.length === 0)
+        return [];
+    const scriptMeta = await buildMetaIndex(repoRoot);
+    if (scriptMeta.size === 0)
+        return [];
+    const lowerToPath = new Map();
+    for (const [guid, scriptPath] of scriptMeta.entries()) {
+        lowerToPath.set(guid.toLowerCase(), scriptPath.replace(/\\/g, '/'));
+    }
+    const scriptPaths = scriptGuids
+        .map((guid) => lowerToPath.get(guid))
+        .filter((value) => Boolean(value))
+        .sort((left, right) => left.localeCompare(right));
+    if (scriptPaths.length > 0) {
+        return [...new Set(scriptPaths)];
+    }
+    return (await glob('**/*.cs', { cwd: repoRoot, nodir: true, dot: false }))
+        .filter((scriptPath) => canonicalKey(path.basename(scriptPath, '.cs')) === targetKey)
+        .sort((left, right) => left.localeCompare(right));
+}
+async function resolveStyleSelectorsForUxml(repoRoot, uxmlPath, uiMeta) {
+    const uxmlSource = await safeRead(path.join(repoRoot, uxmlPath));
+    const parsed = parseUxmlRefs(uxmlSource);
+    const stylePaths = parsed.styles
+        .map((style) => uiMeta.ussGuidToPath.get(style.guid))
+        .filter((value) => Boolean(value));
+    const out = [];
+    for (const ussPath of stylePaths) {
+        const ussSource = await safeRead(path.join(repoRoot, ussPath));
+        for (const selector of parseUssSelectors(ussSource)) {
+            out.push({
+                path: ussPath,
+                line: selector.line,
+                snippet: selector.snippet,
+                selector: selector.selector,
+            });
+        }
+    }
+    return out;
+}
+async function safeRead(filePath) {
+    try {
+        return await fs.readFile(filePath, 'utf-8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return '';
+        throw error;
+    }
+}
+function normalizeUxmlTargetPath(repoRoot, target) {
+    const normalizedTarget = String(target || '').trim().replace(/\\/g, '/');
+    if (!normalizedTarget.toLowerCase().endsWith('.uxml'))
+        return null;
+    const relative = path.isAbsolute(normalizedTarget)
+        ? path.relative(repoRoot, normalizedTarget).replace(/\\/g, '/')
+        : normalizedTarget;
+    if (relative.startsWith('../'))
+        return null;
+    return relative;
+}
+function findExactUxmlPath(targetPath, uxmlGuidToPath) {
+    for (const candidate of uxmlGuidToPath.values()) {
+        if (candidate.toLowerCase() === targetPath.toLowerCase()) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function findGuidForUxmlPath(targetUxmlPath, uxmlGuidToPath) {
+    for (const [guid, assetPath] of uxmlGuidToPath.entries()) {
+        if (assetPath !== targetUxmlPath)
+            continue;
+        if (!/^[0-9a-f]{32}$/i.test(guid))
+            continue;
+        return guid.toLowerCase();
+    }
+    return null;
+}
+function buildStyleSelectorTokenIndex(styles, selectorMode) {
+    const index = new Map();
+    for (const style of styles) {
+        for (const token of extractClassTokens(style.selector, selectorMode)) {
+            const bucket = index.get(token) || [];
+            bucket.push(style);
+            index.set(token, bucket);
+        }
+    }
+    return index;
+}
+function extractClassTokens(selector, selectorMode) {
+    if (selectorMode === 'strict') {
+        const trimmed = selector.trim();
+        if (/^\.[A-Za-z_][A-Za-z0-9_-]*$/.test(trimmed)) {
+            return [trimmed.slice(1)];
+        }
+        return [];
+    }
+    const out = new Set();
+    const pattern = /\.([A-Za-z_][A-Za-z0-9_-]*)/g;
+    let match = pattern.exec(selector);
+    while (match) {
+        const token = normalizeClassToken(match[1]);
+        if (token)
+            out.add(token);
+        match = pattern.exec(selector);
+    }
+    return [...out];
+}
+function normalizeClassToken(value) {
+    return String(value || '').trim();
+}
+function dedupeTraceResults(results) {
+    const seen = new Set();
+    const out = [];
+    for (const result of results) {
+        const signature = result.evidence_chain.map((hop) => `${hop.path}:${hop.line}:${hop.snippet}`).join('|');
+        if (seen.has(signature))
+            continue;
+        seen.add(signature);
+        const score = result.score;
+        out.push({
+            ...result,
+            confidence: toConfidence(score),
+        });
+    }
+    return out;
+}
+function toConfidence(score) {
+    const value = Number(score || 0);
+    if (value >= 7)
+        return 'high';
+    if (value >= 4)
+        return 'medium';
+    return 'low';
+}
+function scoreSelectorBindingMatch(binding, styleEvidence, targetKey) {
+    let score = 0;
+    if (binding.source === 'resource_chain') {
+        score += 6;
+    }
+    const scriptBaseKey = canonicalKey(path.basename(binding.path, '.cs'));
+    if (scriptBaseKey === targetKey) {
+        score += 4;
+    }
+    const normalizedSelector = styleEvidence.selector.trim();
+    const exactSelector = `.${binding.className}`;
+    if (normalizedSelector === exactSelector) {
+        score += 2;
+    }
+    if (normalizedSelector.startsWith(`${exactSelector} `)) {
+        score += 1;
+    }
+    return score;
+}

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

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