@veewo/gitnexus 1.5.6 → 1.5.8

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>;

package/dist/rule-lab/curate.js

@@ -1,155 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { getRuleLabPaths } from './paths.js';
-const PLACEHOLDER_RE = /TODO|TBD|placeholder|<[^>]+>/i;
-function hasPlaceholderText(value) {
-    return PLACEHOLDER_RE.test(String(value || ''));
-}
-function normalizeForSet(values) {
-    return new Set(values.map((value) => value.trim().toLowerCase()));
-}
-function ensureStringArray(values, field) {
-    if (!Array.isArray(values) || values.length === 0) {
-        throw new Error(`${field} must be non-empty`);
-    }
-    if (values.some((value) => !String(value || '').trim())) {
-        throw new Error(`${field} entries must be non-empty strings`);
-    }
-    return values.map((value) => String(value).trim());
-}
-function validateDslFields(item) {
-    if (!item.match || !Array.isArray(item.match.trigger_tokens) || item.match.trigger_tokens.length === 0) {
-        throw new Error('match.trigger_tokens must be non-empty');
-    }
-    ensureStringArray(item.match.trigger_tokens, 'match.trigger_tokens');
-    if (!Array.isArray(item.topology) || item.topology.length === 0) {
-        throw new Error('topology must be non-empty');
-    }
-    item.topology.forEach((hop, index) => {
-        if (!String(hop.hop || '').trim()) {
-            throw new Error(`topology[${index}].hop must be non-empty`);
-        }
-        if (!String(hop.edge?.kind || '').trim()) {
-            throw new Error(`topology[${index}].edge.kind must be non-empty`);
-        }
-    });
-    if (!item.closure || !Array.isArray(item.closure.required_hops) || item.closure.required_hops.length === 0) {
-        throw new Error('closure.required_hops must be non-empty');
-    }
-    if (!item.closure.failure_map || Object.keys(item.closure.failure_map).length === 0) {
-        throw new Error('closure.failure_map must be non-empty');
-    }
-    ensureStringArray(item.closure.required_hops, 'closure.required_hops');
-    if (!item.claims) {
-        throw new Error('claims must be present');
-    }
-    ensureStringArray(item.claims.guarantees, 'claims.guarantees');
-    ensureStringArray(item.claims.non_guarantees, 'claims.non_guarantees');
-    if (!String(item.claims.next_action || '').trim()) {
-        throw new Error('claims.next_action must be non-empty');
-    }
-}
-function validateCuratedItem(item) {
-    if (!Array.isArray(item.confirmed_chain?.steps) || item.confirmed_chain.steps.length === 0) {
-        throw new Error('confirmed_chain.steps must be non-empty for promotion');
-    }
-    item.confirmed_chain.steps.forEach((step, index) => {
-        if (!String(step.anchor || '').trim()) {
-            throw new Error(`confirmed_chain.steps[${index}].anchor must be non-empty`);
-        }
-        if (!String(step.snippet || '').trim()) {
-            throw new Error(`confirmed_chain.steps[${index}].snippet must be non-empty`);
-        }
-        if (hasPlaceholderText(step.anchor) || hasPlaceholderText(step.snippet)) {
-            throw new Error(`confirmed_chain.steps[${index}] contains placeholder text`);
-        }
-    });
-    if (!Array.isArray(item.guarantees) || item.guarantees.length === 0) {
-        throw new Error('guarantees must be non-empty');
-    }
-    if (!Array.isArray(item.non_guarantees) || item.non_guarantees.length === 0) {
-        throw new Error('non_guarantees must be non-empty');
-    }
-    if (item.guarantees.some((entry) => !String(entry || '').trim()) || item.non_guarantees.some((entry) => !String(entry || '').trim())) {
-        throw new Error('guarantees/non_guarantees entries must be non-empty strings');
-    }
-    if (hasPlaceholderText(JSON.stringify(item))) {
-        throw new Error('curated item contains placeholder text');
-    }
-    if (Array.isArray(item.resource_bindings)) {
-        const rawBindings = JSON.stringify(item.resource_bindings);
-        if (/UnknownClass|UnknownMethod|UnknownSource|UnknownTarget/i.test(rawBindings)) {
-            throw new Error('binding unresolved: unknown placeholder binding values are forbidden');
-        }
-    }
-    const guaranteeSet = normalizeForSet(item.guarantees);
-    const nonGuaranteeSet = normalizeForSet(item.non_guarantees);
-    const overlap = [...guaranteeSet].filter((entry) => nonGuaranteeSet.has(entry));
-    if (overlap.length === guaranteeSet.size && overlap.length === nonGuaranteeSet.size) {
-        throw new Error('guarantees and non_guarantees must have semantic distinction');
-    }
-    validateDslFields(item);
-}
-function toDslDraft(item) {
-    return {
-        id: String(item.rule_id || item.id || '').trim(),
-        version: '2.0.0',
-        match: item.match,
-        topology: item.topology,
-        closure: item.closure,
-        claims: item.claims,
-        ...(Array.isArray(item.resource_bindings) && item.resource_bindings.length > 0
-            ? { resource_bindings: item.resource_bindings }
-            : {}),
-    };
-}
-function validateDslDraft(draft) {
-    if (!String(draft.id || '').trim()) {
-        throw new Error('dsl draft id must be non-empty');
-    }
-    ensureStringArray(draft.match.trigger_tokens, 'match.trigger_tokens');
-    if (!Array.isArray(draft.topology) || draft.topology.length === 0) {
-        throw new Error('topology must be non-empty');
-    }
-    ensureStringArray(draft.closure.required_hops, 'closure.required_hops');
-    if (!draft.closure.failure_map || Object.keys(draft.closure.failure_map).length === 0) {
-        throw new Error('closure.failure_map must be non-empty');
-    }
-    ensureStringArray(draft.claims.guarantees, 'claims.guarantees');
-    ensureStringArray(draft.claims.non_guarantees, 'claims.non_guarantees');
-    if (!String(draft.claims.next_action || '').trim()) {
-        throw new Error('claims.next_action must be non-empty');
-    }
-}
-export async function curateRuleLabSlice(input) {
-    const normalizedRepoPath = path.resolve(input.repoPath);
-    const paths = getRuleLabPaths(normalizedRepoPath, input.runId, input.sliceId);
-    const raw = await fs.readFile(path.resolve(input.inputPath), 'utf-8');
-    const parsed = JSON.parse(raw);
-    const curated = Array.isArray(parsed.curated) ? parsed.curated : [];
-    if (curated.length === 0) {
-        throw new Error('curated must contain at least one candidate');
-    }
-    curated.forEach(validateCuratedItem);
-    const drafts = curated.map((item) => toDslDraft(item));
-    drafts.forEach(validateDslDraft);
-    const firstDraft = drafts[0];
-    const sliceDir = path.dirname(paths.curatedPath);
-    await fs.mkdir(path.dirname(paths.curatedPath), { recursive: true });
-    await fs.writeFile(paths.curatedPath, `${JSON.stringify({ run_id: input.runId, slice_id: input.sliceId, curated }, null, 2)}\n`, 'utf-8');
-    await fs.writeFile(path.join(sliceDir, 'dsl-drafts.json'), `${JSON.stringify({ run_id: input.runId, slice_id: input.sliceId, drafts }, null, 2)}\n`, 'utf-8');
-    if (drafts.length === 1) {
-        await fs.writeFile(path.join(sliceDir, 'dsl-draft.json'), `${JSON.stringify(firstDraft, null, 2)}\n`, 'utf-8');
-    }
-    else {
-        await fs.writeFile(path.join(sliceDir, 'dsl-draft.json'), `${JSON.stringify({
-            compatibility_warning: 'multi-draft mode active; use dsl-drafts.json for complete draft set',
-            primary_draft_id: firstDraft.id,
-            primary_draft: firstDraft,
-        }, null, 2)}\n`, 'utf-8');
-    }
-    return {
-        paths,
-        curated,
-    };
-}

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

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