@veewo/gitnexus 1.4.11-rc.2 → 1.5.0-rc

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

@@ -0,0 +1,42 @@
+import type { Command } from 'commander';
+declare const RULE_LAB_COMMANDS: readonly ["discover", "analyze", "review-pack", "curate", "promote", "regress"];
+type RuleLabHandlerName = 'ruleLabDiscoverCommand' | 'ruleLabAnalyzeCommand' | 'ruleLabReviewPackCommand' | 'ruleLabCurateCommand' | 'ruleLabPromoteCommand' | 'ruleLabRegressCommand';
+type LazyFactory = (handlerName: RuleLabHandlerName) => (...args: any[]) => void | Promise<void>;
+export declare function getRuleLabCommandNames(program: Command): string[];
+export declare function attachRuleLabCommands(program: Command, lazyFactory?: LazyFactory): void;
+export declare function ruleLabDiscoverCommand(options: {
+    repoPath?: string;
+    scope?: 'full' | 'diff';
+    seed?: string;
+}): Promise<void>;
+export declare function ruleLabAnalyzeCommand(options: {
+    repoPath?: string;
+    runId: string;
+    sliceId: string;
+}): Promise<void>;
+export declare function ruleLabReviewPackCommand(options: {
+    repoPath?: string;
+    runId: string;
+    sliceId: string;
+    maxTokens?: string | number;
+}): Promise<void>;
+export declare function ruleLabCurateCommand(options: {
+    repoPath?: string;
+    runId: string;
+    sliceId: string;
+    inputPath: string;
+}): Promise<void>;
+export declare function ruleLabPromoteCommand(options: {
+    repoPath?: string;
+    runId: string;
+    sliceId: string;
+    version?: string;
+}): Promise<void>;
+export declare function ruleLabRegressCommand(options: {
+    precision: string | number;
+    coverage: string | number;
+    repoPath?: string;
+    runId?: string;
+    probesPath?: string;
+}): Promise<void>;
+export { RULE_LAB_COMMANDS };

package/dist/cli/rule-lab.js

@@ -0,0 +1,157 @@
+import { writeSync } from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { discoverRuleLabRun } from '../rule-lab/discover.js';
+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 = ['discover', '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());
+}
+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 'ruleLabDiscoverCommand':
+                return (options) => ruleLabDiscoverCommand(options);
+            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 discover/analyze/review-pack/curate/promote/regress');
+    root
+        .command('discover')
+        .option('--repo-path <path>', 'Repository path (default: cwd)')
+        .option('--scope <scope>', 'Discovery scope: full|diff', 'full')
+        .option('--seed <seed>', 'Optional deterministic seed')
+        .action(action('ruleLabDiscoverCommand'));
+    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('--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 ruleLabDiscoverCommand(options) {
+    const result = await discoverRuleLabRun({
+        repoPath: resolveRepoPath(options?.repoPath),
+        scope: options?.scope || 'full',
+        seed: options?.seed,
+    });
+    output(result);
+}
+export async function ruleLabAnalyzeCommand(options) {
+    const result = await analyzeRuleLabSlice({
+        repoPath: resolveRepoPath(options?.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 result = await promoteCuratedRules({
+        repoPath: resolveRepoPath(options?.repoPath),
+        runId: options.runId,
+        sliceId: options.sliceId,
+        version: options.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

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

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

@@ -0,0 +1,11 @@
+import { describe, expect, it } from 'vitest';
+import { Command } from 'commander';
+import { attachRuleLabCommands, getRuleLabCommandNames } from './rule-lab.js';
+describe('rule-lab cli', () => {
+    it('registers all six rule-lab subcommands', async () => {
+        const program = new Command();
+        attachRuleLabCommands(program);
+        const cmds = getRuleLabCommandNames(program);
+        expect(cmds).toEqual(['discover', 'analyze', 'review-pack', 'curate', 'promote', 'regress']);
+    });
+});

package/dist/cli/tool.d.ts

@@ -14,7 +14,7 @@
  * native module which captures the Node.js process.stdout stream during init.
  * See the output() function for details (#324).
  */
-import type { UnityHydrationMode, UnityResourcesMode } from '../core/unity/options.js';
+import type { UnityEvidenceMode, UnityHydrationMode, UnityResourcesMode } from '../core/unity/options.js';
 export declare function queryCommand(queryText: string, options?: {
     repo?: string;
     context?: string;
@@ -24,6 +24,9 @@ export declare function queryCommand(queryText: string, options?: {
     scopePreset?: 'unity-gameplay' | 'unity-all';
     unityResources?: UnityResourcesMode;
     unityHydration?: UnityHydrationMode;
+    unityEvidence?: UnityEvidenceMode;
+    resourcePathPrefix?: string;
+    resourceSeedMode?: 'strict' | 'balanced';
     runtimeChainVerify?: 'off' | 'on-demand';
 }): Promise<void>;
 export declare function contextCommand(name: string, options?: {
@@ -33,6 +36,9 @@ export declare function contextCommand(name: string, options?: {
     content?: boolean;
     unityResources?: UnityResourcesMode;
     unityHydration?: UnityHydrationMode;
+    unityEvidence?: UnityEvidenceMode;
+    resourcePathPrefix?: string;
+    resourceSeedMode?: 'strict' | 'balanced';
     runtimeChainVerify?: 'off' | 'on-demand';
 }): Promise<void>;
 export declare function impactCommand(target: string, options?: {

package/dist/cli/tool.js

@@ -94,6 +94,9 @@ export async function queryCommand(queryText, options) {
         scope_preset: options?.scopePreset,
         unity_resources: options?.unityResources,
         unity_hydration_mode: options?.unityHydration,
+        unity_evidence_mode: options?.unityEvidence,
+        resource_path_prefix: options?.resourcePathPrefix,
+        resource_seed_mode: options?.resourceSeedMode,
         runtime_chain_verify: options?.runtimeChainVerify,
         repo,
     });
@@ -113,6 +116,9 @@ export async function contextCommand(name, options) {
         include_content: options?.content ?? false,
         unity_resources: options?.unityResources,
         unity_hydration_mode: options?.unityHydration,
+        unity_evidence_mode: options?.unityEvidence,
+        resource_path_prefix: options?.resourcePathPrefix,
+        resource_seed_mode: options?.resourceSeedMode,
         runtime_chain_verify: options?.runtimeChainVerify,
         repo,
     });

package/dist/core/config/unity-config.d.ts

@@ -0,0 +1,20 @@
+export interface UnityConfig {
+    maxSyntheticEdgesPerClass: number;
+    maxSyntheticEdgesTotal: number;
+    lazyMaxPaths: number;
+    lazyBatchSize: number;
+    lazyMaxMs: number;
+    payloadMode: 'compact' | 'full';
+    persistLifecycleProcessMetadata: boolean;
+    parityWarmup: boolean;
+    parityWarmupMaxParallel: number;
+    paritySeedCacheIdleMs: number;
+    paritySeedCacheMaxEntries: number;
+    parityCacheMaxEntries: number;
+}
+export type ConfigSourceMap = Record<keyof UnityConfig, 'cli' | 'config_file' | 'default'>;
+export interface ResolvedUnityConfig {
+    config: UnityConfig;
+    configSource: ConfigSourceMap;
+}
+export declare function resolveUnityConfig(cliArgs?: Partial<UnityConfig>, configPath?: string): ResolvedUnityConfig;

package/dist/core/config/unity-config.js

@@ -0,0 +1,46 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const DEFAULTS = {
+    maxSyntheticEdgesPerClass: 12,
+    maxSyntheticEdgesTotal: 256,
+    lazyMaxPaths: 120,
+    lazyBatchSize: 30,
+    lazyMaxMs: 5000,
+    payloadMode: 'compact',
+    persistLifecycleProcessMetadata: false,
+    parityWarmup: false,
+    parityWarmupMaxParallel: 4,
+    paritySeedCacheIdleMs: 60000,
+    paritySeedCacheMaxEntries: 100,
+    parityCacheMaxEntries: 500,
+};
+export function resolveUnityConfig(cliArgs, configPath) {
+    let fileValues = {};
+    try {
+        const path = configPath ?? join(process.cwd(), '.gitnexus', 'config.json');
+        const raw = JSON.parse(readFileSync(path, 'utf-8'));
+        if (raw?.unity && typeof raw.unity === 'object') {
+            fileValues = raw.unity;
+        }
+    }
+    catch {
+        // missing or invalid config file — skip
+    }
+    const config = {};
+    const configSource = {};
+    for (const key of Object.keys(DEFAULTS)) {
+        if (cliArgs?.[key] !== undefined) {
+            config[key] = cliArgs[key];
+            configSource[key] = 'cli';
+        }
+        else if (fileValues[key] !== undefined) {
+            config[key] = fileValues[key];
+            configSource[key] = 'config_file';
+        }
+        else {
+            config[key] = DEFAULTS[key];
+            configSource[key] = 'default';
+        }
+    }
+    return { config, configSource };
+}

package/dist/core/graph/types.d.ts

@@ -25,7 +25,7 @@ export type NodeProperties = {
     parameterCount?: number;
     returnType?: string;
 };
-export type RelationshipType = 'CONTAINS' | 'CALLS' | 'INHERITS' | 'OVERRIDES' | 'IMPORTS' | 'USES' | 'DEFINES' | 'DECORATES' | 'IMPLEMENTS' | 'EXTENDS' | 'HAS_METHOD' | 'MEMBER_OF' | 'STEP_IN_PROCESS' | 'UNITY_COMPONENT_IN' | 'UNITY_COMPONENT_INSTANCE' | 'UNITY_RESOURCE_SUMMARY' | 'UNITY_SERIALIZED_TYPE_IN';
+export type RelationshipType = 'CONTAINS' | 'CALLS' | 'INHERITS' | 'OVERRIDES' | 'IMPORTS' | 'USES' | 'DEFINES' | 'DECORATES' | 'IMPLEMENTS' | 'EXTENDS' | 'HAS_METHOD' | 'MEMBER_OF' | 'STEP_IN_PROCESS' | 'UNITY_COMPONENT_IN' | 'UNITY_COMPONENT_INSTANCE' | 'UNITY_RESOURCE_SUMMARY' | 'UNITY_SERIALIZED_TYPE_IN' | 'UNITY_ASSET_GUID_REF' | 'UNITY_GRAPH_NODE_SCRIPT_REF';
 export interface GraphNode {
     id: string;
     label: NodeLabel;

package/dist/core/ingestion/pipeline.js

@@ -9,7 +9,9 @@ import { processCommunities } from './community-processor.js';
 import { processProcesses } from './process-processor.js';
 import { processUnityResources } from './unity-resource-processor.js';
 import { applyUnityLifecycleSyntheticCalls } from './unity-lifecycle-synthetic-calls.js';
-import { resolveUnityLifecycleConfig } from './unity-lifecycle-config.js';
+import { applyUnityRuntimeBindingRules } from './unity-runtime-binding-rules.js';
+import { resolveUnityConfig } from '../config/unity-config.js';
+import { loadAnalyzeRules } from '../../mcp/local/runtime-claim-rule-registry.js';
 import { createResolutionContext } from './resolution-context.js';
 import { createASTCache } from './ast-cache.js';
 import { walkRepositoryPaths, readFileContents, walkUnityResourcePaths } from './filesystem-walker.js';
@@ -290,6 +292,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         importCtx.normalizedFileList = null;
         let communityResult;
         let processResult;
+        let unityResult;
         if (!options?.skipGraphPhases) {
             // ── Phase 4.5: Method Resolution Order ──────────────────────────────
             onProgress({
@@ -344,14 +347,43 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
                     reason: 'leiden-algorithm',
                 });
             });
-            const unityLifecycleConfig = resolveUnityLifecycleConfig(process.env);
-            const persistLifecycleProcessMetadata = unityLifecycleConfig.persistLifecycleProcessMetadata;
-            const unityLifecycleSyntheticResult = applyUnityLifecycleSyntheticCalls(graph, unityLifecycleConfig);
+            // ── Phase 5.5: Unity resource bindings (before lifecycle injection) ─
+            onProgress({
+                phase: 'enriching',
+                percent: 93,
+                message: 'Extracting Unity resource bindings...',
+                stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+            });
+            unityResult = await processUnityResources(graph, { repoPath, scopedPaths: unityScopedPaths });
+            // ── Phase 5.6: Unity lifecycle synthetic calls (auto-detect) ────────
+            const isUnityProject = allPaths.some(p => p.startsWith('Assets/') && p.endsWith('.cs'));
+            const unityConfig = resolveUnityConfig();
+            const persistLifecycleProcessMetadata = unityConfig.config.persistLifecycleProcessMetadata ?? false;
+            const unityLifecycleSyntheticResult = isUnityProject
+                ? applyUnityLifecycleSyntheticCalls(graph, {
+                    maxSyntheticEdgesPerClass: unityConfig.config.maxSyntheticEdgesPerClass,
+                    maxSyntheticEdgesTotal: unityConfig.config.maxSyntheticEdgesTotal,
+                })
+                : { syntheticEdgeCount: 0, lifecycleEdgeCount: 0, loaderEdgeCount: 0, hostCount: 0, rejectedHostCount: 0 };
             const syntheticEdgeDetail = unityLifecycleSyntheticResult.syntheticEdgeCount > 0
                 ? ` (Unity synthetic edges: ${unityLifecycleSyntheticResult.syntheticEdgeCount})`
                 : '';
-            if (isDev && unityLifecycleConfig.enabled) {
-                console.log(`[UnityLifecycle] enabled=${unityLifecycleConfig.enabled} hosts=${unityLifecycleSyntheticResult.hostCount} syntheticEdges=${unityLifecycleSyntheticResult.syntheticEdgeCount} rejectedHosts=${unityLifecycleSyntheticResult.rejectedHostCount}`);
+            if (isDev && isUnityProject) {
+                console.log(`[UnityLifecycle] auto-detected hosts=${unityLifecycleSyntheticResult.hostCount} syntheticEdges=${unityLifecycleSyntheticResult.syntheticEdgeCount} rejectedHosts=${unityLifecycleSyntheticResult.rejectedHostCount}`);
+            }
+            // Phase 5.7: rule-driven binding injection (Phase 3)
+            try {
+                const analyzeRules = await loadAnalyzeRules(repoPath);
+                if (analyzeRules.length > 0) {
+                    const bindingResult = applyUnityRuntimeBindingRules(graph, analyzeRules, unityConfig.config);
+                    if (isDev && bindingResult.edgesInjected > 0) {
+                        console.log(`[UnityRuleBinding] injected ${bindingResult.edgesInjected} edges from ${analyzeRules.length} rule(s)`);
+                    }
+                }
+            }
+            catch (err) {
+                // rule catalog missing or invalid — skip silently
+                console.warn(`[UnityRuleBinding] failed to load or apply analyze rules: ${err instanceof Error ? err.message : String(err)}`);
             }
             // ── Phase 6: Processes ─────────────────────────────────────────────
             onProgress({
@@ -414,13 +446,6 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
                 });
             });
         }
-        onProgress({
-            phase: 'enriching',
-            percent: 99,
-            message: 'Extracting Unity resource bindings...',
-            stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
-        });
-        const unityResult = await processUnityResources(graph, { repoPath, scopedPaths: unityScopedPaths });
         onProgress({
             phase: 'complete',
             percent: 100,

package/dist/core/ingestion/unity-lifecycle-synthetic-calls.d.ts

@@ -4,14 +4,12 @@ export interface UnityLifecycleSyntheticConfig {
     maxSyntheticEdgesPerClass: number;
     maxSyntheticEdgesTotal: number;
     lifecycleEdgeConfidence: number;
-    loaderEdgeConfidence: number;
 }
 export declare const DEFAULT_UNITY_LIFECYCLE_SYNTHETIC_CONFIG: UnityLifecycleSyntheticConfig;
 export interface UnityLifecycleHost {
     classNode: GraphNode;
     baseType: 'MonoBehaviour' | 'ScriptableObject';
     lifecycleCallbacks: GraphNode[];
-    loaderAnchors: GraphNode[];
     methods: GraphNode[];
 }
 export interface UnityLifecycleSyntheticResult {