vibecodedshit 0.0.0-stage → 0.3.0

package/dist/exec/test-runners/vitest.js

@@ -0,0 +1,28 @@
+import { parseCoverageRanges } from '../test-reports/coverage-ranges.js';
+import { parseCoverageSummary } from '../test-reports/coverage-summary.js';
+import { parseVitestJson } from '../test-reports/vitest-json.js';
+/** vitest 4 has no `coverage.all`; `coverage.include` reports files no test loads. The provider is `@vitest/coverage-v8`, see `health-coverage-install`. */
+export const vitest = {
+    results: 'results.json',
+    coverage: 'coverage/coverage-summary.json',
+    ranges: 'coverage/coverage-final.json',
+    argv: (invocation, globs) => [
+        'npx',
+        '--no-install',
+        'vitest',
+        'run',
+        '--reporter=json',
+        '--outputFile=/out/results.json',
+        '--coverage.enabled',
+        '--coverage.provider=v8',
+        '--coverage.reporter=json-summary',
+        '--coverage.reporter=json',
+        '--coverage.reportsDirectory=/out/coverage',
+        '--coverage.reportOnFailure',
+        ...globs.map((glob) => `--coverage.include=${glob}`),
+        ...invocation.args,
+    ],
+    parseResults: parseVitestJson,
+    parseCoverage: parseCoverageSummary,
+    parseRanges: parseCoverageRanges,
+};

package/dist/exec/tests.js

@@ -0,0 +1,120 @@
+import { emptyTallies, tallyUnits, unitId } from '../measure/units.js';
+import { analyzeTsFile } from '../scope/ts-lines.js';
+import { failedRootOf, withFailedUnits } from './roots.js';
+import { coveredLines } from './test-reports/coverage-ranges.js';
+/** Why the test run is a repository failure (1.1 to 1.3, 6.3 score 0), or null when every run has a usable results report. */
+export function testFailure(exec) {
+    if (!exec.checksRan)
+        return 'install failed, so the step did not run';
+    for (const run of exec.test.invocations) {
+        if (run.outcome.status === 'timeout')
+            return `${run.runner} timed out in ${run.dir}`;
+        if (!run.results)
+            return `${run.runner} wrote no usable results report in ${run.dir}`;
+    }
+    return null;
+}
+export function totalCases(exec) {
+    return exec.test.invocations.reduce((sum, run) => sum + (run.results ? run.results.passed + run.results.failed + run.results.errored + run.results.skipped : 0), 0);
+}
+function isUnder(file, dir) {
+    return dir === '.' || file.startsWith(`${dir}/`);
+}
+/** 1.1: passed / (passed + failed + errored) per test invocation. Skipped cases are in neither. With no case anywhere every unit is 0 of 0. */
+export function measurePassRate(ctx) {
+    const exec = ctx.exec;
+    if (!exec)
+        return { status: 'not_measured', reason: 'execution layer did not run' };
+    const reason = testFailure(exec);
+    if (reason !== null)
+        return { status: 'failed', reason };
+    const logic = ctx.scope.files.filter((f) => f.role === 'logic');
+    if (exec.test.invocations.length === 0)
+        return { status: 'measured', units: withFailedUnits(exec, ctx.scope, tallyUnits(emptyTallies(logic))) };
+    const units = exec.test.invocations.map((run) => {
+        const counts = run.results ?? { passed: 0, failed: 0, errored: 0, skipped: 0 };
+        return {
+            package: run.dir,
+            group: run.group,
+            weight: logic.filter((f) => f.group === run.group && isUnder(f.path, run.dir)).reduce((sum, f) => sum + f.logicLines, 0),
+            raw: { kind: 'ratio', numerator: counts.passed, denominator: counts.passed + counts.failed + counts.errored, scale: 100 },
+        };
+    });
+    return { status: 'measured', units: withFailedUnits(exec, ctx.scope, units) };
+}
+/** Code lines of a TS/JS logic file and how many ran, or null when no invocation's coverage-final.json lists the file. */
+function tsLineCoverage(ctx, exec, file) {
+    const reported = exec.test.invocations.map((run) => run.ranges?.get(file)).filter((r) => r !== undefined);
+    if (reported.length === 0)
+        return null;
+    const codeLines = analyzeTsFile(file, ctx.scope.getTsSourceFile(file).text).codeLineNumbers;
+    const covered = new Set();
+    for (const ranges of reported)
+        for (const line of coveredLines(codeLines, ranges))
+            covered.add(line);
+    return { total: codeLines.size, covered: covered.size };
+}
+/**
+ * 1.2 (lines) and 1.3 (branches): covered over coverable across the in-scope logic files, per (package,
+ * group) unit. 1.2 does not take the runner's line counts, which differ between runners for the same code:
+ * for a TS/JS file the coverable lines are health's own code lines and a line is covered when the innermost
+ * statement or function range holding it ran in any invocation (see `coveredLines`). Python lines and all
+ * branches are the tool's counts. A logic file the coverage report lacks counts as 0 covered with its logic
+ * lines coverable (it adds no branches), so it cannot raise the ratio. Coverage entries outside the logic set are dropped.
+ * With no test case at all every unit is 0 of 0 and scores `when_empty`.
+ */
+export function measureCoverage(ctx, kind) {
+    const exec = ctx.exec;
+    if (!exec)
+        return { status: 'not_measured', reason: 'execution layer did not run' };
+    const reason = testFailure(exec);
+    if (reason !== null)
+        return { status: 'failed', reason };
+    const logic = ctx.scope.files.filter((f) => f.role === 'logic');
+    const tallies = emptyTallies(logic);
+    if (totalCases(exec) === 0)
+        return { status: 'measured', units: withFailedUnits(exec, ctx.scope, tallyUnits(tallies)) };
+    const merged = new Map();
+    for (const run of exec.test.invocations) {
+        for (const [file, cov] of run.coverage ?? []) {
+            const had = merged.get(file);
+            merged.set(file, {
+                lines: { total: (had?.lines.total ?? 0) + cov.lines.total, covered: (had?.lines.covered ?? 0) + cov.lines.covered },
+                branches: { total: (had?.branches.total ?? 0) + cov.branches.total, covered: (had?.branches.covered ?? 0) + cov.branches.covered },
+            });
+        }
+    }
+    let missing = 0;
+    for (const file of logic) {
+        const tally = tallies.get(unitId(file));
+        if (!tally || failedRootOf(exec, file.path, file.group))
+            continue;
+        if (kind === 'lines' && file.group === 'typescript_javascript') {
+            const lines = tsLineCoverage(ctx, exec, file.path);
+            if (lines === null) {
+                missing += 1;
+                tally.denominator += file.logicLines;
+            }
+            else {
+                tally.numerator += lines.covered;
+                tally.denominator += lines.total;
+            }
+            continue;
+        }
+        const cov = merged.get(file.path);
+        if (cov) {
+            tally.numerator += cov[kind].covered;
+            tally.denominator += cov[kind].total;
+        }
+        else {
+            missing += 1;
+            if (kind === 'lines')
+                tally.denominator += file.logicLines;
+        }
+    }
+    return {
+        status: 'measured',
+        units: withFailedUnits(exec, ctx.scope, tallyUnits(tallies)),
+        ...(kind === 'lines' && missing > 0 ? { warnings: [`${missing} logic file(s) missing from the coverage report were counted as 0% covered`] } : {}),
+    };
+}

package/dist/exec/types.js

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

package/dist/interactive/after-scan.js

@@ -0,0 +1,121 @@
+import { renderReport } from '../report/render.js';
+import { EMAIL_PATTERN, MAX_EMAIL_CHARS, MAX_PAYLOAD_BYTES, PRIVACY_URL, QUOTE_URL } from '../submit/constants.js';
+import { buildPayload, PayloadError } from '../submit/payload.js';
+import { repoIdentity, RepoIdentityError } from '../submit/repo-identity.js';
+import { sendPayload } from '../submit/send.js';
+/** Bands whose owners are offered a quote for the fixing service. */
+const QUOTE_BANDS = new Set(['vibe_coded', 'fragile']);
+const QUOTE_TIMEOUT_MS = 30_000;
+async function askEmail(prompt, io) {
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        const email = await prompt.text('Your email:');
+        if (email.length <= MAX_EMAIL_CHARS && EMAIL_PATTERN.test(email))
+            return email;
+        io.stderr('That is not a valid email address.\n');
+    }
+    return null;
+}
+async function submitToLeaderboard(run, ctx, emailFor) {
+    const { io, prompt } = ctx;
+    if (run.mode !== 'full' || !run.comparable) {
+        const why = run.mode === 'full' ? (run.comparableReason ?? 'not comparable') : 'a preview scan, a full scan with Docker is needed';
+        io.stdout(`This run cannot go on the global leaderboard: ${why}.\n`);
+        return;
+    }
+    io.stdout(`The leaderboard gets your scores, a hash of your repository URL and your email. No code, no file paths. Privacy: ${PRIVACY_URL}\n`);
+    if (!(await prompt.confirm('Submit your score to the global leaderboard?')))
+        return;
+    const email = await emailFor();
+    if (email === null)
+        return;
+    try {
+        const identity = await repoIdentity(run.repo.path, ctx.git);
+        const payload = buildPayload({ run, repoHash: identity.hash, email });
+        if (Buffer.byteLength(JSON.stringify(payload), 'utf8') > MAX_PAYLOAD_BYTES) {
+            io.stderr('Not submitted: the payload is larger than 64 KB, the server limit.\n');
+            return;
+        }
+        const result = await sendPayload(payload, ctx.fetch);
+        if (!result.ok) {
+            io.stderr(`Not submitted. ${result.message}\n`);
+            return;
+        }
+        const rank = result.rank;
+        const rankLine = rank ? ` Rank ${rank.rank} of ${rank.total}.${rank.top10Threshold === null ? '' : ` Top 10 starts at ${rank.top10Threshold}.`}` : '';
+        io.stdout(`Submitted.${rankLine}\n`);
+    }
+    catch (err) {
+        if (err instanceof RepoIdentityError || err instanceof PayloadError) {
+            io.stderr(`Not submitted: ${err.message}\n`);
+            return;
+        }
+        throw err;
+    }
+}
+async function requestQuote(run, methodology, ctx, emailFor) {
+    const { io, prompt } = ctx;
+    if (!run.health || !QUOTE_BANDS.has(run.health.band))
+        return;
+    const bandName = methodology.bands.find((b) => b.key === run.health?.band)?.name ?? run.health.band;
+    io.stdout(`\nYour app is ${bandName}. Peter, the creator of this scan, runs a service that fixes vibe-coded apps.\n`);
+    io.stdout('A quote request sends your name, email, run.json and the HTML report (scores and file paths, no source code).\n');
+    if (!(await prompt.confirm('Do you want to ask for a quote?')))
+        return;
+    const name = await prompt.text('Your name:');
+    if (name === '') {
+        io.stderr('A name is needed for the quote request. Nothing was sent.\n');
+        return;
+    }
+    const email = await emailFor();
+    if (email === null)
+        return;
+    const note = await prompt.text('Anything Peter should know? (optional, press Enter to skip)');
+    let repoHash;
+    try {
+        repoHash = (await repoIdentity(run.repo.path, ctx.git)).hash;
+    }
+    catch (err) {
+        if (!(err instanceof RepoIdentityError))
+            throw err;
+        io.stderr(`Nothing was sent: ${err.message}\n`);
+        return;
+    }
+    const body = {
+        contact: { name, email, ...(note === '' ? {} : { note }) },
+        methodologyVersion: run.methodology.version,
+        health: run.health.displayed,
+        band: run.health.band,
+        repoHash,
+        run,
+        report: renderReport(run, methodology),
+    };
+    try {
+        const response = await ctx.fetch(QUOTE_URL, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(QUOTE_TIMEOUT_MS),
+        });
+        if (response.ok) {
+            io.stdout('Quote requested. Peter will reply by email.\n');
+            return;
+        }
+        io.stderr(`The quote request failed (${response.status}): ${(await response.text()).slice(0, 300)}. Reach Peter at https://vibecodedshit.com\n`);
+    }
+    catch (err) {
+        io.stderr(`The quote request failed: ${err instanceof Error ? err.message : String(err)}. Reach Peter at https://vibecodedshit.com\n`);
+    }
+}
+/** After an interactive scan: offer the leaderboard, then a quote for Vibe-coded and Fragile apps. Nothing is sent without a yes. */
+export async function afterScan(run, methodology, ctx) {
+    if (!run.valid)
+        return;
+    let email;
+    const emailFor = async () => {
+        if (email === undefined)
+            email = await askEmail(ctx.prompt, ctx.io);
+        return email;
+    };
+    await submitToLeaderboard(run, ctx, emailFor);
+    await requestQuote(run, methodology, ctx, emailFor);
+}

package/dist/interactive/docker-setup.js

@@ -0,0 +1,97 @@
+import { imageBuildCommand } from '../commands/footer.js';
+import { ToolError } from '../scope/types.js';
+const DOWNLOAD_URL = 'https://www.docker.com/products/docker-desktop/';
+const START_TIMEOUT_MS = 180_000;
+const POLL_MS = 3_000;
+const ok = (code) => code === 0;
+async function install(ctx) {
+    const { system, io } = ctx;
+    if (system.platform === 'darwin') {
+        if (!ok(await system.exec('brew', ['--version']))) {
+            io.stderr(`Homebrew is not installed, so Docker cannot be installed for you. Download Docker Desktop from ${DOWNLOAD_URL}\n`);
+            return false;
+        }
+        return ok(await system.exec('brew', ['install', '--cask', 'docker-desktop'], { inherit: true }));
+    }
+    if (system.platform === 'linux') {
+        return ok(await system.exec('sh', ['-c', 'curl -fsSL https://get.docker.com | sudo sh'], { inherit: true }));
+    }
+    if (system.platform === 'win32') {
+        const args = ['install', '-e', '--id', 'Docker.DockerDesktop', '--accept-package-agreements', '--accept-source-agreements'];
+        return ok(await system.exec('winget', args, { inherit: true }));
+    }
+    io.stderr(`Docker cannot be installed for you on ${system.platform}. Download it from ${DOWNLOAD_URL}\n`);
+    return false;
+}
+async function start(ctx) {
+    const { system, io } = ctx;
+    if (system.platform === 'darwin') {
+        await system.exec('open', ['-a', 'Docker']);
+        io.stdout('Starting Docker Desktop. If it asks you to accept its terms, do that in its window.\n');
+    }
+    else if (system.platform === 'linux') {
+        await system.exec('sudo', ['systemctl', 'start', 'docker'], { inherit: true });
+    }
+    else if (system.platform === 'win32') {
+        await system.exec('cmd', ['/c', 'start', '', 'C:\\Program Files\\Docker\\Docker\\Docker Desktop.exe']);
+        io.stdout('Starting Docker Desktop. If it asks you to accept its terms, do that in its window.\n');
+    }
+    io.stdout('Waiting for Docker to start (up to 3 minutes)...\n');
+    for (let waited = 0; waited < START_TIMEOUT_MS; waited += POLL_MS) {
+        if (ok(await system.exec('docker', ['info'])))
+            return true;
+        await system.sleep(POLL_MS);
+    }
+    return false;
+}
+function notStarted(platform) {
+    const linux = platform === 'linux' ? ' If Docker runs but needs sudo, run `sudo usermod -aG docker $USER`, log in again and rerun the scan.' : '';
+    return `Docker did not start within 3 minutes.${linux}`;
+}
+/**
+ * Get Docker and the scan image ready for a full run, asking before each install, start or build.
+ * Any No, or a step that fails, returns the reason to fall back to a preview scan.
+ */
+export async function setUpDocker(tag, ctx) {
+    const { system, prompt, io } = ctx;
+    if (!ok(await system.exec('docker', ['--version']))) {
+        if (!(await prompt.confirm('Docker is not installed. A full scan needs it. Install and start Docker now?'))) {
+            return { previewReason: 'Docker is not installed.' };
+        }
+        if (!(await install(ctx)))
+            return { previewReason: 'Docker could not be installed.' };
+        if (!(await start(ctx)))
+            return { previewReason: notStarted(system.platform) };
+    }
+    else if (!ok(await system.exec('docker', ['info']))) {
+        if (!(await prompt.confirm('Docker is installed but not running. Start it now?'))) {
+            return { previewReason: 'Docker is not running.' };
+        }
+        if (!(await start(ctx)))
+            return { previewReason: notStarted(system.platform) };
+    }
+    try {
+        return { digest: await ctx.imageDigest(tag) };
+    }
+    catch (err) {
+        if (!(err instanceof ToolError))
+            throw err;
+        const state = err.message.includes('out of date') ? 'is out of date' : 'is not built yet';
+        if (!(await prompt.confirm(`The scan image ${tag} ${state}. Build it now? The first build takes about 5 to 10 minutes.`))) {
+            return { previewReason: `The scan image ${tag} ${state}.` };
+        }
+    }
+    const build = imageBuildCommand(ctx.packageRoot, tag).split(' ');
+    if (!ok(await system.exec(build[0] ?? 'docker', build.slice(1), { inherit: true }))) {
+        return { previewReason: `Building the scan image failed. Retry with: ${build.join(' ')}` };
+    }
+    try {
+        io.stdout(`Built ${tag}.\n`);
+        return { digest: await ctx.imageDigest(tag) };
+    }
+    catch (err) {
+        if (!(err instanceof ToolError))
+            throw err;
+        return { previewReason: err.message };
+    }
+}

package/dist/interactive/prompt.js

@@ -0,0 +1,17 @@
+import { createInterface } from 'node:readline/promises';
+async function ask(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return (await rl.question(question)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+export const terminalPrompter = {
+    async confirm(question) {
+        const answer = await ask(`${question} [y/N] `);
+        return /^y(es)?$/i.test(answer);
+    },
+    text: (question) => ask(`${question} `),
+};

package/dist/interactive/system.js

@@ -0,0 +1,10 @@
+import { spawn } from 'node:child_process';
+export const hostSystem = {
+    platform: process.platform,
+    exec: (command, args, opts = {}) => new Promise((resolve) => {
+        const child = spawn(command, args, { stdio: opts.inherit ? 'inherit' : 'ignore' });
+        child.on('error', () => resolve(null));
+        child.on('close', (code) => resolve(code));
+    }),
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+};

package/dist/manifest/package-json.js

@@ -0,0 +1,36 @@
+import path from 'node:path';
+import { readTracked } from '../scope/tracked.js';
+const DEPENDENCY_FIELDS = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
+function stringRecord(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === 'string'));
+}
+/** The `package.json` in `dir` (repo-relative, "." for the root). Missing or invalid JSON gives undefined. */
+export function readPackageJson(repoPath, dir) {
+    const text = readTracked(repoPath, path.posix.join(dir === '' ? '.' : dir, 'package.json'));
+    if (text === null)
+        return undefined;
+    let json;
+    try {
+        json = JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+    if (json === null || typeof json !== 'object' || Array.isArray(json))
+        return undefined;
+    const bag = json;
+    const dependencies = {};
+    for (const field of DEPENDENCY_FIELDS)
+        Object.assign(dependencies, stringRecord(bag[field]));
+    return {
+        ...(typeof bag.name === 'string' ? { name: bag.name } : {}),
+        scripts: stringRecord(bag.scripts),
+        dependencies,
+        engines: stringRecord(bag.engines),
+        ...(bag.volta !== null && typeof bag.volta === 'object' ? { volta: bag.volta } : {}),
+        ...(typeof bag.packageManager === 'string' ? { packageManager: bag.packageManager } : {}),
+        ...(bag.workspaces === undefined ? {} : { workspaces: bag.workspaces }),
+    };
+}

package/dist/manifest/python.js

@@ -0,0 +1,106 @@
+import path from 'node:path';
+import { parse } from 'smol-toml';
+import { readTracked, trackedPaths } from '../scope/tracked.js';
+import { parseIni } from '../util/ini.js';
+/** PEP 503 normalisation: lowercase, runs of `-`, `_` and `.` become `-`. */
+export function normalizeName(name) {
+    return name.toLowerCase().replace(/[-_.]+/g, '-');
+}
+/** The distribution name at the start of a requirement string (`Django[argon2]>=4 ; python_version>"3"`). */
+function requirementName(text) {
+    const match = /^\s*([A-Za-z0-9][A-Za-z0-9._-]*)/.exec(text);
+    return match?.[1] === undefined ? undefined : normalizeName(match[1]);
+}
+function readTomlTracked(repoPath, rel) {
+    const text = readTracked(repoPath, rel);
+    if (text === null)
+        return undefined;
+    try {
+        return parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+const asRecord = (value) => (typeof value === 'object' && value !== null && !Array.isArray(value) ? value : {});
+function addRequirements(out, value) {
+    if (!Array.isArray(value))
+        return;
+    for (const entry of value) {
+        if (typeof entry !== 'string')
+            continue;
+        const name = requirementName(entry);
+        if (name !== undefined)
+            out.add(name);
+    }
+}
+function addKeys(out, value) {
+    for (const key of Object.keys(asRecord(value))) {
+        if (key.toLowerCase() !== 'python')
+            out.add(normalizeName(key));
+    }
+}
+function addRequirementsFile(repoPath, rel, out, followIncludes) {
+    const text = readTracked(repoPath, rel);
+    if (text === null)
+        return;
+    for (const raw of text.split(/\r\n|\r|\n/)) {
+        const line = raw.replace(/(^|\s)#.*$/, '').trim();
+        if (line === '')
+            continue;
+        const include = /^(?:-r|--requirement)[\s=]+(\S+)/.exec(line);
+        if (include?.[1] !== undefined) {
+            if (followIncludes)
+                addRequirementsFile(repoPath, path.posix.normalize(path.posix.join(path.posix.dirname(rel), include[1])), out, false);
+            continue;
+        }
+        if (line.startsWith('-'))
+            continue;
+        const name = requirementName(line);
+        if (name !== undefined)
+            out.add(name);
+    }
+}
+/**
+ * Dependency names declared by the manifests in `dir` only (never an ancestor's): `[project]` dependencies and
+ * optional dependencies, `[dependency-groups]`, `[tool.poetry]` tables, `requirements*.txt` (with `-r` includes one
+ * level deep), `Pipfile` packages and `setup.cfg` `install_requires`. Names are PEP 503 normalised.
+ */
+export function pythonDeclaredDeps(repoPath, dir) {
+    const out = new Set();
+    const at = (name) => (dir === '.' || dir === '' ? name : path.posix.join(dir, name));
+    const pyproject = readTomlTracked(repoPath, at('pyproject.toml'));
+    if (pyproject !== undefined) {
+        const project = asRecord(pyproject.project);
+        addRequirements(out, project.dependencies);
+        for (const list of Object.values(asRecord(project['optional-dependencies'])))
+            addRequirements(out, list);
+        for (const list of Object.values(asRecord(pyproject['dependency-groups'])))
+            addRequirements(out, list);
+        const poetry = asRecord(asRecord(pyproject.tool).poetry);
+        addKeys(out, poetry.dependencies);
+        addKeys(out, poetry['dev-dependencies']);
+        for (const group of Object.values(asRecord(poetry.group)))
+            addKeys(out, asRecord(group).dependencies);
+    }
+    const prefix = dir === '.' || dir === '' ? '' : `${dir}/`;
+    for (const file of trackedPaths(repoPath)) {
+        if (!file.startsWith(prefix))
+            continue;
+        const name = file.slice(prefix.length);
+        if (/^requirements[^/]*\.txt$/.test(name))
+            addRequirementsFile(repoPath, file, out, true);
+    }
+    const pipfile = readTomlTracked(repoPath, at('Pipfile'));
+    if (pipfile !== undefined) {
+        addKeys(out, pipfile.packages);
+        addKeys(out, pipfile['dev-packages']);
+    }
+    const setupCfg = readTracked(repoPath, at('setup.cfg'));
+    if (setupCfg !== null) {
+        const required = parseIni(setupCfg).options?.install_requires;
+        if (required !== undefined)
+            addRequirements(out, required.split('\n'));
+    }
+    return out;
+}

package/dist/measure/d3/index.js

@@ -0,0 +1,45 @@
+import { pyAdapter } from './py/adapter.js';
+import { tsAdapter } from './ts/adapter.js';
+/** Explicit list. */
+const D3_ADAPTERS = [tsAdapter, pyAdapter];
+function adaptersFor(ctx) {
+    const groups = new Set(ctx.scope.files.filter((f) => f.role === 'logic').map((f) => f.group));
+    return D3_ADAPTERS.filter((adapter) => groups.has(adapter.group));
+}
+/**
+ * Why D3 cannot be measured as a whole: a language group has logic files but no adapter yet.
+ * Partial pooling would score only the languages that have one.
+ */
+export function d3Gap(ctx) {
+    const covered = new Set(D3_ADAPTERS.map((adapter) => adapter.group));
+    const missing = [...new Set(ctx.scope.files.filter((f) => f.role === 'logic').map((f) => f.group))].filter((g) => !covered.has(g));
+    return missing.length === 0 ? undefined : `D3 is not implemented yet for ${missing.join(', ')}`;
+}
+/** The rules facet: needs no external tool. Memoized per scan. */
+export function getD3Rules(ctx) {
+    return ctx.tools.memo(`d3:rules:${ctx.repoPath}`, async () => {
+        const units = [];
+        const warnings = [];
+        for (const adapter of adaptersFor(ctx)) {
+            const result = await adapter.rules(ctx);
+            units.push(...result.units);
+            warnings.push(...result.warnings);
+        }
+        return { units, warnings };
+    });
+}
+/** The graph facet. When any needed adapter is unavailable, the whole facet is (no partial pool). Memoized per scan. */
+export function getD3Graph(ctx) {
+    return ctx.tools.memo(`d3:graph:${ctx.repoPath}`, async () => {
+        const units = [];
+        const warnings = [];
+        for (const adapter of adaptersFor(ctx)) {
+            const result = await adapter.graph(ctx);
+            if ('unavailable' in result)
+                return result;
+            units.push(...result.units);
+            warnings.push(...result.warnings);
+        }
+        return { units, warnings };
+    });
+}