@veewo/gitnexus 1.5.6 → 1.5.8

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

@@ -1,395 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { analyzeRuleLabSlice } from '../../rule-lab/analyze.js';
-import { buildReviewPack } from '../../rule-lab/review-pack.js';
-import { curateRuleLabSlice } from '../../rule-lab/curate.js';
-import { promoteCuratedRules } from '../../rule-lab/promote.js';
-import { runRuleLabRegress } from '../../rule-lab/regress.js';
-function commandFor(stage, input) {
-    switch (stage) {
-        case 'analyze':
-            return `gitnexus rule-lab analyze --run-id ${input.runId} --slice-id ${input.sliceId}`;
-        case 'review-pack':
-            return `gitnexus rule-lab review-pack --run-id ${input.runId} --slice-id ${input.sliceId} --max-tokens 6000`;
-        case 'curate':
-            return `gitnexus rule-lab curate --run-id ${input.runId} --slice-id ${input.sliceId} --input-path ${input.curationInputPath}`;
-        case 'promote':
-            return `gitnexus rule-lab promote --run-id ${input.runId} --slice-id ${input.sliceId}`;
-        case 'regress':
-            return `gitnexus rule-lab regress --precision 0.93 --coverage 0.85 --run-id ${input.runId}`;
-        default:
-            return 'gitnexus rule-lab <unknown>';
-    }
-}
-async function mustExist(filePath) {
-    await fs.access(filePath);
-}
-async function bootstrapReducedRuleLabRun(input) {
-    const normalizedSeed = String(input.seed || Date.now())
-        .replace(/[^a-zA-Z0-9]+/g, '-')
-        .toLowerCase();
-    const runId = `phase5-${normalizedSeed}-${Date.now()}`;
-    const sliceId = 'slice-startup-exact-pair';
-    const runRoot = path.join(input.repoPath, '.gitnexus', 'rules', 'lab', 'runs', runId);
-    const sliceRoot = path.join(runRoot, 'slices', sliceId);
-    const manifestPath = path.join(runRoot, 'manifest.json');
-    const slicePath = path.join(sliceRoot, 'slice.json');
-    await fs.mkdir(sliceRoot, { recursive: true });
-    await fs.writeFile(manifestPath, `${JSON.stringify({
-        run_id: runId,
-        repo_path: input.repoPath,
-        scope: 'full',
-        generated_at: new Date().toISOString(),
-        slices: [
-            {
-                id: sliceId,
-                trigger_family: 'startup',
-                resource_types: ['asset'],
-                host_base_type: ['StartupNode'],
-                required_hops: ['resource', 'code_runtime'],
-            },
-        ],
-        stages: ['analyze'],
-        next_actions: [`gitnexus rule-lab analyze --run-id ${runId} --slice-id ${sliceId}`],
-    }, null, 2)}\n`, 'utf-8');
-    await fs.writeFile(slicePath, `${JSON.stringify({
-        id: sliceId,
-        trigger_family: 'startup',
-        resource_types: ['asset'],
-        host_base_type: ['StartupNode'],
-        required_hops: ['resource', 'code_runtime'],
-        exact_pairs: [
-            {
-                id: 'pair-startup-1',
-                binding_kind: 'method_triggers_method',
-                draft_rule_id: 'demo.startup.v1',
-                source_anchor: {
-                    file: 'Assets/Rules/startup.asset',
-                    line: 1,
-                    symbol: 'StartupNode.Initialize',
-                },
-                target_anchor: {
-                    file: 'Assets/Rules/startup.asset',
-                    line: 1,
-                    symbol: 'StartupNode.Bootstrap',
-                },
-            },
-        ],
-    }, null, 2)}\n`, 'utf-8');
-    return {
-        runId,
-        sliceId,
-        manifestPath,
-    };
-}
-function buildFailureTaxonomy(runId) {
-    return [
-        {
-            code: 'rule_not_matched',
-            retry_hint: 'confirm trigger_family tokens and rerun analyze/promote',
-            repro_command: `gitnexus rule-lab analyze --run-id ${runId} --slice-id <slice_id>`,
-        },
-        {
-            code: 'rule_matched_but_evidence_missing',
-            retry_hint: 'add stronger confirmed_chain anchors in curation input and promote again',
-            repro_command: `gitnexus rule-lab curate --run-id ${runId} --slice-id <slice_id> --input-path <curation-input.json>`,
-        },
-        {
-            code: 'precision_below_threshold',
-            retry_hint: 'trim noisy rules or tighten curation semantics before regress',
-            repro_command: `gitnexus rule-lab regress --precision 0.85 --coverage 0.92 --run-id ${runId}`,
-        },
-        {
-            code: 'coverage_below_threshold',
-            retry_hint: 'add additional approved rules/slices and rerun regress',
-            repro_command: `gitnexus rule-lab regress --precision 0.95 --coverage 0.70 --run-id ${runId}`,
-        },
-        {
-            code: 'probe_pass_rate_below_threshold',
-            retry_hint: 're-run regress with refreshed probes and inspect replay commands',
-            repro_command: `gitnexus rule-lab regress --precision 0.95 --coverage 0.90 --run-id ${runId}`,
-        },
-        {
-            code: 'static_hardcode_detected',
-            retry_hint: 'remove project-specific reload fallback constants/branches from runtime verifier',
-            repro_command: 'rg -n "RESOURCE_ASSET_PATH|GRAPH_ASSET_PATH|RELOAD_GUID|shouldVerifyReloadChain|verifyReloadRuntimeChain" gitnexus/src/mcp/local/runtime-chain-verify.ts',
-        },
-        {
-            code: 'dsl_lint_failed',
-            retry_hint: 'fix promoted DSL placeholders and rerun promote/regress',
-            repro_command: `gitnexus rule-lab promote --run-id ${runId} --slice-id <slice_id>`,
-        },
-    ];
-}
-function hasDslPlaceholders(text) {
-    return /(^|\s)(unknown|todo|tbd)(\s|$)|<[^>]+>/i.test(text);
-}
-async function buildAuthenticityChecks(input) {
-    const verifierPathCandidates = [
-        path.join(input.repoPath, 'gitnexus', 'src', 'mcp', 'local', 'runtime-chain-verify.ts'),
-        path.join(input.repoPath, 'src', 'mcp', 'local', 'runtime-chain-verify.ts'),
-    ];
-    let verifierPath = verifierPathCandidates[0];
-    for (const candidate of verifierPathCandidates) {
-        try {
-            await fs.access(candidate);
-            verifierPath = candidate;
-            break;
-        }
-        catch {
-        }
-    }
-    const verifierRaw = await fs.readFile(verifierPath, 'utf-8');
-    const blockedSymbols = [
-        'RESOURCE_ASSET_PATH',
-        'GRAPH_ASSET_PATH',
-        'RELOAD_GUID',
-        'shouldVerifyReloadChain',
-        'verifyReloadRuntimeChain',
-    ].filter((token) => verifierRaw.includes(token));
-    let dslLintPass = true;
-    for (const promotedPath of input.promotedFiles) {
-        const raw = await fs.readFile(promotedPath, 'utf-8');
-        if (hasDslPlaceholders(raw)) {
-            dslLintPass = false;
-            break;
-        }
-    }
-    return {
-        static_no_hardcoded_reload: {
-            pass: blockedSymbols.length === 0,
-            blocked_symbols: blockedSymbols,
-        },
-        dsl_lint_pass: dslLintPass,
-    };
-}
-export async function buildPhase5RuleLabAcceptanceReport(input) {
-    const repoPath = path.resolve(input.repoPath || process.cwd());
-    const stageCoverage = [];
-    const bootstrapped = await bootstrapReducedRuleLabRun({
-        repoPath,
-        seed: input.seed || 'phase5-acceptance',
-    });
-    const sliceId = bootstrapped.sliceId;
-    const runId = bootstrapped.runId;
-    const analyze = await analyzeRuleLabSlice({ repoPath, runId, sliceId });
-    stageCoverage.push({
-        stage: 'analyze',
-        command: commandFor('analyze', { runId, sliceId }),
-        status: 'passed',
-    });
-    const reviewPack = await buildReviewPack({ repoPath, runId, sliceId, maxTokens: 6000 });
-    stageCoverage.push({
-        stage: 'review-pack',
-        command: commandFor('review-pack', { runId, sliceId }),
-        status: 'passed',
-    });
-    const firstCandidate = analyze.candidates[0];
-    const promotedRuleId = `demo.startup.${runId}.v1`;
-    const curationInputPath = path.join(repoPath, '.gitnexus', 'rules', 'lab', 'runs', runId, 'slices', sliceId, 'curation-input.json');
-    await fs.writeFile(curationInputPath, `${JSON.stringify({
-        run_id: runId,
-        slice_id: sliceId,
-        curated: [
-            {
-                id: firstCandidate.id,
-                rule_id: promotedRuleId,
-                title: 'startup startup graph',
-                match: {
-                    trigger_tokens: ['startup'],
-                },
-                topology: Array.isArray(firstCandidate.topology) && firstCandidate.topology.length > 0
-                    ? firstCandidate.topology
-                    : firstCandidate.evidence.hops.map((hop) => ({
-                        hop: hop.hop_type,
-                        from: { entity: 'resource' },
-                        to: { entity: 'script' },
-                        edge: { kind: 'binds_script' },
-                    })),
-                closure: {
-                    required_hops: Array.isArray(firstCandidate.topology) && firstCandidate.topology.length > 0
-                        ? firstCandidate.topology.map((hop) => hop.hop)
-                        : ['code_runtime'],
-                    failure_map: {
-                        missing_evidence: 'rule_matched_but_evidence_missing',
-                    },
-                },
-                claims: {
-                    guarantees: ['startup trigger matching is confirmed'],
-                    non_guarantees: ['does not prove full runtime ordering'],
-                    next_action: 'gitnexus query "Startup Graph Trigger"',
-                },
-                confirmed_chain: {
-                    steps: firstCandidate.evidence.hops.map((hop) => ({ ...hop, hop_type: 'code_runtime' })),
-                },
-                guarantees: ['startup trigger matching is confirmed'],
-                non_guarantees: ['does not prove full runtime ordering'],
-            },
-        ],
-    }, null, 2)}\n`, 'utf-8');
-    const curated = await curateRuleLabSlice({ repoPath, runId, sliceId, inputPath: curationInputPath });
-    stageCoverage.push({
-        stage: 'curate',
-        command: commandFor('curate', { runId, sliceId, curationInputPath }),
-        status: 'passed',
-    });
-    const promoted = await promoteCuratedRules({ repoPath, runId, sliceId, version: '1.0.0' });
-    stageCoverage.push({
-        stage: 'promote',
-        command: commandFor('promote', { runId, sliceId }),
-        status: 'passed',
-    });
-    const regress = await runRuleLabRegress({
-        precision: 0.93,
-        coverage: 0.85,
-        probes: [
-            {
-                id: 'probe-startup-trigger',
-                pass: true,
-                replay_command: 'gitnexus query "Startup Graph Trigger" --runtime-chain-verify on-demand',
-            },
-        ],
-        repoPath,
-        runId,
-    });
-    stageCoverage.push({
-        stage: 'regress',
-        command: commandFor('regress', { runId, sliceId }),
-        status: regress.pass ? 'passed' : 'failed',
-        retry_hint: regress.pass ? undefined : regress.failures.join(','),
-    });
-    const artifactPaths = {
-        manifest: bootstrapped.manifestPath,
-        candidates: analyze.paths.candidatesPath,
-        review_cards: reviewPack.paths.reviewCardsPath,
-        curation_input: curationInputPath,
-        curated: curated.paths.curatedPath,
-        catalog: path.join(promoted.paths.rulesRoot, 'catalog.json'),
-        promoted_files: promoted.promotedFiles,
-        regress_report: regress.reportPath,
-    };
-    await mustExist(artifactPaths.manifest);
-    await mustExist(artifactPaths.candidates);
-    await mustExist(artifactPaths.review_cards);
-    await mustExist(artifactPaths.curation_input);
-    await mustExist(artifactPaths.curated);
-    await mustExist(artifactPaths.catalog);
-    await Promise.all(artifactPaths.promoted_files.map((filePath) => mustExist(filePath)));
-    if (artifactPaths.regress_report) {
-        await mustExist(artifactPaths.regress_report);
-    }
-    const authenticityChecks = await buildAuthenticityChecks({
-        repoPath,
-        promotedFiles: artifactPaths.promoted_files,
-    });
-    return {
-        generated_at: new Date().toISOString(),
-        repo_alias: input.repoAlias,
-        repo_path: repoPath,
-        run_id: runId,
-        stage_coverage: stageCoverage,
-        metrics: {
-            precision: regress.metrics.precision,
-            coverage: regress.metrics.coverage,
-            probe_pass_rate: regress.metrics.probe_pass_rate,
-            token_budget: reviewPack.meta.token_budget_estimate,
-        },
-        authenticity_checks: authenticityChecks,
-        failure_classifications: buildFailureTaxonomy(runId),
-        artifact_paths: artifactPaths,
-    };
-}
-export async function runPhase5RuleLabGate(input) {
-    const reportPath = path.resolve(input.reportPath);
-    try {
-        const raw = await fs.readFile(reportPath, 'utf-8');
-        const report = JSON.parse(raw);
-        if (!Array.isArray(report.stage_coverage) || report.stage_coverage.length !== 5) {
-            return { pass: false, reason: 'stage_coverage_incomplete' };
-        }
-        if (typeof report.metrics?.precision !== 'number' || typeof report.metrics?.coverage !== 'number') {
-            return { pass: false, reason: 'metrics_missing' };
-        }
-        if (!report.authenticity_checks?.static_no_hardcoded_reload?.pass) {
-            return { pass: false, reason: 'static_hardcode_detected' };
-        }
-        if (!report.authenticity_checks?.dsl_lint_pass) {
-            return { pass: false, reason: 'dsl_lint_failed' };
-        }
-        if (Number(report.metrics?.probe_pass_rate) < 0.85) {
-            return { pass: false, reason: 'probe_pass_rate_below_threshold' };
-        }
-        return { pass: true };
-    }
-    catch {
-        return { pass: false, reason: 'acceptance_report_missing' };
-    }
-}
-export async function writePhase5RuleLabAcceptanceArtifacts(input) {
-    const jsonPath = path.resolve(input.jsonPath);
-    const mdPath = path.resolve(input.mdPath);
-    await fs.mkdir(path.dirname(jsonPath), { recursive: true });
-    await fs.writeFile(jsonPath, `${JSON.stringify(input.report, null, 2)}\n`, 'utf-8');
-    const markdown = [
-        '# Phase 5 Rule Lab Acceptance',
-        '',
-        `- generated_at: ${input.report.generated_at}`,
-        `- repo_alias: ${input.report.repo_alias}`,
-        `- run_id: ${input.report.run_id}`,
-        '',
-        '## Stage Coverage',
-        ...input.report.stage_coverage.map((stage) => `- ${stage.stage}: ${stage.status} (${stage.command})`),
-        '',
-        '## Metrics',
-        `- precision: ${input.report.metrics.precision}`,
-        `- coverage: ${input.report.metrics.coverage}`,
-        `- probe_pass_rate: ${input.report.metrics.probe_pass_rate}`,
-        `- token_budget: ${input.report.metrics.token_budget}`,
-        '',
-        '## Authenticity Checks',
-        `- static_no_hardcoded_reload.pass: ${input.report.authenticity_checks.static_no_hardcoded_reload.pass}`,
-        `- static_no_hardcoded_reload.blocked_symbols: ${input.report.authenticity_checks.static_no_hardcoded_reload.blocked_symbols.join(', ') || 'none'}`,
-        `- dsl_lint_pass: ${input.report.authenticity_checks.dsl_lint_pass}`,
-        '',
-        '## Failure Classifications',
-        ...input.report.failure_classifications.map((failure) => `- ${failure.code}: ${failure.retry_hint} | repro: ${failure.repro_command}`),
-        '',
-        '## Artifact Paths',
-        `- manifest: ${input.report.artifact_paths.manifest}`,
-        `- candidates: ${input.report.artifact_paths.candidates}`,
-        `- review_cards: ${input.report.artifact_paths.review_cards}`,
-        `- curation_input: ${input.report.artifact_paths.curation_input}`,
-        `- curated: ${input.report.artifact_paths.curated}`,
-        `- catalog: ${input.report.artifact_paths.catalog}`,
-        `- promoted_files: ${input.report.artifact_paths.promoted_files.join(', ')}`,
-        `- regress_report: ${input.report.artifact_paths.regress_report || 'n/a'}`,
-        '',
-    ].join('\n');
-    await fs.mkdir(path.dirname(mdPath), { recursive: true });
-    await fs.writeFile(mdPath, markdown, 'utf-8');
-}
-async function main(argv) {
-    const repoArgIndex = argv.indexOf('--repo-path');
-    const repoPath = repoArgIndex >= 0 ? argv[repoArgIndex + 1] : process.cwd();
-    const outJsonIndex = argv.indexOf('--out-json');
-    const outMdIndex = argv.indexOf('--out-md');
-    const outJson = outJsonIndex >= 0
-        ? argv[outJsonIndex + 1]
-        : path.resolve('docs/reports/2026-04-02-phase5-rule-lab-acceptance.json');
-    const outMd = outMdIndex >= 0
-        ? argv[outMdIndex + 1]
-        : path.resolve('docs/reports/2026-04-02-phase5-rule-lab-acceptance.md');
-    const report = await buildPhase5RuleLabAcceptanceReport({
-        repoAlias: 'GitNexus',
-        repoPath,
-        seed: 'phase5-acceptance-main',
-    });
-    await writePhase5RuleLabAcceptanceArtifacts({ report, jsonPath: outJson, mdPath: outMd });
-    process.stdout.write(`${JSON.stringify({ outJson, outMd, run_id: report.run_id }, null, 2)}\n`);
-}
-if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(new URL(import.meta.url).pathname)) {
-    main(process.argv.slice(2)).catch((error) => {
-        console.error(error instanceof Error ? error.message : String(error));
-        process.exit(1);
-    });
-}

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

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

package/dist/benchmark/u2-e2e/phase5-rule-lab-acceptance-runner.test.js

@@ -1,41 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { buildPhase5RuleLabAcceptanceReport, runPhase5RuleLabGate } from './phase5-rule-lab-acceptance-runner.js';
-const { test: rawTest } = process.env.VITEST
-    ? await import('vitest')
-    : await import('node:test');
-const test = rawTest;
-test('phase5 rule-lab acceptance runner emits complete stage coverage', async () => {
-    const report = await buildPhase5RuleLabAcceptanceReport({ repoAlias: 'GitNexus' });
-    assert.equal(report.stage_coverage.length, 5);
-    assert.equal(typeof report.metrics.precision, 'number');
-});
-test('phase5 gate fails when required artifacts are missing', async () => {
-    const gate = await runPhase5RuleLabGate({ reportPath: '/tmp/missing.json' });
-    assert.equal(gate.pass, false);
-    assert.equal(gate.reason, 'acceptance_report_missing');
-});
-test('phase5 gate fails when anti-hardcode scan or dsl lint fails', async () => {
-    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'phase5-gate-'));
-    const reportPath = path.join(tmpDir, 'report.json');
-    await fs.writeFile(reportPath, JSON.stringify({
-        stage_coverage: [
-            { stage: 'analyze', status: 'passed' },
-            { stage: 'review-pack', status: 'passed' },
-            { stage: 'curate', status: 'passed' },
-            { stage: 'promote', status: 'passed' },
-            { stage: 'regress', status: 'passed' },
-        ],
-        metrics: { precision: 0.93, coverage: 0.9, probe_pass_rate: 0.9 },
-        authenticity_checks: {
-            static_no_hardcoded_reload: { pass: false },
-            dsl_lint_pass: false,
-        },
-    }), 'utf-8');
-    const gate = await runPhase5RuleLabGate({ reportPath });
-    assert.equal(gate.pass, false);
-    assert.ok(['static_hardcode_detected', 'dsl_lint_failed'].includes(String(gate.reason)));
-    await fs.rm(tmpDir, { recursive: true, force: true });
-});

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

@@ -1,38 +0,0 @@
-import type { Command } from 'commander';
-declare const RULE_LAB_COMMANDS: readonly ["analyze", "review-pack", "curate", "promote", "regress"];
-type RuleLabHandlerName = 'ruleLabAnalyzeCommand' | 'ruleLabReviewPackCommand' | 'ruleLabCurateCommand' | 'ruleLabPromoteCommand' | 'ruleLabRegressCommand';
-type LazyFactory = (handlerName: RuleLabHandlerName) => (...args: any[]) => void | Promise<void>;
-export declare function getRuleLabCommandNames(program: Command): string[];
-export declare function attachRuleLabCommands(program: Command, lazyFactory?: LazyFactory): void;
-export declare function ruleLabAnalyzeCommand(options: {
-    repoPath?: string;
-    runId: string;
-    sliceId: string;
-}): Promise<void>;
-export declare function ruleLabReviewPackCommand(options: {
-    repoPath?: string;
-    runId: string;
-    sliceId: string;
-    maxTokens?: string | number;
-}): Promise<void>;
-export declare function ruleLabCurateCommand(options: {
-    repoPath?: string;
-    runId: string;
-    sliceId: string;
-    inputPath: string;
-}): Promise<void>;
-export declare function ruleLabPromoteCommand(options: {
-    repoPath?: string;
-    runId: string;
-    sliceId: string;
-    ruleVersion?: string;
-    version?: string;
-}): Promise<void>;
-export declare function ruleLabRegressCommand(options: {
-    precision: string | number;
-    coverage: string | number;
-    repoPath?: string;
-    runId?: string;
-    probesPath?: string;
-}): Promise<void>;
-export { RULE_LAB_COMMANDS };

package/dist/cli/rule-lab.js

@@ -1,148 +0,0 @@
-import { writeSync } from 'node:fs';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { analyzeRuleLabSlice } from '../rule-lab/analyze.js';
-import { buildReviewPack } from '../rule-lab/review-pack.js';
-import { curateRuleLabSlice } from '../rule-lab/curate.js';
-import { promoteCuratedRules } from '../rule-lab/promote.js';
-import { runRuleLabRegress } from '../rule-lab/regress.js';
-import { compileRules } from '../rule-lab/compile.js';
-const RULE_LAB_COMMANDS = ['analyze', 'review-pack', 'curate', 'promote', 'regress'];
-function output(data) {
-    const text = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
-    writeSync(1, `${text}\n`);
-}
-function resolveRepoPath(repoPath) {
-    return path.resolve(repoPath || process.cwd());
-}
-function assertConcreteRunSliceIds(runId, sliceId) {
-    if (/[<>]/.test(runId) || /[<>]/.test(sliceId)) {
-        throw new Error('Invalid run/slice id: placeholder values are not allowed');
-    }
-}
-export function getRuleLabCommandNames(program) {
-    const root = program.commands.find((command) => command.name() === 'rule-lab');
-    if (!root)
-        return [];
-    return root.commands.map((command) => command.name());
-}
-export function attachRuleLabCommands(program, lazyFactory) {
-    const action = (handlerName) => {
-        if (lazyFactory)
-            return lazyFactory(handlerName);
-        switch (handlerName) {
-            case 'ruleLabAnalyzeCommand':
-                return (options) => ruleLabAnalyzeCommand(options);
-            case 'ruleLabReviewPackCommand':
-                return (options) => ruleLabReviewPackCommand(options);
-            case 'ruleLabCurateCommand':
-                return (options) => ruleLabCurateCommand(options);
-            case 'ruleLabPromoteCommand':
-                return (options) => ruleLabPromoteCommand(options);
-            case 'ruleLabRegressCommand':
-                return (options) => ruleLabRegressCommand(options);
-            default:
-                return () => {
-                    throw new Error(`Unknown rule lab handler: ${handlerName}`);
-                };
-        }
-    };
-    const root = program
-        .command('rule-lab')
-        .description('Offline rule-lab workflow for analyze/review-pack/curate/promote/regress');
-    root
-        .command('analyze')
-        .requiredOption('--run-id <id>', 'Rule-lab run id')
-        .requiredOption('--slice-id <id>', 'Slice id')
-        .option('--repo-path <path>', 'Repository path (default: cwd)')
-        .action(action('ruleLabAnalyzeCommand'));
-    root
-        .command('review-pack')
-        .requiredOption('--run-id <id>', 'Rule-lab run id')
-        .requiredOption('--slice-id <id>', 'Slice id')
-        .option('--repo-path <path>', 'Repository path (default: cwd)')
-        .option('--max-tokens <n>', 'Token budget', '6000')
-        .action(action('ruleLabReviewPackCommand'));
-    root
-        .command('curate')
-        .requiredOption('--run-id <id>', 'Rule-lab run id')
-        .requiredOption('--slice-id <id>', 'Slice id')
-        .requiredOption('--input-path <path>', 'Path to curation input JSON')
-        .option('--repo-path <path>', 'Repository path (default: cwd)')
-        .action(action('ruleLabCurateCommand'));
-    root
-        .command('promote')
-        .requiredOption('--run-id <id>', 'Rule-lab run id')
-        .requiredOption('--slice-id <id>', 'Slice id')
-        .option('--repo-path <path>', 'Repository path (default: cwd)')
-        .option('--rule-version <version>', 'Promoted rule version', '1.0.0')
-        .action(action('ruleLabPromoteCommand'));
-    root
-        .command('regress')
-        .requiredOption('--precision <n>', 'Precision metric')
-        .requiredOption('--coverage <n>', 'Coverage metric')
-        .option('--repo-path <path>', 'Repository path (default: cwd)')
-        .option('--run-id <id>', 'Run id (if provided, write report to .gitnexus/rules/reports)')
-        .option('--probes-path <path>', 'Optional JSON file containing regress probes')
-        .action(action('ruleLabRegressCommand'));
-    root
-        .command('compile')
-        .description('Compile approved YAML rules into a JSON bundle')
-        .option('--repo-path <path>', 'Repository path (default: cwd)')
-        .option('--family <family>', 'Rule family to compile', 'analyze_rules')
-        .action((options) => compileRules({ repoPath: options.repoPath, family: options.family }));
-}
-export async function ruleLabAnalyzeCommand(options) {
-    assertConcreteRunSliceIds(options.runId, options.sliceId);
-    const repoPath = resolveRepoPath(options?.repoPath);
-    const result = await analyzeRuleLabSlice({
-        repoPath,
-        runId: options.runId,
-        sliceId: options.sliceId,
-    });
-    output(result);
-}
-export async function ruleLabReviewPackCommand(options) {
-    const result = await buildReviewPack({
-        repoPath: resolveRepoPath(options?.repoPath),
-        runId: options.runId,
-        sliceId: options.sliceId,
-        maxTokens: Number(options.maxTokens || 6000),
-    });
-    output(result);
-}
-export async function ruleLabCurateCommand(options) {
-    const result = await curateRuleLabSlice({
-        repoPath: resolveRepoPath(options?.repoPath),
-        runId: options.runId,
-        sliceId: options.sliceId,
-        inputPath: path.resolve(options.inputPath),
-    });
-    output(result);
-}
-export async function ruleLabPromoteCommand(options) {
-    const version = options.ruleVersion ?? options.version;
-    const result = await promoteCuratedRules({
-        repoPath: resolveRepoPath(options?.repoPath),
-        runId: options.runId,
-        sliceId: options.sliceId,
-        version,
-    });
-    output(result);
-}
-export async function ruleLabRegressCommand(options) {
-    let probes;
-    if (options.probesPath) {
-        const raw = await fs.readFile(path.resolve(options.probesPath), 'utf-8');
-        probes = JSON.parse(raw);
-    }
-    const result = await runRuleLabRegress({
-        precision: Number(options.precision),
-        coverage: Number(options.coverage),
-        repoPath: options.repoPath ? resolveRepoPath(options.repoPath) : undefined,
-        runId: options.runId,
-        probes,
-    });
-    output(result);
-}
-export { RULE_LAB_COMMANDS };

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

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

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

@@ -1,31 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { Command } from 'commander';
-import { attachRuleLabCommands, getRuleLabCommandNames, ruleLabAnalyzeCommand } from './rule-lab.js';
-describe('rule-lab cli', () => {
-    it('registers all rule-lab subcommands', async () => {
-        const program = new Command();
-        program.version('test-version');
-        attachRuleLabCommands(program);
-        const cmds = getRuleLabCommandNames(program);
-        expect(cmds).toEqual(['analyze', 'review-pack', 'curate', 'promote', 'regress', 'compile']);
-    });
-    it('uses --rule-version for promote to avoid root --version collision', () => {
-        const program = new Command();
-        program.version('test-version');
-        attachRuleLabCommands(program);
-        const ruleLab = program.commands.find((command) => command.name() === 'rule-lab');
-        expect(ruleLab).toBeTruthy();
-        const promote = ruleLab?.commands.find((command) => command.name() === 'promote');
-        expect(promote).toBeTruthy();
-        const optionNames = (promote?.options || []).map((option) => option.long);
-        expect(optionNames).toContain('--rule-version');
-        expect(optionNames).not.toContain('--version');
-    });
-    it('rejects placeholder run/slice ids at analyze command boundary', async () => {
-        await expect(ruleLabAnalyzeCommand({
-            repoPath: process.cwd(),
-            runId: '<run_id>',
-            sliceId: '<slice_id>',
-        })).rejects.toThrow(/placeholder/i);
-    });
-});

package/dist/cli/scope-manifest-config.d.ts

@@ -1,9 +0,0 @@
-export interface ScopeManifestConfig {
-    scopeRules: string[];
-    directives: {
-        extensions?: string;
-        repoAlias?: string;
-        embeddings?: string;
-    };
-}
-export declare function parseScopeManifestConfig(raw: string): ScopeManifestConfig;