@veewo/gitnexus 1.5.7 → 1.5.9

package/dist/rule-lab/analyze.js

@@ -1,125 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { createHash } from 'node:crypto';
-import { getRuleLabPaths } from './paths.js';
-import { buildCurationInput } from './curation-input-builder.js';
-function buildCandidateId(slice, variant) {
-    return createHash('sha1')
-        .update(`${slice.id}:${slice.trigger_family}:${slice.resource_types.join('|')}:${slice.host_base_type.join('|')}:${variant}`)
-        .digest('hex')
-        .slice(0, 12);
-}
-function normalizeToken(value) {
-    return String(value || '')
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '');
-}
-function inferRuleStem(slice, pair) {
-    const source = normalizeToken(pair.source_anchor.symbol || pair.source_anchor.file || `${slice.id}-source`);
-    const target = normalizeToken(pair.target_anchor.symbol || pair.target_anchor.file || `${slice.id}-target`);
-    const joined = [source, target].filter(Boolean).join('-');
-    return joined || normalizeToken(slice.id) || 'runtime-rule';
-}
-function buildProposalTopology(slice) {
-    const requiredHops = Array.isArray(slice.required_hops) && slice.required_hops.length > 0
-        ? slice.required_hops
-        : ['resource', 'code_runtime'];
-    return requiredHops.map((hop) => ({
-        hop,
-        from: { entity: hop === 'resource' ? 'resource' : 'script' },
-        to: { entity: hop === 'code_runtime' ? 'runtime' : 'script' },
-        edge: { kind: hop === 'resource' ? 'binds_script' : 'calls' },
-    }));
-}
-function buildExactPairCandidates(slice) {
-    const pairs = Array.isArray(slice.exact_pairs) ? slice.exact_pairs : [];
-    if (pairs.length === 0) {
-        throw new Error('exact_pairs must be non-empty for reduced rule-lab analyze flow');
-    }
-    const seenPairIds = new Set();
-    for (const pair of pairs) {
-        const pairId = String(pair.id || '').trim();
-        if (!pairId)
-            continue;
-        if (seenPairIds.has(pairId)) {
-            throw new Error(`duplicate_exact_pair_id: ${pairId}`);
-        }
-        seenPairIds.add(pairId);
-    }
-    const topology = buildProposalTopology(slice);
-    return pairs.map((pair, index) => {
-        const pairKey = String(pair.id || `${index + 1}`).trim();
-        const sourceAnchor = `${String(pair.source_anchor.file || '').trim()}:${Number(pair.source_anchor.line || 1)}`;
-        const targetAnchor = `${String(pair.target_anchor.file || '').trim()}:${Number(pair.target_anchor.line || 1)}`;
-        const draftRuleId = String(pair.draft_rule_id || '').trim() || `unity.event.${inferRuleStem(slice, pair)}.v1`;
-        const bindingKind = pair.binding_kind || 'method_triggers_method';
-        return {
-            id: buildCandidateId(slice, `exact:${pairKey}`),
-            title: `${slice.trigger_family} exact pair ${pairKey}`,
-            rule_hint: `${slice.trigger_family}.${slice.id}.exact.${pairKey}`,
-            proposal_kind: 'per_anchor_rule',
-            aggregation_mode: 'per_anchor_rules',
-            binding_kind: bindingKind,
-            draft_rule_id: draftRuleId,
-            topology,
-            closure: {
-                required_hops: topology.map((hop) => hop.hop),
-                failure_map: {
-                    missing_evidence: 'rule_matched_but_evidence_missing',
-                },
-            },
-            claims: {
-                guarantees: [`exact pair linked: ${sourceAnchor} -> ${targetAnchor}`],
-                non_guarantees: ['sparse gap path only; no exhaustive discovery semantics'],
-                next_action: `gitnexus query "${slice.trigger_family}"`,
-            },
-            exact_pair: pair,
-            evidence: {
-                hops: [
-                    {
-                        hop_type: 'code_runtime',
-                        anchor: sourceAnchor,
-                        snippet: String(pair.source_anchor.symbol || 'source'),
-                    },
-                    {
-                        hop_type: 'code_runtime',
-                        anchor: targetAnchor,
-                        snippet: String(pair.target_anchor.symbol || 'target'),
-                    },
-                ],
-            },
-        };
-    });
-}
-function assertNoPlaceholderIds(runId, sliceId) {
-    const placeholderRe = /<[^>]+>|placeholder|todo|tbd/i;
-    if (placeholderRe.test(runId) || placeholderRe.test(sliceId)) {
-        throw new Error('placeholder run/slice ids are not allowed');
-    }
-}
-export async function analyzeRuleLabSlice(input) {
-    assertNoPlaceholderIds(input.runId, input.sliceId);
-    const normalizedRepoPath = path.resolve(input.repoPath);
-    const paths = getRuleLabPaths(normalizedRepoPath, input.runId, input.sliceId);
-    const slicePath = path.join(paths.slicesRoot, input.sliceId, 'slice.json');
-    const raw = await fs.readFile(slicePath, 'utf-8');
-    const slice = JSON.parse(raw);
-    const candidates = buildExactPairCandidates(slice);
-    const curation = buildCurationInput({
-        runId: input.runId,
-        sliceId: input.sliceId,
-        slice,
-        candidates,
-    });
-    await fs.mkdir(path.dirname(paths.candidatesPath), { recursive: true });
-    await fs.writeFile(paths.candidatesPath, `${candidates.map((candidate) => JSON.stringify(candidate)).join('\n')}\n`, 'utf-8');
-    await fs.writeFile(slicePath, `${JSON.stringify(slice, null, 2)}\n`, 'utf-8');
-    await fs.writeFile(path.join(path.dirname(paths.candidatesPath), 'curation-input.json'), `${JSON.stringify(curation, null, 2)}\n`, 'utf-8');
-    return {
-        paths,
-        candidates,
-        slice,
-    };
-}

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

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

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

@@ -1,246 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { analyzeRuleLabSlice } from './analyze.js';
-import { curateRuleLabSlice } from './curate.js';
-import { promoteCuratedRules } from './promote.js';
-async function writeJson(filePath, value) {
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
-}
-describe('rule-lab analyze (exact pair flow)', () => {
-    it('builds proposal candidates and curation input directly from exact_pairs', async () => {
-        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-analyze-exact-'));
-        const runId = 'run-x';
-        const sliceId = 'slice-a';
-        const slicePath = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', runId, 'slices', sliceId, 'slice.json');
-        await writeJson(slicePath, {
-            id: sliceId,
-            trigger_family: 'event_delegate',
-            resource_types: ['syncvar_hook'],
-            host_base_type: ['network_behaviour'],
-            required_hops: ['code_runtime'],
-            exact_pairs: [
-                {
-                    id: 'pair-a',
-                    binding_kind: 'method_triggers_method',
-                    source_anchor: { file: 'Assets/Gameplay/SourceA.cs', line: 12, symbol: 'SourceA.Trigger' },
-                    target_anchor: { file: 'Assets/Gameplay/TargetA.cs', line: 32, symbol: 'TargetA.OnTrigger' },
-                },
-                {
-                    id: 'pair-b',
-                    binding_kind: 'method_triggers_method',
-                    source_anchor: { file: 'Assets/Gameplay/SourceB.cs', line: 15, symbol: 'SourceB.Trigger' },
-                    target_anchor: { file: 'Assets/Gameplay/TargetB.cs', line: 36, symbol: 'TargetB.OnTrigger' },
-                },
-            ],
-        });
-        const out = await analyzeRuleLabSlice({ repoPath: repoRoot, runId, sliceId });
-        expect(out.candidates).toHaveLength(2);
-        expect(out.candidates.every((candidate) => candidate.proposal_kind === 'per_anchor_rule')).toBe(true);
-        expect(out.candidates.every((candidate) => candidate.exact_pair)).toBe(true);
-        const curationPath = path.join(path.dirname(out.paths.candidatesPath), 'curation-input.json');
-        const curation = JSON.parse(await fs.readFile(curationPath, 'utf-8'));
-        expect(curation.curated).toHaveLength(2);
-        expect(curation.curated.every((item) => item.confirmed_chain.steps.length > 0)).toBe(true);
-        expect(curation.curated.every((item) => Array.isArray(item.resource_bindings) && item.resource_bindings.length > 0)).toBe(true);
-        await fs.rm(repoRoot, { recursive: true, force: true });
-    });
-    it('fails when exact_pairs are missing', async () => {
-        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-analyze-exact-missing-'));
-        const runId = 'run-x';
-        const sliceId = 'slice-a';
-        const slicePath = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', runId, 'slices', sliceId, 'slice.json');
-        await writeJson(slicePath, {
-            id: sliceId,
-            trigger_family: 'event_delegate',
-            resource_types: ['syncvar_hook'],
-            host_base_type: ['network_behaviour'],
-            required_hops: ['code_runtime'],
-        });
-        await expect(analyzeRuleLabSlice({ repoPath: repoRoot, runId, sliceId })).rejects.toThrow(/exact_pairs/i);
-        await fs.rm(repoRoot, { recursive: true, force: true });
-    });
-    it('fails fast when exact_pairs contain duplicate non-empty ids', async () => {
-        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-analyze-exact-dup-id-'));
-        const runId = 'run-x';
-        const sliceId = 'slice-a';
-        const slicePath = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', runId, 'slices', sliceId, 'slice.json');
-        await writeJson(slicePath, {
-            id: sliceId,
-            trigger_family: 'event_delegate',
-            resource_types: ['syncvar_hook'],
-            host_base_type: ['network_behaviour'],
-            required_hops: ['code_runtime'],
-            exact_pairs: [
-                {
-                    id: 'pair-dup',
-                    binding_kind: 'method_triggers_method',
-                    source_anchor: { file: 'Assets/Gameplay/SourceA.cs', line: 12, symbol: 'SourceA.Trigger' },
-                    target_anchor: { file: 'Assets/Gameplay/TargetA.cs', line: 32, symbol: 'TargetA.OnTrigger' },
-                },
-                {
-                    id: 'pair-dup',
-                    binding_kind: 'method_triggers_method',
-                    source_anchor: { file: 'Assets/Gameplay/SourceB.cs', line: 15, symbol: 'SourceB.Trigger' },
-                    target_anchor: { file: 'Assets/Gameplay/TargetB.cs', line: 36, symbol: 'TargetB.OnTrigger' },
-                },
-            ],
-        });
-        await expect(analyzeRuleLabSlice({ repoPath: repoRoot, runId, sliceId })).rejects.toThrow(/duplicate_exact_pair_id/i);
-        await fs.rm(repoRoot, { recursive: true, force: true });
-    });
-    it('supports exact-pair analyze -> curate -> promote flow', async () => {
-        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-analyze-exact-e2e-'));
-        const runId = 'run-x';
-        const sliceId = 'slice-a';
-        const sliceDir = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', runId, 'slices', sliceId);
-        const rulesRoot = path.join(repoRoot, '.gitnexus', 'rules');
-        const slicePath = path.join(sliceDir, 'slice.json');
-        await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
-        await fs.writeFile(path.join(rulesRoot, 'catalog.json'), JSON.stringify({ version: 1, rules: [] }, null, 2), 'utf-8');
-        await writeJson(slicePath, {
-            id: sliceId,
-            trigger_family: 'event_delegate',
-            resource_types: ['syncvar_hook'],
-            host_base_type: ['network_behaviour'],
-            required_hops: ['code_runtime'],
-            exact_pairs: [
-                {
-                    id: 'pair-a',
-                    binding_kind: 'method_triggers_method',
-                    source_anchor: { file: 'Assets/Gameplay/SourceA.cs', line: 12, symbol: 'SourceA.Trigger' },
-                    target_anchor: { file: 'Assets/Gameplay/TargetA.cs', line: 32, symbol: 'TargetA.OnTrigger' },
-                },
-            ],
-        });
-        const analyzed = await analyzeRuleLabSlice({ repoPath: repoRoot, runId, sliceId });
-        const inputPath = path.join(path.dirname(analyzed.paths.candidatesPath), 'curation-input.json');
-        await curateRuleLabSlice({ repoPath: repoRoot, runId, sliceId, inputPath });
-        const promoted = await promoteCuratedRules({ repoPath: repoRoot, runId, sliceId, version: '1.0.0' });
-        expect(promoted.promotedFiles).toHaveLength(1);
-        await expect(fs.access(promoted.promotedFiles[0])).resolves.toBeUndefined();
-        await fs.rm(repoRoot, { recursive: true, force: true });
-    });
-    it('fails closed when exact-pair symbols cannot resolve Class.Method', async () => {
-        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-analyze-exact-unresolved-'));
-        const runId = 'run-x';
-        const sliceId = 'slice-a';
-        const slicePath = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', runId, 'slices', sliceId, 'slice.json');
-        await writeJson(slicePath, {
-            id: sliceId,
-            trigger_family: 'event_delegate',
-            resource_types: ['syncvar_hook'],
-            host_base_type: ['network_behaviour'],
-            required_hops: ['code_runtime'],
-            exact_pairs: [
-                {
-                    id: 'pair-a',
-                    binding_kind: 'method_triggers_method',
-                    source_anchor: { file: 'Assets/Gameplay/SourceA.cs', line: 12, symbol: 'TriggerOnly' },
-                    target_anchor: { file: 'Assets/Gameplay/TargetA.cs', line: 32, symbol: 'TargetA.OnTrigger' },
-                },
-            ],
-        });
-        await expect(analyzeRuleLabSlice({ repoPath: repoRoot, runId, sliceId })).rejects.toThrow(/binding_unresolved/i);
-        await fs.rm(repoRoot, { recursive: true, force: true });
-    });
-    it('builds scene_load binding with host_class_pattern + loader_methods + scene_name', async () => {
-        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-analyze-scene-load-shape-'));
-        const runId = 'run-x';
-        const sliceId = 'slice-a';
-        const slicePath = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', runId, 'slices', sliceId, 'slice.json');
-        await writeJson(slicePath, {
-            id: sliceId,
-            trigger_family: 'event_delegate',
-            resource_types: ['scene'],
-            host_base_type: ['network_behaviour'],
-            required_hops: ['code_runtime'],
-            exact_pairs: [
-                {
-                    id: 'pair-scene',
-                    binding_kind: 'method_triggers_scene_load',
-                    source_anchor: { file: 'Assets/Gameplay/SourceA.cs', line: 12, symbol: 'SourceA.Trigger' },
-                    target_anchor: { file: 'Assets/Scenes/BattleScene.unity', line: 1, symbol: 'BattleScene' },
-                },
-            ],
-        });
-        const analyzed = await analyzeRuleLabSlice({ repoPath: repoRoot, runId, sliceId });
-        const curationPath = path.join(path.dirname(analyzed.paths.candidatesPath), 'curation-input.json');
-        const curation = JSON.parse(await fs.readFile(curationPath, 'utf-8'));
-        const binding = curation.curated[0].resource_bindings[0];
-        expect(binding.kind).toBe('method_triggers_scene_load');
-        expect(binding.host_class_pattern).toBe('SourceA');
-        expect(binding.loader_methods).toEqual(['Trigger']);
-        expect(binding.scene_name).toBe('BattleScene');
-        expect(binding.source_class_pattern).toBeUndefined();
-        expect(binding.source_method).toBeUndefined();
-        expect(binding.target_class_pattern).toBeUndefined();
-        expect(binding.target_method).toBeUndefined();
-        await fs.rm(repoRoot, { recursive: true, force: true });
-    });
-    it('fails closed for scene_load when target scene token is missing', async () => {
-        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-analyze-scene-load-missing-scene-'));
-        const runId = 'run-x';
-        const sliceId = 'slice-a';
-        const slicePath = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', runId, 'slices', sliceId, 'slice.json');
-        await writeJson(slicePath, {
-            id: sliceId,
-            trigger_family: 'event_delegate',
-            resource_types: ['scene'],
-            host_base_type: ['network_behaviour'],
-            required_hops: ['code_runtime'],
-            exact_pairs: [
-                {
-                    id: 'pair-scene',
-                    binding_kind: 'method_triggers_scene_load',
-                    source_anchor: { file: 'Assets/Gameplay/SourceA.cs', line: 12, symbol: 'SourceA.Trigger' },
-                    target_anchor: { file: '', line: 1, symbol: '' },
-                },
-            ],
-        });
-        await expect(analyzeRuleLabSlice({ repoPath: repoRoot, runId, sliceId })).rejects.toThrow(/binding_unresolved/i);
-        await fs.rm(repoRoot, { recursive: true, force: true });
-    });
-    it('ignores legacy parity/coverage fields when exact_pairs are valid', async () => {
-        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-analyze-exact-legacy-'));
-        const runId = 'run-x';
-        const sliceId = 'slice-a';
-        const slicePath = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', runId, 'slices', sliceId, 'slice.json');
-        await writeJson(slicePath, {
-            id: sliceId,
-            trigger_family: 'event_delegate',
-            resource_types: ['syncvar_hook'],
-            host_base_type: ['network_behaviour'],
-            required_hops: ['code_runtime'],
-            exact_pairs: [
-                {
-                    id: 'pair-a',
-                    binding_kind: 'method_triggers_method',
-                    source_anchor: { file: 'Assets/Gameplay/SourceA.cs', line: 12, symbol: 'SourceA.Trigger' },
-                    target_anchor: { file: 'Assets/Gameplay/TargetA.cs', line: 32, symbol: 'TargetA.OnTrigger' },
-                },
-            ],
-            coverage_gate: {
-                status: 'blocked',
-                reason: 'coverage_incomplete',
-                processed_user_matches: 0,
-                user_raw_matches: 9,
-            },
-            parity_status: {
-                status: 'blocked',
-                reason: 'parity_missing_rules_slice',
-            },
-        });
-        const analyzed = await analyzeRuleLabSlice({ repoPath: repoRoot, runId, sliceId });
-        expect(analyzed.candidates).toHaveLength(1);
-        expect(analyzed.candidates[0].exact_pair?.id).toBe('pair-a');
-        await fs.rm(repoRoot, { recursive: true, force: true });
-    });
-    it('rejects placeholder run/slice ids', async () => {
-        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-analyze-exact-placeholder-'));
-        await expect(analyzeRuleLabSlice({ repoPath: repoRoot, runId: '<run_id>', sliceId: '<slice_id>' })).rejects.toThrow(/placeholder/i);
-        await fs.rm(repoRoot, { recursive: true, force: true });
-    });
-});

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

@@ -1,5 +0,0 @@
-import { type RuleBundleFamily } from './compiled-bundles.js';
-export declare function compileRules(options: {
-    repoPath?: string;
-    family?: RuleBundleFamily;
-}): Promise<void>;

package/dist/rule-lab/compile.js

@@ -1,51 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { parseRuleYaml } from '../mcp/local/runtime-claim-rule-registry.js';
-import { writeCompiledRuleBundle } from './compiled-bundles.js';
-export async function compileRules(options) {
-    const repoPath = path.resolve(options.repoPath || process.cwd());
-    const family = options.family || 'analyze_rules';
-    const rulesRoot = path.join(repoPath, '.gitnexus', 'rules');
-    const catalogPath = path.join(rulesRoot, 'catalog.json');
-    let catalog;
-    try {
-        catalog = JSON.parse(await fs.readFile(catalogPath, 'utf-8'));
-    }
-    catch {
-        console.error(`No catalog.json found at ${catalogPath}`);
-        process.exitCode = 1;
-        return;
-    }
-    const entries = catalog.rules.filter((e) => e.enabled !== false && e.family === family);
-    if (entries.length === 0) {
-        console.log(`No enabled ${family} rules in catalog.`);
-        return;
-    }
-    const compiled = [];
-    for (const entry of entries) {
-        const yamlPath = path.join(rulesRoot, entry.file);
-        const raw = await fs.readFile(yamlPath, 'utf-8');
-        const rule = parseRuleYaml(raw, entry.file);
-        compiled.push({
-            id: rule.id,
-            version: rule.version,
-            trigger_family: rule.trigger_family,
-            trigger_tokens: [...(rule.match?.trigger_tokens || [])],
-            resource_types: [...rule.resource_types],
-            host_base_type: [...rule.host_base_type],
-            required_hops: [...rule.required_hops],
-            guarantees: [...rule.guarantees],
-            non_guarantees: [...rule.non_guarantees],
-            next_action: rule.next_action || '',
-            file_path: entry.file,
-            match: rule.match || { trigger_tokens: [] },
-            topology: [],
-            closure: { required_hops: rule.required_hops, failure_map: {} },
-            claims: { guarantees: rule.guarantees, non_guarantees: rule.non_guarantees, next_action: rule.next_action || '' },
-            ...(rule.resource_bindings ? { resource_bindings: rule.resource_bindings } : {}),
-            ...(rule.lifecycle_overrides ? { lifecycle_overrides: rule.lifecycle_overrides } : {}),
-        });
-    }
-    const outPath = await writeCompiledRuleBundle(rulesRoot, family, compiled);
-    console.log(`Compiled ${compiled.length} ${family} rules → ${outPath}`);
-}

package/dist/rule-lab/compiled-bundles.d.ts

@@ -1,30 +0,0 @@
-import type { RuleDslClaims, RuleDslClosure, RuleDslMatch, RuleDslTopologyHop } from './types.js';
-export type RuleBundleFamily = 'analyze_rules' | 'retrieval_rules' | 'verification_rules';
-export interface StageAwareCompiledRule {
-    id: string;
-    version: string;
-    trigger_family: string;
-    trigger_tokens: string[];
-    resource_types: string[];
-    host_base_type: string[];
-    required_hops: string[];
-    guarantees: string[];
-    non_guarantees: string[];
-    next_action: string;
-    file_path: string;
-    match: RuleDslMatch;
-    topology: RuleDslTopologyHop[];
-    closure: RuleDslClosure;
-    claims: RuleDslClaims;
-    resource_bindings?: import('./types.js').UnityResourceBinding[];
-    lifecycle_overrides?: import('./types.js').LifecycleOverrides;
-}
-export interface CompiledRuleBundle {
-    bundle_version: '2.0.0';
-    family: RuleBundleFamily;
-    generated_at: string;
-    rules: StageAwareCompiledRule[];
-}
-export declare function compiledBundlePath(rulesRoot: string, family: RuleBundleFamily): string;
-export declare function writeCompiledRuleBundle(rulesRoot: string, family: RuleBundleFamily, rules: StageAwareCompiledRule[]): Promise<string>;
-export declare function loadCompiledRuleBundle(repoPath: string, family: RuleBundleFamily, rulesRoot?: string): Promise<CompiledRuleBundle | undefined>;

package/dist/rule-lab/compiled-bundles.js

@@ -1,36 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-export function compiledBundlePath(rulesRoot, family) {
-    return path.join(path.resolve(rulesRoot), 'compiled', `${family}.v2.json`);
-}
-export async function writeCompiledRuleBundle(rulesRoot, family, rules) {
-    const outPath = compiledBundlePath(rulesRoot, family);
-    const bundle = {
-        bundle_version: '2.0.0',
-        family,
-        generated_at: new Date().toISOString(),
-        rules,
-    };
-    await fs.mkdir(path.dirname(outPath), { recursive: true });
-    await fs.writeFile(outPath, `${JSON.stringify(bundle, null, 2)}\n`, 'utf-8');
-    return outPath;
-}
-export async function loadCompiledRuleBundle(repoPath, family, rulesRoot) {
-    const root = rulesRoot
-        ? path.resolve(rulesRoot)
-        : path.join(path.resolve(repoPath), '.gitnexus', 'rules');
-    const bundlePath = compiledBundlePath(root, family);
-    try {
-        const raw = await fs.readFile(bundlePath, 'utf-8');
-        const parsed = JSON.parse(raw);
-        if (parsed.family !== family || !Array.isArray(parsed.rules)) {
-            throw new Error(`Invalid compiled ${family} bundle: ${bundlePath}`);
-        }
-        return parsed;
-    }
-    catch (error) {
-        if (error?.code === 'ENOENT')
-            return undefined;
-        throw error;
-    }
-}

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

@@ -1,33 +0,0 @@
-import { getRuleLabPaths } from './paths.js';
-import type { RuleDslMatch, RuleDslTopologyHop, RuleDslClosure, RuleDslClaims, UnityResourceBinding } from './types.js';
-export interface CurateInput {
-    repoPath: string;
-    runId: string;
-    sliceId: string;
-    inputPath: string;
-}
-export interface CuratedStep {
-    hop_type?: string;
-    anchor: string;
-    snippet: string;
-}
-export interface CuratedItem {
-    id: string;
-    rule_id?: string;
-    title?: string;
-    match?: RuleDslMatch;
-    topology?: RuleDslTopologyHop[];
-    closure?: RuleDslClosure;
-    claims?: RuleDslClaims;
-    resource_bindings?: UnityResourceBinding[];
-    confirmed_chain: {
-        steps: CuratedStep[];
-    };
-    guarantees: string[];
-    non_guarantees: string[];
-}
-export interface CurateOutput {
-    paths: ReturnType<typeof getRuleLabPaths>;
-    curated: CuratedItem[];
-}
-export declare function curateRuleLabSlice(input: CurateInput): Promise<CurateOutput>;