@veewo/gitnexus 1.3.8 → 1.3.10

package/hooks/check-release-path-hygiene.mjs

@@ -0,0 +1,108 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(scriptDir, '..', '..');
+
+const FORBIDDEN_ABSOLUTE_PATTERNS = [
+  /\/Volumes\/[^"'`\s]*unity-projects\/neonspark/g,
+  /\/Users\/[^"'`\s]*unity-projects\/neonspark/g,
+];
+
+const RELEASE_FILES = [
+  'gitnexus/package.json',
+  'benchmarks/u2-e2e/neonspark-full-u2-e2e.config.json',
+];
+
+const RELEASE_DIR_RULES = [
+  { root: '.github/workflows', exts: new Set(['.yml', '.yaml']) },
+  { root: 'gitnexus/src', exts: new Set(['.ts']) },
+];
+
+function shouldScan(relPath) {
+  if (RELEASE_FILES.includes(relPath)) {
+    return true;
+  }
+
+  for (const rule of RELEASE_DIR_RULES) {
+    if (!relPath.startsWith(`${rule.root}/`)) continue;
+    if (relPath.endsWith('.test.ts')) return false;
+    if (rule.exts.has(path.extname(relPath))) return true;
+  }
+
+  return false;
+}
+
+async function walk(dir) {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  const out = [];
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...(await walk(fullPath)));
+    } else if (entry.isFile()) {
+      out.push(fullPath);
+    }
+  }
+  return out;
+}
+
+async function collectReleaseFiles() {
+  const roots = ['.github/workflows', 'gitnexus/src'];
+  const fullPaths = [];
+  for (const root of roots) {
+    const abs = path.join(repoRoot, root);
+    try {
+      fullPaths.push(...(await walk(abs)));
+    } catch (error) {
+      const code = error && typeof error === 'object' ? error.code : undefined;
+      if (code !== 'ENOENT') throw error;
+    }
+  }
+
+  for (const rel of RELEASE_FILES) {
+    fullPaths.push(path.join(repoRoot, rel));
+  }
+
+  const dedup = new Map();
+  for (const full of fullPaths) {
+    const rel = path.relative(repoRoot, full).split(path.sep).join('/');
+    if (!shouldScan(rel)) continue;
+    dedup.set(rel, full);
+  }
+  return [...dedup.entries()];
+}
+
+async function main() {
+  const files = await collectReleaseFiles();
+  const hits = [];
+
+  for (const [relPath, absPath] of files) {
+    const content = await fs.readFile(absPath, 'utf-8');
+    for (const pattern of FORBIDDEN_ABSOLUTE_PATTERNS) {
+      const matched = content.match(pattern);
+      if (matched && matched.length > 0) {
+        hits.push({ relPath, matched: matched[0], pattern: String(pattern) });
+      }
+    }
+  }
+
+  if (hits.length > 0) {
+    process.stderr.write('Release path hygiene check failed.\n');
+    for (const hit of hits) {
+      process.stderr.write(
+        `- ${hit.relPath}: contains "${hit.matched}" (pattern: ${hit.pattern})\n`,
+      );
+    }
+    process.exitCode = 1;
+    return;
+  }
+
+  process.stdout.write('Release path hygiene check passed.\n');
+}
+
+main().catch((error) => {
+  process.stderr.write(`${error instanceof Error ? error.stack || error.message : String(error)}\n`);
+  process.exitCode = 1;
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veewo/gitnexus",
-  "version": "1.3.8",
+  "version": "1.3.10",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",
@@ -36,18 +36,25 @@
     "vendor"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "rm -rf dist && tsc",
     "dev": "tsx watch src/cli/index.ts",
     "prepare": "npm run build",
-    "test:benchmark": "npm run build && node --test dist/benchmark/*.test.js dist/cli/*.test.js",
+    "check:release-paths": "node hooks/check-release-path-hygiene.mjs",
+    "check:neonspark-target": "node -e \"const p=(process.env.GITNEXUS_NEONSPARK_TARGET_PATH||'').trim();if(!p){console.error('Missing env: GITNEXUS_NEONSPARK_TARGET_PATH');process.exit(1);}\"",
+    "check:u2-e2e-target": "node -e \"const p=(process.env.GITNEXUS_U2_E2E_TARGET_PATH||'').trim();if(!p){console.error('Missing env: GITNEXUS_U2_E2E_TARGET_PATH');process.exit(1);}\"",
+    "test:unity": "npm run build && node --test dist/core/unity/*.test.js",
+    "test:u3:gates": "npm run check:release-paths && npm run build && node --test dist/benchmark/u2-e2e/*.test.js dist/mcp/local/unity-enrichment.test.js dist/core/ingestion/unity-resource-processor.test.js",
+    "test:benchmark": "npm run build && node --test dist/benchmark/*.test.js && node --test dist/cli/*.test.js",
     "benchmark:quick": "npm run build && node dist/cli/index.js benchmark-unity ../benchmarks/unity-baseline/v1 --profile quick --target-path ../benchmarks/fixtures/unity-mini",
     "benchmark:full": "npm run build && node dist/cli/index.js benchmark-unity ../benchmarks/unity-baseline/v1 --profile full --target-path ../benchmarks/fixtures/unity-mini",
-    "benchmark:neonspark:full": "npm run build && node dist/cli/index.js benchmark-unity ../benchmarks/unity-baseline/neonspark-v1 --profile full --target-path /Volumes/Shuttle/unity-projects/neonspark --repo-alias neonspark-v1-subset --scope-manifest ../benchmarks/unity-baseline/neonspark-v1/sync-manifest.txt",
-    "benchmark:neonspark:quick": "npm run build && node dist/cli/index.js benchmark-unity ../benchmarks/unity-baseline/neonspark-v1 --profile quick --target-path /Volumes/Shuttle/unity-projects/neonspark --repo-alias neonspark-v1-subset --scope-manifest ../benchmarks/unity-baseline/neonspark-v1/sync-manifest.txt",
-    "benchmark:neonspark:v2:full": "npm run build && node dist/cli/index.js benchmark-unity ../benchmarks/unity-baseline/neonspark-v2 --profile full --target-path /Volumes/Shuttle/unity-projects/neonspark --repo-alias neonspark-v1-subset --scope-manifest ../benchmarks/unity-baseline/neonspark-v2/sync-manifest.txt",
-    "benchmark:neonspark:v2:quick": "npm run build && node dist/cli/index.js benchmark-unity ../benchmarks/unity-baseline/neonspark-v2 --profile quick --target-path /Volumes/Shuttle/unity-projects/neonspark --repo-alias neonspark-v1-subset --scope-manifest ../benchmarks/unity-baseline/neonspark-v2/sync-manifest.txt",
-    "benchmark:agent-context:quick": "npm run build && node dist/cli/index.js benchmark-agent-context ../benchmarks/agent-context/neonspark-refactor-v1 --profile quick --target-path /Volumes/Shuttle/unity-projects/neonspark --repo-alias neonspark-v1-subset --scope-manifest ../benchmarks/unity-baseline/neonspark-v2/sync-manifest.txt",
-    "benchmark:agent-context:full": "npm run build && node dist/cli/index.js benchmark-agent-context ../benchmarks/agent-context/neonspark-refactor-v1 --profile full --target-path /Volumes/Shuttle/unity-projects/neonspark --repo-alias neonspark-v1-subset --scope-manifest ../benchmarks/unity-baseline/neonspark-v2/sync-manifest.txt"
+    "benchmark:neonspark:full": "npm run check:neonspark-target && npm run build && node dist/cli/index.js benchmark-unity ../benchmarks/unity-baseline/neonspark-v1 --profile full --target-path \"$GITNEXUS_NEONSPARK_TARGET_PATH\" --repo-alias neonspark-v1-subset --scope-manifest ../benchmarks/unity-baseline/neonspark-v1/sync-manifest.txt",
+    "benchmark:neonspark:quick": "npm run check:neonspark-target && npm run build && node dist/cli/index.js benchmark-unity ../benchmarks/unity-baseline/neonspark-v1 --profile quick --target-path \"$GITNEXUS_NEONSPARK_TARGET_PATH\" --repo-alias neonspark-v1-subset --scope-manifest ../benchmarks/unity-baseline/neonspark-v1/sync-manifest.txt",
+    "benchmark:neonspark:v2:full": "npm run check:neonspark-target && npm run build && node dist/cli/index.js benchmark-unity ../benchmarks/unity-baseline/neonspark-v2 --profile full --target-path \"$GITNEXUS_NEONSPARK_TARGET_PATH\" --repo-alias neonspark-v1-subset --scope-manifest ../benchmarks/unity-baseline/neonspark-v2/sync-manifest.txt",
+    "benchmark:neonspark:v2:quick": "npm run check:neonspark-target && npm run build && node dist/cli/index.js benchmark-unity ../benchmarks/unity-baseline/neonspark-v2 --profile quick --target-path \"$GITNEXUS_NEONSPARK_TARGET_PATH\" --repo-alias neonspark-v1-subset --scope-manifest ../benchmarks/unity-baseline/neonspark-v2/sync-manifest.txt",
+    "benchmark:agent-context:quick": "npm run check:neonspark-target && npm run build && node dist/cli/index.js benchmark-agent-context ../benchmarks/agent-context/neonspark-refactor-v1 --profile quick --target-path \"$GITNEXUS_NEONSPARK_TARGET_PATH\" --repo-alias neonspark-v1-subset --scope-manifest ../benchmarks/unity-baseline/neonspark-v2/sync-manifest.txt",
+    "benchmark:agent-context:full": "npm run check:neonspark-target && npm run build && node dist/cli/index.js benchmark-agent-context ../benchmarks/agent-context/neonspark-refactor-v1 --profile full --target-path \"$GITNEXUS_NEONSPARK_TARGET_PATH\" --repo-alias neonspark-v1-subset --scope-manifest ../benchmarks/unity-baseline/neonspark-v2/sync-manifest.txt",
+    "benchmark:u2:sample": "npm run build && node dist/benchmark/u2-performance-sampler.js",
+    "benchmark:u2:e2e": "npm run check:u2-e2e-target && npm run build && node dist/cli/index.js benchmark-u2-e2e --config ../benchmarks/u2-e2e/neonspark-full-u2-e2e.config.json"
   },
   "dependencies": {
     "@huggingface/transformers": "^3.0.0",

package/dist/cli/analyze-custom-modules-regression.test.js

@@ -1,75 +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 { runPipelineFromRepo } from '../core/ingestion/pipeline.js';
-const FIXTURE_REPO = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../../benchmarks/fixtures/unity-mini');
-async function copyFixtureRepo() {
-    const tmpRepo = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-custom-modules-'));
-    await fs.cp(FIXTURE_REPO, tmpRepo, { recursive: true });
-    await fs.mkdir(path.join(tmpRepo, '.gitnexus'), { recursive: true });
-    return tmpRepo;
-}
-test('pipeline mixed mode writes config module + auto fallback memberships', { timeout: 120_000 }, async () => {
-    const repoPath = await copyFixtureRepo();
-    const configPath = path.join(repoPath, '.gitnexus', 'modules.json');
-    await fs.writeFile(configPath, JSON.stringify({
-        version: 1,
-        mode: 'mixed',
-        modules: [
-            {
-                name: 'Factory',
-                defaultPriority: 100,
-                rules: [
-                    {
-                        id: 'factory-file-rule',
-                        when: {
-                            all: [{ field: 'file.path', op: 'contains', value: 'MinionFactory.cs' }],
-                        },
-                    },
-                ],
-            },
-            {
-                name: 'Battle',
-                defaultPriority: 100,
-                rules: [],
-            },
-        ],
-    }), 'utf-8');
-    const result = await runPipelineFromRepo(repoPath, () => { }, { includeExtensions: ['.cs'] });
-    const communities = [...result.graph.iterNodes()].filter((n) => n.label === 'Community');
-    const memberships = [...result.graph.iterRelationships()].filter((r) => r.type === 'MEMBER_OF');
-    const commById = new Map(communities.map((c) => [c.id, c]));
-    const labels = communities.map((c) => String(c.properties.heuristicLabel || c.properties.name || c.id));
-    assert.ok(labels.includes('Factory'));
-    assert.ok(labels.includes('Battle'));
-    const createMembership = memberships.find((m) => m.sourceId.includes('MinionFactory.cs:Create'));
-    assert.ok(createMembership);
-    const targetCommunity = commById.get(createMembership.targetId);
-    assert.ok(targetCommunity);
-    assert.equal(String(targetCommunity.properties.heuristicLabel), 'Factory');
-    const uniquePerSymbol = new Set(memberships.map((m) => m.sourceId));
-    assert.equal(uniquePerSymbol.size, memberships.length);
-    const battleCommunity = communities.find((c) => String(c.properties.heuristicLabel) === 'Battle');
-    assert.ok(battleCommunity);
-    assert.ok(!memberships.some((m) => m.targetId === battleCommunity.id));
-    const membershipCommunities = new Set(memberships.map((m) => m.targetId));
-    const processCommunities = new Set((result.processResult?.processes || []).flatMap((p) => p.communities || []));
-    for (const processCommunity of processCommunities) {
-        assert.ok(membershipCommunities.has(processCommunity));
-    }
-});
-test('pipeline mixed + invalid modules.json fails fast', { timeout: 120_000 }, async () => {
-    const repoPath = await copyFixtureRepo();
-    const configPath = path.join(repoPath, '.gitnexus', 'modules.json');
-    await fs.writeFile(configPath, JSON.stringify({
-        version: 1,
-        mode: 'mixed',
-        modules: [
-            { name: 'Dup', defaultPriority: 100, rules: [] },
-            { name: 'Dup', defaultPriority: 100, rules: [] },
-        ],
-    }), 'utf-8');
-    await assert.rejects(runPipelineFromRepo(repoPath, () => { }, { includeExtensions: ['.cs'] }), /duplicate module name/i);
-});

package/dist/cli/analyze-modules-diagnostics.test.js

@@ -1,36 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { formatModuleDiagnostics } from './analyze.js';
-test('prints one-time fallback warning for mixed + missing modules.json', () => {
-    const lines = formatModuleDiagnostics({
-        mode: 'mixed',
-        usedFallbackAuto: true,
-        warnings: ['modules.json missing in mixed mode, fallback to auto'],
-        emptyModules: [],
-        configuredModuleCount: 0,
-        finalModuleCount: 3,
-    });
-    assert.ok(lines.some((line) => /fallback to auto/i.test(line)));
-});
-test('prints warning for empty modules', () => {
-    const lines = formatModuleDiagnostics({
-        mode: 'mixed',
-        usedFallbackAuto: false,
-        warnings: [],
-        emptyModules: ['Battle'],
-        configuredModuleCount: 1,
-        finalModuleCount: 2,
-    });
-    assert.ok(lines.some((line) => /empty module/i.test(line)));
-    assert.ok(lines.some((line) => /Battle/.test(line)));
-});
-test('README mentions modules.json mode semantics and fallback behavior', async () => {
-    const here = path.dirname(fileURLToPath(import.meta.url));
-    const readmePath = path.resolve(here, '../../README.md');
-    const readme = await fs.readFile(readmePath, 'utf-8');
-    assert.match(readme, /\.gitnexus\/modules\.json/);
-    assert.match(readme, /mixed.*fallback.*auto/i);
-});

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

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

@@ -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.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>;