@veewo/gitnexus 1.3.4

package/dist/benchmark/agent-context/report.test.js

@@ -0,0 +1,85 @@
+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 { writeAgentContextReports } from './report.js';
+test('writes benchmark-report.json and benchmark-summary.md with scenario breakdown', async () => {
+    const outDir = await fs.mkdtemp(path.join(os.tmpdir(), 'agent-context-report-'));
+    const result = {
+        pass: true,
+        failures: [],
+        reportDir: outDir,
+        metrics: {
+            avgCoverage: 1,
+            avgToolCalls: 3,
+            mandatoryTargetPassRate: 1,
+        },
+        scenarios: [
+            {
+                scenarioId: 'sample-refactor-context',
+                targetUid: 'Class:Sample:Target',
+                toolCalls: 3,
+                coverage: 1,
+                gatePass: true,
+                checks: [
+                    { id: 'T', pass: true },
+                    { id: 'E', pass: true },
+                ],
+                stepOutputs: [],
+            },
+        ],
+    };
+    await writeAgentContextReports(outDir, result);
+    const jsonPath = path.join(outDir, 'benchmark-report.json');
+    const mdPath = path.join(outDir, 'benchmark-summary.md');
+    await fs.access(jsonPath);
+    await fs.access(mdPath);
+    const summary = await fs.readFile(mdPath, 'utf-8');
+    assert.match(summary, /sample-refactor-context/);
+    assert.match(summary, /coverage/i);
+});
+test('summary includes failure classes and triage order for failing runs', async () => {
+    const outDir = await fs.mkdtemp(path.join(os.tmpdir(), 'agent-context-report-fail-'));
+    const result = {
+        pass: false,
+        failures: ['scenario.a.coverage', 'suite.coverage'],
+        reportDir: outDir,
+        metrics: {
+            avgCoverage: 0.6,
+            avgToolCalls: 3,
+            mandatoryTargetPassRate: 1,
+        },
+        scenarios: [
+            {
+                scenarioId: 'a',
+                targetUid: 'Class:Sample:A',
+                toolCalls: 3,
+                coverage: 0.5,
+                gatePass: false,
+                checks: [
+                    { id: 'U', pass: false, detail: 'incoming refs 1 < 8' },
+                    { id: 'D', pass: false, detail: 'outgoing refs 2 < 8' },
+                ],
+                stepOutputs: [],
+            },
+            {
+                scenarioId: 'b',
+                targetUid: 'Class:Sample:B',
+                toolCalls: 3,
+                coverage: 0.7,
+                gatePass: false,
+                checks: [
+                    { id: 'U', pass: false, detail: 'incoming refs 2 < 6' },
+                    { id: 'I', pass: false, detail: 'internal anchors matched 0 < 2' },
+                ],
+                stepOutputs: [],
+            },
+        ],
+    };
+    await writeAgentContextReports(outDir, result);
+    const summary = await fs.readFile(path.join(outDir, 'benchmark-summary.md'), 'utf-8');
+    assert.match(summary, /Top Failure Classes/i);
+    assert.match(summary, /Recommended Triage Order/i);
+    assert.match(summary, /U/);
+});

package/dist/benchmark/agent-context/runner.d.ts

@@ -0,0 +1,46 @@
+import type { AgentContextCheckResult, AgentContextDataset, AgentContextToolStep } from './types.js';
+export interface AgentContextToolRunner {
+    query: (params: any) => Promise<any>;
+    context: (params: any) => Promise<any>;
+    impact: (params: any) => Promise<any>;
+    cypher: (params: any) => Promise<any>;
+    close: () => Promise<void>;
+}
+export interface AgentContextScenarioRun {
+    scenarioId: string;
+    targetUid: string;
+    toolCalls: number;
+    coverage: number;
+    checks: AgentContextCheckResult[];
+    gatePass: boolean;
+    stepOutputs: Array<{
+        tool: string;
+        input: Record<string, unknown>;
+        output: any;
+    }>;
+}
+export interface AgentContextBenchmarkResult {
+    pass: boolean;
+    failures: string[];
+    reportDir: string;
+    metrics: {
+        avgCoverage: number;
+        avgToolCalls: number;
+        mandatoryTargetPassRate: number;
+    };
+    scenarios: AgentContextScenarioRun[];
+}
+export interface RunAgentContextBenchmarkOptions {
+    repo?: string;
+    reportDir?: string;
+    profile?: {
+        maxScenarios: number;
+    };
+    runner?: AgentContextToolRunner;
+}
+export declare function executeToolPlan(plan: AgentContextToolStep[], runner: AgentContextToolRunner, repo?: string): Promise<Array<{
+    tool: string;
+    input: Record<string, unknown>;
+    output: any;
+}>>;
+export declare function runAgentContextBenchmark(dataset: AgentContextDataset, options: RunAgentContextBenchmarkOptions): Promise<AgentContextBenchmarkResult>;

package/dist/benchmark/agent-context/runner.js

@@ -0,0 +1,111 @@
+import path from 'node:path';
+import { evaluateScenarioChecks } from './evaluators.js';
+import { createAgentContextToolRunner } from './tool-runner.js';
+function buildToolInput(step, repo) {
+    const input = { ...step.input };
+    if (repo) {
+        input.repo = repo;
+    }
+    // LocalBackend impact contract uses `target_uid`, while dataset rows may carry `uid`.
+    if (step.tool === 'impact') {
+        const uid = input.uid;
+        if (typeof uid === 'string' && uid.trim() && !input.target_uid) {
+            input.target_uid = uid;
+        }
+    }
+    return input;
+}
+function callTool(runner, step, repo) {
+    const params = buildToolInput(step, repo);
+    if (step.tool === 'query') {
+        return runner.query(params);
+    }
+    if (step.tool === 'context') {
+        return runner.context(params);
+    }
+    if (step.tool === 'impact') {
+        return runner.impact(params);
+    }
+    return runner.cypher(params);
+}
+export async function executeToolPlan(plan, runner, repo) {
+    const outputs = [];
+    for (const step of plan) {
+        const input = buildToolInput(step, repo);
+        const output = await callTool(runner, step, repo);
+        outputs.push({ tool: step.tool, input, output });
+    }
+    return outputs;
+}
+function computeCoverage(checks) {
+    if (checks.length === 0) {
+        return 0;
+    }
+    const passed = checks.filter((check) => check.pass).length;
+    return passed / checks.length;
+}
+export async function runAgentContextBenchmark(dataset, options) {
+    const reportDir = path.resolve(options.reportDir || '.gitnexus/benchmark-agent-context');
+    const scenariosToRun = options.profile?.maxScenarios && Number.isFinite(options.profile.maxScenarios)
+        ? dataset.scenarios.slice(0, options.profile.maxScenarios)
+        : dataset.scenarios;
+    const runner = options.runner || (await createAgentContextToolRunner());
+    const ownsRunner = !options.runner;
+    const scenarioRuns = [];
+    const failures = [];
+    try {
+        for (const scenario of scenariosToRun) {
+            const stepOutputs = await executeToolPlan(scenario.tool_plan, runner, options.repo);
+            const checkResults = evaluateScenarioChecks(stepOutputs.map((entry) => entry.output), scenario.checks, {
+                targetUid: scenario.target_uid,
+                toolCalls: stepOutputs.length,
+            });
+            const coverage = computeCoverage(checkResults);
+            const targetCheck = checkResults.find((check) => check.id === 'T');
+            const gatePass = Boolean(targetCheck?.pass) && coverage >= dataset.thresholds.coverage.minPerScenario;
+            scenarioRuns.push({
+                scenarioId: scenario.scenario_id,
+                targetUid: scenario.target_uid,
+                toolCalls: stepOutputs.length,
+                coverage,
+                checks: checkResults,
+                gatePass,
+                stepOutputs,
+            });
+        }
+    }
+    finally {
+        if (ownsRunner) {
+            await runner.close();
+        }
+    }
+    const avgCoverage = scenarioRuns.length === 0 ? 0 : scenarioRuns.reduce((acc, scenario) => acc + scenario.coverage, 0) / scenarioRuns.length;
+    const avgToolCalls = scenarioRuns.length === 0 ? 0 : scenarioRuns.reduce((acc, scenario) => acc + scenario.toolCalls, 0) / scenarioRuns.length;
+    const targetPassCount = scenarioRuns.filter((scenario) => scenario.checks.some((check) => check.id === 'T' && check.pass)).length;
+    const mandatoryTargetPassRate = scenarioRuns.length === 0 ? 0 : targetPassCount / scenarioRuns.length;
+    for (const scenario of scenarioRuns) {
+        if (!scenario.checks.some((check) => check.id === 'T' && check.pass)) {
+            failures.push(`scenario.${scenario.scenarioId}.target`);
+        }
+        if (scenario.coverage < dataset.thresholds.coverage.minPerScenario) {
+            failures.push(`scenario.${scenario.scenarioId}.coverage`);
+        }
+    }
+    if (avgCoverage < dataset.thresholds.coverage.suiteAvgMin) {
+        failures.push('suite.coverage');
+    }
+    if (avgToolCalls > dataset.thresholds.efficiency.suiteAvgMax) {
+        failures.push('suite.efficiency');
+    }
+    return {
+        pass: failures.length === 0,
+        failures,
+        reportDir,
+        metrics: {
+            avgCoverage,
+            avgToolCalls,
+            mandatoryTargetPassRate,
+        },
+        scenarios: scenarioRuns,
+    };
+}

package/dist/benchmark/agent-context/runner.test.d.ts

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

package/dist/benchmark/agent-context/runner.test.js

@@ -0,0 +1,79 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { executeToolPlan, runAgentContextBenchmark } from './runner.js';
+test('runner computes per-scenario coverage and suite averages', async () => {
+    const dataset = {
+        thresholds: {
+            coverage: { minPerScenario: 0.5, suiteAvgMin: 0.5 },
+            efficiency: { maxToolCallsPerScenario: 4, suiteAvgMax: 4 },
+        },
+        scenarios: [
+            {
+                scenario_id: 'sample-refactor-context',
+                target_uid: 'Class:Sample:Target',
+                tool_plan: [
+                    { tool: 'query', input: { query: 'Target' } },
+                    { tool: 'context', input: { uid: 'Class:Sample:Target' } },
+                    { tool: 'impact', input: { target: 'Target', direction: 'upstream' } },
+                ],
+                checks: [
+                    { id: 'T', required_uid: 'Class:Sample:Target' },
+                    { id: 'U', min_incoming: 1 },
+                    { id: 'D', min_outgoing: 1 },
+                    { id: 'B', min_impacted: 1 },
+                    { id: 'I', internal_anchors: ['AddMinion'], min_internal_hits: 1 },
+                    { id: 'E', max_tool_calls: 4 },
+                ],
+            },
+        ],
+    };
+    const fakeRunner = {
+        query: async () => ({
+            process_symbols: [{ id: 'Class:Sample:Target', name: 'Target' }],
+            definitions: [{ id: 'Method:Sample:AddMinion', name: 'AddMinion' }],
+            symbol: { uid: 'Class:Sample:Target', name: 'Target' },
+        }),
+        context: async () => ({
+            incoming: { depth_1: [{ id: 'Caller:1' }] },
+            outgoing: { depth_1: [{ id: 'Callee:1' }] },
+            symbol: { uid: 'Class:Sample:Target', name: 'Target' },
+        }),
+        impact: async () => ({
+            impactedCount: 3,
+            target: { id: 'Class:Sample:Target', name: 'Target' },
+        }),
+        cypher: async () => ({ rows: [] }),
+        close: async () => { },
+    };
+    const result = await runAgentContextBenchmark(dataset, {
+        repo: 'sample-repo',
+        runner: fakeRunner,
+    });
+    assert.ok(result.metrics.avgCoverage > 0);
+    assert.ok(result.scenarios[0].checks.length > 0);
+});
+test('executeToolPlan maps impact uid to target_uid for backend impact contract', async () => {
+    const calls = [];
+    const fakeRunner = {
+        query: async () => ({}),
+        context: async () => ({}),
+        impact: async (params) => {
+            calls.push(params);
+            return { impactedCount: 1 };
+        },
+        cypher: async () => ({}),
+        close: async () => { },
+    };
+    await executeToolPlan([
+        {
+            tool: 'impact',
+            input: {
+                target: 'MirrorNetMgr',
+                uid: 'Class:Assets/NEON/Code/NetworkCode/NeonMgr/MirrorNetMgr.cs:MirrorNetMgr',
+                direction: 'upstream',
+            },
+        },
+    ], fakeRunner, 'neonspark-v1-subset');
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0].target_uid, 'Class:Assets/NEON/Code/NetworkCode/NeonMgr/MirrorNetMgr.cs:MirrorNetMgr');
+});

package/dist/benchmark/agent-context/tool-runner.d.ts

@@ -0,0 +1,7 @@
+export declare function createAgentContextToolRunner(): Promise<{
+    query: (params: any) => Promise<any>;
+    context: (params: any) => Promise<any>;
+    impact: (params: any) => Promise<any>;
+    cypher: (params: any) => Promise<any>;
+    close: () => Promise<void>;
+}>;

package/dist/benchmark/agent-context/tool-runner.js

@@ -0,0 +1,18 @@
+import { closeKuzu } from '../../mcp/core/kuzu-adapter.js';
+import { LocalBackend } from '../../mcp/local/local-backend.js';
+export async function createAgentContextToolRunner() {
+    const backend = new LocalBackend();
+    const ok = await backend.init();
+    if (!ok) {
+        throw new Error('No indexed repositories found. Run analyze first.');
+    }
+    return {
+        query: (params) => backend.callTool('query', params),
+        context: (params) => backend.callTool('context', params),
+        impact: (params) => backend.callTool('impact', params),
+        cypher: (params) => backend.callTool('cypher', params),
+        close: async () => {
+            await closeKuzu();
+        },
+    };
+}

package/dist/benchmark/agent-context/tool-runner.test.d.ts

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

package/dist/benchmark/agent-context/tool-runner.test.js

@@ -0,0 +1,11 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createAgentContextToolRunner } from './tool-runner.js';
+test('agent-context tool runner exposes query/context/impact/cypher', async () => {
+    const runner = await createAgentContextToolRunner();
+    assert.equal(typeof runner.query, 'function');
+    assert.equal(typeof runner.context, 'function');
+    assert.equal(typeof runner.impact, 'function');
+    assert.equal(typeof runner.cypher, 'function');
+    await runner.close();
+});

package/dist/benchmark/agent-context/types.d.ts

@@ -0,0 +1,40 @@
+export interface AgentContextThresholds {
+    coverage: {
+        minPerScenario: number;
+        suiteAvgMin: number;
+    };
+    efficiency: {
+        maxToolCallsPerScenario: number;
+        suiteAvgMax: number;
+    };
+}
+export interface AgentContextToolStep {
+    tool: 'query' | 'context' | 'impact' | 'cypher';
+    input: Record<string, unknown>;
+}
+export interface AgentContextCheck {
+    id: 'T' | 'U' | 'D' | 'B' | 'I' | 'E' | string;
+    required_uid?: string;
+    forbidden_uid?: string;
+    min_incoming?: number;
+    min_outgoing?: number;
+    min_impacted?: number;
+    internal_anchors?: string[];
+    min_internal_hits?: number;
+    max_tool_calls?: number;
+}
+export interface AgentContextScenario {
+    scenario_id: string;
+    target_uid: string;
+    tool_plan: AgentContextToolStep[];
+    checks: AgentContextCheck[];
+}
+export interface AgentContextDataset {
+    thresholds: AgentContextThresholds;
+    scenarios: AgentContextScenario[];
+}
+export interface AgentContextCheckResult {
+    id: string;
+    pass: boolean;
+    detail?: string;
+}

package/dist/benchmark/agent-context/types.js

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

package/dist/benchmark/analyze-runner.d.ts

@@ -0,0 +1,16 @@
+export interface AnalyzeRunOptions {
+    extensions: string;
+    repoAlias?: string;
+    scopeManifest?: string;
+    scopePrefix?: string[];
+}
+export declare function parseAnalyzeSummary(output: string): {
+    totalSeconds: number;
+    nodes: number;
+    edges: number;
+};
+export declare function buildAnalyzeArgs(repoPath: string, options: AnalyzeRunOptions): string[];
+export declare function runAnalyze(repoPath: string, options: AnalyzeRunOptions): Promise<{
+    stdout: string;
+    stderr: string;
+}>;

package/dist/benchmark/analyze-runner.js

@@ -0,0 +1,51 @@
+import { spawn } from 'node:child_process';
+export function parseAnalyzeSummary(output) {
+    const timeMatch = output.match(/indexed successfully \(([\d.]+)s\)/i);
+    const graphMatch = output.match(/([\d,]+)\s+nodes\s+\|\s+([\d,]+)\s+edges/i);
+    return {
+        totalSeconds: timeMatch ? Number(timeMatch[1]) : Number.NaN,
+        nodes: graphMatch ? Number(graphMatch[1].replace(/,/g, '')) : Number.NaN,
+        edges: graphMatch ? Number(graphMatch[2].replace(/,/g, '')) : Number.NaN,
+    };
+}
+export function buildAnalyzeArgs(repoPath, options) {
+    const args = [
+        'dist/cli/index.js',
+        'analyze',
+        '--force',
+        '--extensions',
+        options.extensions,
+        repoPath,
+    ];
+    if (options.repoAlias) {
+        args.push('--repo-alias', options.repoAlias);
+    }
+    if (options.scopeManifest) {
+        args.push('--scope-manifest', options.scopeManifest);
+    }
+    for (const prefix of options.scopePrefix || []) {
+        args.push('--scope-prefix', prefix);
+    }
+    return args;
+}
+export async function runAnalyze(repoPath, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('node', buildAnalyzeArgs(repoPath, options), { cwd: process.cwd() });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (d) => {
+            stdout += d.toString();
+        });
+        child.stderr.on('data', (d) => {
+            stderr += d.toString();
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error(`analyze failed: ${code}`));
+                return;
+            }
+            resolve({ stdout, stderr });
+        });
+        child.on('error', reject);
+    });
+}

package/dist/benchmark/analyze-runner.test.d.ts

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

package/dist/benchmark/analyze-runner.test.js

@@ -0,0 +1,37 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { buildAnalyzeArgs, parseAnalyzeSummary } from './analyze-runner.js';
+test('parseAnalyzeSummary extracts nodes/edges/time', () => {
+    const sample = `
+Repository indexed successfully (42.3s)
+51,172 nodes | 108,578 edges | 2,545 clusters | 300 flows
+`;
+    const parsed = parseAnalyzeSummary(sample);
+    assert.equal(parsed.totalSeconds, 42.3);
+    assert.equal(parsed.nodes, 51172);
+    assert.equal(parsed.edges, 108578);
+});
+test('buildAnalyzeArgs forwards alias and scope options', () => {
+    const args = buildAnalyzeArgs('/repo/path', {
+        extensions: '.cs,.ts',
+        repoAlias: 'neonspark-v1-subset',
+        scopeManifest: '/tmp/scope-manifest.txt',
+        scopePrefix: ['Assets/NEON/Code', 'Packages/com.veewo.*'],
+    });
+    assert.deepEqual(args, [
+        'dist/cli/index.js',
+        'analyze',
+        '--force',
+        '--extensions',
+        '.cs,.ts',
+        '/repo/path',
+        '--repo-alias',
+        'neonspark-v1-subset',
+        '--scope-manifest',
+        '/tmp/scope-manifest.txt',
+        '--scope-prefix',
+        'Assets/NEON/Code',
+        '--scope-prefix',
+        'Packages/com.veewo.*',
+    ]);
+});

package/dist/benchmark/evaluators.d.ts

@@ -0,0 +1,6 @@
+export declare function buildFailureTriage(failures: Array<{
+    kind: string;
+}>): {
+    kind: string;
+    count: number;
+}[];

package/dist/benchmark/evaluators.js

@@ -0,0 +1,10 @@
+export function buildFailureTriage(failures) {
+    const counts = new Map();
+    for (const failure of failures) {
+        counts.set(failure.kind, (counts.get(failure.kind) || 0) + 1);
+    }
+    return [...counts.entries()]
+        .map(([kind, count]) => ({ kind, count }))
+        .sort((a, b) => b.count - a.count)
+        .slice(0, 10);
+}

package/dist/benchmark/evaluators.test.d.ts

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

package/dist/benchmark/evaluators.test.js

@@ -0,0 +1,12 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { buildFailureTriage } from './evaluators.js';
+test('buildFailureTriage groups repeated failure classes', () => {
+    const triage = buildFailureTriage([
+        { kind: 'ambiguous-name-wrong-hit' },
+        { kind: 'ambiguous-name-wrong-hit' },
+        { kind: 'impact-downstream-zero' },
+    ]);
+    assert.equal(triage[0].kind, 'ambiguous-name-wrong-hit');
+    assert.equal(triage[0].count, 2);
+});

package/dist/benchmark/io.d.ts

@@ -0,0 +1,7 @@
+import type { RelationCase, SymbolCase, TaskCase, Thresholds } from './types.js';
+export declare function loadBenchmarkDataset(root: string): Promise<{
+    thresholds: Thresholds;
+    symbols: SymbolCase[];
+    relations: RelationCase[];
+    tasks: TaskCase[];
+}>;

package/dist/benchmark/io.js

@@ -0,0 +1,25 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export async function loadBenchmarkDataset(root) {
+    const thresholds = JSON.parse(await fs.readFile(path.join(root, 'thresholds.json'), 'utf-8'));
+    const symbols = await readJsonl(path.join(root, 'symbols.jsonl'), ['symbol_uid', 'file_path', 'symbol_name', 'symbol_type', 'start_line', 'end_line']);
+    const relations = await readJsonl(path.join(root, 'relations.jsonl'), ['src_uid', 'edge_type', 'dst_uid', 'must_exist']);
+    const tasks = await readJsonl(path.join(root, 'tasks.jsonl'), ['tool', 'input', 'must_hit_uids', 'must_not_hit_uids']);
+    return { thresholds, symbols, relations, tasks };
+}
+async function readJsonl(file, required) {
+    const raw = await fs.readFile(file, 'utf-8');
+    const rows = raw
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+    for (const row of rows) {
+        for (const key of required) {
+            if (!(key in row)) {
+                throw new Error(`missing required field: ${key}`);
+            }
+        }
+    }
+    return rows;
+}

package/dist/benchmark/io.test.d.ts

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

package/dist/benchmark/io.test.js

@@ -0,0 +1,35 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { loadBenchmarkDataset } from './io.js';
+test('loadBenchmarkDataset parses thresholds and jsonl rows', async () => {
+    const root = path.resolve('../benchmarks/unity-baseline/v1');
+    const ds = await loadBenchmarkDataset(root);
+    assert.equal(typeof ds.thresholds.query.precisionMin, 'number');
+    assert.ok(ds.symbols.length > 0);
+    assert.ok(ds.relations.length > 0);
+    assert.ok(ds.tasks.length > 0);
+});
+test('loadBenchmarkDataset rejects missing required fields', async () => {
+    const badRoot = path.resolve('src/benchmark/__fixtures__/bad-dataset');
+    await assert.rejects(() => loadBenchmarkDataset(badRoot), /missing required field/i);
+});
+test('loadBenchmarkDataset parses neonspark-v1 dataset', async () => {
+    const root = path.resolve('../benchmarks/unity-baseline/neonspark-v1');
+    const ds = await loadBenchmarkDataset(root);
+    assert.equal(ds.symbols.length, 20);
+    assert.ok(ds.relations.length > 0);
+    assert.ok(ds.tasks.some((t) => t.tool === 'query'));
+    assert.ok(ds.tasks.some((t) => t.tool === 'context'));
+    assert.ok(ds.tasks.some((t) => t.tool === 'impact'));
+});
+test('loadBenchmarkDataset parses neonspark-v2 dataset', async () => {
+    const root = path.resolve('../benchmarks/unity-baseline/neonspark-v2');
+    const ds = await loadBenchmarkDataset(root);
+    assert.ok(ds.symbols.length >= 40 && ds.symbols.length <= 60);
+    assert.ok(ds.relations.length > 0);
+    assert.ok(ds.tasks.length >= 24);
+    assert.ok(ds.tasks.some((t) => t.tool === 'query'));
+    assert.ok(ds.tasks.some((t) => t.tool === 'context'));
+    assert.ok(ds.tasks.some((t) => t.tool === 'impact'));
+});

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

@@ -0,0 +1,19 @@
+export declare function filterNeonsparkPaths<T extends {
+    file_path?: string;
+}>(rows: T[]): T[];
+export declare function toCandidateRow(row: any): {
+    symbol_uid: string;
+    file_path: string;
+    symbol_name: string;
+    symbol_type: string;
+    start_line: number;
+    end_line: number;
+};
+export declare function extractCandidates(repoName: string, outFile: string): Promise<number>;
+export interface CandidatesCliArgs {
+    repoName: string;
+    outFile: string;
+}
+export type ExtractCandidatesFn = (repoName: string, outFile: string) => Promise<number>;
+export declare function parseCandidatesCliArgs(argv: string[]): CandidatesCliArgs;
+export declare function mainCandidatesCli(argv?: string[], runExtract?: ExtractCandidatesFn): Promise<number>;