@veewo/gitnexus 1.3.7 → 1.3.9

package/dist/benchmark/u2-e2e/neonspark-full-e2e.js

@@ -0,0 +1,439 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { loadE2EConfig } from './config.js';
+import { parseAnalyzeSummary, compareEstimate } from './analyze-parser.js';
+import { runSymbolScenario } from './retrieval-runner.js';
+import { summarizeDurations } from './metrics.js';
+import { writeU2E2EReports } from './report.js';
+import { summarizeCharacterListAssetRefSprite } from './characterlist-assetref.js';
+import { createAgentContextToolRunner } from '../agent-context/tool-runner.js';
+const GATE_ORDER = [
+    'preflight',
+    'build',
+    'pipeline-profile',
+    'analyze',
+    'estimate-compare',
+    'retrieval',
+    'final-report',
+];
+function nowStamp() {
+    const now = new Date();
+    const yyyy = now.getUTCFullYear();
+    const mm = String(now.getUTCMonth() + 1).padStart(2, '0');
+    const dd = String(now.getUTCDate()).padStart(2, '0');
+    const hh = String(now.getUTCHours()).padStart(2, '0');
+    const min = String(now.getUTCMinutes()).padStart(2, '0');
+    const ss = String(now.getUTCSeconds()).padStart(2, '0');
+    return `${yyyy}${mm}${dd}-${hh}${min}${ss}`;
+}
+export function createRunId(prefix = 'neonspark-u2-e2e') {
+    return `${prefix}-${nowStamp()}`;
+}
+async function defaultWriteCheckpoint(reportDir, payload) {
+    await fs.mkdir(reportDir, { recursive: true });
+    await fs.writeFile(path.join(reportDir, 'checkpoint.json'), JSON.stringify(payload, null, 2), 'utf-8');
+}
+async function pathExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveRepoRoot(cwd) {
+    if (await pathExists(path.join(cwd, 'benchmarks')) && await pathExists(path.join(cwd, 'gitnexus'))) {
+        return cwd;
+    }
+    const parent = path.resolve(cwd, '..');
+    if (await pathExists(path.join(parent, 'benchmarks')) && await pathExists(path.join(parent, 'gitnexus'))) {
+        return parent;
+    }
+    throw new Error(`Unable to resolve repo root from cwd=${cwd}`);
+}
+function sanitizeAlias(input) {
+    return input.replace(/[^a-zA-Z0-9._-]/g, '-').slice(0, 120);
+}
+async function execCommand(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const started = Date.now();
+        const child = spawn(command, args, { cwd, env: process.env });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (buf) => {
+            stdout += buf.toString();
+        });
+        child.stderr.on('data', (buf) => {
+            stderr += buf.toString();
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            resolve({
+                code,
+                stdout,
+                stderr,
+                durationMs: Date.now() - started,
+            });
+        });
+    });
+}
+function scopePrefixArgs(prefixes) {
+    const out = [];
+    for (const prefix of prefixes) {
+        out.push('--scope-prefix', prefix);
+    }
+    return out;
+}
+async function runRequiredCommand(command, args, cwd) {
+    const result = await execCommand(command, args, cwd);
+    if (result.code !== 0) {
+        const msg = `Command failed (${result.code}): ${command} ${args.join(' ')}\n${result.stderr || result.stdout}`;
+        throw new Error(msg.trim());
+    }
+    return result;
+}
+function summarizeRetrieval(results) {
+    const symbols = results.map((result) => {
+        const durationMs = result.steps.reduce((sum, step) => sum + step.durationMs, 0);
+        const totalTokensEst = result.steps.reduce((sum, step) => sum + step.totalTokensEst, 0);
+        return {
+            symbol: result.symbol,
+            pass: result.assertions.pass,
+            stepCount: result.steps.length,
+            durationMs: Number(durationMs.toFixed(1)),
+            totalTokensEst,
+            failures: result.assertions.failures,
+        };
+    });
+    const allSteps = results.flatMap((result) => result.steps);
+    const totalTokensEst = allSteps.reduce((sum, step) => sum + step.totalTokensEst, 0);
+    const durationSeries = allSteps.map((step) => step.durationMs);
+    const durationStats = summarizeDurations(durationSeries);
+    const totalDurationMs = allSteps.reduce((sum, step) => sum + step.durationMs, 0);
+    const failures = symbols.flatMap((row) => (row.failures || []).map((item) => `${row.symbol}: ${item}`));
+    return {
+        symbols,
+        tokenSummary: {
+            totalTokensEst,
+            totalDurationMs: Number(totalDurationMs.toFixed(1)),
+        },
+        failures: [
+            ...failures,
+            `duration.min=${durationStats.minMs}ms median=${durationStats.medianMs}ms max=${durationStats.maxMs}ms`,
+        ],
+    };
+}
+function extractPipelineMeanMs(profile) {
+    if (!profile)
+        return 0;
+    const metrics = profile.metrics;
+    const pipelineTotalMs = metrics?.pipelineTotalMs;
+    const mean = pipelineTotalMs?.mean;
+    return typeof mean === 'number' && Number.isFinite(mean) ? mean : 0;
+}
+function parseNumericCount(raw) {
+    if (typeof raw === 'number' && Number.isFinite(raw)) {
+        return raw;
+    }
+    if (typeof raw === 'string') {
+        const cleaned = raw.trim().replace(/,/g, '');
+        if (!cleaned)
+            return null;
+        const parsed = Number(cleaned);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return null;
+}
+export function extractSingleCountFromCypherResult(result) {
+    if (Array.isArray(result) && result.length > 0) {
+        const first = result[0];
+        if (first && typeof first === 'object') {
+            return (parseNumericCount(first.serializedTypeEdgeCount)
+                ?? parseNumericCount(first.c)
+                ?? parseNumericCount(first.count)
+                ?? null);
+        }
+    }
+    if (!result || typeof result !== 'object') {
+        return null;
+    }
+    const row = result;
+    const direct = parseNumericCount(row.serializedTypeEdgeCount)
+        ?? parseNumericCount(row.c)
+        ?? parseNumericCount(row.count);
+    if (direct !== null) {
+        return direct;
+    }
+    const markdown = row.markdown;
+    if (typeof markdown === 'string' && markdown.trim().length > 0) {
+        const lines = markdown
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+        for (let index = 2; index < lines.length; index += 1) {
+            const cells = lines[index]
+                .split('|')
+                .map((cell) => cell.trim())
+                .filter((cell) => cell.length > 0);
+            for (const cell of cells) {
+                const parsed = parseNumericCount(cell);
+                if (parsed !== null) {
+                    return parsed;
+                }
+            }
+        }
+    }
+    return null;
+}
+async function loadSerializedTypeEdgeCount(runner, repoAlias) {
+    const result = await runner.cypher({
+        repo: repoAlias,
+        query: "MATCH ()-[r:CodeRelation]->() WHERE r.type='UNITY_SERIALIZED_TYPE_IN' RETURN COUNT(r) AS serializedTypeEdgeCount",
+    });
+    const count = extractSingleCountFromCypherResult(result);
+    if (count === null) {
+        throw new Error('Unable to parse UNITY_SERIALIZED_TYPE_IN edge count from cypher result');
+    }
+    return count;
+}
+function selectClassUid(contextOutput, expectedSymbol) {
+    const candidates = Array.isArray(contextOutput?.candidates) ? contextOutput.candidates : [];
+    const expectedLower = expectedSymbol.toLowerCase();
+    for (const candidate of candidates) {
+        const kind = String(candidate?.kind || '').toLowerCase();
+        if (kind !== 'class')
+            continue;
+        const name = String(candidate?.name || '').toLowerCase();
+        if (name !== expectedLower)
+            continue;
+        const uid = String(candidate?.uid || '').trim();
+        if (uid)
+            return uid;
+    }
+    return null;
+}
+async function loadCharacterListContext(runner, repoAlias) {
+    const input = { name: 'CharacterList', repo: repoAlias, unity_resources: 'on' };
+    const first = await runner.context(input);
+    if (first?.status !== 'ambiguous') {
+        return first;
+    }
+    const classUid = selectClassUid(first, 'CharacterList');
+    if (!classUid) {
+        return first;
+    }
+    return runner.context({ ...input, uid: classUid });
+}
+export async function runNeonsparkU2E2E(options) {
+    const cwd = process.cwd();
+    const repoRoot = await resolveRepoRoot(cwd);
+    const gitnexusRoot = path.join(repoRoot, 'gitnexus');
+    const config = await loadE2EConfig(options.configPath);
+    const runId = options.runId || createRunId(config.runIdPrefix || 'neonspark-u2-e2e');
+    const reportDir = path.resolve(options.reportDir || path.join(repoRoot, 'docs/reports', runId));
+    const repoAlias = sanitizeAlias(`${config.repoAliasPrefix}-${runId}`);
+    const state = {
+        repoRoot,
+        gitnexusRoot,
+        runId,
+        reportDir,
+        repoAlias,
+        configPath: path.resolve(options.configPath),
+        config,
+    };
+    return runE2E({
+        runId,
+        reportDir,
+        gates: {
+            preflight: async () => {
+                if (!(await pathExists(config.targetPath))) {
+                    throw new Error(`Target path not found: ${config.targetPath}`);
+                }
+                if (!(await pathExists('/usr/bin/time'))) {
+                    throw new Error('Missing required tool: /usr/bin/time');
+                }
+                state.preflight = {
+                    targetPath: config.targetPath,
+                    configPath: state.configPath,
+                    repoAlias,
+                    scenarioCount: config.symbolScenarios.length,
+                };
+                return state.preflight;
+            },
+            build: async () => {
+                const build = await runRequiredCommand('npm', ['--prefix', 'gitnexus', 'run', 'build'], repoRoot);
+                state.buildMs = Number(build.durationMs.toFixed(1));
+                return { durationMs: state.buildMs };
+            },
+            'pipeline-profile': async () => {
+                const reportPath = path.join(reportDir, 'pipeline-profile.json');
+                const scopeArgs = scopePrefixArgs(config.scope.scriptPrefixes || []);
+                await runRequiredCommand('npm', [
+                    '--prefix',
+                    'gitnexus',
+                    'run',
+                    'benchmark:u2:sample',
+                    '--',
+                    '--target-path',
+                    config.targetPath,
+                    '--runs',
+                    '1',
+                    '--report',
+                    reportPath,
+                    ...scopeArgs,
+                ], repoRoot);
+                const raw = await fs.readFile(reportPath, 'utf-8');
+                state.pipelineProfile = JSON.parse(raw);
+                return state.pipelineProfile;
+            },
+            analyze: async () => {
+                const scopeArgs = scopePrefixArgs(config.scope.scriptPrefixes || []);
+                const analyze = await runRequiredCommand('/usr/bin/time', [
+                    '-p',
+                    'node',
+                    'dist/cli/index.js',
+                    'analyze',
+                    '--force',
+                    '--extensions',
+                    '.cs',
+                    '--repo-alias',
+                    repoAlias,
+                    ...scopeArgs,
+                    config.targetPath,
+                ], gitnexusRoot);
+                const logPath = path.join(reportDir, 'analyze.log');
+                await fs.writeFile(logPath, `${analyze.stdout}\n${analyze.stderr}\n`, 'utf-8');
+                state.analyzeSummary = await parseAnalyzeSummary(logPath);
+                return state.analyzeSummary;
+            },
+            'estimate-compare': async () => {
+                if (!state.analyzeSummary) {
+                    throw new Error('analyze summary missing');
+                }
+                state.estimateComparison = compareEstimate(state.analyzeSummary.totalSec, config.estimateRangeSec);
+                return state.estimateComparison;
+            },
+            retrieval: async () => {
+                const runner = await createAgentContextToolRunner();
+                try {
+                    const results = [];
+                    for (const scenario of config.symbolScenarios) {
+                        results.push(await runSymbolScenario(runner, scenario, repoAlias));
+                    }
+                    const serializedTypeEdgeCount = await loadSerializedTypeEdgeCount(runner, repoAlias);
+                    if (serializedTypeEdgeCount <= 0) {
+                        throw new Error('U3 gate failed: UNITY_SERIALIZED_TYPE_IN edge count must be > 0');
+                    }
+                    const characterListContext = await loadCharacterListContext(runner, repoAlias);
+                    const characterBindings = Array.isArray(characterListContext?.resourceBindings)
+                        ? characterListContext.resourceBindings
+                        : [];
+                    const characterListAssetRefSprite = summarizeCharacterListAssetRefSprite(characterBindings);
+                    if (characterListAssetRefSprite.spriteAssetRefInstances <= 0) {
+                        throw new Error('U3 gate failed: CharacterList AssetRef sprite instances must be > 0');
+                    }
+                    state.retrievalResults = results;
+                    state.retrievalSummary = {
+                        ...summarizeRetrieval(results),
+                        serializedTypeEdgeCount,
+                        characterListAssetRefSprite: {
+                            extractedAssetRefInstances: characterListAssetRefSprite.extractedAssetRefInstances,
+                            nonEmptyAssetRefInstances: characterListAssetRefSprite.nonEmptyAssetRefInstances,
+                            spriteAssetRefInstances: characterListAssetRefSprite.spriteAssetRefInstances,
+                            spriteRatioInNonEmpty: characterListAssetRefSprite.spriteRatioInNonEmpty,
+                            uniqueSpriteAssets: characterListAssetRefSprite.uniqueSpriteAssets,
+                        },
+                    };
+                    return state.retrievalSummary;
+                }
+                finally {
+                    await runner.close();
+                }
+            },
+            'final-report': async () => {
+                await writeU2E2EReports(reportDir, {
+                    preflight: state.preflight,
+                    scopeCounts: {
+                        scriptPrefixCount: config.scope.scriptPrefixes.length,
+                        resourcePrefixCount: config.scope.resourcePrefixes.length,
+                    },
+                    pipelineProfile: state.pipelineProfile,
+                    analyzeSummary: state.analyzeSummary,
+                    estimateComparison: state.estimateComparison,
+                    retrievalSteps: state.retrievalResults?.flatMap((scenario) => scenario.steps.map((step) => ({
+                        symbol: scenario.symbol,
+                        ...step,
+                    }))) || [],
+                    retrievalSummary: state.retrievalSummary,
+                    finalVerdict: {
+                        runId,
+                        buildTimings: {
+                            buildMs: state.buildMs,
+                            pipelineProfileMs: extractPipelineMeanMs(state.pipelineProfile),
+                            analyzeSec: state.analyzeSummary?.totalSec,
+                        },
+                        estimateComparison: state.estimateComparison,
+                        retrievalSummary: state.retrievalSummary,
+                        failures: state.retrievalSummary?.failures || [],
+                    },
+                });
+                return {
+                    reportDir,
+                    runId,
+                };
+            },
+        },
+    });
+}
+export async function runE2E(options = {}) {
+    const runId = options.runId || createRunId();
+    const reportDir = options.reportDir || path.resolve('.gitnexus/u2-e2e', runId);
+    const writeCheckpoint = options.writeCheckpoint || defaultWriteCheckpoint;
+    const gates = options.gates || {};
+    await fs.mkdir(reportDir, { recursive: true });
+    const completedGates = [];
+    const gateOutputs = {};
+    for (const gate of GATE_ORDER) {
+        const gateRunner = gates[gate];
+        if (!gateRunner) {
+            completedGates.push(gate);
+            continue;
+        }
+        try {
+            gateOutputs[gate] = await gateRunner();
+            completedGates.push(gate);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const checkpointPayload = {
+                runId,
+                status: 'failed',
+                failedGate: gate,
+                completedGates,
+                error: message,
+                capturedAt: new Date().toISOString(),
+            };
+            await writeCheckpoint(reportDir, checkpointPayload);
+            return {
+                status: 'failed',
+                runId,
+                reportDir,
+                completedGates,
+                failedGate: gate,
+                error: message,
+                gateOutputs,
+            };
+        }
+    }
+    return {
+        status: 'passed',
+        runId,
+        reportDir,
+        completedGates,
+        gateOutputs,
+    };
+}

package/dist/benchmark/u2-e2e/neonspark-full-e2e.test.d.ts

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

package/dist/benchmark/u2-e2e/neonspark-full-e2e.test.js

@@ -0,0 +1,40 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { extractSingleCountFromCypherResult, runE2E } from './neonspark-full-e2e.js';
+test('runE2E stops on first gate failure and writes checkpoint', async () => {
+    const checkpoints = [];
+    const out = await runE2E({
+        runId: 'unit-test-run',
+        reportDir: '/tmp/u2-e2e-unit',
+        gates: {
+            preflight: async () => ({ ok: true }),
+            build: async () => {
+                throw new Error('build failed');
+            },
+            'pipeline-profile': async () => ({ skipped: true }),
+            analyze: async () => ({ totalSec: 1 }),
+            'estimate-compare': async () => ({ status: 'in-range' }),
+            retrieval: async () => ({ symbols: [] }),
+            'final-report': async () => ({ written: true }),
+        },
+        writeCheckpoint: async (reportDir, payload) => {
+            checkpoints.push({ reportDir, payload });
+        },
+    });
+    assert.equal(out.status, 'failed');
+    assert.equal(out.failedGate, 'build');
+    assert.equal(checkpoints.length, 1);
+    assert.equal(checkpoints[0].reportDir, '/tmp/u2-e2e-unit');
+    assert.equal(checkpoints[0].payload.failedGate, 'build');
+});
+test('extractSingleCountFromCypherResult parses markdown-formatted cypher output', () => {
+    const count = extractSingleCountFromCypherResult({
+        markdown: '| serializedTypeEdgeCount |\n| --- |\n| 3791 |',
+        row_count: 1,
+    });
+    assert.equal(count, 3791);
+});
+test('extractSingleCountFromCypherResult parses raw row output', () => {
+    const count = extractSingleCountFromCypherResult([{ serializedTypeEdgeCount: 42 }]);
+    assert.equal(count, 42);
+});

package/dist/benchmark/u2-e2e/report.d.ts

@@ -0,0 +1,58 @@
+export interface U2EstimateComparison {
+    status: string;
+    inRange: boolean;
+    actualSec: number;
+    lower: number;
+    upper: number;
+    deltaSec: number;
+}
+export interface U2SymbolOutcome {
+    symbol: string;
+    pass: boolean;
+    stepCount: number;
+    durationMs?: number;
+    totalTokensEst?: number;
+    failures?: string[];
+}
+export interface U2CharacterListAssetRefSpriteSummary {
+    extractedAssetRefInstances: number;
+    nonEmptyAssetRefInstances: number;
+    spriteAssetRefInstances: number;
+    spriteRatioInNonEmpty: number | null;
+    uniqueSpriteAssets: number;
+}
+export interface U2RetrievalSummary {
+    symbols: U2SymbolOutcome[];
+    tokenSummary?: {
+        totalTokensEst: number;
+        totalDurationMs: number;
+    };
+    serializedTypeEdgeCount?: number;
+    characterListAssetRefSprite?: U2CharacterListAssetRefSpriteSummary;
+    failures?: string[];
+}
+export interface FinalVerdictInput {
+    runId: string;
+    buildTimings?: {
+        buildMs?: number;
+        pipelineProfileMs?: number;
+        analyzeSec?: number;
+    };
+    estimateComparison?: U2EstimateComparison;
+    retrievalSummary?: U2RetrievalSummary;
+    failures?: string[];
+}
+export interface E2EReportWriteInput {
+    preflight?: unknown;
+    scopeCounts?: unknown;
+    pipelineProfile?: unknown;
+    analyzeSummary?: unknown;
+    estimateComparison?: U2EstimateComparison;
+    retrievalSteps?: unknown[];
+    retrievalSummary?: U2RetrievalSummary;
+    finalVerdict: FinalVerdictInput;
+}
+export declare function buildEstimateComparisonMarkdown(estimate?: U2EstimateComparison): string;
+export declare function buildRetrievalSummaryMarkdown(summary?: U2RetrievalSummary): string;
+export declare function buildFinalVerdictMarkdown(input: FinalVerdictInput): string;
+export declare function writeU2E2EReports(reportDir: string, input: E2EReportWriteInput): Promise<void>;

package/dist/benchmark/u2-e2e/report.js

@@ -0,0 +1,130 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+function formatMs(value) {
+    if (typeof value !== 'number' || Number.isNaN(value))
+        return 'n/a';
+    return `${value.toFixed(1)}ms`;
+}
+function formatSec(value) {
+    if (typeof value !== 'number' || Number.isNaN(value))
+        return 'n/a';
+    return `${value.toFixed(1)}s`;
+}
+export function buildEstimateComparisonMarkdown(estimate) {
+    if (!estimate) {
+        return '# Estimate Comparison\n\nNo estimate comparison data.\n';
+    }
+    return [
+        '# Estimate Comparison',
+        '',
+        `- Status: ${estimate.status}`,
+        `- In Range: ${estimate.inRange ? 'YES' : 'NO'}`,
+        `- Actual: ${estimate.actualSec.toFixed(1)}s`,
+        `- Expected Range: ${estimate.lower.toFixed(1)}s - ${estimate.upper.toFixed(1)}s`,
+        `- Delta: ${estimate.deltaSec.toFixed(1)}s`,
+        '',
+    ].join('\n');
+}
+export function buildRetrievalSummaryMarkdown(summary) {
+    if (!summary) {
+        return '# Retrieval Summary\n\nNo retrieval summary data.\n';
+    }
+    const symbolRows = summary.symbols.length > 0
+        ? summary.symbols.map((row) => `- ${row.symbol}: ${row.pass ? 'PASS' : 'FAIL'} (steps=${row.stepCount}, duration=${formatMs(row.durationMs)}, tokens=${typeof row.totalTokensEst === 'number' ? row.totalTokensEst : 'n/a'})`)
+        : ['- none'];
+    const failures = summary.failures || [];
+    const failureRows = failures.length > 0 ? failures.map((row) => `- ${row}`) : ['- none'];
+    return [
+        '# Retrieval Summary',
+        '',
+        '## Symbols',
+        ...symbolRows,
+        '',
+        '## Token And Duration',
+        `- Total Tokens (est): ${summary.tokenSummary?.totalTokensEst ?? 0}`,
+        `- Total Duration: ${formatMs(summary.tokenSummary?.totalDurationMs)}`,
+        `- UNITY_SERIALIZED_TYPE_IN Edges: ${typeof summary.serializedTypeEdgeCount === 'number' ? summary.serializedTypeEdgeCount : 'n/a'}`,
+        `- CharacterList AssetRef Sprite Instances: ${summary.characterListAssetRefSprite?.spriteAssetRefInstances ?? 'n/a'}`,
+        `- CharacterList AssetRef Sprite Ratio: ${typeof summary.characterListAssetRefSprite?.spriteRatioInNonEmpty === 'number'
+            ? `${(summary.characterListAssetRefSprite.spriteRatioInNonEmpty * 100).toFixed(2)}%`
+            : 'n/a'}`,
+        '',
+        '## Failures',
+        ...failureRows,
+        '',
+    ].join('\n');
+}
+export function buildFinalVerdictMarkdown(input) {
+    const summary = input.retrievalSummary;
+    const failures = [...(input.failures || []), ...((summary?.failures || []))].filter((failure, index, all) => all.indexOf(failure) === index);
+    return [
+        '# U2 E2E Final Verdict',
+        '',
+        `- Run ID: ${input.runId}`,
+        '',
+        '## Build Timings',
+        `- Build: ${formatMs(input.buildTimings?.buildMs)}`,
+        `- Pipeline Profile: ${formatMs(input.buildTimings?.pipelineProfileMs)}`,
+        `- Analyze: ${formatSec(input.buildTimings?.analyzeSec)}`,
+        '',
+        '## Estimate Comparison',
+        ...(input.estimateComparison
+            ? [
+                `- Status: ${input.estimateComparison.status}`,
+                `- In Range: ${input.estimateComparison.inRange ? 'YES' : 'NO'}`,
+                `- Actual: ${input.estimateComparison.actualSec.toFixed(1)}s`,
+                `- Expected: ${input.estimateComparison.lower.toFixed(1)}s - ${input.estimateComparison.upper.toFixed(1)}s`,
+                `- Delta: ${input.estimateComparison.deltaSec.toFixed(1)}s`,
+            ]
+            : ['- no estimate data']),
+        '',
+        '## U2 Capability Checks by Symbol',
+        ...(summary?.symbols?.length
+            ? summary.symbols.map((row) => `- ${row.symbol}: ${row.pass ? 'PASS' : 'FAIL'} (steps=${row.stepCount}, duration=${formatMs(row.durationMs)}, tokens=${typeof row.totalTokensEst === 'number' ? row.totalTokensEst : 'n/a'})`)
+            : ['- none']),
+        '',
+        '## Token Consumption Summary',
+        `- Total Tokens (est): ${summary?.tokenSummary?.totalTokensEst ?? 0}`,
+        `- Total Duration: ${formatMs(summary?.tokenSummary?.totalDurationMs)}`,
+        `- UNITY_SERIALIZED_TYPE_IN Edges: ${typeof summary?.serializedTypeEdgeCount === 'number' ? summary.serializedTypeEdgeCount : 'n/a'}`,
+        `- CharacterList AssetRef Sprite Instances: ${summary?.characterListAssetRefSprite?.spriteAssetRefInstances ?? 'n/a'}`,
+        `- CharacterList AssetRef Sprite Ratio: ${typeof summary?.characterListAssetRefSprite?.spriteRatioInNonEmpty === 'number'
+            ? `${(summary.characterListAssetRefSprite.spriteRatioInNonEmpty * 100).toFixed(2)}%`
+            : 'n/a'}`,
+        '',
+        '## Failures and Manual Actions',
+        ...(failures.length > 0 ? failures.map((f) => `- ${f}`) : ['- none']),
+        '',
+    ].join('\n');
+}
+async function writeJson(reportDir, fileName, payload) {
+    await fs.writeFile(path.join(reportDir, fileName), JSON.stringify(payload, null, 2), 'utf-8');
+}
+export async function writeU2E2EReports(reportDir, input) {
+    await fs.mkdir(reportDir, { recursive: true });
+    if (input.preflight !== undefined) {
+        await writeJson(reportDir, 'preflight.json', input.preflight);
+    }
+    if (input.scopeCounts !== undefined) {
+        await writeJson(reportDir, 'scope-counts.json', input.scopeCounts);
+    }
+    if (input.pipelineProfile !== undefined) {
+        await writeJson(reportDir, 'pipeline-profile.json', input.pipelineProfile);
+    }
+    if (input.analyzeSummary !== undefined) {
+        await writeJson(reportDir, 'analyze-summary.json', input.analyzeSummary);
+    }
+    if (input.estimateComparison !== undefined) {
+        await writeJson(reportDir, 'estimate-comparison.json', input.estimateComparison);
+        await fs.writeFile(path.join(reportDir, 'estimate-comparison.md'), buildEstimateComparisonMarkdown(input.estimateComparison), 'utf-8');
+    }
+    if (input.retrievalSteps !== undefined) {
+        const jsonl = input.retrievalSteps.map((row) => JSON.stringify(row)).join('\n');
+        await fs.writeFile(path.join(reportDir, 'retrieval-steps.jsonl'), `${jsonl}${jsonl ? '\n' : ''}`, 'utf-8');
+    }
+    if (input.retrievalSummary !== undefined) {
+        await writeJson(reportDir, 'retrieval-summary.json', input.retrievalSummary);
+        await fs.writeFile(path.join(reportDir, 'retrieval-summary.md'), buildRetrievalSummaryMarkdown(input.retrievalSummary), 'utf-8');
+    }
+    await fs.writeFile(path.join(reportDir, 'final-verdict.md'), buildFinalVerdictMarkdown(input.finalVerdict), 'utf-8');
+}

package/dist/benchmark/u2-e2e/report.test.d.ts

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