@veewo/gitnexus 1.3.9 → 1.3.10

package/dist/core/ingestion/modules/assignment-engine.js

@@ -1,179 +0,0 @@
-import { matchRule, ruleSpecificityScore } from './rule-matcher.js';
-function sanitizeModuleId(name) {
-    const base = name.toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '');
-    return base || 'module';
-}
-function resolveBy(top, second) {
-    if (!second)
-        return 'priority';
-    if (top.effectivePriority !== second.effectivePriority)
-        return 'priority';
-    if (top.specificity !== second.specificity)
-        return 'specificity';
-    if (top.ruleOrder !== second.ruleOrder)
-        return 'rule-order';
-    return 'module-lexicographic';
-}
-function pickWinner(candidates) {
-    const sorted = [...candidates].sort((a, b) => {
-        if (a.effectivePriority !== b.effectivePriority)
-            return b.effectivePriority - a.effectivePriority;
-        if (a.specificity !== b.specificity)
-            return b.specificity - a.specificity;
-        if (a.ruleOrder !== b.ruleOrder)
-            return a.ruleOrder - b.ruleOrder;
-        return a.moduleName.localeCompare(b.moduleName);
-    });
-    return { winner: sorted[0], resolvedBy: resolveBy(sorted[0], sorted[1]) };
-}
-function buildAutoFallbackMap(autoCommunities) {
-    const m = new Map();
-    for (const comm of autoCommunities)
-        m.set(comm.id, comm);
-    return m;
-}
-function toConfiguredCommunities(config) {
-    const seen = new Set();
-    return config.modules.map((mod) => {
-        let idBase = `comm_cfg_${sanitizeModuleId(mod.name)}`;
-        let suffix = 1;
-        while (seen.has(idBase)) {
-            idBase = `comm_cfg_${sanitizeModuleId(mod.name)}_${suffix++}`;
-        }
-        seen.add(idBase);
-        return {
-            id: idBase,
-            moduleName: mod.name,
-            label: mod.name,
-            heuristicLabel: mod.name,
-            cohesion: 0,
-            symbolCount: 0,
-        };
-    });
-}
-export function assignModules(input) {
-    const membershipsBySymbol = new Map();
-    if (input.mode === 'auto' || !input.config) {
-        const autoCommunityById = buildAutoFallbackMap(input.autoCommunities);
-        for (const membership of input.autoMemberships) {
-            const autoComm = autoCommunityById.get(membership.communityId);
-            const moduleName = autoComm?.heuristicLabel || autoComm?.label || membership.communityId;
-            membershipsBySymbol.set(membership.nodeId, {
-                symbolId: membership.nodeId,
-                moduleName,
-                communityId: membership.communityId,
-                assignmentSource: 'auto-fallback',
-                resolvedBy: 'fallback-auto',
-            });
-        }
-        return {
-            finalModules: input.autoCommunities,
-            finalMemberships: input.autoMemberships,
-            membershipsBySymbol,
-            diagnostics: {
-                mode: input.mode,
-                configuredModuleCount: 0,
-                finalModuleCount: input.autoCommunities.length,
-                emptyModules: [],
-            },
-        };
-    }
-    const configuredCommunities = toConfiguredCommunities(input.config);
-    const configuredCommByName = new Map();
-    for (const comm of configuredCommunities) {
-        configuredCommByName.set(comm.moduleName, comm);
-    }
-    const autoCommunityById = buildAutoFallbackMap(input.autoCommunities);
-    const symbolById = new Map(input.symbols.map((s) => [s.id, s]));
-    const autoMembershipBySymbol = new Map(input.autoMemberships.map((m) => [m.nodeId, m.communityId]));
-    const configModuleCounts = new Map();
-    const fallbackCommunityCounts = new Map();
-    const finalMemberships = [];
-    for (const [symbolId, autoCommunityId] of autoMembershipBySymbol.entries()) {
-        const symbol = symbolById.get(symbolId);
-        if (!symbol)
-            continue;
-        const candidates = [];
-        let ruleOrder = 0;
-        for (const moduleDef of input.config.modules) {
-            const comm = configuredCommByName.get(moduleDef.name);
-            if (!comm)
-                continue;
-            for (const rule of moduleDef.rules) {
-                if (!matchRule(symbol, rule)) {
-                    ruleOrder += 1;
-                    continue;
-                }
-                candidates.push({
-                    moduleName: moduleDef.name,
-                    communityId: comm.id,
-                    ruleId: rule.id,
-                    effectivePriority: rule.priority ?? moduleDef.defaultPriority,
-                    specificity: ruleSpecificityScore(rule),
-                    ruleOrder,
-                });
-                ruleOrder += 1;
-            }
-        }
-        if (candidates.length === 0) {
-            finalMemberships.push({ nodeId: symbolId, communityId: autoCommunityId });
-            fallbackCommunityCounts.set(autoCommunityId, (fallbackCommunityCounts.get(autoCommunityId) || 0) + 1);
-            const autoCommunity = autoCommunityById.get(autoCommunityId);
-            membershipsBySymbol.set(symbolId, {
-                symbolId,
-                moduleName: autoCommunity?.heuristicLabel || autoCommunity?.label || autoCommunityId,
-                communityId: autoCommunityId,
-                assignmentSource: 'auto-fallback',
-                resolvedBy: 'fallback-auto',
-            });
-            continue;
-        }
-        const { winner, resolvedBy } = pickWinner(candidates);
-        finalMemberships.push({ nodeId: symbolId, communityId: winner.communityId });
-        configModuleCounts.set(winner.moduleName, (configModuleCounts.get(winner.moduleName) || 0) + 1);
-        membershipsBySymbol.set(symbolId, {
-            symbolId,
-            moduleName: winner.moduleName,
-            communityId: winner.communityId,
-            assignmentSource: 'config-rule',
-            matchedRuleId: winner.ruleId,
-            resolvedBy,
-        });
-    }
-    const emptyModules = [];
-    const finalModules = configuredCommunities.map((comm) => {
-        const count = configModuleCounts.get(comm.moduleName) || 0;
-        if (count === 0)
-            emptyModules.push(comm.moduleName);
-        return {
-            id: comm.id,
-            label: comm.label,
-            heuristicLabel: comm.heuristicLabel,
-            cohesion: 0,
-            symbolCount: count,
-        };
-    });
-    for (const autoComm of input.autoCommunities) {
-        const fallbackCount = fallbackCommunityCounts.get(autoComm.id) || 0;
-        if (fallbackCount <= 0)
-            continue;
-        finalModules.push({
-            id: autoComm.id,
-            label: autoComm.label,
-            heuristicLabel: autoComm.heuristicLabel,
-            cohesion: autoComm.cohesion,
-            symbolCount: fallbackCount,
-        });
-    }
-    return {
-        finalModules,
-        finalMemberships,
-        membershipsBySymbol,
-        diagnostics: {
-            mode: input.mode,
-            configuredModuleCount: input.config.modules.length,
-            finalModuleCount: finalModules.length,
-            emptyModules,
-        },
-    };
-}

package/dist/core/ingestion/modules/assignment-engine.test.d.ts

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

package/dist/core/ingestion/modules/assignment-engine.test.js

@@ -1,111 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { assignModules } from './assignment-engine.js';
-function baseInput() {
-    return {
-        mode: 'mixed',
-        symbols: [
-            {
-                id: 'Class:MinionFactory',
-                name: 'MinionFactory',
-                kind: 'Class',
-                filePath: 'Assets/Scripts/MinionFactory.cs',
-            },
-            {
-                id: 'Class:Minion',
-                name: 'Minion',
-                kind: 'Class',
-                filePath: 'Assets/Scripts/Minion.cs',
-            },
-        ],
-        autoCommunities: [
-            {
-                id: 'comm_0',
-                label: 'AutoGroup',
-                heuristicLabel: 'AutoGroup',
-                cohesion: 0.7,
-                symbolCount: 2,
-            },
-        ],
-        autoMemberships: [
-            { nodeId: 'Class:MinionFactory', communityId: 'comm_0' },
-            { nodeId: 'Class:Minion', communityId: 'comm_0' },
-        ],
-        config: {
-            version: 1,
-            mode: 'mixed',
-            modules: [
-                {
-                    name: 'Factory',
-                    defaultPriority: 100,
-                    rules: [
-                        {
-                            id: 'factory-rule',
-                            when: {
-                                all: [{ field: 'symbol.name', op: 'contains', value: 'Factory' }],
-                            },
-                        },
-                    ],
-                },
-            ],
-        },
-    };
-}
-test('mixed mode applies config override and auto fallback with single membership', () => {
-    const out = assignModules(baseInput());
-    assert.equal(out.finalMemberships.length, 2);
-    assert.equal(new Set(out.finalMemberships.map((m) => m.nodeId)).size, 2);
-    assert.equal(out.membershipsBySymbol.get('Class:MinionFactory')?.moduleName, 'Factory');
-    assert.equal(out.membershipsBySymbol.get('Class:MinionFactory')?.assignmentSource, 'config-rule');
-    assert.equal(out.membershipsBySymbol.get('Class:Minion')?.assignmentSource, 'auto-fallback');
-});
-test('conflict resolution order: priority > specificity > rule-order > module-name', () => {
-    const input = baseInput();
-    input.symbols = [{ id: 'Class:X', name: 'X', kind: 'Class', filePath: 'x.ts' }];
-    input.autoMemberships = [{ nodeId: 'Class:X', communityId: 'comm_0' }];
-    input.autoCommunities = [{ id: 'comm_0', label: 'Auto', heuristicLabel: 'Auto', cohesion: 0.4, symbolCount: 1 }];
-    input.config = {
-        version: 1,
-        mode: 'mixed',
-        modules: [
-            {
-                name: 'ContainsWinsByOrder',
-                defaultPriority: 100,
-                rules: [{ id: 'contains-a', when: { all: [{ field: 'symbol.name', op: 'contains', value: 'X' }] } }],
-            },
-            {
-                name: 'EqWinsBySpecificity',
-                defaultPriority: 100,
-                rules: [{ id: 'eq-b', when: { all: [{ field: 'symbol.name', op: 'eq', value: 'X' }] } }],
-            },
-        ],
-    };
-    const out = assignModules(input);
-    assert.equal(out.membershipsBySymbol.get('Class:X')?.moduleName, 'EqWinsBySpecificity');
-    assert.equal(out.membershipsBySymbol.get('Class:X')?.resolvedBy, 'specificity');
-});
-test('higher effective priority wins even with lower specificity', () => {
-    const input = baseInput();
-    input.symbols = [{ id: 'Class:X', name: 'X', kind: 'Class', filePath: 'x.ts' }];
-    input.autoMemberships = [{ nodeId: 'Class:X', communityId: 'comm_0' }];
-    input.autoCommunities = [{ id: 'comm_0', label: 'Auto', heuristicLabel: 'Auto', cohesion: 0.4, symbolCount: 1 }];
-    input.config = {
-        version: 1,
-        mode: 'mixed',
-        modules: [
-            {
-                name: 'HighPriorityContains',
-                defaultPriority: 120,
-                rules: [{ id: 'contains-a', when: { all: [{ field: 'symbol.name', op: 'contains', value: 'X' }] } }],
-            },
-            {
-                name: 'LowPriorityEq',
-                defaultPriority: 100,
-                rules: [{ id: 'eq-b', when: { all: [{ field: 'symbol.name', op: 'eq', value: 'X' }] } }],
-            },
-        ],
-    };
-    const out = assignModules(input);
-    assert.equal(out.membershipsBySymbol.get('Class:X')?.moduleName, 'HighPriorityContains');
-    assert.equal(out.membershipsBySymbol.get('Class:X')?.resolvedBy, 'priority');
-});

package/dist/core/ingestion/modules/config-loader.d.ts

@@ -1,2 +0,0 @@
-import { type LoadModuleConfigInput, type ModuleConfigLoadResult } from './types.js';
-export declare function loadModuleConfig(input: LoadModuleConfigInput): Promise<ModuleConfigLoadResult>;

package/dist/core/ingestion/modules/config-loader.js

@@ -1,186 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { MODULE_FIELDS, MODULE_OPERATORS, } from './types.js';
-const MODULE_CONFIG_RELATIVE_PATH = path.join('.gitnexus', 'modules.json');
-function assertObject(input, fieldPath) {
-    if (!input || typeof input !== 'object' || Array.isArray(input)) {
-        throw new Error(`${fieldPath} must be an object`);
-    }
-    return input;
-}
-function assertString(input, fieldPath) {
-    if (typeof input !== 'string' || input.trim().length === 0) {
-        throw new Error(`${fieldPath} must be a non-empty string`);
-    }
-    return input.trim();
-}
-function assertNumber(input, fieldPath) {
-    if (typeof input !== 'number' || !Number.isFinite(input)) {
-        throw new Error(`${fieldPath} must be a finite number`);
-    }
-    return input;
-}
-function toMode(input, defaultMode) {
-    if (input === undefined || input === null || input === '')
-        return defaultMode;
-    if (input === 'auto' || input === 'mixed')
-        return input;
-    throw new Error(`mode must be one of: auto, mixed`);
-}
-function validateCondition(input, fieldPath) {
-    const obj = assertObject(input, fieldPath);
-    const field = assertString(obj.field, `${fieldPath}.field`);
-    const op = assertString(obj.op, `${fieldPath}.op`);
-    if (!MODULE_FIELDS.includes(field)) {
-        throw new Error(`${fieldPath}.field must be one of: ${MODULE_FIELDS.join(', ')}`);
-    }
-    if (!MODULE_OPERATORS.includes(op)) {
-        throw new Error(`${fieldPath}.op must be one of: ${MODULE_OPERATORS.join(', ')}`);
-    }
-    const value = obj.value;
-    if (op === 'in') {
-        if (!Array.isArray(value) || value.length === 0 || value.some((v) => typeof v !== 'string' || v.length === 0)) {
-            throw new Error(`${fieldPath}.value must be a non-empty string array when op=in`);
-        }
-        return { field: field, op: 'in', value: value };
-    }
-    if (typeof value !== 'string') {
-        throw new Error(`${fieldPath}.value must be a string when op=${op}`);
-    }
-    if (op === 'regex') {
-        try {
-            new RegExp(value);
-        }
-        catch (error) {
-            throw new Error(`${fieldPath}.value regex compile failed: ${error?.message || String(error)}`);
-        }
-    }
-    return {
-        field: field,
-        op: op,
-        value,
-    };
-}
-function validateRule(input, fieldPath, seenRuleIds) {
-    const obj = assertObject(input, fieldPath);
-    const id = assertString(obj.id, `${fieldPath}.id`);
-    const existingPath = seenRuleIds.get(id);
-    if (existingPath) {
-        throw new Error(`${fieldPath}.id duplicate rule id "${id}" (already declared at ${existingPath})`);
-    }
-    seenRuleIds.set(id, `${fieldPath}.id`);
-    const priority = obj.priority === undefined ? undefined : assertNumber(obj.priority, `${fieldPath}.priority`);
-    const whenObj = assertObject(obj.when, `${fieldPath}.when`);
-    const hasAll = Array.isArray(whenObj.all);
-    const hasAny = Array.isArray(whenObj.any);
-    if (!hasAll && !hasAny) {
-        throw new Error(`${fieldPath}.when must include "all" or "any"`);
-    }
-    const all = hasAll ? whenObj.all.map((c, idx) => validateCondition(c, `${fieldPath}.when.all[${idx}]`)) : undefined;
-    const any = hasAny ? whenObj.any.map((c, idx) => validateCondition(c, `${fieldPath}.when.any[${idx}]`)) : undefined;
-    if ((all && all.length === 0) && (!any || any.length === 0)) {
-        throw new Error(`${fieldPath}.when must include at least one condition`);
-    }
-    return {
-        id,
-        priority,
-        when: { all, any },
-    };
-}
-function validateModule(input, fieldPath, seenRuleIds) {
-    const obj = assertObject(input, fieldPath);
-    const name = assertString(obj.name, `${fieldPath}.name`);
-    const defaultPriority = assertNumber(obj.defaultPriority, `${fieldPath}.defaultPriority`);
-    const rawRules = obj.rules;
-    if (rawRules !== undefined && !Array.isArray(rawRules)) {
-        throw new Error(`${fieldPath}.rules must be an array`);
-    }
-    const rules = rawRules?.map((rule, idx) => validateRule(rule, `${fieldPath}.rules[${idx}]`, seenRuleIds)) || [];
-    return { name, defaultPriority, rules };
-}
-function validateMixedConfig(input, defaultMode) {
-    const obj = assertObject(input, 'modules.json');
-    if (obj.version !== 1) {
-        throw new Error(`version must be 1`);
-    }
-    const mode = toMode(obj.mode, defaultMode);
-    if (mode !== 'mixed') {
-        // auto mode intentionally ignores module schema to keep behavior non-blocking.
-        return { version: 1, mode: 'auto', modules: [] };
-    }
-    if (!Array.isArray(obj.modules) || obj.modules.length === 0) {
-        throw new Error(`modules must be a non-empty array`);
-    }
-    const seenModuleNames = new Set();
-    const seenRuleIds = new Map();
-    const modules = obj.modules.map((mod, idx) => {
-        const normalized = validateModule(mod, `modules[${idx}]`, seenRuleIds);
-        if (seenModuleNames.has(normalized.name)) {
-            throw new Error(`modules[${idx}].name duplicate module name "${normalized.name}"`);
-        }
-        seenModuleNames.add(normalized.name);
-        return normalized;
-    });
-    return {
-        version: 1,
-        mode: 'mixed',
-        modules,
-    };
-}
-export async function loadModuleConfig(input) {
-    const defaultMode = input.defaultMode ?? 'mixed';
-    const configPath = path.join(input.repoPath, MODULE_CONFIG_RELATIVE_PATH);
-    const diagnostics = {
-        configPath,
-        usedFallbackAuto: false,
-        warnings: [],
-    };
-    if (defaultMode === 'auto') {
-        return {
-            mode: 'auto',
-            config: null,
-            diagnostics,
-            usedFallbackAuto: false,
-        };
-    }
-    let rawText;
-    try {
-        rawText = await fs.readFile(configPath, 'utf-8');
-    }
-    catch (error) {
-        if (error?.code === 'ENOENT') {
-            diagnostics.usedFallbackAuto = true;
-            diagnostics.warnings.push('modules.json missing in mixed mode, fallback to auto');
-            return {
-                mode: 'mixed',
-                config: null,
-                diagnostics,
-                usedFallbackAuto: true,
-            };
-        }
-        throw error;
-    }
-    let rawConfig;
-    try {
-        rawConfig = JSON.parse(rawText);
-    }
-    catch (error) {
-        throw new Error(`modules.json invalid JSON: ${error?.message || String(error)}`);
-    }
-    const parsedMode = toMode(assertObject(rawConfig, 'modules.json').mode, defaultMode);
-    if (parsedMode === 'auto') {
-        return {
-            mode: 'auto',
-            config: null,
-            diagnostics,
-            usedFallbackAuto: false,
-        };
-    }
-    const config = validateMixedConfig(rawConfig, defaultMode);
-    return {
-        mode: config.mode,
-        config,
-        diagnostics,
-        usedFallbackAuto: false,
-    };
-}

package/dist/core/ingestion/modules/config-loader.test.d.ts

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

package/dist/core/ingestion/modules/config-loader.test.js

@@ -1,57 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { loadModuleConfig } from './config-loader.js';
-async function makeTempRepo() {
-    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-modules-loader-'));
-    await fs.mkdir(path.join(dir, '.gitnexus'), { recursive: true });
-    return dir;
-}
-test('mixed + missing modules.json returns fallback diagnostic (no throw)', async () => {
-    const repoPath = await makeTempRepo();
-    const result = await loadModuleConfig({ repoPath, defaultMode: 'mixed' });
-    assert.equal(result.mode, 'mixed');
-    assert.equal(result.usedFallbackAuto, true);
-    assert.equal(result.config, null);
-});
-test('mixed + invalid duplicate rule id throws with location', async () => {
-    const repoPath = await makeTempRepo();
-    const cfgPath = path.join(repoPath, '.gitnexus', 'modules.json');
-    await fs.writeFile(cfgPath, JSON.stringify({
-        version: 1,
-        mode: 'mixed',
-        modules: [
-            {
-                name: 'A',
-                defaultPriority: 10,
-                rules: [{ id: 'dup', when: { all: [{ field: 'symbol.name', op: 'contains', value: 'X' }] } }],
-            },
-            {
-                name: 'B',
-                defaultPriority: 10,
-                rules: [{ id: 'dup', when: { all: [{ field: 'symbol.name', op: 'contains', value: 'Y' }] } }],
-            },
-        ],
-    }), 'utf-8');
-    await assert.rejects(loadModuleConfig({ repoPath, defaultMode: 'mixed' }), /rules\[0\]\.id.*duplicate/i);
-});
-test('valid config defaults mode to mixed when omitted', async () => {
-    const repoPath = await makeTempRepo();
-    const cfgPath = path.join(repoPath, '.gitnexus', 'modules.json');
-    await fs.writeFile(cfgPath, JSON.stringify({
-        version: 1,
-        modules: [
-            {
-                name: 'Battle',
-                defaultPriority: 100,
-                rules: [{ id: 'battle-rule', when: { all: [{ field: 'symbol.name', op: 'contains', value: 'Battle' }] } }],
-            },
-        ],
-    }), 'utf-8');
-    const result = await loadModuleConfig({ repoPath, defaultMode: 'mixed' });
-    assert.equal(result.mode, 'mixed');
-    assert.equal(result.usedFallbackAuto, false);
-    assert.equal(result.config?.modules.length, 1);
-});

package/dist/core/ingestion/modules/rule-matcher.d.ts

@@ -1,12 +0,0 @@
-import type { ModuleCondition, ModuleRule } from './types.js';
-export interface MatchableSymbol {
-    id: string;
-    name: string;
-    kind: string;
-    fqn?: string;
-    filePath: string;
-}
-export declare function matchCondition(symbol: MatchableSymbol, condition: ModuleCondition): boolean;
-export declare function matchRule(symbol: MatchableSymbol, rule: ModuleRule): boolean;
-export declare function specificityScore(condition: ModuleCondition): number;
-export declare function ruleSpecificityScore(rule: ModuleRule): number;

package/dist/core/ingestion/modules/rule-matcher.js

@@ -1,63 +0,0 @@
-function readFieldValue(symbol, field) {
-    switch (field) {
-        case 'symbol.name':
-            return symbol.name;
-        case 'symbol.kind':
-            return symbol.kind;
-        case 'symbol.fqn':
-            return symbol.fqn && symbol.fqn.length > 0 ? symbol.fqn : symbol.name;
-        case 'file.path':
-            return symbol.filePath;
-        default:
-            return '';
-    }
-}
-export function matchCondition(symbol, condition) {
-    const actual = readFieldValue(symbol, condition.field);
-    if (condition.op === 'eq') {
-        return actual === condition.value;
-    }
-    if (condition.op === 'contains') {
-        return actual.includes(String(condition.value));
-    }
-    if (condition.op === 'regex') {
-        try {
-            return new RegExp(String(condition.value)).test(actual);
-        }
-        catch {
-            return false;
-        }
-    }
-    if (condition.op === 'in') {
-        return Array.isArray(condition.value) && condition.value.includes(actual);
-    }
-    return false;
-}
-export function matchRule(symbol, rule) {
-    const hasAll = Array.isArray(rule.when.all);
-    const hasAny = Array.isArray(rule.when.any);
-    if (!hasAll && !hasAny)
-        return false;
-    const allPass = !hasAll || rule.when.all.every((cond) => matchCondition(symbol, cond));
-    const anyPass = !hasAny || rule.when.any.some((cond) => matchCondition(symbol, cond));
-    return allPass && anyPass;
-}
-export function specificityScore(condition) {
-    switch (condition.op) {
-        case 'eq':
-            return 4;
-        case 'in':
-            return 3;
-        case 'regex':
-            return 2;
-        case 'contains':
-            return 1;
-        default:
-            return 0;
-    }
-}
-export function ruleSpecificityScore(rule) {
-    const all = rule.when.all || [];
-    const any = rule.when.any || [];
-    return [...all, ...any].reduce((sum, cond) => sum + specificityScore(cond), 0);
-}

package/dist/core/ingestion/modules/rule-matcher.test.d.ts

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

package/dist/core/ingestion/modules/rule-matcher.test.js

@@ -1,58 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { matchRule, specificityScore } from './rule-matcher.js';
-const sample = {
-    id: 'Class:BattleManager',
-    name: 'BattleManager',
-    kind: 'Class',
-    filePath: 'Assets/Scripts/Battle/BattleManager.cs',
-};
-test('supports eq/contains/regex/in on symbol fields', () => {
-    assert.equal(matchRule(sample, {
-        id: 'r1',
-        when: { all: [{ field: 'symbol.kind', op: 'eq', value: 'Class' }] },
-    }), true);
-    assert.equal(matchRule(sample, {
-        id: 'r2',
-        when: { all: [{ field: 'symbol.name', op: 'contains', value: 'Battle' }] },
-    }), true);
-    assert.equal(matchRule(sample, {
-        id: 'r3',
-        when: { all: [{ field: 'symbol.name', op: 'regex', value: '^Battle.*' }] },
-    }), true);
-    assert.equal(matchRule(sample, {
-        id: 'r4',
-        when: { all: [{ field: 'file.path', op: 'in', value: ['Assets/Scripts/Battle/BattleManager.cs'] }] },
-    }), true);
-});
-test('all + any must both pass when both provided', () => {
-    const pass = matchRule(sample, {
-        id: 'all-any-pass',
-        when: {
-            all: [{ field: 'symbol.name', op: 'contains', value: 'Battle' }],
-            any: [{ field: 'symbol.kind', op: 'eq', value: 'Class' }],
-        },
-    });
-    assert.equal(pass, true);
-    const fail = matchRule(sample, {
-        id: 'all-any-fail',
-        when: {
-            all: [{ field: 'symbol.name', op: 'contains', value: 'Battle' }],
-            any: [{ field: 'symbol.kind', op: 'eq', value: 'Function' }],
-        },
-    });
-    assert.equal(fail, false);
-});
-test('symbol.fqn falls back to symbol.name when fqn missing', () => {
-    const hit = matchRule(sample, {
-        id: 'fqn-fallback',
-        when: { all: [{ field: 'symbol.fqn', op: 'contains', value: 'BattleManager' }] },
-    });
-    assert.equal(hit, true);
-});
-test('specificity score weights operators deterministically', () => {
-    assert.equal(specificityScore({ field: 'symbol.name', op: 'eq', value: 'A' }), 4);
-    assert.equal(specificityScore({ field: 'symbol.name', op: 'in', value: ['A'] }), 3);
-    assert.equal(specificityScore({ field: 'symbol.name', op: 'regex', value: '^A$' }), 2);
-    assert.equal(specificityScore({ field: 'symbol.name', op: 'contains', value: 'A' }), 1);
-});