@veewo/gitnexus 1.5.6 → 1.5.8

package/dist/core/ingestion/unity-runtime-binding-rules.js

@@ -1,408 +0,0 @@
-import { generateId } from '../../lib/utils.js';
-const RULE_EDGE_CONFIDENCE = 0.75;
-const RULE_ANOMALY_PREVIEW_LIMIT = 5;
-export function applyUnityRuntimeBindingRules(graph, rules, config) {
-    const ruleResults = [];
-    let totalEdges = 0;
-    const existingPairs = new Set();
-    for (const rel of graph.iterRelationships()) {
-        if (rel.type === 'CALLS')
-            existingPairs.add(`${rel.sourceId}->${rel.targetId}`);
-    }
-    const addSyntheticEdge = (sourceId, targetId, reason) => {
-        if (sourceId === targetId)
-            return false;
-        const key = `${sourceId}->${targetId}`;
-        if (existingPairs.has(key))
-            return false;
-        graph.addRelationship({
-            id: generateId('CALLS', `${sourceId}->${targetId}:${reason}`),
-            sourceId,
-            targetId,
-            type: 'CALLS',
-            confidence: RULE_EDGE_CONFIDENCE,
-            reason,
-        });
-        existingPairs.add(key);
-        return true;
-    };
-    // Pre-build indexes
-    const methodsByClassId = new Map();
-    const containerNodes = [];
-    const containerLabels = config.enableContainerNodes
-        ? new Set(['Class', 'Struct', 'Interface', 'Record'])
-        : new Set(['Class']);
-    for (const rel of graph.iterRelationships()) {
-        if (rel.type !== 'HAS_METHOD')
-            continue;
-        const method = graph.getNode(rel.targetId);
-        if (!method || (method.label !== 'Method' && method.label !== 'Function'))
-            continue;
-        const list = methodsByClassId.get(rel.sourceId) ?? [];
-        list.push(method);
-        methodsByClassId.set(rel.sourceId, list);
-    }
-    for (const node of graph.iterNodes()) {
-        if (containerLabels.has(node.label))
-            containerNodes.push(node);
-    }
-    // Collect UNITY_ASSET_GUID_REF and UNITY_COMPONENT_INSTANCE edges
-    const assetGuidRefs = [];
-    const componentInstances = [];
-    for (const rel of graph.iterRelationships()) {
-        if (rel.type === 'UNITY_ASSET_GUID_REF')
-            assetGuidRefs.push(rel);
-        else if (rel.type === 'UNITY_COMPONENT_INSTANCE')
-            componentInstances.push(rel);
-    }
-    const prefabSourceTargetsBySource = buildPrefabSourceTargetsBySource(assetGuidRefs);
-    const methodsByResourceId = buildMethodsByResourceId(componentInstances, methodsByClassId);
-    const executionState = {
-        methodsByResourceId,
-        resourceMethodLookupCache: new Map(),
-        sceneRuntimeResourceIdsCache: new Map(),
-        diagnostics: {
-            rulesEvaluated: rules.length,
-            bindingsEvaluated: 0,
-            bindingsByKind: {},
-            methodLookupCalls: 0,
-            methodLookupCacheHits: 0,
-            sceneRuntimeTraversalCalls: 0,
-            sceneRuntimeTraversalCacheHits: 0,
-            sceneRuntimeResourcesVisited: 0,
-            anomalySet: new Set(),
-        },
-    };
-    // Pre-build scene file index: lowercase scene name → fileId[]
-    const sceneFilesByName = new Map();
-    for (const node of graph.iterNodes()) {
-        if (node.label !== 'File')
-            continue;
-        const filePath = String(node.properties.filePath ?? '');
-        if (!filePath.endsWith('.unity'))
-            continue;
-        const fileName = (filePath.split('/').pop() ?? '').replace(/\.unity$/, '').toLowerCase();
-        const list = sceneFilesByName.get(fileName) ?? [];
-        list.push(node.id);
-        sceneFilesByName.set(fileName, list);
-    }
-    for (const rule of rules) {
-        let ruleEdges = 0;
-        for (const binding of rule.resource_bindings ?? []) {
-            executionState.diagnostics.bindingsEvaluated += 1;
-            executionState.diagnostics.bindingsByKind[binding.kind] =
-                (executionState.diagnostics.bindingsByKind[binding.kind] || 0) + 1;
-            ruleEdges += processBinding(binding, rule.id, assetGuidRefs, componentInstances, methodsByClassId, containerNodes, sceneFilesByName, prefabSourceTargetsBySource, executionState, addSyntheticEdge);
-        }
-        if (rule.lifecycle_overrides?.additional_entry_points?.length) {
-            ruleEdges += processLifecycleOverrides(rule, methodsByClassId, containerNodes, addSyntheticEdge);
-        }
-        totalEdges += ruleEdges;
-        ruleResults.push({ ruleId: rule.id, edgesInjected: ruleEdges });
-    }
-    return {
-        edgesInjected: totalEdges,
-        ruleResults,
-        diagnostics: finalizeRuleBindingDiagnostics(executionState.diagnostics, totalEdges),
-    };
-}
-function findMethodsOnResource(resourceFileId, executionState, entryPoints) {
-    executionState.diagnostics.methodLookupCalls += 1;
-    const cacheKey = `${resourceFileId}::${entryPoints.join('|')}`;
-    const cached = executionState.resourceMethodLookupCache.get(cacheKey);
-    if (cached) {
-        executionState.diagnostics.methodLookupCacheHits += 1;
-        return cached;
-    }
-    const methods = executionState.methodsByResourceId.get(resourceFileId) ?? [];
-    if (methods.length === 0) {
-        executionState.resourceMethodLookupCache.set(cacheKey, []);
-        return [];
-    }
-    const entrySet = new Set(entryPoints);
-    const results = [];
-    for (const method of methods) {
-        if (entrySet.has(method.properties.name))
-            results.push(method);
-    }
-    executionState.resourceMethodLookupCache.set(cacheKey, results);
-    return results;
-}
-function processBinding(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, containerNodes, sceneFilesByName, prefabSourceTargetsBySource, executionState, addEdge) {
-    if (binding.kind === 'asset_ref_loads_components') {
-        return processAssetRefLoadsComponents(binding, ruleId, assetGuidRefs, executionState, addEdge);
-    }
-    if (binding.kind === 'method_triggers_field_load') {
-        return processMethodTriggersFieldLoad(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, containerNodes, executionState, addEdge);
-    }
-    if (binding.kind === 'method_triggers_scene_load') {
-        return processMethodTriggersSceneLoad(binding, ruleId, componentInstances, methodsByClassId, containerNodes, sceneFilesByName, prefabSourceTargetsBySource, executionState, addEdge);
-    }
-    if (binding.kind === 'method_triggers_method') {
-        return processMethodTriggersMethod(binding, ruleId, methodsByClassId, containerNodes, addEdge);
-    }
-    addAnomaly(executionState.diagnostics, `rule=${ruleId}: unsupported resource_binding kind "${binding.kind}"`);
-    return 0;
-}
-function processAssetRefLoadsComponents(binding, ruleId, assetGuidRefs, executionState, addEdge) {
-    let count = 0;
-    const pattern = binding.ref_field_pattern ? new RegExp(binding.ref_field_pattern) : null;
-    const entryPoints = binding.target_entry_points ?? [];
-    if (!pattern || entryPoints.length === 0) {
-        addAnomaly(executionState.diagnostics, `rule=${ruleId}: asset_ref_loads_components missing ref_field_pattern or target_entry_points`);
-        return 0;
-    }
-    const runtimeRootId = generateId('Method', 'unity-runtime-root');
-    for (const ref of assetGuidRefs) {
-        let fieldName = '';
-        try {
-            const parsed = JSON.parse(ref.reason);
-            fieldName = parsed.fieldName ?? '';
-        }
-        catch {
-            continue;
-        }
-        if (!pattern.test(fieldName))
-            continue;
-        const targetMethods = findMethodsOnResource(ref.targetId, executionState, entryPoints);
-        for (const method of targetMethods) {
-            if (addEdge(runtimeRootId, method.id, `unity-rule-resource-load:${ruleId}`))
-                count++;
-        }
-    }
-    return count;
-}
-function processMethodTriggersFieldLoad(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, containerNodes, executionState, addEdge) {
-    let count = 0;
-    const classPattern = binding.host_class_pattern ? new RegExp(binding.host_class_pattern) : null;
-    const loaderMethodNames = new Set(binding.loader_methods ?? []);
-    const entryPoints = binding.target_entry_points ?? [];
-    const defaultEntryPoints = ['OnEnable', 'Awake', 'Start'];
-    const resolvedEntryPoints = entryPoints.length > 0 ? entryPoints : defaultEntryPoints;
-    if (!classPattern || loaderMethodNames.size === 0) {
-        addAnomaly(executionState.diagnostics, `rule=${ruleId}: method_triggers_field_load missing host_class_pattern or loader_methods`);
-        return 0;
-    }
-    // Build asset ref index by source file
-    const refsBySource = new Map();
-    for (const ref of assetGuidRefs) {
-        const list = refsBySource.get(ref.sourceId) ?? [];
-        list.push(ref);
-        refsBySource.set(ref.sourceId, list);
-    }
-    for (const cls of containerNodes) {
-        if (!classPattern.test(cls.properties.name))
-            continue;
-        const methods = methodsByClassId.get(cls.id) ?? [];
-        const loaders = methods.filter(m => loaderMethodNames.has(m.properties.name));
-        if (loaders.length === 0)
-            continue;
-        // Find resource files this class is mounted on
-        const resourceFileIds = new Set();
-        for (const ci of componentInstances) {
-            if (ci.sourceId === cls.id)
-                resourceFileIds.add(ci.targetId);
-        }
-        // Follow asset refs from those resource files
-        for (const resourceFileId of resourceFileIds) {
-            for (const ref of refsBySource.get(resourceFileId) ?? []) {
-                const targetMethods = findMethodsOnResource(ref.targetId, executionState, resolvedEntryPoints);
-                for (const loader of loaders) {
-                    for (const target of targetMethods) {
-                        if (addEdge(loader.id, target.id, `unity-rule-loader-bridge:${ruleId}`))
-                            count++;
-                    }
-                }
-            }
-        }
-    }
-    return count;
-}
-function processMethodTriggersSceneLoad(binding, ruleId, componentInstances, methodsByClassId, containerNodes, sceneFilesByName, prefabSourceTargetsBySource, executionState, addEdge) {
-    const classPattern = binding.host_class_pattern ? new RegExp(binding.host_class_pattern) : null;
-    const loaderMethodNames = new Set(binding.loader_methods ?? []);
-    const sceneName = binding.scene_name;
-    const defaultEntryPoints = ['OnEnable', 'Awake', 'Start'];
-    const entryPoints = (binding.target_entry_points ?? []).length > 0
-        ? binding.target_entry_points
-        : defaultEntryPoints;
-    if (!classPattern || loaderMethodNames.size === 0 || !sceneName) {
-        addAnomaly(executionState.diagnostics, `rule=${ruleId}: method_triggers_scene_load missing host_class_pattern, loader_methods, or scene_name`);
-        return 0;
-    }
-    const sceneFileIds = sceneFilesByName.get(sceneName.toLowerCase()) ?? [];
-    if (sceneFileIds.length === 0) {
-        addAnomaly(executionState.diagnostics, `rule=${ruleId}: scene "${sceneName}" not found in File(.unity) index`);
-        return 0;
-    }
-    let count = 0;
-    for (const cls of containerNodes) {
-        if (!classPattern.test(cls.properties.name))
-            continue;
-        const methods = methodsByClassId.get(cls.id) ?? [];
-        const loaders = methods.filter(m => loaderMethodNames.has(m.properties.name));
-        if (loaders.length === 0)
-            continue;
-        for (const sceneFileId of sceneFileIds) {
-            const runtimeResourceIds = getSceneRuntimeResourceIds(sceneFileId, prefabSourceTargetsBySource, executionState);
-            for (const runtimeResourceId of runtimeResourceIds) {
-                const targetMethods = findMethodsOnResource(runtimeResourceId, executionState, entryPoints);
-                for (const loader of loaders) {
-                    for (const target of targetMethods) {
-                        if (addEdge(loader.id, target.id, `unity-rule-scene-load:${ruleId}`))
-                            count++;
-                    }
-                }
-            }
-        }
-    }
-    return count;
-}
-function buildMethodsByResourceId(componentInstances, methodsByClassId) {
-    const methodsByResourceId = new Map();
-    for (const componentRef of componentInstances) {
-        const methods = methodsByClassId.get(componentRef.sourceId) ?? [];
-        if (methods.length === 0)
-            continue;
-        const list = methodsByResourceId.get(componentRef.targetId) ?? [];
-        list.push(...methods);
-        methodsByResourceId.set(componentRef.targetId, list);
-    }
-    return methodsByResourceId;
-}
-function buildPrefabSourceTargetsBySource(assetGuidRefs) {
-    const targetsBySource = new Map();
-    for (const ref of assetGuidRefs) {
-        let fieldName = '';
-        try {
-            const parsed = JSON.parse(String(ref.reason || '{}'));
-            fieldName = String(parsed?.fieldName || '');
-        }
-        catch {
-            continue;
-        }
-        if (fieldName !== 'm_SourcePrefab')
-            continue;
-        const targets = targetsBySource.get(ref.sourceId) ?? new Set();
-        targets.add(ref.targetId);
-        targetsBySource.set(ref.sourceId, targets);
-    }
-    const out = new Map();
-    for (const [sourceId, targets] of targetsBySource.entries()) {
-        out.set(sourceId, [...targets]);
-    }
-    return out;
-}
-function collectSceneRuntimeResourceIds(sceneFileId, prefabSourceTargetsBySource) {
-    const visited = new Set([sceneFileId]);
-    const queue = [sceneFileId];
-    while (queue.length > 0) {
-        const currentId = queue.shift();
-        for (const targetId of prefabSourceTargetsBySource.get(currentId) ?? []) {
-            if (visited.has(targetId))
-                continue;
-            visited.add(targetId);
-            queue.push(targetId);
-        }
-    }
-    return [...visited];
-}
-function getSceneRuntimeResourceIds(sceneFileId, prefabSourceTargetsBySource, executionState) {
-    executionState.diagnostics.sceneRuntimeTraversalCalls += 1;
-    const cached = executionState.sceneRuntimeResourceIdsCache.get(sceneFileId);
-    if (cached) {
-        executionState.diagnostics.sceneRuntimeTraversalCacheHits += 1;
-        return cached;
-    }
-    const ids = collectSceneRuntimeResourceIds(sceneFileId, prefabSourceTargetsBySource);
-    executionState.sceneRuntimeResourceIdsCache.set(sceneFileId, ids);
-    executionState.diagnostics.sceneRuntimeResourcesVisited += ids.length;
-    return ids;
-}
-function processMethodTriggersMethod(binding, ruleId, methodsByClassId, containerNodes, addEdge) {
-    const { source_class_pattern, source_method, target_class_pattern, target_method } = binding;
-    if (!source_class_pattern || !source_method || !target_class_pattern || !target_method)
-        return 0;
-    const srcPattern = new RegExp(source_class_pattern);
-    const tgtPattern = new RegExp(target_class_pattern);
-    let sourceMethodId;
-    let targetMethodId;
-    for (const cls of containerNodes) {
-        if (!sourceMethodId && srcPattern.test(cls.properties.name)) {
-            const match = (methodsByClassId.get(cls.id) ?? []).find(m => m.properties.name === source_method);
-            if (match)
-                sourceMethodId = match.id;
-        }
-        if (!targetMethodId && tgtPattern.test(cls.properties.name)) {
-            const match = (methodsByClassId.get(cls.id) ?? []).find(m => m.properties.name === target_method);
-            if (match)
-                targetMethodId = match.id;
-        }
-        if (sourceMethodId && targetMethodId)
-            break;
-    }
-    if (!sourceMethodId || !targetMethodId)
-        return 0;
-    return addEdge(sourceMethodId, targetMethodId, `unity-rule-method-bridge:${ruleId}`) ? 1 : 0;
-}
-function processLifecycleOverrides(rule, methodsByClassId, containerNodes, addEdge) {
-    const overrides = rule.lifecycle_overrides;
-    if (!overrides?.additional_entry_points?.length)
-        return 0;
-    const entrySet = new Set(overrides.additional_entry_points);
-    const scopePattern = overrides.scope ? new RegExp(overrides.scope) : null;
-    let count = 0;
-    const runtimeRootId = generateId('Method', 'unity-runtime-root');
-    for (const cls of containerNodes) {
-        if (scopePattern && !scopePattern.test(cls.properties.filePath ?? cls.properties.name))
-            continue;
-        for (const method of methodsByClassId.get(cls.id) ?? []) {
-            if (!entrySet.has(method.properties.name))
-                continue;
-            if (addEdge(runtimeRootId, method.id, `unity-rule-lifecycle-override:${rule.id}`))
-                count++;
-        }
-    }
-    return count;
-}
-function addAnomaly(diagnostics, message) {
-    diagnostics.anomalySet.add(message);
-}
-function finalizeRuleBindingDiagnostics(diagnostics, edgesInjected) {
-    const anomalies = [...diagnostics.anomalySet];
-    const shouldAgentReport = anomalies.length > 0;
-    const bindingsByKind = Object.fromEntries(Object.entries(diagnostics.bindingsByKind).sort(([a], [b]) => a.localeCompare(b)));
-    const kindSummary = Object.entries(bindingsByKind)
-        .map(([kind, count]) => `${kind}=${count}`)
-        .join(', ') || 'none';
-    const summary = [
-        `rule_binding.summary: rules=${diagnostics.rulesEvaluated}, bindings=${diagnostics.bindingsEvaluated}, edges=${edgesInjected}`,
-        `rule_binding.bindings_by_kind: ${kindSummary}`,
-        `rule_binding.lookup: method_calls=${diagnostics.methodLookupCalls}, cache_hits=${diagnostics.methodLookupCacheHits}`,
-        `rule_binding.scene_closure: traversals=${diagnostics.sceneRuntimeTraversalCalls}, cache_hits=${diagnostics.sceneRuntimeTraversalCacheHits}, visited_resources=${diagnostics.sceneRuntimeResourcesVisited}`,
-        `rule_binding.agent_report: should_report=${shouldAgentReport} reason="${shouldAgentReport ? 'rule-binding anomalies detected' : 'no anomalies detected'}"`,
-    ];
-    if (anomalies.length > 0) {
-        summary.push(`rule_binding.anomalies: count=${anomalies.length}`);
-        for (const anomaly of anomalies.slice(0, RULE_ANOMALY_PREVIEW_LIMIT)) {
-            summary.push(`rule_binding.anomaly: ${anomaly}`);
-        }
-        if (anomalies.length > RULE_ANOMALY_PREVIEW_LIMIT) {
-            summary.push(`rule_binding.anomaly: ... ${anomalies.length - RULE_ANOMALY_PREVIEW_LIMIT} more`);
-        }
-    }
-    return {
-        rulesEvaluated: diagnostics.rulesEvaluated,
-        bindingsEvaluated: diagnostics.bindingsEvaluated,
-        bindingsByKind,
-        methodLookupCalls: diagnostics.methodLookupCalls,
-        methodLookupCacheHits: diagnostics.methodLookupCacheHits,
-        sceneRuntimeTraversalCalls: diagnostics.sceneRuntimeTraversalCalls,
-        sceneRuntimeTraversalCacheHits: diagnostics.sceneRuntimeTraversalCacheHits,
-        sceneRuntimeResourcesVisited: diagnostics.sceneRuntimeResourcesVisited,
-        anomalies,
-        shouldAgentReport,
-        agentReportReason: shouldAgentReport ? 'rule-binding anomalies detected' : 'no anomalies detected',
-        summary,
-    };
-}

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

@@ -1,13 +0,0 @@
-import { getRuleLabPaths } from './paths.js';
-import type { RuleLabCandidate, RuleLabSlice } from './types.js';
-export interface AnalyzeInput {
-    repoPath: string;
-    runId: string;
-    sliceId: string;
-}
-export interface AnalyzeOutput {
-    paths: ReturnType<typeof getRuleLabPaths>;
-    candidates: RuleLabCandidate[];
-    slice: RuleLabSlice;
-}
-export declare function analyzeRuleLabSlice(input: AnalyzeInput): Promise<AnalyzeOutput>;

package/dist/rule-lab/analyze.js

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

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

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