@veewo/gitnexus 1.5.7 → 1.5.9

package/dist/cli/rule-lab.js

@@ -1,148 +0,0 @@
-import { writeSync } from 'node:fs';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { analyzeRuleLabSlice } from '../rule-lab/analyze.js';
-import { buildReviewPack } from '../rule-lab/review-pack.js';
-import { curateRuleLabSlice } from '../rule-lab/curate.js';
-import { promoteCuratedRules } from '../rule-lab/promote.js';
-import { runRuleLabRegress } from '../rule-lab/regress.js';
-import { compileRules } from '../rule-lab/compile.js';
-const RULE_LAB_COMMANDS = ['analyze', 'review-pack', 'curate', 'promote', 'regress'];
-function output(data) {
-    const text = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
-    writeSync(1, `${text}\n`);
-}
-function resolveRepoPath(repoPath) {
-    return path.resolve(repoPath || process.cwd());
-}
-function assertConcreteRunSliceIds(runId, sliceId) {
-    if (/[<>]/.test(runId) || /[<>]/.test(sliceId)) {
-        throw new Error('Invalid run/slice id: placeholder values are not allowed');
-    }
-}
-export function getRuleLabCommandNames(program) {
-    const root = program.commands.find((command) => command.name() === 'rule-lab');
-    if (!root)
-        return [];
-    return root.commands.map((command) => command.name());
-}
-export function attachRuleLabCommands(program, lazyFactory) {
-    const action = (handlerName) => {
-        if (lazyFactory)
-            return lazyFactory(handlerName);
-        switch (handlerName) {
-            case 'ruleLabAnalyzeCommand':
-                return (options) => ruleLabAnalyzeCommand(options);
-            case 'ruleLabReviewPackCommand':
-                return (options) => ruleLabReviewPackCommand(options);
-            case 'ruleLabCurateCommand':
-                return (options) => ruleLabCurateCommand(options);
-            case 'ruleLabPromoteCommand':
-                return (options) => ruleLabPromoteCommand(options);
-            case 'ruleLabRegressCommand':
-                return (options) => ruleLabRegressCommand(options);
-            default:
-                return () => {
-                    throw new Error(`Unknown rule lab handler: ${handlerName}`);
-                };
-        }
-    };
-    const root = program
-        .command('rule-lab')
-        .description('Offline rule-lab workflow for analyze/review-pack/curate/promote/regress');
-    root
-        .command('analyze')
-        .requiredOption('--run-id <id>', 'Rule-lab run id')
-        .requiredOption('--slice-id <id>', 'Slice id')
-        .option('--repo-path <path>', 'Repository path (default: cwd)')
-        .action(action('ruleLabAnalyzeCommand'));
-    root
-        .command('review-pack')
-        .requiredOption('--run-id <id>', 'Rule-lab run id')
-        .requiredOption('--slice-id <id>', 'Slice id')
-        .option('--repo-path <path>', 'Repository path (default: cwd)')
-        .option('--max-tokens <n>', 'Token budget', '6000')
-        .action(action('ruleLabReviewPackCommand'));
-    root
-        .command('curate')
-        .requiredOption('--run-id <id>', 'Rule-lab run id')
-        .requiredOption('--slice-id <id>', 'Slice id')
-        .requiredOption('--input-path <path>', 'Path to curation input JSON')
-        .option('--repo-path <path>', 'Repository path (default: cwd)')
-        .action(action('ruleLabCurateCommand'));
-    root
-        .command('promote')
-        .requiredOption('--run-id <id>', 'Rule-lab run id')
-        .requiredOption('--slice-id <id>', 'Slice id')
-        .option('--repo-path <path>', 'Repository path (default: cwd)')
-        .option('--rule-version <version>', 'Promoted rule version', '1.0.0')
-        .action(action('ruleLabPromoteCommand'));
-    root
-        .command('regress')
-        .requiredOption('--precision <n>', 'Precision metric')
-        .requiredOption('--coverage <n>', 'Coverage metric')
-        .option('--repo-path <path>', 'Repository path (default: cwd)')
-        .option('--run-id <id>', 'Run id (if provided, write report to .gitnexus/rules/reports)')
-        .option('--probes-path <path>', 'Optional JSON file containing regress probes')
-        .action(action('ruleLabRegressCommand'));
-    root
-        .command('compile')
-        .description('Compile approved YAML rules into a JSON bundle')
-        .option('--repo-path <path>', 'Repository path (default: cwd)')
-        .option('--family <family>', 'Rule family to compile', 'analyze_rules')
-        .action((options) => compileRules({ repoPath: options.repoPath, family: options.family }));
-}
-export async function ruleLabAnalyzeCommand(options) {
-    assertConcreteRunSliceIds(options.runId, options.sliceId);
-    const repoPath = resolveRepoPath(options?.repoPath);
-    const result = await analyzeRuleLabSlice({
-        repoPath,
-        runId: options.runId,
-        sliceId: options.sliceId,
-    });
-    output(result);
-}
-export async function ruleLabReviewPackCommand(options) {
-    const result = await buildReviewPack({
-        repoPath: resolveRepoPath(options?.repoPath),
-        runId: options.runId,
-        sliceId: options.sliceId,
-        maxTokens: Number(options.maxTokens || 6000),
-    });
-    output(result);
-}
-export async function ruleLabCurateCommand(options) {
-    const result = await curateRuleLabSlice({
-        repoPath: resolveRepoPath(options?.repoPath),
-        runId: options.runId,
-        sliceId: options.sliceId,
-        inputPath: path.resolve(options.inputPath),
-    });
-    output(result);
-}
-export async function ruleLabPromoteCommand(options) {
-    const version = options.ruleVersion ?? options.version;
-    const result = await promoteCuratedRules({
-        repoPath: resolveRepoPath(options?.repoPath),
-        runId: options.runId,
-        sliceId: options.sliceId,
-        version,
-    });
-    output(result);
-}
-export async function ruleLabRegressCommand(options) {
-    let probes;
-    if (options.probesPath) {
-        const raw = await fs.readFile(path.resolve(options.probesPath), 'utf-8');
-        probes = JSON.parse(raw);
-    }
-    const result = await runRuleLabRegress({
-        precision: Number(options.precision),
-        coverage: Number(options.coverage),
-        repoPath: options.repoPath ? resolveRepoPath(options.repoPath) : undefined,
-        runId: options.runId,
-        probes,
-    });
-    output(result);
-}
-export { RULE_LAB_COMMANDS };

package/dist/cli/rule-lab.test.d.ts

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

package/dist/cli/rule-lab.test.js

@@ -1,31 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { Command } from 'commander';
-import { attachRuleLabCommands, getRuleLabCommandNames, ruleLabAnalyzeCommand } from './rule-lab.js';
-describe('rule-lab cli', () => {
-    it('registers all rule-lab subcommands', async () => {
-        const program = new Command();
-        program.version('test-version');
-        attachRuleLabCommands(program);
-        const cmds = getRuleLabCommandNames(program);
-        expect(cmds).toEqual(['analyze', 'review-pack', 'curate', 'promote', 'regress', 'compile']);
-    });
-    it('uses --rule-version for promote to avoid root --version collision', () => {
-        const program = new Command();
-        program.version('test-version');
-        attachRuleLabCommands(program);
-        const ruleLab = program.commands.find((command) => command.name() === 'rule-lab');
-        expect(ruleLab).toBeTruthy();
-        const promote = ruleLab?.commands.find((command) => command.name() === 'promote');
-        expect(promote).toBeTruthy();
-        const optionNames = (promote?.options || []).map((option) => option.long);
-        expect(optionNames).toContain('--rule-version');
-        expect(optionNames).not.toContain('--version');
-    });
-    it('rejects placeholder run/slice ids at analyze command boundary', async () => {
-        await expect(ruleLabAnalyzeCommand({
-            repoPath: process.cwd(),
-            runId: '<run_id>',
-            sliceId: '<slice_id>',
-        })).rejects.toThrow(/placeholder/i);
-    });
-});

package/dist/core/ingestion/unity-runtime-binding-rules.d.ts

@@ -1,26 +0,0 @@
-import type { KnowledgeGraph } from '../graph/types.js';
-import type { RuntimeClaimRule } from '../../mcp/local/runtime-claim-rule-registry.js';
-import type { UnityConfig } from '../config/unity-config.js';
-export interface UnityRuntimeBindingResult {
-    edgesInjected: number;
-    ruleResults: Array<{
-        ruleId: string;
-        edgesInjected: number;
-    }>;
-    diagnostics: UnityRuntimeBindingDiagnostics;
-}
-export interface UnityRuntimeBindingDiagnostics {
-    rulesEvaluated: number;
-    bindingsEvaluated: number;
-    bindingsByKind: Record<string, number>;
-    methodLookupCalls: number;
-    methodLookupCacheHits: number;
-    sceneRuntimeTraversalCalls: number;
-    sceneRuntimeTraversalCacheHits: number;
-    sceneRuntimeResourcesVisited: number;
-    anomalies: string[];
-    shouldAgentReport: boolean;
-    agentReportReason: string;
-    summary: string[];
-}
-export declare function applyUnityRuntimeBindingRules(graph: KnowledgeGraph, rules: RuntimeClaimRule[], config: UnityConfig): UnityRuntimeBindingResult;

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

@@ -1,408 +0,0 @@
-import { generateId } from '../../lib/utils.js';
-const RULE_EDGE_CONFIDENCE = 0.75;
-const RULE_ANOMALY_PREVIEW_LIMIT = 5;
-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 containerNodes = [];
-    const containerLabels = config.enableContainerNodes
-        ? new Set(['Class', 'Struct', 'Interface', 'Record'])
-        : new Set(['Class']);
-    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 (containerLabels.has(node.label))
-            containerNodes.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);
-    }
-    const prefabSourceTargetsBySource = buildPrefabSourceTargetsBySource(assetGuidRefs);
-    const methodsByResourceId = buildMethodsByResourceId(componentInstances, methodsByClassId);
-    const executionState = {
-        methodsByResourceId,
-        resourceMethodLookupCache: new Map(),
-        sceneRuntimeResourceIdsCache: new Map(),
-        diagnostics: {
-            rulesEvaluated: rules.length,
-            bindingsEvaluated: 0,
-            bindingsByKind: {},
-            methodLookupCalls: 0,
-            methodLookupCacheHits: 0,
-            sceneRuntimeTraversalCalls: 0,
-            sceneRuntimeTraversalCacheHits: 0,
-            sceneRuntimeResourcesVisited: 0,
-            anomalySet: new Set(),
-        },
-    };
-    // Pre-build scene file index: lowercase scene name → fileId[]
-    const sceneFilesByName = new Map();
-    for (const node of graph.iterNodes()) {
-        if (node.label !== 'File')
-            continue;
-        const filePath = String(node.properties.filePath ?? '');
-        if (!filePath.endsWith('.unity'))
-            continue;
-        const fileName = (filePath.split('/').pop() ?? '').replace(/\.unity$/, '').toLowerCase();
-        const list = sceneFilesByName.get(fileName) ?? [];
-        list.push(node.id);
-        sceneFilesByName.set(fileName, list);
-    }
-    for (const rule of rules) {
-        let ruleEdges = 0;
-        for (const binding of rule.resource_bindings ?? []) {
-            executionState.diagnostics.bindingsEvaluated += 1;
-            executionState.diagnostics.bindingsByKind[binding.kind] =
-                (executionState.diagnostics.bindingsByKind[binding.kind] || 0) + 1;
-            ruleEdges += processBinding(binding, rule.id, assetGuidRefs, componentInstances, methodsByClassId, containerNodes, sceneFilesByName, prefabSourceTargetsBySource, executionState, addSyntheticEdge);
-        }
-        if (rule.lifecycle_overrides?.additional_entry_points?.length) {
-            ruleEdges += processLifecycleOverrides(rule, methodsByClassId, containerNodes, addSyntheticEdge);
-        }
-        totalEdges += ruleEdges;
-        ruleResults.push({ ruleId: rule.id, edgesInjected: ruleEdges });
-    }
-    return {
-        edgesInjected: totalEdges,
-        ruleResults,
-        diagnostics: finalizeRuleBindingDiagnostics(executionState.diagnostics, totalEdges),
-    };
-}
-function findMethodsOnResource(resourceFileId, executionState, entryPoints) {
-    executionState.diagnostics.methodLookupCalls += 1;
-    const cacheKey = `${resourceFileId}::${entryPoints.join('|')}`;
-    const cached = executionState.resourceMethodLookupCache.get(cacheKey);
-    if (cached) {
-        executionState.diagnostics.methodLookupCacheHits += 1;
-        return cached;
-    }
-    const methods = executionState.methodsByResourceId.get(resourceFileId) ?? [];
-    if (methods.length === 0) {
-        executionState.resourceMethodLookupCache.set(cacheKey, []);
-        return [];
-    }
-    const entrySet = new Set(entryPoints);
-    const results = [];
-    for (const method of methods) {
-        if (entrySet.has(method.properties.name))
-            results.push(method);
-    }
-    executionState.resourceMethodLookupCache.set(cacheKey, results);
-    return results;
-}
-function processBinding(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, containerNodes, sceneFilesByName, prefabSourceTargetsBySource, executionState, addEdge) {
-    if (binding.kind === 'asset_ref_loads_components') {
-        return processAssetRefLoadsComponents(binding, ruleId, assetGuidRefs, executionState, addEdge);
-    }
-    if (binding.kind === 'method_triggers_field_load') {
-        return processMethodTriggersFieldLoad(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, containerNodes, executionState, addEdge);
-    }
-    if (binding.kind === 'method_triggers_scene_load') {
-        return processMethodTriggersSceneLoad(binding, ruleId, componentInstances, methodsByClassId, containerNodes, sceneFilesByName, prefabSourceTargetsBySource, executionState, addEdge);
-    }
-    if (binding.kind === 'method_triggers_method') {
-        return processMethodTriggersMethod(binding, ruleId, methodsByClassId, containerNodes, addEdge);
-    }
-    addAnomaly(executionState.diagnostics, `rule=${ruleId}: unsupported resource_binding kind "${binding.kind}"`);
-    return 0;
-}
-function processAssetRefLoadsComponents(binding, ruleId, assetGuidRefs, executionState, 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) {
-        addAnomaly(executionState.diagnostics, `rule=${ruleId}: asset_ref_loads_components missing ref_field_pattern or target_entry_points`);
-        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, executionState, 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, containerNodes, executionState, 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) {
-        addAnomaly(executionState.diagnostics, `rule=${ruleId}: method_triggers_field_load missing host_class_pattern or loader_methods`);
-        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 containerNodes) {
-        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, executionState, 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 processMethodTriggersSceneLoad(binding, ruleId, componentInstances, methodsByClassId, containerNodes, sceneFilesByName, prefabSourceTargetsBySource, executionState, addEdge) {
-    const classPattern = binding.host_class_pattern ? new RegExp(binding.host_class_pattern) : null;
-    const loaderMethodNames = new Set(binding.loader_methods ?? []);
-    const sceneName = binding.scene_name;
-    const defaultEntryPoints = ['OnEnable', 'Awake', 'Start'];
-    const entryPoints = (binding.target_entry_points ?? []).length > 0
-        ? binding.target_entry_points
-        : defaultEntryPoints;
-    if (!classPattern || loaderMethodNames.size === 0 || !sceneName) {
-        addAnomaly(executionState.diagnostics, `rule=${ruleId}: method_triggers_scene_load missing host_class_pattern, loader_methods, or scene_name`);
-        return 0;
-    }
-    const sceneFileIds = sceneFilesByName.get(sceneName.toLowerCase()) ?? [];
-    if (sceneFileIds.length === 0) {
-        addAnomaly(executionState.diagnostics, `rule=${ruleId}: scene "${sceneName}" not found in File(.unity) index`);
-        return 0;
-    }
-    let count = 0;
-    for (const cls of containerNodes) {
-        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;
-        for (const sceneFileId of sceneFileIds) {
-            const runtimeResourceIds = getSceneRuntimeResourceIds(sceneFileId, prefabSourceTargetsBySource, executionState);
-            for (const runtimeResourceId of runtimeResourceIds) {
-                const targetMethods = findMethodsOnResource(runtimeResourceId, executionState, entryPoints);
-                for (const loader of loaders) {
-                    for (const target of targetMethods) {
-                        if (addEdge(loader.id, target.id, `unity-rule-scene-load:${ruleId}`))
-                            count++;
-                    }
-                }
-            }
-        }
-    }
-    return count;
-}
-function buildMethodsByResourceId(componentInstances, methodsByClassId) {
-    const methodsByResourceId = new Map();
-    for (const componentRef of componentInstances) {
-        const methods = methodsByClassId.get(componentRef.sourceId) ?? [];
-        if (methods.length === 0)
-            continue;
-        const list = methodsByResourceId.get(componentRef.targetId) ?? [];
-        list.push(...methods);
-        methodsByResourceId.set(componentRef.targetId, list);
-    }
-    return methodsByResourceId;
-}
-function buildPrefabSourceTargetsBySource(assetGuidRefs) {
-    const targetsBySource = new Map();
-    for (const ref of assetGuidRefs) {
-        let fieldName = '';
-        try {
-            const parsed = JSON.parse(String(ref.reason || '{}'));
-            fieldName = String(parsed?.fieldName || '');
-        }
-        catch {
-            continue;
-        }
-        if (fieldName !== 'm_SourcePrefab')
-            continue;
-        const targets = targetsBySource.get(ref.sourceId) ?? new Set();
-        targets.add(ref.targetId);
-        targetsBySource.set(ref.sourceId, targets);
-    }
-    const out = new Map();
-    for (const [sourceId, targets] of targetsBySource.entries()) {
-        out.set(sourceId, [...targets]);
-    }
-    return out;
-}
-function collectSceneRuntimeResourceIds(sceneFileId, prefabSourceTargetsBySource) {
-    const visited = new Set([sceneFileId]);
-    const queue = [sceneFileId];
-    while (queue.length > 0) {
-        const currentId = queue.shift();
-        for (const targetId of prefabSourceTargetsBySource.get(currentId) ?? []) {
-            if (visited.has(targetId))
-                continue;
-            visited.add(targetId);
-            queue.push(targetId);
-        }
-    }
-    return [...visited];
-}
-function getSceneRuntimeResourceIds(sceneFileId, prefabSourceTargetsBySource, executionState) {
-    executionState.diagnostics.sceneRuntimeTraversalCalls += 1;
-    const cached = executionState.sceneRuntimeResourceIdsCache.get(sceneFileId);
-    if (cached) {
-        executionState.diagnostics.sceneRuntimeTraversalCacheHits += 1;
-        return cached;
-    }
-    const ids = collectSceneRuntimeResourceIds(sceneFileId, prefabSourceTargetsBySource);
-    executionState.sceneRuntimeResourceIdsCache.set(sceneFileId, ids);
-    executionState.diagnostics.sceneRuntimeResourcesVisited += ids.length;
-    return ids;
-}
-function processMethodTriggersMethod(binding, ruleId, methodsByClassId, containerNodes, addEdge) {
-    const { source_class_pattern, source_method, target_class_pattern, target_method } = binding;
-    if (!source_class_pattern || !source_method || !target_class_pattern || !target_method)
-        return 0;
-    const srcPattern = new RegExp(source_class_pattern);
-    const tgtPattern = new RegExp(target_class_pattern);
-    let sourceMethodId;
-    let targetMethodId;
-    for (const cls of containerNodes) {
-        if (!sourceMethodId && srcPattern.test(cls.properties.name)) {
-            const match = (methodsByClassId.get(cls.id) ?? []).find(m => m.properties.name === source_method);
-            if (match)
-                sourceMethodId = match.id;
-        }
-        if (!targetMethodId && tgtPattern.test(cls.properties.name)) {
-            const match = (methodsByClassId.get(cls.id) ?? []).find(m => m.properties.name === target_method);
-            if (match)
-                targetMethodId = match.id;
-        }
-        if (sourceMethodId && targetMethodId)
-            break;
-    }
-    if (!sourceMethodId || !targetMethodId)
-        return 0;
-    return addEdge(sourceMethodId, targetMethodId, `unity-rule-method-bridge:${ruleId}`) ? 1 : 0;
-}
-function processLifecycleOverrides(rule, methodsByClassId, containerNodes, 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 containerNodes) {
-        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;
-}
-function addAnomaly(diagnostics, message) {
-    diagnostics.anomalySet.add(message);
-}
-function finalizeRuleBindingDiagnostics(diagnostics, edgesInjected) {
-    const anomalies = [...diagnostics.anomalySet];
-    const shouldAgentReport = anomalies.length > 0;
-    const bindingsByKind = Object.fromEntries(Object.entries(diagnostics.bindingsByKind).sort(([a], [b]) => a.localeCompare(b)));
-    const kindSummary = Object.entries(bindingsByKind)
-        .map(([kind, count]) => `${kind}=${count}`)
-        .join(', ') || 'none';
-    const summary = [
-        `rule_binding.summary: rules=${diagnostics.rulesEvaluated}, bindings=${diagnostics.bindingsEvaluated}, edges=${edgesInjected}`,
-        `rule_binding.bindings_by_kind: ${kindSummary}`,
-        `rule_binding.lookup: method_calls=${diagnostics.methodLookupCalls}, cache_hits=${diagnostics.methodLookupCacheHits}`,
-        `rule_binding.scene_closure: traversals=${diagnostics.sceneRuntimeTraversalCalls}, cache_hits=${diagnostics.sceneRuntimeTraversalCacheHits}, visited_resources=${diagnostics.sceneRuntimeResourcesVisited}`,
-        `rule_binding.agent_report: should_report=${shouldAgentReport} reason="${shouldAgentReport ? 'rule-binding anomalies detected' : 'no anomalies detected'}"`,
-    ];
-    if (anomalies.length > 0) {
-        summary.push(`rule_binding.anomalies: count=${anomalies.length}`);
-        for (const anomaly of anomalies.slice(0, RULE_ANOMALY_PREVIEW_LIMIT)) {
-            summary.push(`rule_binding.anomaly: ${anomaly}`);
-        }
-        if (anomalies.length > RULE_ANOMALY_PREVIEW_LIMIT) {
-            summary.push(`rule_binding.anomaly: ... ${anomalies.length - RULE_ANOMALY_PREVIEW_LIMIT} more`);
-        }
-    }
-    return {
-        rulesEvaluated: diagnostics.rulesEvaluated,
-        bindingsEvaluated: diagnostics.bindingsEvaluated,
-        bindingsByKind,
-        methodLookupCalls: diagnostics.methodLookupCalls,
-        methodLookupCacheHits: diagnostics.methodLookupCacheHits,
-        sceneRuntimeTraversalCalls: diagnostics.sceneRuntimeTraversalCalls,
-        sceneRuntimeTraversalCacheHits: diagnostics.sceneRuntimeTraversalCacheHits,
-        sceneRuntimeResourcesVisited: diagnostics.sceneRuntimeResourcesVisited,
-        anomalies,
-        shouldAgentReport,
-        agentReportReason: shouldAgentReport ? 'rule-binding anomalies detected' : 'no anomalies detected',
-        summary,
-    };
-}

package/dist/rule-lab/analyze.d.ts

@@ -1,13 +0,0 @@
-import { getRuleLabPaths } from './paths.js';
-import type { RuleLabCandidate, RuleLabSlice } from './types.js';
-export interface AnalyzeInput {
-    repoPath: string;
-    runId: string;
-    sliceId: string;
-}
-export interface AnalyzeOutput {
-    paths: ReturnType<typeof getRuleLabPaths>;
-    candidates: RuleLabCandidate[];
-    slice: RuleLabSlice;
-}
-export declare function analyzeRuleLabSlice(input: AnalyzeInput): Promise<AnalyzeOutput>;