@veewo/gitnexus 1.3.4

package/dist/benchmark/neonspark-candidates.js

@@ -0,0 +1,94 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { listRegisteredRepos } from '../storage/repo-manager.js';
+import { closeKuzu, executeQuery, initKuzu } from '../mcp/core/kuzu-adapter.js';
+const ALLOWED_PREFIXES = ['Assets/NEON/Code/', 'Packages/com.veewo.', 'Packages/com.neonspark.'];
+export function filterNeonsparkPaths(rows) {
+    return rows.filter((r) => {
+        const p = (r.file_path || '').replace(/\\/g, '/');
+        return ALLOWED_PREFIXES.some((prefix) => p.startsWith(prefix));
+    });
+}
+export function toCandidateRow(row) {
+    return {
+        symbol_uid: String(row.symbol_uid),
+        file_path: String(row.file_path),
+        symbol_name: String(row.symbol_name),
+        symbol_type: String(row.symbol_type),
+        start_line: Number(row.start_line || 0),
+        end_line: Number(row.end_line || 0),
+    };
+}
+export async function extractCandidates(repoName, outFile) {
+    const repos = await listRegisteredRepos({ validate: true });
+    const repo = repos.find((r) => r.name === repoName);
+    if (!repo)
+        throw new Error(`repo not indexed: ${repoName}`);
+    await initKuzu(repoName, path.join(repo.storagePath, 'kuzu'));
+    try {
+        const rows = await executeQuery(repoName, `
+      MATCH (s:Class)
+      RETURN s.id AS symbol_uid,
+             s.filePath AS file_path,
+             s.name AS symbol_name,
+             'Class' AS symbol_type,
+             COALESCE(s.startLine, 0) AS start_line,
+             COALESCE(s.endLine, 0) AS end_line
+      UNION
+      MATCH (s:Interface)
+      RETURN s.id AS symbol_uid,
+             s.filePath AS file_path,
+             s.name AS symbol_name,
+             'Interface' AS symbol_type,
+             COALESCE(s.startLine, 0) AS start_line,
+             COALESCE(s.endLine, 0) AS end_line
+      UNION
+      MATCH (s:Method)
+      RETURN s.id AS symbol_uid,
+             s.filePath AS file_path,
+             s.name AS symbol_name,
+             'Method' AS symbol_type,
+             COALESCE(s.startLine, 0) AS start_line,
+             COALESCE(s.endLine, 0) AS end_line
+      UNION
+      MATCH (s:Function)
+      RETURN s.id AS symbol_uid,
+             s.filePath AS file_path,
+             s.name AS symbol_name,
+             'Function' AS symbol_type,
+             COALESCE(s.startLine, 0) AS start_line,
+             COALESCE(s.endLine, 0) AS end_line
+    `);
+        const normalized = filterNeonsparkPaths(rows.map(toCandidateRow));
+        const jsonl = normalized.map((r) => JSON.stringify(r)).join('\n') + '\n';
+        await fs.mkdir(path.dirname(outFile), { recursive: true });
+        await fs.writeFile(outFile, jsonl, 'utf-8');
+        return normalized.length;
+    }
+    finally {
+        await closeKuzu(repoName);
+    }
+}
+export function parseCandidatesCliArgs(argv) {
+    if (argv.length !== 2) {
+        throw new Error('usage: node dist/benchmark/neonspark-candidates.js <repoName> <outFile>');
+    }
+    const [repoName, outFile] = argv;
+    return { repoName, outFile };
+}
+export async function mainCandidatesCli(argv = process.argv.slice(2), runExtract = extractCandidates) {
+    const { repoName, outFile } = parseCandidatesCliArgs(argv);
+    const written = await runExtract(repoName, outFile);
+    return written;
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    mainCandidatesCli()
+        .then((written) => {
+        console.log(`wrote ${written} candidate rows`);
+    })
+        .catch((error) => {
+        console.error(String(error?.message || error));
+        process.exitCode = 1;
+    });
+}

package/dist/benchmark/neonspark-candidates.test.d.ts

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

package/dist/benchmark/neonspark-candidates.test.js

@@ -0,0 +1,43 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { filterNeonsparkPaths, mainCandidatesCli, parseCandidatesCliArgs, toCandidateRow } from './neonspark-candidates.js';
+test('filterNeonsparkPaths keeps code and allowed package prefixes', () => {
+    const rows = [
+        { file_path: 'Assets/NEON/Code/Game/A.cs' },
+        { file_path: 'Packages/com.veewo.stat/Runtime/Stat.cs' },
+        { file_path: 'Packages/com.neonspark.inspector-navigator/Editor/NavigatorMenu.cs' },
+        { file_path: 'Packages/com.unity.inputsystem/Runtime/InputAction.cs' },
+    ];
+    const filtered = filterNeonsparkPaths(rows);
+    assert.equal(filtered.length, 3);
+});
+test('toCandidateRow normalizes required fields', () => {
+    const row = toCandidateRow({
+        symbol_uid: 'Method:Assets/NEON/Code/Game/A.cs:Tick',
+        file_path: 'Assets/NEON/Code/Game/A.cs',
+        symbol_name: 'Tick',
+        symbol_type: 'Method',
+        start_line: 11,
+        end_line: 22,
+    });
+    assert.equal(row.symbol_name, 'Tick');
+    assert.equal(row.start_line, 11);
+});
+test('parseCandidatesCliArgs parses repoName and outFile', () => {
+    const parsed = parseCandidatesCliArgs(['neonspark-v1', '/tmp/candidates.jsonl']);
+    assert.equal(parsed.repoName, 'neonspark-v1');
+    assert.equal(parsed.outFile, '/tmp/candidates.jsonl');
+});
+test('parseCandidatesCliArgs rejects missing required args', () => {
+    assert.throws(() => parseCandidatesCliArgs(['neonspark-v1']), /usage/i);
+    assert.throws(() => parseCandidatesCliArgs([]), /usage/i);
+});
+test('mainCandidatesCli parses args and forwards to extractor', async () => {
+    const calls = [];
+    const written = await mainCandidatesCli(['neonspark-v1', '/tmp/candidates.jsonl'], async (repoName, outFile) => {
+        calls.push({ repoName, outFile });
+        return 42;
+    });
+    assert.equal(written, 42);
+    assert.deepEqual(calls, [{ repoName: 'neonspark-v1', outFile: '/tmp/candidates.jsonl' }]);
+});

package/dist/benchmark/neonspark-materialize.d.ts

@@ -0,0 +1,19 @@
+export interface BuildSymbolRowsOptions {
+    minSelected?: number;
+    maxSelected?: number;
+}
+export declare function buildSymbolRows(candidates: any[], selectedUids: string[], options?: BuildSymbolRowsOptions): {
+    symbol_uid: string;
+    file_path: string;
+    symbol_name: string;
+    symbol_type: string;
+    start_line: number;
+    end_line: number;
+}[];
+export interface MaterializeCliArgs extends Required<BuildSymbolRowsOptions> {
+    candidatesFile: string;
+    selectedFile: string;
+    outFile: string;
+}
+export declare function parseMaterializeCliArgs(argv: string[]): MaterializeCliArgs;
+export declare function mainMaterializeCli(argv?: string[]): Promise<number>;

package/dist/benchmark/neonspark-materialize.js

@@ -0,0 +1,111 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+export function buildSymbolRows(candidates, selectedUids, options = {}) {
+    const minSelected = options.minSelected ?? 20;
+    const maxSelected = options.maxSelected ?? 20;
+    for (const [key, value] of [['minSelected', minSelected], ['maxSelected', maxSelected]]) {
+        if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
+            throw new Error(`${key} must be a finite non-negative integer, got ${value}`);
+        }
+    }
+    if (minSelected > maxSelected) {
+        throw new Error(`invalid selected symbol range: minSelected (${minSelected}) exceeds maxSelected (${maxSelected})`);
+    }
+    if (selectedUids.length < minSelected || selectedUids.length > maxSelected) {
+        if (minSelected === 20 && maxSelected === 20) {
+            throw new Error(`selected symbol count must be exactly 20, got ${selectedUids.length}`);
+        }
+        throw new Error(`selected symbol count must be between ${minSelected} and ${maxSelected}, got ${selectedUids.length}`);
+    }
+    const byUid = new Map(candidates.map((c) => [String(c.symbol_uid), c]));
+    return selectedUids.map((uid) => {
+        const row = byUid.get(uid);
+        if (!row)
+            throw new Error(`selected uid not found in candidates: ${uid}`);
+        return {
+            symbol_uid: String(row.symbol_uid),
+            file_path: String(row.file_path),
+            symbol_name: String(row.symbol_name),
+            symbol_type: String(row.symbol_type),
+            start_line: Number(row.start_line || 0),
+            end_line: Number(row.end_line || 0),
+        };
+    });
+}
+function parseNonNegativeInteger(value, flagName) {
+    if (!/^\d+$/.test(value)) {
+        throw new Error(`${flagName} must be a finite non-negative integer, got ${value}`);
+    }
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || !Number.isInteger(parsed) || parsed < 0) {
+        throw new Error(`${flagName} must be a finite non-negative integer, got ${value}`);
+    }
+    return parsed;
+}
+export function parseMaterializeCliArgs(argv) {
+    const positional = [];
+    let minSelected = 20;
+    let maxSelected = 20;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === '--min-selected' || arg === '--max-selected') {
+            const value = argv[i + 1];
+            if (value == null) {
+                throw new Error(`${arg} requires a value`);
+            }
+            const parsed = parseNonNegativeInteger(value, arg);
+            if (arg === '--min-selected')
+                minSelected = parsed;
+            if (arg === '--max-selected')
+                maxSelected = parsed;
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            throw new Error(`unknown option: ${arg}`);
+        }
+        positional.push(arg);
+    }
+    if (positional.length !== 3) {
+        throw new Error('usage: node dist/benchmark/neonspark-materialize.js <candidatesFile> <selectedFile> <outFile> [--min-selected N] [--max-selected N]');
+    }
+    if (minSelected > maxSelected) {
+        throw new Error(`invalid selected symbol range: minSelected (${minSelected}) exceeds maxSelected (${maxSelected})`);
+    }
+    const [candidatesFile, selectedFile, outFile] = positional;
+    return { candidatesFile, selectedFile, outFile, minSelected, maxSelected };
+}
+function parseJsonlRows(raw) {
+    return raw
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+}
+function parseSelectedUids(raw) {
+    return raw
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+export async function mainMaterializeCli(argv = process.argv.slice(2)) {
+    const { candidatesFile, selectedFile, outFile, minSelected, maxSelected } = parseMaterializeCliArgs(argv);
+    const candidatesRaw = await fs.readFile(candidatesFile, 'utf-8');
+    const selectedRaw = await fs.readFile(selectedFile, 'utf-8');
+    const rows = buildSymbolRows(parseJsonlRows(candidatesRaw), parseSelectedUids(selectedRaw), { minSelected, maxSelected });
+    const jsonl = rows.length > 0 ? `${rows.map((row) => JSON.stringify(row)).join('\n')}\n` : '';
+    await fs.mkdir(path.dirname(outFile), { recursive: true });
+    await fs.writeFile(outFile, jsonl, 'utf-8');
+    return rows.length;
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    mainMaterializeCli()
+        .then((written) => {
+        console.log(`wrote ${written} symbol rows`);
+    })
+        .catch((error) => {
+        console.error(String(error?.message || error));
+        process.exitCode = 1;
+    });
+}

package/dist/benchmark/neonspark-materialize.test.d.ts

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

package/dist/benchmark/neonspark-materialize.test.js

@@ -0,0 +1,124 @@
+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 { buildSymbolRows, mainMaterializeCli, parseMaterializeCliArgs } from './neonspark-materialize.js';
+test('buildSymbolRows enforces exactly 20 selected uids', () => {
+    const candidates = [{ symbol_uid: 'a' }];
+    assert.throws(() => buildSymbolRows(candidates, ['a']), /exactly 20/i);
+});
+test('buildSymbolRows maps selected uids to candidate rows', () => {
+    const c = [
+        { symbol_uid: 'u1', file_path: 'Assets/NEON/Code/A.cs', symbol_name: 'A', symbol_type: 'Class', start_line: 1, end_line: 9 },
+        { symbol_uid: 'u2', file_path: 'Assets/NEON/Code/B.cs', symbol_name: 'B', symbol_type: 'Class', start_line: 1, end_line: 9 },
+    ];
+    const ids = [...Array(20)].map((_, i) => i < 19 ? 'u1' : 'u2');
+    const rows = buildSymbolRows(c, ids);
+    assert.equal(rows.length, 20);
+});
+test('buildSymbolRows supports ranged selected uid counts', () => {
+    const c = [
+        { symbol_uid: 'u1', file_path: 'Assets/NEON/Code/A.cs', symbol_name: 'A', symbol_type: 'Class', start_line: 1, end_line: 9 },
+        { symbol_uid: 'u2', file_path: 'Assets/NEON/Code/B.cs', symbol_name: 'B', symbol_type: 'Class', start_line: 1, end_line: 9 },
+    ];
+    const ids = [...Array(40)].map((_, i) => i < 39 ? 'u1' : 'u2');
+    const rows = buildSymbolRows(c, ids, { minSelected: 40, maxSelected: 60 });
+    assert.equal(rows.length, 40);
+});
+test('buildSymbolRows rejects selection below minSelected', () => {
+    const c = [{ symbol_uid: 'u1', file_path: 'Assets/NEON/Code/A.cs', symbol_name: 'A', symbol_type: 'Class', start_line: 1, end_line: 9 }];
+    const ids = [...Array(39)].map(() => 'u1');
+    assert.throws(() => buildSymbolRows(c, ids, { minSelected: 40, maxSelected: 60 }), /between 40 and 60/i);
+});
+test('buildSymbolRows rejects selection above maxSelected', () => {
+    const c = [{ symbol_uid: 'u1', file_path: 'Assets/NEON/Code/A.cs', symbol_name: 'A', symbol_type: 'Class', start_line: 1, end_line: 9 }];
+    const ids = [...Array(61)].map(() => 'u1');
+    assert.throws(() => buildSymbolRows(c, ids, { minSelected: 40, maxSelected: 60 }), /between 40 and 60/i);
+});
+test('buildSymbolRows rejects minSelected greater than maxSelected', () => {
+    const c = [{ symbol_uid: 'u1', file_path: 'Assets/NEON/Code/A.cs', symbol_name: 'A', symbol_type: 'Class', start_line: 1, end_line: 9 }];
+    const ids = [...Array(40)].map(() => 'u1');
+    assert.throws(() => buildSymbolRows(c, ids, { minSelected: 60, maxSelected: 40 }), /invalid selected symbol range/i);
+});
+test('buildSymbolRows still validates selected uid existence when range options are used', () => {
+    const c = [{ symbol_uid: 'u1', file_path: 'Assets/NEON/Code/A.cs', symbol_name: 'A', symbol_type: 'Class', start_line: 1, end_line: 9 }];
+    const ids = [...Array(40)].map((_, i) => i < 39 ? 'u1' : 'missing');
+    assert.throws(() => buildSymbolRows(c, ids, { minSelected: 40, maxSelected: 60 }), /selected uid not found in candidates: missing/i);
+});
+test('buildSymbolRows validates minSelected and maxSelected as finite non-negative integers', () => {
+    const c = [{ symbol_uid: 'u1', file_path: 'Assets/NEON/Code/A.cs', symbol_name: 'A', symbol_type: 'Class', start_line: 1, end_line: 9 }];
+    const ids = [...Array(40)].map(() => 'u1');
+    assert.throws(() => buildSymbolRows(c, ids, { minSelected: -1, maxSelected: 60 }), /non-negative integer/i);
+    assert.throws(() => buildSymbolRows(c, ids, { minSelected: 40.5, maxSelected: 60 }), /non-negative integer/i);
+    assert.throws(() => buildSymbolRows(c, ids, { minSelected: 40, maxSelected: Number.POSITIVE_INFINITY }), /finite/i);
+});
+test('parseMaterializeCliArgs parses positional args and default selected range', () => {
+    const parsed = parseMaterializeCliArgs(['candidates.jsonl', 'selected.txt', 'symbols.jsonl']);
+    assert.equal(parsed.candidatesFile, 'candidates.jsonl');
+    assert.equal(parsed.selectedFile, 'selected.txt');
+    assert.equal(parsed.outFile, 'symbols.jsonl');
+    assert.equal(parsed.minSelected, 20);
+    assert.equal(parsed.maxSelected, 20);
+});
+test('parseMaterializeCliArgs parses --min-selected and --max-selected', () => {
+    const parsed = parseMaterializeCliArgs([
+        'candidates.jsonl',
+        'selected.txt',
+        'symbols.jsonl',
+        '--min-selected',
+        '40',
+        '--max-selected',
+        '60',
+    ]);
+    assert.equal(parsed.minSelected, 40);
+    assert.equal(parsed.maxSelected, 60);
+});
+test('parseMaterializeCliArgs rejects invalid CLI flags and values', () => {
+    assert.throws(() => parseMaterializeCliArgs(['candidates.jsonl', 'selected.txt', 'symbols.jsonl', '--min-selected', '-1']), /non-negative integer/i);
+    assert.throws(() => parseMaterializeCliArgs(['candidates.jsonl', 'selected.txt', 'symbols.jsonl', '--max-selected']), /requires a value/i);
+    assert.throws(() => parseMaterializeCliArgs(['candidates.jsonl', 'selected.txt', 'symbols.jsonl', '--unknown', '1']), /unknown option/i);
+    assert.throws(() => parseMaterializeCliArgs(['candidates.jsonl', 'selected.txt', 'symbols.jsonl', '--min-selected', '']), /non-negative integer/i);
+    assert.throws(() => parseMaterializeCliArgs(['candidates.jsonl', 'selected.txt', 'symbols.jsonl', '--min-selected', '   ']), /non-negative integer/i);
+    assert.throws(() => parseMaterializeCliArgs(['candidates.jsonl', 'selected.txt', 'symbols.jsonl', '--min-selected', '1e2']), /non-negative integer/i);
+    assert.throws(() => parseMaterializeCliArgs(['candidates.jsonl', 'selected.txt', 'symbols.jsonl', '--min-selected', '0x10']), /non-negative integer/i);
+});
+test('parseMaterializeCliArgs rejects minSelected greater than maxSelected', () => {
+    assert.throws(() => parseMaterializeCliArgs(['candidates.jsonl', 'selected.txt', 'symbols.jsonl', '--min-selected', '60', '--max-selected', '40']), /invalid selected symbol range/i);
+});
+test('mainMaterializeCli reads candidates and selected files and writes symbols jsonl', async () => {
+    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'neonspark-materialize-'));
+    const candidatesFile = path.join(tmp, 'candidates.jsonl');
+    const selectedFile = path.join(tmp, 'selected.txt');
+    const outFile = path.join(tmp, 'symbols.jsonl');
+    const candidates = [
+        { symbol_uid: 'u1', file_path: 'Assets/NEON/Code/A.cs', symbol_name: 'A', symbol_type: 'Class', start_line: 1, end_line: 9 },
+        { symbol_uid: 'u2', file_path: 'Assets/NEON/Code/B.cs', symbol_name: 'B', symbol_type: 'Class', start_line: 10, end_line: 20 },
+    ];
+    try {
+        await fs.writeFile(candidatesFile, `${JSON.stringify(candidates[0])}\n${JSON.stringify(candidates[1])}\n`, 'utf-8');
+        await fs.writeFile(selectedFile, 'u2\n', 'utf-8');
+        const written = await mainMaterializeCli([
+            candidatesFile,
+            selectedFile,
+            outFile,
+            '--min-selected',
+            '1',
+            '--max-selected',
+            '2',
+        ]);
+        assert.equal(written, 1);
+        const output = await fs.readFile(outFile, 'utf-8');
+        const rows = output
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+        assert.equal(rows.length, 1);
+        assert.equal(rows[0].symbol_uid, 'u2');
+        assert.equal(rows[0].symbol_name, 'B');
+    }
+    finally {
+        await fs.rm(tmp, { recursive: true, force: true });
+    }
+});

package/dist/benchmark/neonspark-sync.d.ts

@@ -0,0 +1,3 @@
+export declare function parseManifest(raw: string): string[];
+export declare function shouldIncludeRelativePath(relPath: string, roots: string[]): boolean;
+export declare function syncFixture(sourceRoot: string, fixtureRoot: string, manifestPath: string): Promise<number>;

package/dist/benchmark/neonspark-sync.js

@@ -0,0 +1,53 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export function parseManifest(raw) {
+    return raw
+        .split(/\r?\n/)
+        .map((s) => s.trim())
+        .filter((s) => s && !s.startsWith('#'));
+}
+function wildcardPrefix(rule) {
+    return rule.endsWith('*') ? rule.slice(0, -1) : rule;
+}
+export function shouldIncludeRelativePath(relPath, roots) {
+    const normalized = relPath.replace(/\\/g, '/');
+    if (!normalized.endsWith('.cs'))
+        return false;
+    return roots.some((rule) => {
+        const normalizedRule = rule.replace(/\\/g, '/');
+        const prefix = wildcardPrefix(normalizedRule);
+        if (normalizedRule.endsWith('*')) {
+            return normalized.startsWith(prefix);
+        }
+        return normalized === prefix || normalized.startsWith(`${prefix}/`);
+    });
+}
+async function walk(dir, base, out) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const e of entries) {
+        const full = path.join(dir, e.name);
+        if (e.isDirectory()) {
+            if (['.git', 'Library', 'Logs', 'Temp', 'Obj', 'UserSettings'].includes(e.name))
+                continue;
+            await walk(full, base, out);
+            continue;
+        }
+        const rel = path.relative(base, full).replace(/\\/g, '/');
+        out.push(rel);
+    }
+}
+export async function syncFixture(sourceRoot, fixtureRoot, manifestPath) {
+    const manifest = await fs.readFile(manifestPath, 'utf-8');
+    const roots = parseManifest(manifest);
+    const allFiles = [];
+    await walk(sourceRoot, sourceRoot, allFiles);
+    const selected = allFiles.filter((rel) => shouldIncludeRelativePath(rel, roots));
+    await fs.rm(fixtureRoot, { recursive: true, force: true });
+    for (const rel of selected) {
+        const src = path.join(sourceRoot, rel);
+        const dst = path.join(fixtureRoot, rel);
+        await fs.mkdir(path.dirname(dst), { recursive: true });
+        await fs.copyFile(src, dst);
+    }
+    return selected.length;
+}

package/dist/benchmark/neonspark-sync.test.d.ts

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

package/dist/benchmark/neonspark-sync.test.js

@@ -0,0 +1,20 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { parseManifest, shouldIncludeRelativePath } from './neonspark-sync.js';
+test('parseManifest strips comments and blank lines', () => {
+    const roots = parseManifest(`
+# main gameplay
+Assets/NEON/Code
+
+Packages/com.veewo.*
+Packages/com.neonspark.*
+`);
+    assert.deepEqual(roots, ['Assets/NEON/Code', 'Packages/com.veewo.*', 'Packages/com.neonspark.*']);
+});
+test('shouldIncludeRelativePath keeps only .cs under allowed roots', () => {
+    const roots = ['Assets/NEON/Code', 'Packages/com.veewo.*', 'Packages/com.neonspark.*'];
+    assert.equal(shouldIncludeRelativePath('Assets/NEON/Code/Game/A.cs', roots), true);
+    assert.equal(shouldIncludeRelativePath('Packages/com.veewo.stat/Runtime/Stat.cs', roots), true);
+    assert.equal(shouldIncludeRelativePath('Packages/com.unity.inputsystem/Runtime/X.cs', roots), false);
+    assert.equal(shouldIncludeRelativePath('Assets/NEON/Code/Game/A.prefab', roots), false);
+});

package/dist/benchmark/report.d.ts

@@ -0,0 +1 @@
+export declare function writeReports(reportDir: string, jsonReport: unknown, markdown: string): Promise<void>;

package/dist/benchmark/report.js

@@ -0,0 +1,7 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export async function writeReports(reportDir, jsonReport, markdown) {
+    await fs.mkdir(reportDir, { recursive: true });
+    await fs.writeFile(path.join(reportDir, 'benchmark-report.json'), JSON.stringify(jsonReport, null, 2), 'utf-8');
+    await fs.writeFile(path.join(reportDir, 'benchmark-summary.md'), markdown, 'utf-8');
+}

package/dist/benchmark/runner.d.ts

@@ -0,0 +1,48 @@
+import type { RelationCase, SymbolCase, TaskCase, Thresholds } from './types.js';
+interface Dataset {
+    thresholds: Thresholds;
+    symbols: SymbolCase[];
+    relations: RelationCase[];
+    tasks: TaskCase[];
+}
+interface ProfileConfig {
+    maxSymbols: number;
+    maxTasks: number;
+}
+interface RunBenchmarkOptions {
+    repo?: string;
+    repoAlias?: string;
+    targetPath?: string;
+    profile: ProfileConfig;
+    reportDir?: string;
+    extensions: string;
+    scopeManifest?: string;
+    scopePrefix?: string[];
+    skipAnalyze: boolean;
+}
+export interface BenchmarkResult {
+    pass: boolean;
+    failures: string[];
+    metrics: {
+        queryPrecision: number;
+        queryRecall: number;
+        contextImpactF1: number;
+        smokePassRate: number;
+        perfRegressionPct: number;
+    };
+    triage: Array<{
+        kind: string;
+        count: number;
+    }>;
+    analyze?: {
+        totalSeconds: number;
+        nodes: number;
+        edges: number;
+    };
+    reportDir: string;
+}
+export declare function resolveBenchmarkRepoName(options: Pick<RunBenchmarkOptions, 'repo' | 'repoAlias' | 'targetPath'>): string | undefined;
+export declare function hasRequiredHitFuzzy(expectedUid: string, hitUids: string[], hitNames: string[]): boolean;
+export declare function hasForbiddenUidHitStrict(forbiddenUid: string, hitUids: string[]): boolean;
+export declare function runBenchmark(ds: Dataset, options: RunBenchmarkOptions): Promise<BenchmarkResult>;
+export {};