@veewo/gitnexus 1.3.6 → 1.3.8

package/dist/cli/setup.test.js

@@ -10,16 +10,58 @@ const execFileAsync = promisify(execFile);
 const here = path.dirname(fileURLToPath(import.meta.url));
 const packageRoot = path.resolve(here, '..', '..');
 const cliPath = path.join(packageRoot, 'dist', 'cli', 'index.js');
-test('setup installs global skills under ~/.agents/skills/gitnexus', async () => {
+const packageName = JSON.parse(await fs.readFile(path.join(packageRoot, 'package.json'), 'utf-8'));
+const expectedMcpPackage = `${packageName.name || 'gitnexus'}@latest`;
+async function runSetup(args, env, cwd = packageRoot) {
+    return execFileAsync(process.execPath, [cliPath, 'setup', ...args], { cwd, env });
+}
+test('setup requires --agent', async () => {
     const fakeHome = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-setup-home-'));
     try {
-        await execFileAsync(process.execPath, [cliPath, 'setup'], {
-            cwd: packageRoot,
-            env: {
+        try {
+            await runSetup([], {
                 ...process.env,
                 HOME: fakeHome,
                 USERPROFILE: fakeHome,
-            },
+            });
+            assert.fail('expected setup without --agent to fail');
+        }
+        catch (err) {
+            assert.equal(typeof err?.stdout, 'string');
+            assert.match(err.stdout, /Missing --agent/);
+        }
+    }
+    finally {
+        await fs.rm(fakeHome, { recursive: true, force: true });
+    }
+});
+test('setup rejects invalid --agent', async () => {
+    const fakeHome = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-setup-home-'));
+    try {
+        try {
+            await runSetup(['--agent', 'cursor'], {
+                ...process.env,
+                HOME: fakeHome,
+                USERPROFILE: fakeHome,
+            });
+            assert.fail('expected setup with invalid --agent to fail');
+        }
+        catch (err) {
+            assert.equal(typeof err?.stdout, 'string');
+            assert.match(err.stdout, /Invalid --agent value/);
+        }
+    }
+    finally {
+        await fs.rm(fakeHome, { recursive: true, force: true });
+    }
+});
+test('setup installs global skills under ~/.agents/skills/gitnexus', async () => {
+    const fakeHome = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-setup-home-'));
+    try {
+        await runSetup(['--agent', 'claude'], {
+            ...process.env,
+            HOME: fakeHome,
+            USERPROFILE: fakeHome,
         });
         const skillPath = path.join(fakeHome, '.agents', 'skills', 'gitnexus', 'gitnexus-exploring', 'SKILL.md');
         const configPath = path.join(fakeHome, '.gitnexus', 'config.json');
@@ -27,7 +69,6 @@ test('setup installs global skills under ~/.agents/skills/gitnexus', async () =>
         const configRaw = await fs.readFile(configPath, 'utf-8');
         const config = JSON.parse(configRaw);
         assert.equal(config.setupScope, 'global');
-        assert.ok(true);
     }
     finally {
         await fs.rm(fakeHome, { recursive: true, force: true });
@@ -63,20 +104,17 @@ process.exit(0);
         else {
             await fs.writeFile(codexShimPath, `#!/usr/bin/env node\n${shimLogic}`, { mode: 0o755 });
         }
-        await execFileAsync(process.execPath, [cliPath, 'setup'], {
-            cwd: packageRoot,
-            env: {
-                ...process.env,
-                HOME: fakeHome,
-                USERPROFILE: fakeHome,
-                PATH: `${fakeBin}${path.delimiter}${process.env.PATH || ''}`,
-            },
+        await runSetup(['--agent', 'codex'], {
+            ...process.env,
+            HOME: fakeHome,
+            USERPROFILE: fakeHome,
+            PATH: `${fakeBin}${path.delimiter}${process.env.PATH || ''}`,
         });
         const outputPath = path.join(fakeHome, '.codex', 'gitnexus-mcp-add.json');
         const raw = await fs.readFile(outputPath, 'utf-8');
         const parsed = JSON.parse(raw);
         assert.deepEqual(parsed.args.slice(0, 4), ['mcp', 'add', 'gitnexus', '--']);
-        assert.ok(parsed.args.includes('gitnexus@latest'));
+        assert.ok(parsed.args.includes(expectedMcpPackage));
         assert.ok(parsed.args.includes('mcp'));
     }
     finally {
@@ -84,35 +122,143 @@ process.exit(0);
         await fs.rm(fakeBin, { recursive: true, force: true });
     }
 });
-test('setup with --scope project writes local MCP and repo-local skills only', async () => {
+test('setup configures OpenCode MCP in ~/.config/opencode/opencode.json', async () => {
     const fakeHome = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-setup-home-'));
-    const fakeRepo = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-setup-repo-'));
     try {
-        await execFileAsync('git', ['init'], {
-            cwd: fakeRepo,
-            env: {
-                ...process.env,
-                HOME: fakeHome,
-                USERPROFILE: fakeHome,
-            },
+        const opencodeDir = path.join(fakeHome, '.config', 'opencode');
+        await fs.mkdir(opencodeDir, { recursive: true });
+        await runSetup(['--agent', 'opencode'], {
+            ...process.env,
+            HOME: fakeHome,
+            USERPROFILE: fakeHome,
         });
-        await execFileAsync(process.execPath, [cliPath, 'setup', '--scope', 'project'], {
-            cwd: fakeRepo,
-            env: {
-                ...process.env,
-                HOME: fakeHome,
-                USERPROFILE: fakeHome,
-            },
+        const opencodeConfigPath = path.join(opencodeDir, 'opencode.json');
+        const opencodeRaw = await fs.readFile(opencodeConfigPath, 'utf-8');
+        const opencodeConfig = JSON.parse(opencodeRaw);
+        assert.equal(opencodeConfig.mcp?.gitnexus?.type, 'local');
+        assert.deepEqual(opencodeConfig.mcp?.gitnexus?.command, ['npx', '-y', expectedMcpPackage, 'mcp']);
+    }
+    finally {
+        await fs.rm(fakeHome, { recursive: true, force: true });
+    }
+});
+test('setup keeps using legacy ~/.config/opencode/config.json when it already exists', async () => {
+    const fakeHome = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-setup-home-'));
+    try {
+        const opencodeDir = path.join(fakeHome, '.config', 'opencode');
+        const legacyConfigPath = path.join(opencodeDir, 'config.json');
+        const preferredConfigPath = path.join(opencodeDir, 'opencode.json');
+        await fs.mkdir(opencodeDir, { recursive: true });
+        await fs.writeFile(legacyConfigPath, JSON.stringify({ existing: true }, null, 2), 'utf-8');
+        await runSetup(['--agent', 'opencode'], {
+            ...process.env,
+            HOME: fakeHome,
+            USERPROFILE: fakeHome,
         });
+        const legacyRaw = await fs.readFile(legacyConfigPath, 'utf-8');
+        const legacyConfig = JSON.parse(legacyRaw);
+        assert.equal(legacyConfig.existing, true);
+        assert.equal(legacyConfig.mcp?.gitnexus?.type, 'local');
+        assert.deepEqual(legacyConfig.mcp?.gitnexus?.command, ['npx', '-y', expectedMcpPackage, 'mcp']);
+        await assert.rejects(fs.access(preferredConfigPath));
+    }
+    finally {
+        await fs.rm(fakeHome, { recursive: true, force: true });
+    }
+});
+test('setup --agent opencode does not install Claude hooks', async () => {
+    const fakeHome = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-setup-home-'));
+    try {
+        const opencodeDir = path.join(fakeHome, '.config', 'opencode');
+        const claudeDir = path.join(fakeHome, '.claude');
+        const claudeSettingsPath = path.join(claudeDir, 'settings.json');
+        const claudeHookPath = path.join(claudeDir, 'hooks', 'gitnexus', 'gitnexus-hook.cjs');
+        await fs.mkdir(opencodeDir, { recursive: true });
+        await fs.mkdir(claudeDir, { recursive: true });
+        await runSetup(['--agent', 'opencode'], {
+            ...process.env,
+            HOME: fakeHome,
+            USERPROFILE: fakeHome,
+        });
+        await assert.rejects(fs.access(claudeSettingsPath));
+        await assert.rejects(fs.access(claudeHookPath));
+    }
+    finally {
+        await fs.rm(fakeHome, { recursive: true, force: true });
+    }
+});
+test('setup --scope project --agent claude writes only .mcp.json', async () => {
+    const fakeHome = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-setup-home-'));
+    const fakeRepo = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-setup-repo-'));
+    try {
+        await execFileAsync('git', ['init'], { cwd: fakeRepo });
+        await runSetup(['--scope', 'project', '--agent', 'claude'], {
+            ...process.env,
+            HOME: fakeHome,
+            USERPROFILE: fakeHome,
+        }, fakeRepo);
         const projectMcpPath = path.join(fakeRepo, '.mcp.json');
+        const codexConfigPath = path.join(fakeRepo, '.codex', 'config.toml');
+        const opencodeConfigPath = path.join(fakeRepo, 'opencode.json');
+        const projectMcpRaw = await fs.readFile(projectMcpPath, 'utf-8');
+        const projectMcp = JSON.parse(projectMcpRaw);
+        assert.equal(projectMcp.mcpServers?.gitnexus?.command, 'npx');
+        await assert.rejects(fs.access(codexConfigPath));
+        await assert.rejects(fs.access(opencodeConfigPath));
+    }
+    finally {
+        await fs.rm(fakeHome, { recursive: true, force: true });
+        await fs.rm(fakeRepo, { recursive: true, force: true });
+    }
+});
+test('setup --scope project --agent codex writes only .codex/config.toml', async () => {
+    const fakeHome = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-setup-home-'));
+    const fakeRepo = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-setup-repo-'));
+    try {
+        await execFileAsync('git', ['init'], { cwd: fakeRepo });
+        await runSetup(['--scope', 'project', '--agent', 'codex'], {
+            ...process.env,
+            HOME: fakeHome,
+            USERPROFILE: fakeHome,
+        }, fakeRepo);
+        const projectMcpPath = path.join(fakeRepo, '.mcp.json');
+        const codexConfigPath = path.join(fakeRepo, '.codex', 'config.toml');
+        const opencodeConfigPath = path.join(fakeRepo, 'opencode.json');
+        const codexConfigRaw = await fs.readFile(codexConfigPath, 'utf-8');
+        assert.match(codexConfigRaw, /\[mcp_servers\.gitnexus\]/);
+        assert.match(codexConfigRaw, /command = "npx"/);
+        await assert.rejects(fs.access(projectMcpPath));
+        await assert.rejects(fs.access(opencodeConfigPath));
+    }
+    finally {
+        await fs.rm(fakeHome, { recursive: true, force: true });
+        await fs.rm(fakeRepo, { recursive: true, force: true });
+    }
+});
+test('setup --scope project --agent opencode writes only opencode.json', async () => {
+    const fakeHome = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-setup-home-'));
+    const fakeRepo = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-setup-repo-'));
+    try {
+        await execFileAsync('git', ['init'], { cwd: fakeRepo });
+        await runSetup(['--scope', 'project', '--agent', 'opencode'], {
+            ...process.env,
+            HOME: fakeHome,
+            USERPROFILE: fakeHome,
+        }, fakeRepo);
+        const projectMcpPath = path.join(fakeRepo, '.mcp.json');
+        const codexConfigPath = path.join(fakeRepo, '.codex', 'config.toml');
+        const opencodeConfigPath = path.join(fakeRepo, 'opencode.json');
         const localSkillPath = path.join(fakeRepo, '.agents', 'skills', 'gitnexus', 'gitnexus-exploring', 'SKILL.md');
         const globalSkillPath = path.join(fakeHome, '.agents', 'skills', 'gitnexus', 'gitnexus-exploring', 'SKILL.md');
         const configPath = path.join(fakeHome, '.gitnexus', 'config.json');
-        const projectMcpRaw = await fs.readFile(projectMcpPath, 'utf-8');
-        const projectMcp = JSON.parse(projectMcpRaw);
+        const opencodeRaw = await fs.readFile(opencodeConfigPath, 'utf-8');
+        const opencodeConfig = JSON.parse(opencodeRaw);
         const configRaw = await fs.readFile(configPath, 'utf-8');
         const config = JSON.parse(configRaw);
-        assert.equal(projectMcp.mcpServers?.gitnexus?.command, 'npx');
+        assert.equal(opencodeConfig.mcp?.gitnexus?.type, 'local');
+        assert.deepEqual(opencodeConfig.mcp?.gitnexus?.command, ['npx', '-y', expectedMcpPackage, 'mcp']);
+        await assert.rejects(fs.access(projectMcpPath));
+        await assert.rejects(fs.access(codexConfigPath));
         await fs.access(localSkillPath);
         await assert.rejects(fs.access(globalSkillPath));
         assert.equal(config.setupScope, 'project');

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

@@ -0,0 +1,33 @@
+import type { CommunityMembership, CommunityNode } from '../community-processor.js';
+import type { ModuleConfig, ModuleMode } from './types.js';
+import { type MatchableSymbol } from './rule-matcher.js';
+export type AssignmentSource = 'config-rule' | 'auto-fallback';
+export type AssignmentResolvedBy = 'priority' | 'specificity' | 'rule-order' | 'module-lexicographic' | 'fallback-auto';
+export interface AssignmentInput {
+    mode: ModuleMode;
+    symbols: MatchableSymbol[];
+    autoCommunities: CommunityNode[];
+    autoMemberships: CommunityMembership[];
+    config: ModuleConfig | null;
+}
+export interface SymbolAssignment {
+    symbolId: string;
+    moduleName: string;
+    communityId: string;
+    assignmentSource: AssignmentSource;
+    matchedRuleId?: string;
+    resolvedBy: AssignmentResolvedBy;
+}
+export interface AssignmentDiagnostics {
+    mode: ModuleMode;
+    configuredModuleCount: number;
+    finalModuleCount: number;
+    emptyModules: string[];
+}
+export interface AssignmentOutput {
+    finalModules: CommunityNode[];
+    finalMemberships: CommunityMembership[];
+    membershipsBySymbol: Map<string, SymbolAssignment>;
+    diagnostics: AssignmentDiagnostics;
+}
+export declare function assignModules(input: AssignmentInput): AssignmentOutput;

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

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

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

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

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

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