@veewo/gitnexus 1.4.11-rc → 1.5.0-rc

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

@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { curateRuleLabSlice } from './curate.js';
+describe('rule-lab curate', () => {
+    it('rejects curation input with empty confirmed_chain.steps', async () => {
+        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-curate-'));
+        const inputPath = path.join(repoRoot, 'curation-input.json');
+        await fs.writeFile(inputPath, JSON.stringify({
+            run_id: 'run-x',
+            slice_id: 'slice-a',
+            curated: [
+                {
+                    id: 'candidate-1',
+                    title: 'reload rule',
+                    match: { trigger_tokens: ['reload'] },
+                    topology: [
+                        { hop: 'resource', from: { entity: 'resource' }, to: { entity: 'script' }, edge: { kind: 'binds_script' } },
+                    ],
+                    closure: {
+                        required_hops: ['resource'],
+                        failure_map: { missing_evidence: 'rule_matched_but_evidence_missing' },
+                    },
+                    claims: {
+                        guarantees: ['reload_chain_closed'],
+                        non_guarantees: ['no_runtime_execution'],
+                        next_action: 'gitnexus query "Reload"',
+                    },
+                    confirmed_chain: { steps: [] },
+                    guarantees: ['can verify reload trigger'],
+                    non_guarantees: ['does not prove runtime ordering'],
+                },
+            ],
+        }), 'utf-8');
+        await expect(curateRuleLabSlice({ repoPath: repoRoot, runId: 'run-x', sliceId: 'slice-a', inputPath })).rejects.toThrow(/confirmed_chain\.steps/i);
+        await fs.rm(repoRoot, { recursive: true, force: true });
+    });
+    it('writes dsl-draft.json and rejects missing failure mapping', async () => {
+        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-curate-'));
+        const inputPath = path.join(repoRoot, 'curation-input.json');
+        await fs.writeFile(inputPath, JSON.stringify({
+            run_id: 'run-x',
+            slice_id: 'slice-a',
+            curated: [
+                {
+                    id: 'candidate-1',
+                    rule_id: 'demo.reload.v2',
+                    match: { trigger_tokens: ['reload'] },
+                    topology: [
+                        { hop: 'resource', from: { entity: 'resource' }, to: { entity: 'script' }, edge: { kind: 'binds_script' } },
+                    ],
+                    closure: { required_hops: ['resource'] },
+                    claims: {
+                        guarantees: ['reload_chain_closed'],
+                        non_guarantees: ['no_runtime_execution'],
+                        next_action: 'gitnexus query "Reload"',
+                    },
+                    confirmed_chain: {
+                        steps: [
+                            { hop_type: 'resource', anchor: 'Assets/Example.prefab:1', snippet: 'ReloadGraph' },
+                        ],
+                    },
+                    guarantees: ['can verify reload trigger'],
+                    non_guarantees: ['does not prove runtime ordering'],
+                },
+            ],
+        }), 'utf-8');
+        await expect(curateRuleLabSlice({ repoPath: repoRoot, runId: 'run-x', sliceId: 'slice-a', inputPath })).rejects.toThrow(/failure_map/i);
+        await fs.rm(repoRoot, { recursive: true, force: true });
+    });
+});

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

@@ -0,0 +1,13 @@
+import { getRuleLabPaths } from './paths.js';
+import type { RuleLabManifest, RuleLabScope } from './types.js';
+export interface DiscoverInput {
+    repoPath: string;
+    scope: RuleLabScope;
+    seed?: string;
+}
+export interface DiscoverOutput {
+    runId: string;
+    manifest: RuleLabManifest;
+    paths: ReturnType<typeof getRuleLabPaths>;
+}
+export declare function discoverRuleLabRun(input: DiscoverInput): Promise<DiscoverOutput>;

package/dist/rule-lab/discover.js

@@ -0,0 +1,74 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { loadRuleRegistry } from '../mcp/local/runtime-claim-rule-registry.js';
+import { buildRunId, getRuleLabPaths } from './paths.js';
+import { loadCompiledRuleBundle } from './compiled-bundles.js';
+function buildSliceId(rule) {
+    const hash = createHash('sha1')
+        .update(JSON.stringify({
+        id: rule.id,
+        trigger_family: rule.trigger_family,
+        resource_types: [...rule.resource_types].sort(),
+        host_base_type: [...rule.host_base_type].sort(),
+        required_hops: [...(rule.required_hops || [])].sort(),
+    }))
+        .digest('hex')
+        .slice(0, 10);
+    return `slice-${hash}`;
+}
+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');
+}
+export async function discoverRuleLabRun(input) {
+    const normalizedRepoPath = path.resolve(input.repoPath);
+    const analyzeBundle = await loadCompiledRuleBundle(normalizedRepoPath, 'analyze_rules');
+    const registry = analyzeBundle ? undefined : await loadRuleRegistry(normalizedRepoPath);
+    const runId = buildRunId({
+        repo: path.basename(normalizedRepoPath),
+        scope: input.scope,
+        seed: input.seed || 'default',
+    });
+    const runPaths = getRuleLabPaths(normalizedRepoPath, runId);
+    const sourceRules = analyzeBundle?.rules || registry?.activeRules || [];
+    const slices = sourceRules.map((rule) => ({
+        id: buildSliceId(rule),
+        trigger_family: rule.trigger_family,
+        resource_types: rule.resource_types,
+        host_base_type: rule.host_base_type,
+        required_hops: rule.required_hops,
+    }));
+    const manifest = {
+        run_id: runId,
+        repo_path: normalizedRepoPath,
+        scope: input.scope,
+        generated_at: new Date().toISOString(),
+        slices,
+        stages: ['discover'],
+        next_actions: [
+            `gitnexus rule-lab analyze --run-id ${runId}`,
+            `gitnexus rule-lab review-pack --run-id ${runId}`,
+        ],
+    };
+    await writeJson(runPaths.manifestPath, manifest);
+    await writeJson(path.join(runPaths.runRoot, 'slice-plan.json'), {
+        run_id: runId,
+        generated_at: manifest.generated_at,
+        slices: slices.map((slice) => ({
+            slice_id: slice.id,
+            trigger_family: slice.trigger_family,
+            required_hops: slice.required_hops || [],
+            candidate_count_target: 2,
+        })),
+    });
+    await Promise.all(slices.map(async (slice) => {
+        const slicePath = path.join(runPaths.slicesRoot, slice.id, 'slice.json');
+        await writeJson(slicePath, slice);
+    }));
+    return {
+        runId,
+        manifest,
+        paths: runPaths,
+    };
+}

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

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

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

@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { discoverRuleLabRun } from './discover.js';
+describe('rule-lab discover', () => {
+    it('writes manifest with slices and next_actions', async () => {
+        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-discover-'));
+        const rulesRoot = path.join(repoRoot, '.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');
+        await fs.writeFile(path.join(rulesRoot, 'approved', 'demo.reload.rule.v1.yaml'), [
+            'id: demo.reload.rule.v1',
+            'version: 1.0.0',
+            'trigger_family: reload',
+            'resource_types:',
+            '  - prefab',
+            'host_base_type:',
+            '  - ReloadBase',
+        ].join('\n'), 'utf-8');
+        const out = await discoverRuleLabRun({ repoPath: repoRoot, scope: 'full' });
+        expect(out.manifest.slices.length).toBeGreaterThan(0);
+        expect(out.manifest.next_actions.join(' ')).toContain('rule-lab analyze');
+        const manifestOnDisk = JSON.parse(await fs.readFile(out.paths.manifestPath, 'utf-8'));
+        expect(manifestOnDisk.run_id).toBe(out.manifest.run_id);
+        expect(Array.isArray(manifestOnDisk.slices)).toBe(true);
+        const slicePlanPath = path.join(out.paths.runRoot, 'slice-plan.json');
+        const slicePlan = JSON.parse(await fs.readFile(slicePlanPath, 'utf-8'));
+        expect(slicePlan.run_id).toBe(out.manifest.run_id);
+        expect(Array.isArray(slicePlan.slices)).toBe(true);
+        expect(slicePlan.slices[0]).toHaveProperty('candidate_count_target');
+        await fs.rm(repoRoot, { recursive: true, force: true });
+    });
+});

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

@@ -0,0 +1,21 @@
+import type { RuleLabScope } from './types.js';
+export interface BuildRunIdInput {
+    repo: string;
+    scope: RuleLabScope;
+    seed: string;
+}
+export interface RuleLabPaths {
+    rulesRoot: string;
+    compiledRoot: string;
+    runsRoot: string;
+    runRoot: string;
+    slicesRoot: string;
+    manifestPath: string;
+    candidatesPath: string;
+    reviewCardsPath: string;
+    curatedPath: string;
+    promotedRoot: string;
+    reportsRoot: string;
+}
+export declare function buildRunId(input: BuildRunIdInput): string;
+export declare function getRuleLabPaths(repoPath: string, runId: string, sliceId?: string): RuleLabPaths;

package/dist/rule-lab/paths.js

@@ -0,0 +1,37 @@
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+function normalizeIdPart(value) {
+    return String(value || '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '') || 'unknown';
+}
+export function buildRunId(input) {
+    return createHash('sha1')
+        .update(`${normalizeIdPart(input.repo)}:${input.scope}:${input.seed}`)
+        .digest('hex')
+        .slice(0, 12);
+}
+export function getRuleLabPaths(repoPath, runId, sliceId = 'default') {
+    const normalizedRepoPath = path.resolve(repoPath);
+    const rulesRoot = path.join(normalizedRepoPath, '.gitnexus', 'rules');
+    const compiledRoot = path.join(rulesRoot, 'compiled');
+    const runsRoot = path.join(rulesRoot, 'lab', 'runs');
+    const runRoot = path.join(runsRoot, normalizeIdPart(runId));
+    const slicesRoot = path.join(runRoot, 'slices');
+    const sliceRoot = path.join(slicesRoot, normalizeIdPart(sliceId));
+    return {
+        rulesRoot,
+        compiledRoot,
+        runsRoot,
+        runRoot,
+        slicesRoot,
+        manifestPath: path.join(runRoot, 'manifest.json'),
+        candidatesPath: path.join(sliceRoot, 'candidates.jsonl'),
+        reviewCardsPath: path.join(sliceRoot, 'review-cards.md'),
+        curatedPath: path.join(sliceRoot, 'curated.json'),
+        promotedRoot: path.join(rulesRoot, 'approved'),
+        reportsRoot: path.join(rulesRoot, 'reports'),
+    };
+}

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

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

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

@@ -0,0 +1,46 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { buildRunId, getRuleLabPaths } from './paths.js';
+const TEST_DIR = path.dirname(new URL(import.meta.url).pathname);
+describe('rule-lab paths', () => {
+    it('builds deterministic run/slice paths under .gitnexus/rules/lab/runs', () => {
+        const runId = buildRunId({ repo: 'GitNexus', scope: 'full', seed: 'abc' });
+        const p = getRuleLabPaths('/repo', runId, 'slice-a');
+        expect(p.manifestPath).toContain('/.gitnexus/rules/lab/runs/');
+        expect(p.candidatesPath).toContain('/slices/slice-a/candidates.jsonl');
+    });
+    it('exposes DSL v2 topology and closure schema fields', async () => {
+        const sample = {
+            id: 'demo.reload.v2',
+            match: { trigger_tokens: ['reload'] },
+            topology: [
+                {
+                    hop: 'resource',
+                    from: { entity: 'resource' },
+                    to: { entity: 'script' },
+                    edge: { kind: 'binds_script' },
+                },
+            ],
+            closure: {
+                required_hops: ['resource'],
+                failure_map: { missing_evidence: 'rule_matched_but_evidence_missing' },
+            },
+            claims: {
+                guarantees: ['g1'],
+                non_guarantees: ['ng1'],
+                next_action: 'gitnexus query "Reload"',
+            },
+        };
+        expect(sample.topology[0].edge.kind).toBe('binds_script');
+        const ruleDslSchema = JSON.parse(await fs.readFile(path.join(TEST_DIR, 'schema', 'rule-dsl.schema.json'), 'utf-8'));
+        const draftSchema = JSON.parse(await fs.readFile(path.join(TEST_DIR, 'schema', 'dsl-draft.schema.json'), 'utf-8'));
+        expect(ruleDslSchema.properties).toHaveProperty('match');
+        expect(ruleDslSchema.properties).toHaveProperty('topology');
+        expect(ruleDslSchema.properties).toHaveProperty('closure');
+        expect(ruleDslSchema.properties).toHaveProperty('claims');
+        expect(draftSchema.properties).toHaveProperty('topology');
+        expect(draftSchema.properties).toHaveProperty('closure');
+        expect(draftSchema.properties).toHaveProperty('claims');
+    });
+});

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

@@ -0,0 +1,26 @@
+import { getRuleLabPaths } from './paths.js';
+interface CatalogEntry {
+    id: string;
+    version: string;
+    enabled: boolean;
+    file: string;
+    family?: string;
+}
+interface CatalogShape {
+    version: number;
+    rules: CatalogEntry[];
+}
+export interface PromoteInput {
+    repoPath: string;
+    runId: string;
+    sliceId: string;
+    version?: string;
+}
+export interface PromoteOutput {
+    catalog: CatalogShape;
+    promotedFiles: string[];
+    compiledPaths: Record<'analyze_rules' | 'retrieval_rules' | 'verification_rules', string>;
+    paths: ReturnType<typeof getRuleLabPaths>;
+}
+export declare function promoteCuratedRules(input: PromoteInput): Promise<PromoteOutput>;
+export {};

package/dist/rule-lab/promote.js

@@ -0,0 +1,314 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getRuleLabPaths } from './paths.js';
+import { writeCompiledRuleBundle, loadCompiledRuleBundle } from './compiled-bundles.js';
+function quoteYaml(value) {
+    const raw = String(value || '');
+    if (/^[a-zA-Z0-9._-]+$/.test(raw))
+        return raw;
+    return `'${raw.replace(/'/g, "''")}'`;
+}
+function inferTriggerFamily(item) {
+    const fromTitle = String(item.title || '').trim().split(/\s+/)[0];
+    if (fromTitle)
+        return fromTitle.toLowerCase();
+    return 'runtime';
+}
+function unique(values) {
+    return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))];
+}
+function toComparableToken(value) {
+    return String(value || '').trim().toLowerCase();
+}
+function isForbiddenPlaceholder(value) {
+    const token = toComparableToken(value);
+    return token === 'unknown' || token === 'todo' || token === 'tbd' || /<[^>]+>/.test(token);
+}
+function assertNoPlaceholderScope(values, field) {
+    if (values.length === 0) {
+        throw new Error(`promote lint failed: ${field} must be non-empty`);
+    }
+    if (values.some((entry) => isForbiddenPlaceholder(entry))) {
+        throw new Error(`promote lint failed: unknown scope placeholder is forbidden (${field})`);
+    }
+}
+function toDraftFromCurated(item) {
+    const triggerTokens = unique(item.match?.trigger_tokens || [inferTriggerFamily(item)]);
+    const topology = Array.isArray(item.topology) && item.topology.length > 0
+        ? item.topology
+        : item.confirmed_chain.steps.map((step) => ({
+            hop: String(step.hop_type || 'resource'),
+            from: { entity: 'resource' },
+            to: { entity: 'script' },
+            edge: { kind: 'binds_script' },
+        }));
+    const requiredHops = unique(item.closure?.required_hops || topology.map((step) => step.hop));
+    const failureMap = item.closure?.failure_map && Object.keys(item.closure.failure_map).length > 0
+        ? item.closure.failure_map
+        : { missing_evidence: 'rule_matched_but_evidence_missing' };
+    const guarantees = unique(item.claims?.guarantees || item.guarantees);
+    const nonGuarantees = unique(item.claims?.non_guarantees || item.non_guarantees);
+    const nextAction = String(item.claims?.next_action || '').trim() || 'gitnexus query "runtime"';
+    return {
+        id: String(item.rule_id || item.id || '').trim(),
+        version: '2.0.0',
+        match: {
+            trigger_tokens: triggerTokens,
+            symbol_kind: item.match?.symbol_kind || [],
+            module_scope: item.match?.module_scope || [],
+            resource_types: unique(item.match?.resource_types || []),
+            host_base_type: unique(item.match?.host_base_type || []),
+        },
+        topology,
+        closure: {
+            required_hops: requiredHops,
+            failure_map: failureMap,
+        },
+        claims: {
+            guarantees,
+            non_guarantees: nonGuarantees,
+            next_action: nextAction,
+        },
+    };
+}
+function compileRule(ruleId, version, draft) {
+    const triggerFamily = String(draft.match.trigger_tokens[0] || '').trim() || 'runtime';
+    const resourceTypes = unique(draft.match.resource_types || []);
+    const hostBaseType = unique(draft.match.host_base_type || []);
+    if (resourceTypes.length === 0) {
+        resourceTypes.push('unspecified_resource');
+    }
+    if (hostBaseType.length === 0) {
+        hostBaseType.push('unspecified_host');
+    }
+    const requiredHops = unique(draft.closure.required_hops);
+    const guarantees = unique(draft.claims.guarantees);
+    const nonGuarantees = unique(draft.claims.non_guarantees);
+    const nextAction = String(draft.claims.next_action || '').trim() || 'gitnexus query "runtime"';
+    assertNoPlaceholderScope(resourceTypes, 'resource_types');
+    assertNoPlaceholderScope(hostBaseType, 'host_base_type');
+    return {
+        id: ruleId,
+        version,
+        trigger_family: triggerFamily,
+        resource_types: resourceTypes,
+        host_base_type: hostBaseType,
+        required_hops: requiredHops,
+        guarantees,
+        non_guarantees: nonGuarantees,
+        next_action: nextAction,
+        match: draft.match,
+        topology: draft.topology,
+        closure: draft.closure,
+        claims: draft.claims,
+        ...(draft.resource_bindings ? { resource_bindings: draft.resource_bindings } : {}),
+        ...(draft.lifecycle_overrides ? { lifecycle_overrides: draft.lifecycle_overrides } : {}),
+    };
+}
+function toStageAwareCompiledRule(rule, relativeFile) {
+    return {
+        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: relativeFile,
+        match: rule.match,
+        topology: rule.topology,
+        closure: rule.closure,
+        claims: rule.claims,
+        ...(rule.resource_bindings ? { resource_bindings: rule.resource_bindings } : {}),
+        ...(rule.lifecycle_overrides ? { lifecycle_overrides: rule.lifecycle_overrides } : {}),
+    };
+}
+function pushList(lines, key, values, indent = '') {
+    lines.push(`${indent}${key}:`);
+    values.forEach((value) => lines.push(`${indent}  - ${quoteYaml(value)}`));
+}
+function renderObjectLines(lines, object, indent = '') {
+    const entries = Object.entries(object || {});
+    for (const [key, value] of entries) {
+        const scalar = typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean'
+            ? String(value)
+            : JSON.stringify(value);
+        lines.push(`${indent}${key}: ${quoteYaml(scalar)}`);
+    }
+}
+function buildRuleYaml(rule) {
+    const lines = [
+        `id: ${quoteYaml(rule.id)}`,
+        `version: ${quoteYaml(rule.version)}`,
+        ...(rule.family ? [`family: ${quoteYaml(rule.family)}`] : []),
+        `trigger_family: ${quoteYaml(rule.trigger_family)}`,
+    ];
+    pushList(lines, 'resource_types', rule.resource_types);
+    pushList(lines, 'host_base_type', rule.host_base_type);
+    pushList(lines, 'required_hops', rule.required_hops);
+    pushList(lines, 'guarantees', rule.guarantees);
+    pushList(lines, 'non_guarantees', rule.non_guarantees);
+    lines.push(`next_action: ${quoteYaml(rule.next_action)}`);
+    lines.push('match:');
+    pushList(lines, 'trigger_tokens', rule.match.trigger_tokens, '  ');
+    if (Array.isArray(rule.match.symbol_kind) && rule.match.symbol_kind.length > 0) {
+        pushList(lines, 'symbol_kind', rule.match.symbol_kind, '  ');
+    }
+    if (Array.isArray(rule.match.module_scope) && rule.match.module_scope.length > 0) {
+        pushList(lines, 'module_scope', rule.match.module_scope, '  ');
+    }
+    if (Array.isArray(rule.match.resource_types) && rule.match.resource_types.length > 0) {
+        pushList(lines, 'resource_types', rule.match.resource_types, '  ');
+    }
+    if (Array.isArray(rule.match.host_base_type) && rule.match.host_base_type.length > 0) {
+        pushList(lines, 'host_base_type', rule.match.host_base_type, '  ');
+    }
+    lines.push('topology:');
+    for (const hop of rule.topology) {
+        lines.push(`  - hop: ${quoteYaml(hop.hop)}`);
+        lines.push('    from:');
+        renderObjectLines(lines, hop.from || {}, '      ');
+        lines.push('    to:');
+        renderObjectLines(lines, hop.to || {}, '      ');
+        lines.push('    edge:');
+        lines.push(`      kind: ${quoteYaml(String(hop.edge?.kind || 'calls'))}`);
+        if (hop.constraints && Object.keys(hop.constraints).length > 0) {
+            lines.push('    constraints:');
+            renderObjectLines(lines, hop.constraints, '      ');
+        }
+    }
+    lines.push('closure:');
+    pushList(lines, 'required_hops', rule.closure.required_hops, '  ');
+    lines.push('  failure_map:');
+    for (const [key, value] of Object.entries(rule.closure.failure_map || {})) {
+        lines.push(`    ${quoteYaml(key)}: ${quoteYaml(String(value || 'rule_matched_but_evidence_missing'))}`);
+    }
+    lines.push('claims:');
+    pushList(lines, 'guarantees', rule.claims.guarantees, '  ');
+    pushList(lines, 'non_guarantees', rule.claims.non_guarantees, '  ');
+    lines.push(`  next_action: ${quoteYaml(rule.claims.next_action)}`);
+    if (rule.resource_bindings && rule.resource_bindings.length > 0) {
+        lines.push('resource_bindings:');
+        for (const binding of rule.resource_bindings) {
+            lines.push(`  - kind: ${binding.kind}`);
+            if (binding.ref_field_pattern)
+                lines.push(`    ref_field_pattern: ${quoteYaml(binding.ref_field_pattern)}`);
+            if (binding.target_entry_points?.length)
+                pushList(lines, 'target_entry_points', binding.target_entry_points, '    ');
+            if (binding.host_class_pattern)
+                lines.push(`    host_class_pattern: ${quoteYaml(binding.host_class_pattern)}`);
+            if (binding.field_name)
+                lines.push(`    field_name: ${quoteYaml(binding.field_name)}`);
+            if (binding.loader_methods?.length)
+                pushList(lines, 'loader_methods', binding.loader_methods, '    ');
+        }
+    }
+    if (rule.lifecycle_overrides) {
+        lines.push('lifecycle_overrides:');
+        if (rule.lifecycle_overrides.additional_entry_points?.length) {
+            pushList(lines, 'additional_entry_points', rule.lifecycle_overrides.additional_entry_points, '  ');
+        }
+        if (rule.lifecycle_overrides.scope) {
+            lines.push(`  scope: ${quoteYaml(rule.lifecycle_overrides.scope)}`);
+        }
+    }
+    return `${lines.join('\n')}\n`;
+}
+async function readCatalog(catalogPath) {
+    try {
+        const raw = await fs.readFile(catalogPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return {
+            version: Number(parsed.version || 1),
+            rules: Array.isArray(parsed.rules) ? parsed.rules : [],
+        };
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            return { version: 1, rules: [] };
+        }
+        throw error;
+    }
+}
+export async function promoteCuratedRules(input) {
+    const normalizedRepoPath = path.resolve(input.repoPath);
+    const paths = getRuleLabPaths(normalizedRepoPath, input.runId, input.sliceId);
+    const version = String(input.version || '1.0.0');
+    const curatedRaw = await fs.readFile(paths.curatedPath, 'utf-8');
+    const curatedDoc = JSON.parse(curatedRaw);
+    const curatedItems = Array.isArray(curatedDoc.curated) ? curatedDoc.curated : [];
+    if (curatedItems.length === 0) {
+        throw new Error('No curated candidates available for promotion');
+    }
+    let dslDraftFromCurate;
+    try {
+        const dslDraftRaw = await fs.readFile(path.join(path.dirname(paths.curatedPath), 'dsl-draft.json'), 'utf-8');
+        dslDraftFromCurate = JSON.parse(dslDraftRaw);
+    }
+    catch (error) {
+        if (error?.code !== 'ENOENT')
+            throw error;
+    }
+    const catalogPath = path.join(paths.rulesRoot, 'catalog.json');
+    const catalog = await readCatalog(catalogPath);
+    const promotedFiles = [];
+    const compiledRules = [];
+    await fs.mkdir(paths.promotedRoot, { recursive: true });
+    for (const item of curatedItems) {
+        const ruleId = String(item.rule_id || item.id || '').trim();
+        if (!ruleId) {
+            throw new Error('curated item missing rule id');
+        }
+        const relativeFile = path.join('approved', `${ruleId}.yaml`).split(path.sep).join('/');
+        const absoluteFile = path.join(paths.rulesRoot, relativeFile);
+        const draft = dslDraftFromCurate && curatedItems.length === 1
+            ? { ...dslDraftFromCurate, id: ruleId, version }
+            : { ...toDraftFromCurated(item), id: ruleId, version };
+        const compiledRule = compileRule(ruleId, version, draft);
+        const yaml = buildRuleYaml(compiledRule);
+        await fs.writeFile(absoluteFile, yaml, 'utf-8');
+        promotedFiles.push(absoluteFile);
+        compiledRules.push(toStageAwareCompiledRule(compiledRule, relativeFile));
+        const nextEntry = {
+            id: ruleId,
+            version,
+            enabled: true,
+            file: relativeFile,
+            ...(compiledRule.family ? { family: compiledRule.family } : {}),
+        };
+        const existingIndex = catalog.rules.findIndex((entry) => entry.id === ruleId);
+        if (existingIndex >= 0) {
+            catalog.rules[existingIndex] = nextEntry;
+        }
+        else {
+            catalog.rules.push(nextEntry);
+        }
+    }
+    await fs.mkdir(path.dirname(catalogPath), { recursive: true });
+    await fs.writeFile(catalogPath, `${JSON.stringify(catalog, null, 2)}\n`, 'utf-8');
+    const mergeCompiledRules = async (family) => {
+        const existing = await loadCompiledRuleBundle(normalizedRepoPath, family, paths.rulesRoot);
+        const merged = new Map();
+        for (const rule of existing?.rules || []) {
+            merged.set(rule.id, rule);
+        }
+        for (const rule of compiledRules) {
+            merged.set(rule.id, rule);
+        }
+        return writeCompiledRuleBundle(paths.rulesRoot, family, [...merged.values()]);
+    };
+    const compiledPaths = {
+        analyze_rules: await mergeCompiledRules('analyze_rules'),
+        retrieval_rules: await mergeCompiledRules('retrieval_rules'),
+        verification_rules: await mergeCompiledRules('verification_rules'),
+    };
+    return {
+        catalog,
+        promotedFiles,
+        compiledPaths,
+        paths,
+    };
+}

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

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