Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.
C aiderastclaude-codecode-analysiscode-intelligencecodexcursorcypherdeveloper-toolsgemini-cligraph-visualizationkilocodeknowledge-graphmcpmcp-servermodel-context-protocolopencodesqlitetree-sitterwindsurf
#!/usr/bin/env node
/*
* W4d-Smoke: der Explorer zeigt die Datei-Wahrheit, und was fehlt, wird
* gemessen statt vermutet.
*
* Was hier bewiesen wird, koennen die Unit-Tests nicht beweisen. Sie zeigen an
* abgeschriebenen Antworten, dass der Join keine Stufe erfindet und dass ein
* Konflikt zugunsten des Problems entschieden wird. Sie sagen nichts darueber,
* WELCHE Liste der Server fuer eine kaputte, eine binaere und eine
* gitignorierte Datei wirklich fuellt. Genau das ist die Frage dieses Laufs,
* und sie wird beantwortet, indem die Faelle praepariert, indiziert, an der
* Serverantwort abgelesen und danach im Baum wiedererkannt werden.
*
* Ablauf:
* 1. `npm run build`
* 2. isoliertes HOME, eigenes Rendezvous-Verzeichnis
* 3. eine KOPIE von fixtures/atlas-sample im Scratch, mit vier Praeparaten:
* saubere TS-Datei (unveraendert aus der Fixture), kaputte TS-Datei,
* Binaerdatei mit Nicht-Code-Endung, .gitignore samt gitignorierter Datei
* 4. die Kopie indizieren (die Fixture selbst bleibt byte-identisch)
* 5. C-Server auf einem freien Port >= 4320, dist/ auf einem zweiten
* 6. die Wahrheit am Server ablesen: index_status, check_index_coverage
* (scopes und paths), /api/tree rekursiv
* 7. Chromium ohne Aussenwelt, plus Route-Sperre
* 8a. Baum aufklappen und Zeile fuer Zeile gegen das Gemessene halten
* 8b. Galaxy-Legende: Eintraege, Klappen, Ueberleben des Reloads
* 8c. Reader: partielle Datei mit Inhalt und Notiz, inhaltslose Datei mit
* ehrlicher Erklaerung statt Fehler
* 8d. Frische: eine Datei nach dem Index aendern und die Notiz lesen
* 9. abraeumen, Restprozesse zaehlen, JSON und Screenshot schreiben
*
* Das Ganze laeuft unter dem Netz-Deny-Gate (npm run smoke:w4d).
*
* ## Drei Entscheidungen, die man sonst raten muesste
*
* **Praepariert wird nur an der Kopie.** fixtures/atlas-sample bleibt
* byte-identisch; eine kaputte Datei in der Fixture waere ein Praeparat, das
* jeder spaetere Lauf mitschleppt, ohne davon zu wissen.
*
* **Die Binaerdatei traegt feste Bytes.** Kein Zufall: derselbe Lauf soll
* zweimal dieselbe Datei erzeugen, sonst waere die Groesse in der Antwort des
* Servers von Lauf zu Lauf eine andere Zahl.
*
* **CBM_RUNTIME_DIR wird gesetzt.** Der Daemon des Servers und jede CLI
* verabreden sich in einem Rendezvous-Verzeichnis, das per Konto und nicht per
* HOME gilt: laeuft irgendwo sonst auf der Maschine eine CBM-Instanz mit einem
* anderen Cache-Verzeichnis, lehnt jede CLI dieses Laufs ab, und der Lauf waere
* nicht rot, sondern kaputt. Wortgleich mit tools/smoke-w4b.mjs.
*/
import { spawn } from 'node:child_process';
import { existsSync } from 'node:fs';
import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { dirname, join, resolve } from 'node:path';
import { fileURLToPath } from 'node:url';
import {
countListeners,
findFreePort,
indexRepository,
sleep,
startServer,
stopServer,
} from './lib/cbm-server.mjs';
import { startStaticProxy } from './lib/static-proxy.mjs';
const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
const BINARY = join(ROOT, 'cbm', 'build', 'c', 'codebase-memory-mcp');
const DIST = join(ROOT, 'dist');
const FIXTURE = join(ROOT, 'fixtures', 'atlas-sample');
const PROJECT = 'codeatlasweb-w4d';
const OUT_DIR = join(ROOT, 'verification', 'w4');
const OUT_JSON = join(OUT_DIR, 'coverage.json');
const SHOT = join(OUT_DIR, 'explorer-coverage.png');
const MIN_PORT = 4320;
/** Die vier Praeparate, je mit dem Pfad, unter dem sie in der Kopie liegen. */
const CLEAN_FILE = 'src/services/userService.ts';
const BROKEN_FILE = 'src/broken.ts';
const BINARY_FILE = 'assets/beleg.png';
const IGNORED_FILE = 'ignored-note.ts';
/** Die Datei, die nach dem Index geaendert wird, um die Frische zu pruefen. */
const FRESHNESS_FILE = 'src/config.ts';
/**
* Eine TypeScript-Datei mit echten Syntaxfehlern.
*
* Absichtlich unbalancierte Klammern in zwei Zeilen: tree-sitter faengt sich
* danach wieder, und genau das ist der interessante Fall. Eine Datei, die von
* der ersten Zeile an Muell ist, wuerde der Indexer moeglicherweise komplett
* verwerfen, und dann waere gemessen, was mit Muell passiert, und nicht, was
* mit einer Datei passiert, die jemand halb fertig gespeichert hat.
*/
const BROKEN_SOURCE = `// Deliberately broken for the W4d coverage measurement.
export function brokenGreeting(name: string): string {
const parts = [ 'hello', name ;
if (parts.length > {
return parts.join(' '
}
return name;
}
export function stillHere(value: number): number {
return value * 2;
}
`;
/** Chromium ohne Aussenwelt. Wortgleich mit smoke-w4c. */
const CHROMIUM_ARGS = [
'--host-resolver-rules=MAP * ~NOTFOUND, EXCLUDE 127.0.0.1, EXCLUDE localhost',
'--disable-background-networking',
'--disable-component-update',
'--disable-domain-reliability',
'--disable-client-side-phishing-detection',
'--disable-sync',
'--disable-default-apps',
'--no-first-run',
'--no-default-browser-check',
'--metrics-recording-only',
'--no-pings',
'--disable-breakpad',
'--disable-features=Translate,OptimizationHints,MediaRouter,AutofillServerCommunication,InterestFeedContentSuggestions,DialMediaRouteProvider,CalculateNativeWinOcclusion',
'--use-angle=swiftshader',
'--enable-unsafe-swiftshader',
];
const log = (...parts) => console.log('[smoke-w4d]', ...parts);
const serverLog = [];
function run(command, args, options = {}) {
return new Promise((done) => {
const child = spawn(command, args, {
cwd: options.cwd ?? ROOT,
env: {
...process.env,
...(options.env ?? {}),
NO_UPDATE_NOTIFIER: '1',
npm_config_update_notifier: 'false',
npm_config_audit: 'false',
npm_config_fund: 'false',
},
stdio: ['pipe', 'pipe', 'pipe'],
});
let out = '';
let err = '';
child.stdout.on('data', (d) => {
out += d.toString();
});
child.stderr.on('data', (d) => {
err += d.toString();
});
child.on('error', (error) => done({ code: 127, out, err: err + error.message }));
child.on('close', (code) => done({ code: code ?? 1, out, err }));
child.stdin.end();
});
}
/**
* Feste Bytes fuer die Binaerdatei: PNG-Signatur plus ein deterministisches
* Muster. Kein Math.random, siehe Kopf.
*/
function fixedBinary(size = 4096) {
const bytes = Buffer.alloc(size);
Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]).copy(bytes, 0);
for (let i = 8; i < size; i += 1) {
bytes[i] = (i * 37 + 11) & 0xff;
}
return bytes;
}
/** Die Fixture-Kopie mit ihren Praeparaten. Die Fixture selbst wird nur gelesen. */
async function prepareCopy(scratch) {
const copy = join(scratch, 'atlas-sample-w4d');
await cp(FIXTURE, copy, { recursive: true });
await writeFile(join(copy, BROKEN_FILE), BROKEN_SOURCE, 'utf8');
await mkdir(join(copy, 'assets'), { recursive: true });
await writeFile(join(copy, BINARY_FILE), fixedBinary());
// Die gitignorierte Datei ist gueltiges TypeScript und wuerde ohne die
// Regel indiziert. Nur so misst der Lauf die Regel und nicht die Endung.
await writeFile(
join(copy, IGNORED_FILE),
'export function ignoredHelper(value: string): string {\n'
+ ' return value.trim();\n'
+ '}\n',
'utf8',
);
await writeFile(join(copy, '.gitignore'), `${IGNORED_FILE}\n`, 'utf8');
return copy;
}
/** Ein Werkzeug ueber POST /rpc rufen, direkt am Server und ohne Origin. */
async function rpc(port, tool, args) {
const response = await fetch(`http://127.0.0.1:${port}/rpc`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
jsonrpc: '2.0',
id: Date.now() % 100000,
method: 'tools/call',
params: { name: tool, arguments: { ...args, format: 'json' } },
}),
});
const body = await response.json();
const text = body?.result?.content?.[0]?.text;
if (typeof text !== 'string') {
throw new Error(`/rpc ${tool}: Antwort ohne result.content[0].text: ${JSON.stringify(body).slice(0, 300)}`);
}
if (body.result.isError === true) {
throw new Error(`/rpc ${tool}: ${text.slice(0, 300)}`);
}
try {
return JSON.parse(text);
} catch {
throw new Error(`/rpc ${tool}: Antworttext war kein JSON: ${text.slice(0, 300)}`);
}
}
/** Den Graph-Baum rekursiv abfragen, so wie die Oberflaeche es tut. */
async function graphFiles(port, path = '', seen = new Set(), files = new Set(), dirs = new Set()) {
if (seen.has(path)) {
return { files, dirs };
}
seen.add(path);
const query = new URLSearchParams({ project: PROJECT });
if (path.length > 0) {
query.set('path', path);
}
const response = await fetch(`http://127.0.0.1:${port}/api/tree?${query.toString()}`, {
headers: { Accept: 'application/json' },
});
const body = await response.json();
for (const child of Array.isArray(body?.children) ? body.children : []) {
if (typeof child?.path !== 'string' || child.path === '{}' || child.path.length === 0) {
continue;
}
if (child.kind === 'dir') {
dirs.add(child.path);
await graphFiles(port, child.path, seen, files, dirs);
} else if (!dirs.has(child.path)) {
files.add(child.path);
}
}
return { files, dirs };
}
/** Alle Scope-Seiten holen, bis der Server keine mehr meldet. */
async function allScopeEntries(port) {
const pages = [];
let offset = 0;
for (let page = 0; page < 20; page += 1) {
const answer = await rpc(port, 'check_index_coverage', {
project: PROJECT,
scopes: ['.'],
scope_limit: 1000,
scope_offset: offset,
});
pages.push(answer);
const scope = answer?.scopes?.[0];
if (!scope || scope.has_more !== true) {
break;
}
const next = typeof scope.next_offset === 'number' ? scope.next_offset : offset;
if (next <= offset) {
break;
}
offset = next;
}
const entries = [];
for (const answer of pages) {
for (const entry of answer?.scopes?.[0]?.entries ?? []) {
entries.push(entry);
}
}
return { pages, entries, metadata: pages[pages.length - 1]?.metadata ?? {} };
}
// ------------------------------------------------------------- Browser ------
/** Der Coverage-Griff der Anwendung. */
const coverageSeam = (page) =>
page.evaluate(() => ({
rows: globalThis.__atlasCoverage?.rows ?? [],
records: globalThis.__atlasCoverage?.records ?? [],
truncations: globalThis.__atlasCoverage?.truncations ?? [],
counts: globalThis.__atlasCoverage?.counts ?? {},
metadata: globalThis.__atlasCoverage?.metadata ?? {},
open: globalThis.__atlasCoverage?.open,
error: globalThis.__atlasCoverage?.error ?? '',
}));
/** Was der Baum wirklich zeigt, mit den Werten, die der Browser malt. */
const treeSeam = (page) =>
page.evaluate(() => ({
rows: [...document.querySelectorAll('[data-testid="atlas-tree-row"][data-path]')].map((row) => {
const style = globalThis.getComputedStyle(row);
const mark = row.querySelector('[data-testid="atlas-tree-mark"]');
return {
path: row.getAttribute('data-path'),
kind: row.getAttribute('data-kind'),
coverage: row.getAttribute('data-coverage'),
expanded: row.getAttribute('data-expanded'),
title: row.getAttribute('title') ?? '',
mark: mark?.textContent ?? '',
markColor: mark === null ? '' : globalThis.getComputedStyle(mark).color,
opacity: Number(style.opacity),
color: style.color,
};
}),
legend: {
present: document.querySelector('[data-testid="atlas-tree-legend"]') !== null,
entries: [...document.querySelectorAll('[data-testid="atlas-tree-legend-entry"]')]
.map((entry) => entry.textContent?.replace(/\s+/g, ' ').trim() ?? ''),
source: document.querySelector('[data-testid="atlas-tree-legend-source"]')?.textContent ?? '',
},
truncationLines: [...document.querySelectorAll('[data-testid="atlas-tree-truncation"]')]
.map((line) => line.textContent ?? ''),
note: document.querySelector('.atlas-tree-note')?.textContent ?? '',
}));
/** Alles, was die Galaxy-Legende gerade zeigt. */
const galaxySeam = (page) =>
page.evaluate(() => {
const toggle = document.querySelector('[data-testid="atlas-galaxy-legend-toggle"]');
return {
togglePresent: toggle !== null,
expanded: toggle?.getAttribute('aria-expanded') ?? '',
arrow: toggle?.textContent?.trim() ?? '',
present: document.querySelector('[data-testid="atlas-galaxy-legend"]') !== null,
entries: [...document.querySelectorAll('[data-testid="atlas-galaxy-legend-entry"]')]
.map((entry) => ({
key: entry.getAttribute('data-entry'),
text: entry.textContent?.replace(/\s+/g, ' ').trim() ?? '',
})),
swatches: [...document.querySelectorAll('[data-testid="atlas-galaxy-legend-swatch"]')]
.map((swatch) => ({
type: swatch.getAttribute('data-type'),
color: swatch.getAttribute('data-color'),
painted: globalThis.getComputedStyle(
swatch.querySelector('.atlas-galaxy-legend-dot'),
).backgroundColor,
})),
};
});
/** Was der Reader gerade zeigt: Lage, Platzhalter und die Notiz darueber. */
const readerSeam = (page) =>
page.evaluate(() => {
const placeholder = document.querySelector('[data-testid="atlas-reader-placeholder"]');
const note = document.querySelector('[data-testid="atlas-coverage-note"]');
return {
status: globalThis.__atlasReader?.status ?? '',
path: globalThis.__atlasReader?.document?.path ?? '',
lines: (globalThis.__atlasReader?.value?.() ?? '').split('\n').length,
hasContent: (globalThis.__atlasReader?.value?.() ?? '').length > 0,
placeholderState: placeholder?.getAttribute('data-state') ?? '',
placeholder: placeholder?.textContent?.replace(/\s+/g, ' ').trim() ?? '',
coverageNote: note?.textContent?.replace(/\s+/g, ' ').trim() ?? '',
coverageNoteState: note?.getAttribute('data-coverage') ?? '',
statusCoverage:
document.querySelector('[data-chip="coverage"]')?.textContent?.replace(/\s+/g, ' ').trim() ?? '',
};
});
/** Bis in die letzte Ebene aufklappen, ueber genau den Klick, den ein Leser tut. */
async function expandAll(page) {
for (let round = 0; round < 12; round += 1) {
const clicked = await page.evaluate(() => {
const rows = [...document.querySelectorAll(
'[data-testid="atlas-tree-row"][data-kind="dir"][data-expanded="false"]',
)];
for (const row of rows) {
row.click();
}
return rows.length;
});
if (clicked === 0) {
return round;
}
await page.waitForTimeout(400);
}
return 12;
}
/** Die Seite laden und warten, bis Baum und Coverage-Join beide da sind. */
async function openApp(page, origin) {
await page.goto(`${origin}/?project=${PROJECT}`, { waitUntil: 'load' });
await page.waitForSelector('[data-testid="atlas-statusbar"]', { timeout: 30000 });
await page.waitForSelector('[data-testid="atlas-tree-row"]', { timeout: 30000 });
await page.waitForFunction(
() => (globalThis.__atlasCoverage?.records?.length ?? -1) >= 0
&& !/joining the coverage lists/.test(
document.querySelector('.atlas-tree-note')?.textContent ?? 'joining the coverage lists',
),
undefined,
{ timeout: 40000 },
);
}
/** Eine Datei im Baum anklicken und warten, bis der Reader eine Lage hat. */
async function openInTree(page, path) {
await page.click(`[data-testid="atlas-tree-row"][data-path="${path}"]`);
await page.waitForFunction(
(expected) => {
const seam = globalThis.__atlasReader;
if (seam === undefined) {
return false;
}
if (seam.status === 'unavailable' || seam.status === 'failed') {
return true;
}
return seam.status === 'ready' && seam.document?.path === expected;
},
path,
{ timeout: 40000 },
);
await page.waitForTimeout(500);
}
async function main() {
const totalStarted = Date.now();
let serverChild = null;
let proxy = null;
let browser = null;
let home = null;
let runtimeDir = null;
let scratch = null;
let serverPort = 0;
let uiPort = 0;
let failure = null;
const timings = {};
const result = {
treeShowsAllDiscovered: false,
states: [],
partialOrSkippedVisible: false,
dimmedNotIndexed: false,
legendShown: false,
brokenFileHonest: false,
freshnessNoteWorks: false,
undiscoveredGap: '',
galaxyLegendToggles: false,
galaxyLegendEntries: 0,
galaxyLegendStatePersists: false,
port: 0,
leftoverProcesses: 0,
};
const extras = { blockedRequests: [], consoleErrors: [], pageErrors: [], measured: {} };
try {
if (!existsSync(BINARY)) {
throw new Error(`Binary fehlt: ${BINARY} (erst 'make -f Makefile.cbm cbm-with-ui' im cbm-Clone bauen)`);
}
if (!existsSync(FIXTURE)) {
throw new Error(`Fixture fehlt: ${FIXTURE}`);
}
// ------------------------------------------------------------ 1. Bau
log('npm run build');
const buildStarted = Date.now();
const build = await run('npm', ['run', 'build']);
timings.buildMs = Date.now() - buildStarted;
if (build.code !== 0) {
throw new Error(`npm run build endete mit ${build.code}: ${build.err.trim().slice(-600)}`);
}
if (!existsSync(join(DIST, 'index.html'))) {
throw new Error('dist/index.html fehlt nach dem Build');
}
// ---------------------------------------------- 2. HOME, Rendezvous
home = await mkdtemp(join(tmpdir(), 'codeatlasweb-w4d-home-'));
runtimeDir = await mkdtemp('/private/tmp/codeatlasweb-w4d-run-');
scratch = await mkdtemp('/private/tmp/codeatlasweb-w4d-fix-');
process.env.CBM_RUNTIME_DIR = runtimeDir;
log('isoliertes HOME:', home);
log('Rendezvous:', runtimeDir);
// ------------------------------------------ 3. Die praeparierte Kopie
const repo = await prepareCopy(scratch);
extras.fixtureCopy = repo;
extras.prepared = {
clean: CLEAN_FILE,
broken: BROKEN_FILE,
binary: BINARY_FILE,
gitignored: IGNORED_FILE,
gitignoreLine: IGNORED_FILE,
};
log('Fixture-Kopie:', repo);
// -------------------------------------------------------- 4. Index
const indexed = await indexRepository(BINARY, { home, repoPath: repo, project: PROJECT });
extras.indexed = { nodes: indexed.nodes, edges: indexed.edges, skipped: indexed.skipped_count };
log(`indiziert: ${indexed.nodes} Knoten, ${indexed.edges} Kanten`);
// -------------------------------------------------------- 5. Server
serverPort = await findFreePort(MIN_PORT);
const started = await startServer(BINARY, { home, port: serverPort, log: serverLog });
serverChild = started.child;
timings.serverStartMs = started.durationMs;
uiPort = await findFreePort(MIN_PORT, [serverPort]);
proxy = await startStaticProxy({ distDir: DIST, upstreamPort: serverPort, port: uiPort });
result.port = uiPort;
extras.serverPort = serverPort;
log(`C-Server auf ${serverPort}, dist/ auf ${uiPort}`);
// --------------------------------- 6. Die Wahrheit am Server ablesen
const status = await rpc(serverPort, 'index_status', { project: PROJECT });
const scopes = await allScopeEntries(serverPort);
const { files: graphFileSet, dirs: graphDirSet } = await graphFiles(serverPort);
const measured = {
parsePartial: status?.parse_partial ?? null,
skipped: status?.skipped ?? null,
notIndexed: status?.not_indexed ?? null,
scopeEntries: scopes.entries,
scopeMetadata: scopes.metadata,
scopePages: scopes.pages.length,
graphFiles: [...graphFileSet].sort(),
graphDirs: [...graphDirSet].sort(),
};
extras.measured = measured;
/** In welcher Liste ein Pfad steht. Die Antwort auf die Kernfrage. */
const whereIs = (path) => {
const found = [];
if (measured.graphFiles.includes(path)) {
found.push('graph');
}
if ((measured.parsePartial?.files ?? []).some((entry) => entry.path === path)) {
found.push('index_status.parse_partial');
}
if ((measured.skipped?.files ?? []).some((entry) => entry.path === path)) {
found.push('index_status.skipped');
}
if ((measured.notIndexed?.files ?? []).some((entry) => entry.path === path)) {
found.push('index_status.not_indexed.files');
}
if ((measured.notIndexed?.dirs ?? []).includes(path)) {
found.push('index_status.not_indexed.dirs');
}
for (const entry of measured.scopeEntries) {
if (entry.path === path) {
found.push(`check_index_coverage.scope(kind=${entry.kind})`);
}
}
return found;
};
extras.whereIs = {
[CLEAN_FILE]: whereIs(CLEAN_FILE),
[BROKEN_FILE]: whereIs(BROKEN_FILE),
[BINARY_FILE]: whereIs(BINARY_FILE),
[IGNORED_FILE]: whereIs(IGNORED_FILE),
};
log('gemessen: broken ->', JSON.stringify(extras.whereIs[BROKEN_FILE]));
log('gemessen: binary ->', JSON.stringify(extras.whereIs[BINARY_FILE]));
log('gemessen: gitignored ->', JSON.stringify(extras.whereIs[IGNORED_FILE]));
// Die ausdrueckliche Pfad-Abfrage zur gitignorierten Datei (AC5).
const ignoredPathAnswer = await rpc(serverPort, 'check_index_coverage', {
project: PROJECT,
paths: [IGNORED_FILE],
});
extras.ignoredPathAnswer = ignoredPathAnswer?.paths?.[0] ?? null;
extras.ignoredMetadata = {
ignored_files_stored: ignoredPathAnswer?.metadata?.ignored_files_stored,
ignored_files_total: ignoredPathAnswer?.metadata?.ignored_files_total,
recording_status: ignoredPathAnswer?.metadata?.recording_status,
generation_matches: ignoredPathAnswer?.metadata?.generation_matches,
};
// ------------------------------------------------------- 7. Browser
const { chromium } = await import('playwright');
browser = await chromium.launch({ headless: true, args: CHROMIUM_ARGS });
const context = await browser.newContext({ viewport: { width: 1680, height: 1050 } });
const origin = `http://127.0.0.1:${uiPort}`;
await context.route('**/*', async (route) => {
const url = route.request().url();
if (url.startsWith(origin) || url.startsWith('data:') || url.startsWith('blob:')) {
await route.continue();
return;
}
extras.blockedRequests.push(url);
await route.abort();
});
const page = await context.newPage();
page.on('console', (message) => {
if (message.type() === 'error') {
extras.consoleErrors.push(message.text());
}
});
page.on('pageerror', (error) => extras.pageErrors.push(String(error)));
await mkdir(OUT_DIR, { recursive: true });
// --------------------------------------------- 8a. Der Baum im Bild
await openApp(page, origin);
const rounds = await expandAll(page);
const tree = await treeSeam(page);
const seam = await coverageSeam(page);
extras.expandRounds = rounds;
extras.tree = tree;
extras.seam = { ...seam, rows: seam.rows.length };
extras.seamRecords = seam.records;
const shownPaths = new Set(tree.rows.map((row) => row.path));
const expectedPaths = new Set([
...measured.graphFiles,
...(measured.parsePartial?.files ?? []).map((entry) => entry.path),
...(measured.skipped?.files ?? []).map((entry) => entry.path),
...(measured.notIndexed?.files ?? []).map((entry) => entry.path),
...(measured.notIndexed?.dirs ?? []),
...measured.scopeEntries.map((entry) => entry.path),
]);
const missing = [...expectedPaths].filter((path) => !shownPaths.has(path));
result.treeShowsAllDiscovered = missing.length === 0 && expectedPaths.size > 0;
extras.missingFromTree = missing;
log(`Baum: ${tree.rows.length} Zeilen, ${expectedPaths.size} erwartete Pfade, `
+ `${missing.length} fehlen`);
result.states = [...new Set(tree.rows.map((row) => row.coverage))].sort();
log('Stufen im Baum:', JSON.stringify(result.states));
// Die kaputte Datei muss die Stufe tragen, die der Server ihr gegeben
// hat, und ein Zeichen zeigen. Welche Stufe das ist, entscheidet der
// Server; dieser Lauf schreibt sie mit.
const brokenRow = tree.rows.find((row) => row.path === BROKEN_FILE);
const binaryRow = tree.rows.find((row) => row.path === BINARY_FILE);
const ignoredRow = tree.rows.find((row) => row.path === IGNORED_FILE);
extras.rows = { broken: brokenRow, binary: binaryRow, ignored: ignoredRow };
result.partialOrSkippedVisible =
brokenRow !== undefined
&& (brokenRow.coverage === 'partial' || brokenRow.coverage === 'skipped')
&& brokenRow.mark.length > 0
&& brokenRow.title.length > 0;
// Gemessen wird an Dateien, nicht an Ordnern: ein Ordner traegt die
// schlechteste Stufe seines Inhalts und bleibt normal hell, weil sie
// von einer Datei unter vielen kommen kann. Sein Punkt sagt genug.
const dimmable = tree.rows.filter((row) =>
row.kind === 'file'
&& (row.coverage === 'skipped' || row.coverage === 'not-indexed' || row.coverage === 'ignored'));
const folders = tree.rows.filter((row) => row.kind === 'dir' && row.coverage !== 'indexed');
result.dimmedNotIndexed = dimmable.length > 0 && dimmable.every((row) => row.opacity < 1);
extras.dimmed = dimmable.map((row) => ({ path: row.path, coverage: row.coverage, opacity: row.opacity }));
extras.markedFolders = folders.map((row) =>
({ path: row.path, coverage: row.coverage, mark: row.mark, opacity: row.opacity }));
if (dimmable.length === 0) {
extras.dimmedNotIndexedNote =
'no file row carried skipped, not-indexed or ignored in this run, so nothing could be dimmed';
}
result.legendShown =
tree.legend.present
&& tree.legend.entries.length >= 2
&& tree.legend.source.includes('files it never met are invisible');
log(`Legende: ${tree.legend.entries.length} Stufen, Quellensatz ${result.legendShown}`);
// --------------------------------------------- 8b. Die Galaxy-Legende
await page.waitForSelector('[data-testid="atlas-galaxy-legend-toggle"]', { timeout: 30000 });
await page.waitForFunction(
() => (globalThis.__atlasGalaxy?.nodes ?? 0) > 0,
undefined,
{ timeout: 40000 },
).catch(() => undefined);
const legendOpen = await galaxySeam(page);
result.galaxyLegendEntries = legendOpen.entries.length;
await page.click('[data-testid="atlas-galaxy-legend-toggle"]');
await page.waitForTimeout(300);
const legendClosed = await galaxySeam(page);
result.galaxyLegendToggles =
legendOpen.present
&& legendOpen.expanded === 'true'
&& legendOpen.arrow.startsWith('▾')
&& !legendClosed.present
&& legendClosed.expanded === 'false'
&& legendClosed.arrow.startsWith('▸');
extras.galaxyLegend = { open: legendOpen, closed: legendClosed };
log(`Galaxy-Legende: ${result.galaxyLegendEntries} Eintraege, `
+ `${legendOpen.swatches.length} Kantenfarben, Klappen ${result.galaxyLegendToggles}`);
// Zugeklappt neu laden: der Zustand muss den Reload ueberleben.
await openApp(page, origin);
const afterReload = await galaxySeam(page);
result.galaxyLegendStatePersists = !afterReload.present && afterReload.expanded === 'false';
extras.galaxyLegend.afterReload = afterReload;
log(`Galaxy-Legende nach Reload: offen=${afterReload.present}`);
// Wieder aufklappen und noch einmal laden, damit das Beweisbild die
// Legende zeigt und zugleich beweist, dass auch "offen" ueberlebt.
await page.click('[data-testid="atlas-galaxy-legend-toggle"]');
await page.waitForTimeout(300);
await openApp(page, origin);
const afterSecondReload = await galaxySeam(page);
extras.galaxyLegend.afterSecondReload = afterSecondReload;
result.galaxyLegendStatePersists =
result.galaxyLegendStatePersists && afterSecondReload.present;
// ------------------------------------------------ 8c. Der Reader
await expandAll(page);
await openInTree(page, BROKEN_FILE);
const brokenReader = await readerSeam(page);
extras.reader = { broken: brokenReader };
const brokenStage = brokenRow?.coverage ?? 'indexed';
// Was ehrlich heisst, haengt an der gemessenen Stufe: eine partielle
// Datei muss ihren Inhalt UND die Notiz zeigen, eine ohne Inhalt die
// Erklaerung statt eines Fehlers.
const brokenPartialOk =
brokenReader.status === 'ready'
&& brokenReader.hasContent
&& brokenReader.coverageNote.includes('partially parsed');
const brokenEmptyOk =
brokenReader.status === 'unavailable'
&& brokenReader.placeholder.includes('get_code_snippet')
&& brokenReader.placeholder.includes('Upstream-Ask 1');
const brokenHonest = brokenStage === 'partial' ? brokenPartialOk : brokenEmptyOk;
log(`Reader auf ${BROKEN_FILE} (Stufe ${brokenStage}): status=${brokenReader.status}, `
+ `Notiz="${brokenReader.coverageNote.slice(0, 80)}"`);
// Eine Datei ohne Inhalt: die ehrliche Erklaerung statt eines Fehlers.
const emptyPath = ignoredRow !== undefined ? IGNORED_FILE
: binaryRow !== undefined ? BINARY_FILE
: undefined;
let emptyReader = null;
if (emptyPath !== undefined) {
await openInTree(page, emptyPath);
emptyReader = await readerSeam(page);
extras.reader.empty = { path: emptyPath, ...emptyReader };
log(`Reader auf ${emptyPath}: status=${emptyReader.status}, `
+ `Platzhalter="${emptyReader.placeholder.slice(0, 90)}"`);
}
const emptyHonest =
emptyReader !== null
&& emptyReader.status === 'unavailable'
&& emptyReader.placeholderState === 'unavailable'
&& emptyReader.placeholder.includes('get_code_snippet')
&& !/failed|error/i.test(emptyReader.placeholder);
result.brokenFileHonest = brokenHonest && emptyHonest;
// ------------------------------------ Das Beweisbild mit den Stufen
await openInTree(page, BROKEN_FILE);
await page.evaluate(() => {
document.querySelector('[data-testid="atlas-tree"]')?.scrollIntoView({ block: 'start' });
// Der Cursor hat die Liste beim Oeffnen mitgezogen. Fuer das Bild
// zaehlt der Anfang des Baums, sonst fehlt die oberste Stufe.
const list = document.querySelector('.atlas-tree-list');
if (list !== null) {
list.scrollTop = 0;
}
});
await page.waitForTimeout(300);
await page.screenshot({ path: SHOT, fullPage: true });
log('explorer-coverage.png geschrieben');
// ---------------------------------------------------- 8d. Die Frische
await openInTree(page, FRESHNESS_FILE);
const beforeChange = await readerSeam(page);
const original = await readFile(join(repo, FRESHNESS_FILE), 'utf8');
await writeFile(
join(repo, FRESHNESS_FILE),
`${original}\n// changed after the index run, for the W4d freshness measurement\n`,
'utf8',
);
// Weg von der Datei und zurueck: die Frische wird beim Oeffnen gefragt,
// und ein zweites Mal auf dieselbe Datei zu klicken fragt nicht neu.
await openInTree(page, CLEAN_FILE);
await openInTree(page, FRESHNESS_FILE);
const afterChange = await readerSeam(page);
const afterSeam = await coverageSeam(page);
extras.freshness = {
file: FRESHNESS_FILE,
before: { chip: beforeChange.statusCoverage },
after: { chip: afterChange.statusCoverage, open: afterSeam.open },
};
result.freshnessNoteWorks =
afterChange.statusCoverage.length > 0
&& /metadata_changed/.test(afterChange.statusCoverage)
&& afterSeam.open?.freshness === 'metadata_changed';
log(`Frische: vorher "${beforeChange.statusCoverage}", nachher "${afterChange.statusCoverage}"`);
// ------------------------------------------- Die gemessene Aussage
const ignoredSources = extras.whereIs[IGNORED_FILE];
const ignoredAnswer = extras.ignoredPathAnswer;
const meta = extras.ignoredMetadata;
result.undiscoveredGap = ignoredSources.length === 0
? `gitignored file "${IGNORED_FILE}" appears nowhere: not in the graph, not in any `
+ 'index_status list, not among the coverage scope entries. '
+ `check_index_coverage(paths) answers status "${ignoredAnswer?.status ?? 'none'}", `
+ `freshness "${ignoredAnswer?.freshness ?? 'none'}"; metadata says `
+ `ignored_files_stored=${meta.ignored_files_stored}, ignored_files_total=${meta.ignored_files_total}. `
+ 'The explorer therefore cannot show it, and the legend says so.'
: `gitignored file "${IGNORED_FILE}" is listed by the server: ${ignoredSources.join(', ')}. `
+ `check_index_coverage(paths) answers status "${ignoredAnswer?.status ?? 'none'}", `
+ `freshness "${ignoredAnswer?.freshness ?? 'none'}", `
+ `recommended_action "${ignoredAnswer?.recommended_action ?? 'none'}"; metadata says `
+ `ignored_files_stored=${meta.ignored_files_stored}, ignored_files_total=${meta.ignored_files_total}, `
+ `recording_status "${meta.recording_status}". `
+ `The explorer shows it as "${ignoredRow?.coverage ?? 'not shown'}", `
+ 'so a file excluded by .gitignore is NOT an undiscovered gap on this server; '
+ 'the remaining gap is a file the discovery never walked at all, which no source names.';
log('undiscoveredGap:', result.undiscoveredGap.slice(0, 160));
extras.apiRoutes = { ...proxy.log.apiRoutes };
extras.rpcTools = { ...proxy.log.rpcTools };
await context.close();
} catch (err) {
failure = err;
console.error('[smoke-w4d] FEHLER:', err.message);
if (serverLog.length > 0) {
console.error('[smoke-w4d] Server-Log (letzte 20 Zeilen):\n' + serverLog.slice(-20).join('\n'));
}
}
if (browser !== null) {
await browser.close().catch(() => undefined);
}
if (proxy !== null) {
await proxy.close();
}
await stopServer(serverChild);
await sleep(500);
const leftovers = [];
for (const port of [serverPort, uiPort].filter((value) => value > 0)) {
leftovers.push(await countListeners(port));
}
result.leftoverProcesses = leftovers.reduce((sum, value) => sum + value, 0);
log('leftoverProcesses:', result.leftoverProcesses);
timings.totalMs = Date.now() - totalStarted;
await mkdir(OUT_DIR, { recursive: true });
await writeFile(
OUT_JSON,
JSON.stringify({
...result,
project: PROJECT,
fixture: 'fixtures/atlas-sample (nur gelesen; praepariert wurde eine Scratch-Kopie)',
timings,
generatedAt: new Date().toISOString(),
error: failure ? failure.message : null,
extras,
}, null, 2) + '\n',
'utf8',
);
log('geschrieben:', OUT_JSON);
const ok =
failure === null
&& result.treeShowsAllDiscovered === true
&& new Set(result.states).size >= 2
&& result.partialOrSkippedVisible === true
&& result.dimmedNotIndexed === true
&& result.legendShown === true
&& result.brokenFileHonest === true
&& result.freshnessNoteWorks === true
&& result.undiscoveredGap.length > 10
&& result.galaxyLegendToggles === true
&& result.galaxyLegendEntries >= 3
&& result.galaxyLegendStatePersists === true
&& result.port >= MIN_PORT
&& result.leftoverProcesses === 0
&& extras.blockedRequests.length === 0
&& extras.pageErrors.length === 0;
if (!ok) {
console.error('[smoke-w4d] W4d-Smoke NICHT gruen.');
if (home) {
console.error('[smoke-w4d] isoliertes HOME bleibt zum Nachsehen liegen:', home);
}
if (scratch) {
console.error('[smoke-w4d] Fixture-Kopie bleibt liegen:', scratch);
}
process.exitCode = 1;
return;
}
for (const directory of [home, runtimeDir, scratch]) {
if (directory) {
await rm(directory, { recursive: true, force: true });
}
}
log('W4d-Smoke gruen.');
}
main().catch((err) => {
console.error('[smoke-w4d] unerwarteter Fehler:', err);
process.exitCode = 1;
});