@veewo/gitnexus 1.5.7 → 1.5.9

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

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

@@ -1,137 +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 { 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 });
-    });
-    it('preserves multi-candidate curation and writes dsl-drafts with compatibility warning', async () => {
-        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-curate-'));
-        const inputPath = path.join(repoRoot, 'curation-input.json');
-        const curated = [
-            {
-                id: 'candidate-1',
-                rule_id: 'demo.rule.first.v1',
-                title: 'first rule',
-                match: {
-                    trigger_tokens: ['reload'],
-                    resource_types: ['syncvar_hook'],
-                    host_base_type: ['network_behaviour'],
-                },
-                topology: [
-                    { hop: 'code_runtime', from: { entity: 'script' }, to: { entity: 'runtime' }, edge: { kind: 'calls' } },
-                ],
-                closure: { required_hops: ['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"',
-                },
-                confirmed_chain: { steps: [{ hop_type: 'code_runtime', anchor: 'Assets/A.cs:1', snippet: 'A' }] },
-                guarantees: ['reload_chain_closed'],
-                non_guarantees: ['no_runtime_execution'],
-            },
-            {
-                id: 'candidate-2',
-                rule_id: 'demo.rule.second.v1',
-                title: 'second rule',
-                match: {
-                    trigger_tokens: ['reload'],
-                    resource_types: ['syncvar_hook'],
-                    host_base_type: ['network_behaviour'],
-                },
-                topology: [
-                    { hop: 'code_runtime', from: { entity: 'script' }, to: { entity: 'runtime' }, edge: { kind: 'calls' } },
-                ],
-                closure: { required_hops: ['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"',
-                },
-                confirmed_chain: { steps: [{ hop_type: 'code_runtime', anchor: 'Assets/B.cs:2', snippet: 'B' }] },
-                guarantees: ['reload_chain_closed'],
-                non_guarantees: ['no_runtime_execution'],
-            },
-        ];
-        await fs.writeFile(inputPath, JSON.stringify({ run_id: 'run-x', slice_id: 'slice-a', curated }, null, 2), 'utf-8');
-        const out = await curateRuleLabSlice({
-            repoPath: repoRoot,
-            runId: 'run-x',
-            sliceId: 'slice-a',
-            inputPath,
-        });
-        const baseDir = path.dirname(out.paths.curatedPath);
-        const curatedOut = JSON.parse(await fs.readFile(out.paths.curatedPath, 'utf-8'));
-        const drafts = JSON.parse(await fs.readFile(path.join(baseDir, 'dsl-drafts.json'), 'utf-8'));
-        const legacy = JSON.parse(await fs.readFile(path.join(baseDir, 'dsl-draft.json'), 'utf-8'));
-        expect(curatedOut.curated).toHaveLength(2);
-        expect(drafts.drafts).toHaveLength(2);
-        expect(legacy.compatibility_warning).toMatch(/multi-draft/i);
-        await fs.rm(repoRoot, { recursive: true, force: true });
-    });
-});

package/dist/rule-lab/curation-input-builder.d.ts

@@ -1,45 +0,0 @@
-import type { RuleLabCandidate, RuleLabSlice, UnityResourceBinding } from './types.js';
-interface CurationInputItem {
-    id: string;
-    rule_id: string;
-    title: string;
-    match: {
-        trigger_tokens: string[];
-        symbol_kind: string[];
-        module_scope: string[];
-        resource_types: string[];
-        host_base_type: string[];
-    };
-    topology: NonNullable<RuleLabCandidate['topology']>;
-    closure: {
-        required_hops: string[];
-        failure_map: Record<string, string>;
-    };
-    claims: {
-        guarantees: string[];
-        non_guarantees: string[];
-        next_action: string;
-    };
-    confirmed_chain: {
-        steps: Array<{
-            hop_type?: string;
-            anchor: string;
-            snippet: string;
-        }>;
-    };
-    guarantees: string[];
-    non_guarantees: string[];
-    resource_bindings: UnityResourceBinding[];
-}
-export interface CurationInputDocument {
-    run_id: string;
-    slice_id: string;
-    curated: CurationInputItem[];
-}
-export declare function buildCurationInput(input: {
-    runId: string;
-    sliceId: string;
-    slice: RuleLabSlice;
-    candidates: RuleLabCandidate[];
-}): CurationInputDocument;
-export {};

package/dist/rule-lab/curation-input-builder.js

@@ -1,133 +0,0 @@
-function unique(values) {
-    return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))];
-}
-function splitSymbol(symbol) {
-    const raw = String(symbol || '').trim();
-    const parts = raw.split('.');
-    if (parts.length < 2) {
-        return { className: '', methodName: '' };
-    }
-    const className = String(parts[parts.length - 2] || '').trim();
-    const methodName = String(parts[parts.length - 1] || '').trim();
-    return { className, methodName };
-}
-function assertResolvedBindingParts(parts, side, candidateId) {
-    const className = String(parts.className || '').trim();
-    const methodName = String(parts.methodName || '').trim();
-    if (!className || !methodName) {
-        throw new Error(`binding_unresolved: ${side} symbol unresolved for candidate ${candidateId}`);
-    }
-    if (/^unknown/i.test(className) || /^unknown/i.test(methodName)) {
-        throw new Error(`binding_unresolved: ${side} symbol contains unknown placeholder for candidate ${candidateId}`);
-    }
-}
-function assertResolvedSceneToken(value, candidateId) {
-    const token = String(value || '').trim();
-    if (!token) {
-        throw new Error(`binding_unresolved: scene token unresolved for candidate ${candidateId}`);
-    }
-    if (/^unknown/i.test(token)) {
-        throw new Error(`binding_unresolved: scene token contains unknown placeholder for candidate ${candidateId}`);
-    }
-    return token;
-}
-function buildBinding(candidate, pair) {
-    const source = splitSymbol(pair.source_anchor.symbol);
-    assertResolvedBindingParts(source, 'source', candidate.id);
-    const kind = candidate.binding_kind === 'method_triggers_scene_load'
-        ? 'method_triggers_scene_load'
-        : 'method_triggers_method';
-    if (kind === 'method_triggers_scene_load') {
-        const sceneName = assertResolvedSceneToken(String(pair.target_anchor.symbol || pair.target_anchor.file || ''), candidate.id);
-        return [{
-                kind,
-                host_class_pattern: source.className,
-                loader_methods: [source.methodName],
-                scene_name: sceneName,
-                description: `Derived from exact pair ${String(pair.id || candidate.id)}`,
-            }];
-    }
-    const target = splitSymbol(pair.target_anchor.symbol);
-    assertResolvedBindingParts(target, 'target', candidate.id);
-    return [{
-            kind,
-            source_class_pattern: source.className,
-            source_method: source.methodName,
-            target_class_pattern: target.className,
-            target_method: target.methodName,
-            description: `Derived from exact pair ${String(pair.id || candidate.id)}`,
-        }];
-}
-function buildConfirmedChain(candidate, pair) {
-    const hops = (candidate.evidence?.hops || []).filter((hop) => String(hop.anchor || '').trim() && String(hop.snippet || '').trim());
-    if (hops.length > 0)
-        return hops;
-    const sourceAnchor = String(pair.source_anchor.file || '').trim();
-    const targetAnchor = String(pair.target_anchor.file || '').trim();
-    const sourceSnippet = String(pair.source_anchor.symbol || '').trim();
-    const targetSnippet = String(pair.target_anchor.symbol || '').trim();
-    const fallback = [
-        sourceAnchor ? {
-            hop_type: 'code_runtime',
-            anchor: `${sourceAnchor}:${Number(pair.source_anchor.line || 1)}`,
-            snippet: sourceSnippet || 'source',
-        } : undefined,
-        targetAnchor ? {
-            hop_type: 'code_runtime',
-            anchor: `${targetAnchor}:${Number(pair.target_anchor.line || 1)}`,
-            snippet: targetSnippet || 'target',
-        } : undefined,
-    ].filter((item) => Boolean(item));
-    if (fallback.length === 0) {
-        throw new Error(`confirmed_chain_empty: no evidence or anchor fallback for candidate ${candidate.id}`);
-    }
-    return fallback;
-}
-export function buildCurationInput(input) {
-    const curated = input.candidates.map((candidate) => {
-        const pair = candidate.exact_pair;
-        if (!pair) {
-            throw new Error(`binding_unresolved: exact_pair missing for candidate ${candidate.id}`);
-        }
-        const requiredHops = unique((candidate.topology || []).map((hop) => hop.hop));
-        const guaranteed = unique(candidate.claims?.guarantees || [`exact pair candidate: ${candidate.id}`]);
-        const nonGuaranteed = unique(candidate.claims?.non_guarantees || ['sparse gap path only']);
-        const bindings = buildBinding(candidate, pair);
-        const confirmedChain = buildConfirmedChain(candidate, pair);
-        return {
-            id: candidate.id,
-            rule_id: String(candidate.draft_rule_id || candidate.id),
-            title: String(candidate.title || ''),
-            match: {
-                trigger_tokens: [input.slice.trigger_family],
-                symbol_kind: ['method'],
-                module_scope: [input.slice.id],
-                resource_types: [...input.slice.resource_types],
-                host_base_type: [...input.slice.host_base_type],
-            },
-            topology: candidate.topology || [],
-            closure: {
-                required_hops: requiredHops.length > 0 ? requiredHops : ['code_runtime'],
-                failure_map: {
-                    missing_evidence: 'rule_matched_but_evidence_missing',
-                },
-            },
-            claims: {
-                guarantees: guaranteed,
-                non_guarantees: nonGuaranteed,
-                next_action: String(candidate.claims?.next_action || `gitnexus query "${input.slice.trigger_family}"`),
-            },
-            confirmed_chain: {
-                steps: confirmedChain,
-            },
-            guarantees: guaranteed,
-            non_guarantees: nonGuaranteed,
-            resource_bindings: bindings,
-        };
-    });
-    return {
-        run_id: input.runId,
-        slice_id: input.sliceId,
-        curated,
-    };
-}

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

@@ -1,13 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

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

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

@@ -1,42 +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 { 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

@@ -1,21 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

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