@veewo/gitnexus 1.4.11-rc → 1.5.0-rc

package/dist/core/ingestion/unity-runtime-binding-rules.js

@@ -0,0 +1,179 @@
+import { generateId } from '../../lib/utils.js';
+const RULE_EDGE_CONFIDENCE = 0.75;
+export function applyUnityRuntimeBindingRules(graph, rules, _config) {
+    const ruleResults = [];
+    let totalEdges = 0;
+    const existingPairs = new Set();
+    for (const rel of graph.iterRelationships()) {
+        if (rel.type === 'CALLS')
+            existingPairs.add(`${rel.sourceId}->${rel.targetId}`);
+    }
+    const addSyntheticEdge = (sourceId, targetId, reason) => {
+        if (sourceId === targetId)
+            return false;
+        const key = `${sourceId}->${targetId}`;
+        if (existingPairs.has(key))
+            return false;
+        graph.addRelationship({
+            id: generateId('CALLS', `${sourceId}->${targetId}:${reason}`),
+            sourceId,
+            targetId,
+            type: 'CALLS',
+            confidence: RULE_EDGE_CONFIDENCE,
+            reason,
+        });
+        existingPairs.add(key);
+        return true;
+    };
+    // Pre-build indexes
+    const methodsByClassId = new Map();
+    const classNodes = [];
+    for (const rel of graph.iterRelationships()) {
+        if (rel.type !== 'HAS_METHOD')
+            continue;
+        const method = graph.getNode(rel.targetId);
+        if (!method || (method.label !== 'Method' && method.label !== 'Function'))
+            continue;
+        const list = methodsByClassId.get(rel.sourceId) ?? [];
+        list.push(method);
+        methodsByClassId.set(rel.sourceId, list);
+    }
+    for (const node of graph.iterNodes()) {
+        if (node.label === 'Class')
+            classNodes.push(node);
+    }
+    // Collect UNITY_ASSET_GUID_REF and UNITY_COMPONENT_INSTANCE edges
+    const assetGuidRefs = [];
+    const componentInstances = [];
+    for (const rel of graph.iterRelationships()) {
+        if (rel.type === 'UNITY_ASSET_GUID_REF')
+            assetGuidRefs.push(rel);
+        else if (rel.type === 'UNITY_COMPONENT_INSTANCE')
+            componentInstances.push(rel);
+    }
+    for (const rule of rules) {
+        let ruleEdges = 0;
+        for (const binding of rule.resource_bindings ?? []) {
+            ruleEdges += processBinding(binding, rule.id, assetGuidRefs, componentInstances, methodsByClassId, classNodes, addSyntheticEdge);
+        }
+        if (rule.lifecycle_overrides?.additional_entry_points?.length) {
+            ruleEdges += processLifecycleOverrides(rule, methodsByClassId, classNodes, addSyntheticEdge);
+        }
+        totalEdges += ruleEdges;
+        ruleResults.push({ ruleId: rule.id, edgesInjected: ruleEdges });
+    }
+    return { edgesInjected: totalEdges, ruleResults };
+}
+function findMethodsOnResource(resourceFileId, componentInstances, methodsByClassId, entryPoints) {
+    const results = [];
+    const entrySet = new Set(entryPoints);
+    for (const ci of componentInstances) {
+        if (ci.targetId !== resourceFileId)
+            continue;
+        const classId = ci.sourceId;
+        for (const method of methodsByClassId.get(classId) ?? []) {
+            if (entrySet.has(method.properties.name))
+                results.push(method);
+        }
+    }
+    return results;
+}
+function processBinding(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, classNodes, addEdge) {
+    if (binding.kind === 'asset_ref_loads_components') {
+        return processAssetRefLoadsComponents(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, addEdge);
+    }
+    if (binding.kind === 'method_triggers_field_load') {
+        return processMethodTriggersFieldLoad(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, classNodes, addEdge);
+    }
+    return 0;
+}
+function processAssetRefLoadsComponents(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, addEdge) {
+    let count = 0;
+    const pattern = binding.ref_field_pattern ? new RegExp(binding.ref_field_pattern) : null;
+    const entryPoints = binding.target_entry_points ?? [];
+    if (!pattern || entryPoints.length === 0)
+        return 0;
+    const runtimeRootId = generateId('Method', 'unity-runtime-root');
+    for (const ref of assetGuidRefs) {
+        let fieldName = '';
+        try {
+            const parsed = JSON.parse(ref.reason);
+            fieldName = parsed.fieldName ?? '';
+        }
+        catch {
+            continue;
+        }
+        if (!pattern.test(fieldName))
+            continue;
+        const targetMethods = findMethodsOnResource(ref.targetId, componentInstances, methodsByClassId, entryPoints);
+        for (const method of targetMethods) {
+            if (addEdge(runtimeRootId, method.id, `unity-rule-resource-load:${ruleId}`))
+                count++;
+        }
+    }
+    return count;
+}
+function processMethodTriggersFieldLoad(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, classNodes, addEdge) {
+    let count = 0;
+    const classPattern = binding.host_class_pattern ? new RegExp(binding.host_class_pattern) : null;
+    const loaderMethodNames = new Set(binding.loader_methods ?? []);
+    const entryPoints = binding.target_entry_points ?? [];
+    const defaultEntryPoints = ['OnEnable', 'Awake', 'Start'];
+    const resolvedEntryPoints = entryPoints.length > 0 ? entryPoints : defaultEntryPoints;
+    if (!classPattern || loaderMethodNames.size === 0)
+        return 0;
+    // Build asset ref index by source file
+    const refsBySource = new Map();
+    for (const ref of assetGuidRefs) {
+        const list = refsBySource.get(ref.sourceId) ?? [];
+        list.push(ref);
+        refsBySource.set(ref.sourceId, list);
+    }
+    for (const cls of classNodes) {
+        if (!classPattern.test(cls.properties.name))
+            continue;
+        const methods = methodsByClassId.get(cls.id) ?? [];
+        const loaders = methods.filter(m => loaderMethodNames.has(m.properties.name));
+        if (loaders.length === 0)
+            continue;
+        // Find resource files this class is mounted on
+        const resourceFileIds = new Set();
+        for (const ci of componentInstances) {
+            if (ci.sourceId === cls.id)
+                resourceFileIds.add(ci.targetId);
+        }
+        // Follow asset refs from those resource files
+        for (const resourceFileId of resourceFileIds) {
+            for (const ref of refsBySource.get(resourceFileId) ?? []) {
+                const targetMethods = findMethodsOnResource(ref.targetId, componentInstances, methodsByClassId, resolvedEntryPoints);
+                for (const loader of loaders) {
+                    for (const target of targetMethods) {
+                        if (addEdge(loader.id, target.id, `unity-rule-loader-bridge:${ruleId}`))
+                            count++;
+                    }
+                }
+            }
+        }
+    }
+    return count;
+}
+function processLifecycleOverrides(rule, methodsByClassId, classNodes, addEdge) {
+    const overrides = rule.lifecycle_overrides;
+    if (!overrides?.additional_entry_points?.length)
+        return 0;
+    const entrySet = new Set(overrides.additional_entry_points);
+    const scopePattern = overrides.scope ? new RegExp(overrides.scope) : null;
+    let count = 0;
+    const runtimeRootId = generateId('Method', 'unity-runtime-root');
+    for (const cls of classNodes) {
+        if (scopePattern && !scopePattern.test(cls.properties.filePath ?? cls.properties.name))
+            continue;
+        for (const method of methodsByClassId.get(cls.id) ?? []) {
+            if (!entrySet.has(method.properties.name))
+                continue;
+            if (addEdge(runtimeRootId, method.id, `unity-rule-lifecycle-override:${rule.id}`))
+                count++;
+        }
+    }
+    return count;
+}

package/dist/core/unity/options.d.ts

@@ -1,4 +1,8 @@
 export type UnityResourcesMode = 'off' | 'on' | 'auto';
 export type UnityHydrationMode = 'parity' | 'compact';
+export type UnityEvidenceMode = 'summary' | 'focused' | 'full';
+export type HydrationPolicy = 'fast' | 'balanced' | 'strict';
 export declare function parseUnityResourcesMode(raw?: string): UnityResourcesMode;
 export declare function parseUnityHydrationMode(raw?: string): UnityHydrationMode;
+export declare function parseUnityEvidenceMode(raw?: string): UnityEvidenceMode;
+export declare function parseHydrationPolicy(raw?: string): HydrationPolicy;

package/dist/core/unity/options.js

@@ -16,3 +16,21 @@ export function parseUnityHydrationMode(raw) {
     }
     throw new Error('Invalid unity hydration mode. Use parity|compact.');
 }
+export function parseUnityEvidenceMode(raw) {
+    if (!raw)
+        return 'summary';
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === 'summary' || normalized === 'focused' || normalized === 'full') {
+        return normalized;
+    }
+    throw new Error('Invalid unity evidence mode. Use summary|focused|full.');
+}
+export function parseHydrationPolicy(raw) {
+    if (!raw)
+        return 'balanced';
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === 'fast' || normalized === 'balanced' || normalized === 'strict') {
+        return normalized;
+    }
+    throw new Error('Invalid hydration policy. Use fast|balanced|strict.');
+}

package/dist/core/unity/options.test.js

@@ -1,6 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { parseUnityHydrationMode, parseUnityResourcesMode } from './options.js';
+import { parseHydrationPolicy, parseUnityEvidenceMode, parseUnityHydrationMode, parseUnityResourcesMode, } from './options.js';
 test('parseUnityResourcesMode defaults to off', () => {
     assert.equal(parseUnityResourcesMode(undefined), 'off');
 });
@@ -15,3 +15,13 @@ test('parseUnityHydrationMode validates mode', () => {
     assert.equal(parseUnityHydrationMode('compact'), 'compact');
     assert.throws(() => parseUnityHydrationMode('bad'), /unity hydration mode/i);
 });
+test('parseUnityEvidenceMode defaults to summary and validates mode', () => {
+    assert.equal(parseUnityEvidenceMode(undefined), 'summary');
+    assert.equal(parseUnityEvidenceMode('focused'), 'focused');
+    assert.throws(() => parseUnityEvidenceMode('bad'), /unity evidence mode/i);
+});
+test('parseHydrationPolicy defaults to balanced and validates mode', () => {
+    assert.equal(parseHydrationPolicy(undefined), 'balanced');
+    assert.equal(parseHydrationPolicy('strict'), 'strict');
+    assert.throws(() => parseHydrationPolicy('bad'), /hydration policy/i);
+});

package/dist/core/unity/resolver.js

@@ -24,7 +24,14 @@ export async function resolveUnityBindings(input) {
             continue;
         }
         const blocks = await getResourceBlocks(input.repoRoot, hit.resourcePath, input.scanContext);
-        const matchedComponents = blocks.filter((block) => block.objectType === 'MonoBehaviour' && block.fields.m_Script?.includes(scriptGuid));
+        const matchedComponents = blocks.filter((block) => {
+            if (block.objectType !== 'MonoBehaviour')
+                return false;
+            const scriptRefGuid = extractGuidFromScriptField(block.fields.m_Script || '');
+            if (!scriptRefGuid)
+                return false;
+            return scriptRefGuid.toLowerCase() === scriptGuid.toLowerCase();
+        });
         if (matchedComponents.length === 0) {
             unityDiagnostics.push(`No MonoBehaviour block matched script guid ${scriptGuid} in ${hit.resourcePath}.`);
             continue;
@@ -413,6 +420,9 @@ function extractFileId(rawValue) {
         return undefined;
     return rawValue.match(/fileID:\s*(\d+)/)?.[1];
 }
+function extractGuidFromScriptField(rawValue) {
+    return rawValue.match(/guid:\s*([0-9a-f]{32})/i)?.[1];
+}
 function parseObjectReference(rawValue) {
     const trimmed = rawValue.trim();
     if (!trimmed.startsWith('{') || !trimmed.includes('fileID:')) {

package/dist/core/unity/resolver.test.js

@@ -234,6 +234,68 @@ test('resolveUnityBindings deepParseLargeResources can override lightweight fall
         await fs.rm(tempRoot, { recursive: true, force: true });
     }
 });
+test('resolveUnityBindings matches MonoBehaviour script guid case-insensitively', async () => {
+    const tempRoot = await fs.mkdtemp(path.join(path.dirname(fixtureRoot), 'tmp-guid-case-unity-'));
+    const scriptsDir = path.join(tempRoot, 'Assets/Scripts');
+    const assetDir = path.join(tempRoot, 'Assets/Data');
+    await fs.mkdir(scriptsDir, { recursive: true });
+    await fs.mkdir(assetDir, { recursive: true });
+    try {
+        const scriptPath = 'Assets/Scripts/CaseGuidSymbol.cs';
+        const assetPath = 'Assets/Data/CaseGuid.asset';
+        const scriptGuid = 'abcdefabcdefabcdefabcdefabcdefab';
+        await fs.writeFile(path.join(tempRoot, scriptPath), 'public class CaseGuidSymbol {}', 'utf-8');
+        await fs.writeFile(path.join(tempRoot, `${scriptPath}.meta`), `guid: ${scriptGuid}\n`, 'utf-8');
+        await fs.writeFile(path.join(tempRoot, assetPath), `--- !u!114 &11400000\nMonoBehaviour:\n  m_Script: {fileID: 11500000, guid: ${scriptGuid.toUpperCase()}, type: 3}\n  value: 1\n`, 'utf-8');
+        const scanContext = await buildUnityScanContext({
+            repoRoot: tempRoot,
+            scopedPaths: [scriptPath, `${scriptPath}.meta`, assetPath],
+            symbolDeclarations: [{ symbol: 'CaseGuidSymbol', scriptPath }],
+        });
+        const resolved = await resolveUnityBindings({
+            repoRoot: tempRoot,
+            symbol: 'CaseGuidSymbol',
+            scanContext,
+        });
+        assert.equal(resolved.resourceBindings.length, 1);
+        assert.equal(resolved.resourceBindings[0]?.resourcePath, assetPath);
+        assert.equal(resolved.unityDiagnostics.length, 0);
+    }
+    finally {
+        await fs.rm(tempRoot, { recursive: true, force: true });
+    }
+});
+test('resolveUnityBindings parses MonoBehaviour blocks with negative object ids', async () => {
+    const tempRoot = await fs.mkdtemp(path.join(path.dirname(fixtureRoot), 'tmp-negative-object-id-'));
+    const scriptsDir = path.join(tempRoot, 'Assets/Scripts');
+    const assetDir = path.join(tempRoot, 'Assets/Graphs');
+    await fs.mkdir(scriptsDir, { recursive: true });
+    await fs.mkdir(assetDir, { recursive: true });
+    try {
+        const scriptPath = 'Assets/Scripts/NegativeIdSymbol.cs';
+        const assetPath = 'Assets/Graphs/NegativeId.asset';
+        const scriptGuid = '1b63118991a192f4d8ac217fd7fe49ce';
+        await fs.writeFile(path.join(tempRoot, scriptPath), 'public class NegativeIdSymbol {}', 'utf-8');
+        await fs.writeFile(path.join(tempRoot, `${scriptPath}.meta`), `guid: ${scriptGuid}\n`, 'utf-8');
+        await fs.writeFile(path.join(tempRoot, assetPath), `--- !u!114 &-8618438378761226257\nMonoBehaviour:\n  m_Script: {fileID: 11500000, guid: ${scriptGuid}, type: 3}\n  m_Name: Negative Id Node\n`, 'utf-8');
+        const scanContext = await buildUnityScanContext({
+            repoRoot: tempRoot,
+            scopedPaths: [scriptPath, `${scriptPath}.meta`, assetPath],
+            symbolDeclarations: [{ symbol: 'NegativeIdSymbol', scriptPath }],
+        });
+        const resolved = await resolveUnityBindings({
+            repoRoot: tempRoot,
+            symbol: 'NegativeIdSymbol',
+            scanContext,
+        });
+        assert.equal(resolved.resourceBindings.length, 1);
+        assert.equal(resolved.resourceBindings[0]?.resourcePath, assetPath);
+        assert.equal(resolved.unityDiagnostics.length, 0);
+    }
+    finally {
+        await fs.rm(tempRoot, { recursive: true, force: true });
+    }
+});
 test('extractAssetRefPathReferences parses nested _relativePath rows and marks sprite assets', () => {
     const refs = extractAssetRefPathReferences({
         scalarFields: [

package/dist/core/unity/yaml-object-graph.js

@@ -24,7 +24,7 @@ export function parseUnityYamlObjects(text) {
         currentBody = [];
     };
     for (const line of lines) {
-        const header = line.match(/^--- !u!\d+ &(\d+)(?:\s+(\w+))?\s*$/);
+        const header = line.match(/^--- !u!\d+ &(-?\d+)(?:\s+(\w+))?\s*$/);
         if (header) {
             flush();
             currentHeader = {

package/dist/core/unity/yaml-object-graph.test.js

@@ -47,3 +47,19 @@ MonoBehaviour:
     assert.equal(mono.fields['- {fileID'], undefined);
     assert.equal(mono.fields.needPause, '0');
 });
+test('parseUnityYamlObjects supports negative object ids in headers', () => {
+    const yamlWithNegativeIds = `--- !u!114 &-8618438378761226257
+MonoBehaviour:
+  m_Script: {fileID: 11500000, guid: 1b63118991a192f4d8ac217fd7fe49ce, type: 3}
+  m_Name: Energy By Attack Count
+--- !u!114 &11400000
+MonoBehaviour:
+  m_Name: Graph Root
+`;
+    const blocks = parseUnityYamlObjects(yamlWithNegativeIds);
+    assert.equal(blocks.length, 2);
+    assert.equal(blocks[0]?.objectId, '-8618438378761226257');
+    assert.equal(blocks[0]?.objectType, 'MonoBehaviour');
+    assert.match(blocks[0]?.fields.m_Script || '', /guid:\s*1b63118991a192f4d8ac217fd7fe49ce/);
+    assert.equal(blocks[1]?.objectId, '11400000');
+});

package/dist/mcp/local/derived-process-reader.d.ts

@@ -0,0 +1,2 @@
+import type { LocalBackend } from './local-backend.js';
+export declare function getDerivedProcessDetailResource(id: string, _backend: LocalBackend, repoName?: string): Promise<string>;

package/dist/mcp/local/derived-process-reader.js

@@ -0,0 +1,15 @@
+export async function getDerivedProcessDetailResource(id, _backend, repoName) {
+    const normalizedId = String(id || '').trim();
+    if (!normalizedId) {
+        return 'error: derived-process id is required';
+    }
+    const lines = [
+        `id: "${normalizedId}"`,
+        'kind: derived',
+        'origin: resource_heuristic',
+        `reader_uri: "gitnexus://repo/${encodeURIComponent(String(repoName || ''))}/derived-process/${encodeURIComponent(normalizedId)}"`,
+        'readable: true',
+        'note: "Derived process references are synthesized at query/context runtime from symbol + evidence fingerprints."',
+    ];
+    return lines.join('\n');
+}

package/dist/mcp/local/local-backend.d.ts

@@ -7,12 +7,14 @@
  */
 import type { ResolvedUnityBinding } from '../../core/unity/resolver.js';
 import { type UnityContextPayload, type UnityHydrationMeta } from './unity-enrichment.js';
+import type { VerificationHint } from './process-confidence.js';
 import { type RegistryEntry } from '../../storage/repo-manager.js';
 /**
  * Quick test-file detection for filtering impact results.
  * Matches common test file patterns across all supported languages.
  */
 export declare function isTestFilePath(filePath: string): boolean;
+type ResourceSeedMode = 'strict' | 'balanced';
 export interface ExpandedSymbolCandidate {
     id: string;
     name: string;
@@ -21,6 +23,54 @@ export interface ExpandedSymbolCandidate {
     startLine?: number;
     endLine?: number;
 }
+export declare function parseResourceSeedMode(raw: unknown): ResourceSeedMode;
+export declare function extractUnityResourcePaths(text: string): string[];
+export declare function resolveSeedPath(input: {
+    queryText?: string;
+    resourcePathPrefix?: string;
+    filePath?: string;
+}): string | undefined;
+interface NextHopPayload {
+    kind: 'resource' | 'symbol' | 'process' | 'verify';
+    target: string;
+    why: string;
+    next_command: string;
+}
+interface RetrievalRuleHint {
+    id: string;
+    next_action: string;
+    host_base_type?: string[];
+}
+export declare function pickVerificationTarget(input: {
+    seedMode: ResourceSeedMode;
+    seedPath?: string;
+    mappedSeedTargets: string[];
+    resourceBindings: ResolvedUnityBinding[];
+    fallback: string;
+}): string;
+export declare function buildNextHops(input: {
+    seedPath?: string;
+    mappedSeedTargets: string[];
+    resourceBindings: ResolvedUnityBinding[];
+    verificationHint?: VerificationHint;
+    retrievalRule?: RetrievalRuleHint;
+    repoName?: string;
+    symbolName: string;
+    queryForSymbol: string;
+}): NextHopPayload[];
+export declare function pickRetrievalRuleHintFromBundle(input: {
+    queryText?: string;
+    symbolName?: string;
+    seedPath?: string;
+    rules: Array<{
+        id: string;
+        trigger_tokens?: string[];
+        host_base_type?: string[];
+        resource_types?: string[];
+        next_action: string;
+    }>;
+}): RetrievalRuleHint | undefined;
+export declare function resolveSeedTargetsFromResourceFile(repoPath: string, seedPath: string): Promise<string[]>;
 export declare function filterBm25ResultsByScopePreset<T extends {
     filePath?: string;
 }>(rows: T[], scopePreset?: string): T[];
@@ -110,6 +160,12 @@ export declare class LocalBackend {
     }>>;
     callTool(method: string, params: any): Promise<any>;
     private unityUiTrace;
+    private ruleLabDiscover;
+    private ruleLabAnalyze;
+    private ruleLabReviewPack;
+    private ruleLabCurate;
+    private ruleLabPromote;
+    private ruleLabRegress;
     /**
      * Query tool — process-grouped search.
      *