@veewo/gitnexus 1.5.7 → 1.5.8

package/dist/mcp/local/runtime-claim-rule-registry.test.js

@@ -1,24 +1,14 @@
 import assert from 'node:assert/strict';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
 import { test } from 'vitest';
-import { RuleRegistryLoadError, loadRuleRegistry } from './runtime-claim-rule-registry.js';
-test('loads active runtime claim rules from project catalog', async () => {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-runtime-claim-rules-'));
-    const repoPath = path.join(tempRoot, 'repo');
-    const rulesRoot = path.join(repoPath, '.gitnexus', 'rules');
-    await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
-    await fs.writeFile(path.join(rulesRoot, 'catalog.json'), JSON.stringify({
-        rules: [
-            {
-                id: 'demo.reload.rule.v1',
-                version: '1.2.3',
-                file: 'approved/demo.reload.rule.v1.yaml',
-            },
-        ],
-    }), 'utf-8');
-    await fs.writeFile(path.join(rulesRoot, 'approved', 'demo.reload.rule.v1.yaml'), [
+import { RuleRegistryLoadError, parseRuleYaml } from './runtime-claim-rule-registry.js';
+test('RuleRegistryLoadError has code and context', () => {
+    const err = new RuleRegistryLoadError('rule_catalog_missing', 'Catalog not found', { repoPath: '/tmp/repo' });
+    assert.ok(err instanceof RuleRegistryLoadError);
+    assert.equal(err.code, 'rule_catalog_missing');
+    assert.match(String(err.message || ''), /Catalog not found/);
+});
+test('parseRuleYaml parses basic fields', () => {
+    const yaml = [
         'id: demo.reload.rule.v1',
         'version: 1.2.3',
         'trigger_family: reload',
@@ -33,106 +23,37 @@ test('loads active runtime claim rules from project catalog', async () => {
         'non_guarantees:',
         '  - no_runtime_execution',
         'next_action: gitnexus query "reload"',
-    ].join('\n'), 'utf-8');
-    try {
-        const registry = await loadRuleRegistry(repoPath);
-        assert.equal(registry.activeRules[0].id, 'demo.reload.rule.v1');
-        assert.equal(registry.activeRules[0].version, '1.2.3');
-    }
-    finally {
-        await fs.rm(tempRoot, { recursive: true, force: true });
-    }
-});
-test('throws rule_catalog_missing when target repo has no catalog (no ancestor fallback)', async () => {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-runtime-claim-rules-'));
-    const workspaceRoot = path.join(tempRoot, 'workspace');
-    const nestedCwd = path.join(workspaceRoot, 'packages', 'app');
-    const rulesRoot = path.join(workspaceRoot, '.gitnexus', 'rules');
-    const catalogPath = path.join(rulesRoot, 'catalog.json');
-    await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
-    await fs.mkdir(nestedCwd, { recursive: true });
-    await fs.writeFile(catalogPath, JSON.stringify({
-        rules: [
-            {
-                id: 'demo.reload.rule.v1',
-                version: '1.2.3',
-                file: 'approved/demo.reload.rule.v1.yaml',
-            },
-        ],
-    }), 'utf-8');
-    await fs.writeFile(path.join(rulesRoot, 'approved', 'demo.reload.rule.v1.yaml'), ['id: demo.reload.rule.v1', 'version: 1.2.3', 'trigger_family: reload'].join('\n'), 'utf-8');
-    const originalCwd = process.cwd();
-    process.chdir(nestedCwd);
-    try {
-        await assert.rejects(() => loadRuleRegistry(path.join(tempRoot, 'does-not-exist')), (error) => {
-            assert.ok(error instanceof RuleRegistryLoadError);
-            assert.equal(error.code, 'rule_catalog_missing');
-            assert.match(String(error.message || ''), /catalog not found/i);
-            return true;
-        });
-    }
-    finally {
-        process.chdir(originalCwd);
-        await fs.rm(tempRoot, { recursive: true, force: true });
-    }
-});
-test('throws rule_catalog_missing when rulesRoot exists but catalog.json is missing', async () => {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-runtime-claim-rules-'));
-    const repoPath = path.join(tempRoot, 'repo');
-    const rulesRoot = path.join(repoPath, '.gitnexus', 'rules');
-    await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
-    try {
-        await assert.rejects(() => loadRuleRegistry(repoPath), (error) => {
-            assert.ok(error instanceof RuleRegistryLoadError);
-            assert.equal(error.code, 'rule_catalog_missing');
-            return true;
-        });
-    }
-    finally {
-        await fs.rm(tempRoot, { recursive: true, force: true });
-    }
-});
-test('throws rule_file_missing when catalog entry points to missing yaml file', async () => {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-runtime-claim-rules-'));
-    const repoPath = path.join(tempRoot, 'repo');
-    const rulesRoot = path.join(repoPath, '.gitnexus', 'rules');
-    await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
-    await fs.writeFile(path.join(rulesRoot, 'catalog.json'), JSON.stringify({
-        rules: [
-            {
-                id: 'demo.reload.rule.v1',
-                version: '1.0.0',
-                file: 'approved/demo.reload.rule.v1.yaml',
-            },
-        ],
-    }), 'utf-8');
-    try {
-        await assert.rejects(() => loadRuleRegistry(repoPath), (error) => {
-            assert.ok(error instanceof RuleRegistryLoadError);
-            assert.equal(error.code, 'rule_file_missing');
-            assert.match(String(error.message || ''), /rule file not found/i);
-            return true;
-        });
-    }
-    finally {
-        await fs.rm(tempRoot, { recursive: true, force: true });
-    }
+        'match:',
+        '  trigger_tokens:',
+        '    - reload',
+        'closure:',
+        '  required_hops:',
+        '    - resource',
+        'claims:',
+        '  guarantees:',
+        '    - reload_chain_closed',
+        '  non_guarantees:',
+        '    - no_runtime_execution',
+        '  next_action: gitnexus query "reload"',
+        'topology:',
+        '  - hop: resource',
+        '    from:',
+        '      entity: resource',
+        '    to:',
+        '      entity: script',
+        '    edge:',
+        '      kind: binds_script',
+    ].join('\n');
+    const rule = parseRuleYaml(yaml, 'test.yaml');
+    assert.equal(rule.id, 'demo.reload.rule.v1');
+    assert.equal(rule.version, '1.2.3');
+    assert.equal(rule.trigger_family, 'reload');
+    assert.deepEqual(rule.resource_types, ['asset']);
+    assert.deepEqual(rule.host_base_type, ['ReloadBase']);
+    assert.equal(rule.file_path, 'test.yaml');
 });
-test('parses scalar/list values with spaces, quotes, and escapes without truncation', async () => {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-runtime-claim-rules-'));
-    const repoPath = path.join(tempRoot, 'repo');
-    const rulesRoot = path.join(repoPath, '.gitnexus', 'rules');
-    await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
-    await fs.writeFile(path.join(rulesRoot, 'catalog.json'), JSON.stringify({
-        rules: [
-            {
-                id: 'demo.scalar-parser.v1',
-                version: '1.0.0',
-                file: 'approved/demo.scalar-parser.v1.yaml',
-            },
-        ],
-    }), 'utf-8');
-    await fs.writeFile(path.join(rulesRoot, 'approved', 'demo.scalar-parser.v1.yaml'), [
+test('parseRuleYaml parses scalar/list values with spaces, quotes, and escapes', () => {
+    const yaml = [
         'id: demo.scalar-parser.v1',
         'version: 1.0.0',
         'trigger_family: reload',
@@ -149,100 +70,32 @@ test('parses scalar/list values with spaces, quotes, and escapes without truncat
         '  - "double-quote \\"inside\\""',
         "  - 'single-quote ''inside'''",
         'next_action: node gitnexus/dist/cli/index.js query --runtime-chain-verify on-demand "Reload NEON.Game.Graph.Nodes.Reloads"',
-    ].join('\n'), 'utf-8');
-    try {
-        const registry = await loadRuleRegistry(repoPath);
-        const rule = registry.activeRules[0];
-        assert.equal(rule.id, 'demo.scalar-parser.v1');
-        assert.deepEqual(rule.resource_types, ['asset ref', 'prefab ref']);
-        assert.deepEqual(rule.guarantees, ['guarantee with spaces']);
-        assert.deepEqual(rule.non_guarantees, ['double-quote "inside"', "single-quote 'inside'"]);
-        assert.equal(rule.next_action, 'node gitnexus/dist/cli/index.js query --runtime-chain-verify on-demand "Reload NEON.Game.Graph.Nodes.Reloads"');
-    }
-    finally {
-        await fs.rm(tempRoot, { recursive: true, force: true });
-    }
-});
-test('rejects rule yaml when topology/closure/claims are missing', async () => {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-runtime-claim-rules-'));
-    const repoPath = path.join(tempRoot, 'repo');
-    const rulesRoot = path.join(repoPath, '.gitnexus', 'rules');
-    await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
-    await fs.writeFile(path.join(rulesRoot, 'catalog.json'), JSON.stringify({
-        rules: [
-            {
-                id: 'demo.reload.rule.v2',
-                version: '2.0.0',
-                file: 'approved/demo.reload.rule.v2.yaml',
-            },
-        ],
-    }), 'utf-8');
-    await fs.writeFile(path.join(rulesRoot, 'approved', 'demo.reload.rule.v2.yaml'), [
-        'id: demo.reload.rule.v2',
-        'version: 2.0.0',
-        'trigger_family: reload',
-        'resource_types:',
-        '  - asset',
-        'host_base_type:',
-        '  - ReloadBase',
-        'required_hops:',
-        '  - resource',
-        'guarantees:',
-        '  - reload_chain_closed',
-        'non_guarantees:',
-        '  - no_runtime_execution_guarantee',
-    ].join('\n'), 'utf-8');
-    try {
-        await assert.rejects(() => loadRuleRegistry(repoPath), /topology|closure|claims/i);
-    }
-    finally {
-        await fs.rm(tempRoot, { recursive: true, force: true });
-    }
-});
-test('loads v2 verification bundle from explicit compiled path without catalog fallback', async () => {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-runtime-claim-rules-'));
-    const repoPath = path.join(tempRoot, 'repo');
-    const compiledRoot = path.join(repoPath, '.gitnexus', 'rules', 'compiled');
-    await fs.mkdir(compiledRoot, { recursive: true });
-    await fs.writeFile(path.join(compiledRoot, 'verification_rules.v2.json'), JSON.stringify({
-        bundle_version: '2.0.0',
-        family: 'verification_rules',
-        generated_at: new Date().toISOString(),
-        rules: [
-            {
-                id: 'demo.bundle.rule.v2',
-                version: '2.0.0',
-                trigger_family: 'reload',
-                resource_types: ['asset'],
-                host_base_type: ['ReloadBase'],
-                required_hops: ['resource', 'code_runtime'],
-                guarantees: ['reload_chain_closed'],
-                non_guarantees: ['no_runtime_execution'],
-                next_action: 'gitnexus query "reload"',
-                file_path: '.gitnexus/rules/compiled/verification_rules.v2.json',
-                match: { trigger_tokens: ['reload'] },
-                topology: [
-                    { hop: 'resource', from: { entity: 'resource' }, to: { entity: 'script' }, edge: { kind: 'binds_script' } },
-                ],
-                closure: {
-                    required_hops: ['resource', 'code_runtime'],
-                    failure_map: { missing_evidence: 'rule_matched_but_evidence_missing' },
-                },
-                claims: {
-                    guarantees: ['reload_chain_closed'],
-                    non_guarantees: ['no_runtime_execution'],
-                    next_action: 'gitnexus query "reload"',
-                },
-            },
-        ],
-    }, null, 2), 'utf-8');
-    try {
-        const registry = await loadRuleRegistry(repoPath);
-        assert.equal(registry.activeRules[0].id, 'demo.bundle.rule.v2');
-        assert.equal(registry.activeRules[0].version, '2.0.0');
-        assert.deepEqual(registry.activeRules[0].required_hops, ['resource', 'code_runtime']);
-    }
-    finally {
-        await fs.rm(tempRoot, { recursive: true, force: true });
-    }
+        'match:',
+        '  trigger_tokens:',
+        '    - reload',
+        'closure:',
+        '  required_hops:',
+        '    - resource',
+        'claims:',
+        '  guarantees:',
+        "    - 'guarantee with spaces'",
+        '  non_guarantees:',
+        '    - "double-quote \\"inside\\""',
+        "    - 'single-quote ''inside'''",
+        '  next_action: query "reload"',
+        'topology:',
+        '  - hop: resource',
+        '    from:',
+        '      entity: resource',
+        '    to:',
+        '      entity: script',
+        '    edge:',
+        '      kind: binds_script',
+    ].join('\n');
+    const rule = parseRuleYaml(yaml, 'scalar.yaml');
+    assert.equal(rule.id, 'demo.scalar-parser.v1');
+    assert.deepEqual(rule.resource_types, ['asset ref', 'prefab ref']);
+    assert.deepEqual(rule.guarantees, ['guarantee with spaces']);
+    assert.deepEqual(rule.non_guarantees, ['double-quote "inside"', "single-quote 'inside'"]);
+    assert.equal(rule.next_action, 'query "reload"');
 });

package/dist/mcp/tools.js

@@ -383,76 +383,6 @@ Output enforces unique-result policy and includes path+line evidence hops.`,
             required: ['target', 'goal'],
         },
     },
-    {
-        name: 'rule_lab_analyze',
-        description: `Analyze one Rule Lab slice and emit anchor-backed candidates.jsonl.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                run_id: { type: 'string', description: 'Rule Lab run id' },
-                slice_id: { type: 'string', description: 'Rule Lab slice id' },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
-            },
-            required: ['run_id', 'slice_id'],
-        },
-    },
-    {
-        name: 'rule_lab_review_pack',
-        description: `Pack analyzed candidates into review cards with token budget enforcement.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                run_id: { type: 'string', description: 'Rule Lab run id' },
-                slice_id: { type: 'string', description: 'Rule Lab slice id' },
-                max_tokens: { type: 'number', description: 'Token budget cap (default: 6000)', default: 6000 },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
-            },
-            required: ['run_id', 'slice_id'],
-        },
-    },
-    {
-        name: 'rule_lab_curate',
-        description: `Validate human-curated semantic closure input and persist curated artifacts for promotion.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                run_id: { type: 'string', description: 'Rule Lab run id' },
-                slice_id: { type: 'string', description: 'Rule Lab slice id' },
-                input_path: { type: 'string', description: 'Absolute or repo-relative path to curation input JSON' },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
-            },
-            required: ['run_id', 'slice_id', 'input_path'],
-        },
-    },
-    {
-        name: 'rule_lab_promote',
-        description: `Promote curated candidates into approved YAML rules and upsert catalog.json entries.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                run_id: { type: 'string', description: 'Rule Lab run id' },
-                slice_id: { type: 'string', description: 'Rule Lab slice id' },
-                version: { type: 'string', description: 'Promoted rule version (default: 1.0.0)', default: '1.0.0' },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
-            },
-            required: ['run_id', 'slice_id'],
-        },
-    },
-    {
-        name: 'rule_lab_regress',
-        description: `Evaluate Rule Lab precision/coverage gates and optionally persist a regression report.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                precision: { type: 'number', description: 'Observed precision metric' },
-                coverage: { type: 'number', description: 'Observed coverage metric' },
-                probes_path: { type: 'string', description: 'Optional path to a JSON array of regression probes with bucket metadata' },
-                run_id: { type: 'string', description: 'Optional run id for report naming' },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
-            },
-            required: ['precision', 'coverage'],
-        },
-    },
     {
         name: 'impact',
         description: `Analyze the blast radius of changing a code symbol.

package/dist/types/pipeline.d.ts

@@ -2,7 +2,6 @@ import { GraphNode, GraphRelationship, KnowledgeGraph } from '../core/graph/type
 import { CommunityDetectionResult } from '../core/ingestion/community-processor.js';
 import { ProcessDetectionResult } from '../core/ingestion/process-processor.js';
 import type { UnityResourceProcessingResult } from '../core/ingestion/unity-resource-processor.js';
-import type { UnityRuntimeBindingResult } from '../core/ingestion/unity-runtime-binding-rules.js';
 import type { ScopeSelectionDiagnostics } from '../core/ingestion/scope-filter.js';
 export type PipelinePhase = 'idle' | 'extracting' | 'structure' | 'parsing' | 'imports' | 'calls' | 'heritage' | 'communities' | 'processes' | 'enriching' | 'complete' | 'error';
 export interface PipelineProgress {
@@ -40,7 +39,6 @@ export interface PipelineResult {
     communityResult?: CommunityDetectionResult;
     processResult?: ProcessDetectionResult;
     unityResult?: UnityResourceProcessingResult;
-    unityRuleBindingResult?: UnityRuntimeBindingResult;
     scopeDiagnostics?: ScopeSelectionDiagnostics;
     csharpPreprocDiagnostics?: CSharpPreprocDiagnostics;
 }
@@ -49,7 +47,6 @@ export interface PipelineRuntimeSummary {
     communityResult?: CommunityDetectionResult;
     processResult?: ProcessDetectionResult;
     unityResult?: UnityResourceProcessingResult;
-    unityRuleBindingResult?: UnityRuntimeBindingResult;
     scopeDiagnostics?: ScopeSelectionDiagnostics;
     csharpPreprocDiagnostics?: CSharpPreprocDiagnostics;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veewo/gitnexus",
-  "version": "1.5.7",
+  "version": "1.5.8",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",

package/dist/benchmark/u2-e2e/phase5-rule-lab-acceptance-runner.d.ts

@@ -1,60 +0,0 @@
-export interface Phase5StageCoverageRow {
-    stage: 'analyze' | 'review-pack' | 'curate' | 'promote' | 'regress';
-    command: string;
-    status: 'passed' | 'failed';
-    retry_hint?: string;
-    error?: string;
-}
-export interface Phase5FailureClassification {
-    code: string;
-    retry_hint: string;
-    repro_command: string;
-}
-export interface Phase5RuleLabAcceptanceReport {
-    generated_at: string;
-    repo_alias: string;
-    repo_path: string;
-    run_id: string;
-    stage_coverage: Phase5StageCoverageRow[];
-    metrics: {
-        precision: number;
-        coverage: number;
-        probe_pass_rate: number;
-        token_budget: number;
-    };
-    authenticity_checks: {
-        static_no_hardcoded_reload: {
-            pass: boolean;
-            blocked_symbols: string[];
-        };
-        dsl_lint_pass: boolean;
-    };
-    failure_classifications: Phase5FailureClassification[];
-    artifact_paths: {
-        manifest: string;
-        candidates: string;
-        review_cards: string;
-        curation_input: string;
-        curated: string;
-        catalog: string;
-        promoted_files: string[];
-        regress_report?: string;
-    };
-}
-export interface BuildPhase5RuleLabAcceptanceInput {
-    repoAlias: string;
-    repoPath?: string;
-    seed?: string;
-}
-export declare function buildPhase5RuleLabAcceptanceReport(input: BuildPhase5RuleLabAcceptanceInput): Promise<Phase5RuleLabAcceptanceReport>;
-export declare function runPhase5RuleLabGate(input: {
-    reportPath: string;
-}): Promise<{
-    pass: boolean;
-    reason?: string;
-}>;
-export declare function writePhase5RuleLabAcceptanceArtifacts(input: {
-    report: Phase5RuleLabAcceptanceReport;
-    jsonPath: string;
-    mdPath: string;
-}): Promise<void>;