pi-python-helper 0.1.0

package/src/project/conformance.ts

@@ -0,0 +1,343 @@
+import { type Diagnostic, warn } from '../core/result.ts';
+import type { InstalledEnvironment } from './installed.ts';
+import { normalizeDistributionName } from './installed.ts';
+import type { LockPackage, LockSection, ManifestSection } from './scanner.ts';
+
+/**
+ * Declared dependencies that `uv sync` installs without extra flags:
+ * `[project] dependencies` plus the default `dev` dependency group. Optional
+ * extras are excluded because a plain sync never installs them.
+ */
+export function requiredDeclarationsFrom(
+  manifest: ManifestSection | undefined,
+  defaultGroup = 'dev',
+): { name: string; normalized: string; marker: string | null }[] {
+  if (!manifest) return [];
+  const groups = [manifest.dependencies, manifest.dependencyGroups[defaultGroup] ?? []];
+  return groups.flatMap((list) =>
+    list.map((dependency) => ({
+      name: dependency.name,
+      normalized: dependency.normalized,
+      marker: dependency.marker,
+    })),
+  );
+}
+
+export type ConformanceCode =
+  | 'INSTALLED_VERSION_MISMATCH'
+  | 'INSTALLED_PACKAGE_MISSING'
+  | 'INSTALLED_PACKAGE_UNTRACKED'
+  | 'INSTALLED_ENVIRONMENT_INDEPENDENT'
+  | 'PROJECT_NOT_INSTALLED'
+  | 'PROJECT_INSTALLED_NOT_EDITABLE';
+
+export interface ConformanceFinding {
+  code: ConformanceCode;
+  message: string;
+  name: string;
+  expected?: string;
+  actual?: string;
+}
+
+export interface ConformanceReport {
+  verdict: 'consistent' | 'drifted' | 'unverifiable';
+  /** False whenever the comparison could not cover every distribution. */
+  complete: boolean;
+  reason: string;
+  checks: {
+    venvPresent: boolean;
+    lockPresent: boolean;
+    installedScanned: boolean;
+    projectInstalled: boolean | null;
+    projectEditable: boolean | null;
+  };
+  counts: {
+    lockPackages: number;
+    installedPackages: number;
+    mismatched: number;
+    missing: number;
+    /** Locked entries that are conditional for this platform and correctly absent. */
+    conditional: number;
+    untracked: number;
+  };
+  findings: ConformanceFinding[];
+  warnings: Diagnostic[];
+  notes: Diagnostic[];
+}
+
+/**
+ * Untracked packages are only reported individually while they look like an
+ * anomaly. Hundreds of them mean the environment is not managed by this
+ * lockfile at all (a shared or conda environment), which deserves one summary
+ * instead of a wall of warnings.
+ */
+const INDEPENDENT_ENVIRONMENT_MIN = 20;
+const INDEPENDENT_ENVIRONMENT_RATIO = 0.5;
+
+/** Lock entries that are a local project rather than an index download. */
+function isLocalProjectEntry(package_: LockPackage): boolean {
+  return package_.source === 'editable' || package_.source === 'virtual';
+}
+
+/** The entry that represents the project this command is running in. */
+function isRootProjectEntry(package_: LockPackage, projectName: string | undefined): boolean {
+  if (!isLocalProjectEntry(package_)) return false;
+  if (!projectName) return true;
+  return package_.normalized === normalizeDistributionName(projectName);
+}
+
+export interface ConformanceInput {
+  lock?: LockSection;
+  installed?: InstalledEnvironment;
+  projectName?: string;
+  /**
+   * Declared dependencies that `uv sync` installs without extra flags:
+   * `[project] dependencies` plus the default `dev` group. Used to decide
+   * whether an absent locked package is genuinely missing.
+   */
+  requiredDeclarations?: { name: string; normalized: string; marker: string | null }[];
+}
+
+/**
+ * Names that must be installed: a declaration with no marker, or an edge
+ * without a marker coming from the root project or from a package that is
+ * itself installed. Everything else is platform- or version-conditional and is
+ * correctly absent, so its absence is not drift.
+ */
+function requiredInstalledNames(
+  lock: LockSection,
+  installedNormalized: Set<string>,
+  input: ConformanceInput,
+): Set<string> {
+  const required = new Set<string>();
+  for (const declaration of input.requiredDeclarations ?? []) {
+    if (declaration.marker === null) required.add(declaration.normalized);
+  }
+  for (const entry of lock.packages) {
+    const isReachableSource =
+      isRootProjectEntry(entry, input.projectName) || installedNormalized.has(entry.normalized);
+    if (!isReachableSource) continue;
+    for (const edge of entry.dependencies ?? []) {
+      if (edge.marker === null) required.add(edge.normalized);
+    }
+  }
+  return required;
+}
+
+/**
+ * Compare the three sources of truth that describe a Python environment:
+ * what `pyproject.toml` declares, what `uv.lock` resolved, and what is actually
+ * present in `.venv`.
+ *
+ * Only the lock-versus-installed leg is computed here; declared-versus-lock is
+ * reported by the manifest drift check, so the two never duplicate a finding.
+ */
+export function compareInstalledConformance(input: ConformanceInput): ConformanceReport {
+  const { lock, installed, projectName } = input;
+  const findings: ConformanceFinding[] = [];
+  const warnings: Diagnostic[] = [];
+  const notes: Diagnostic[] = [];
+  const venvPresent = installed !== undefined;
+  const lockPresent = lock?.present ?? false;
+  const installedPackages = installed?.count ?? 0;
+
+  const checks = {
+    venvPresent,
+    lockPresent,
+    installedScanned: venvPresent,
+    projectInstalled: null as boolean | null,
+    projectEditable: null as boolean | null,
+  };
+  const counts = {
+    lockPackages: lock?.packages.length ?? 0,
+    installedPackages,
+    mismatched: 0,
+    missing: 0,
+    conditional: 0,
+    untracked: 0,
+  };
+
+  for (const message of installed?.warnings ?? []) {
+    warnings.push(warn('INSTALLED_SCAN_WARNING', message));
+  }
+
+  const unverifiable = (reason: string): ConformanceReport => ({
+    verdict: 'unverifiable',
+    complete: false,
+    reason,
+    checks,
+    counts,
+    findings,
+    warnings,
+    notes,
+  });
+
+  if (!venvPresent) {
+    return unverifiable(
+      'No .venv with a site-packages directory was found, so installed versions cannot be compared with uv.lock.',
+    );
+  }
+  if (!lockPresent || !lock) {
+    return unverifiable(
+      'uv.lock is missing, so there is no expected version set to compare the installed distributions against.',
+    );
+  }
+
+  const installedByNormalized = new Map(
+    (installed?.distributions ?? []).map((entry) => [entry.normalized, entry]),
+  );
+  const lockByNormalized = new Map(lock.packages.map((entry) => [entry.normalized, entry]));
+  const required = requiredInstalledNames(lock, new Set(installedByNormalized.keys()), input);
+  const conditionalAbsent: string[] = [];
+
+  for (const entry of lock.packages) {
+    const actual = installedByNormalized.get(entry.normalized);
+    const localProject = isLocalProjectEntry(entry);
+    const rootProject = isRootProjectEntry(entry, projectName);
+
+    if (!actual) {
+      if (localProject) {
+        counts.missing += 1;
+        if (rootProject) checks.projectInstalled = false;
+        findings.push({
+          code: 'PROJECT_NOT_INSTALLED',
+          name: entry.name,
+          expected: entry.version ?? undefined,
+          message: rootProject
+            ? `uv.lock records "${entry.name}" as an editable install, but it is absent from .venv. The project is not importable and no test can exercise it.`
+            : `uv.lock records the local project "${entry.name}" as an editable install, but it is absent from .venv.`,
+        });
+      } else if (required.has(entry.normalized)) {
+        counts.missing += 1;
+        findings.push({
+          code: 'INSTALLED_PACKAGE_MISSING',
+          name: entry.name,
+          expected: entry.version ?? undefined,
+          message: `"${entry.name}" is locked and required unconditionally, but it is not installed in .venv.`,
+        });
+      } else {
+        // Guarded by a platform or version marker, so this platform rightly omits it.
+        counts.conditional += 1;
+        conditionalAbsent.push(`${entry.name}@${entry.version ?? '?'}`);
+      }
+      continue;
+    }
+
+    if (localProject) {
+      if (rootProject) checks.projectInstalled = true;
+      if (actual.source !== 'editable') {
+        if (rootProject) checks.projectEditable = false;
+        findings.push({
+          code: 'PROJECT_INSTALLED_NOT_EDITABLE',
+          name: entry.name,
+          actual: actual.version,
+          message: rootProject
+            ? `"${entry.name}" is installed from a materialised copy instead of an editable link, so tests would import a stale snapshot of the sources.`
+            : `The local project "${entry.name}" is installed from a materialised copy instead of an editable link.`,
+        });
+      } else if (rootProject) {
+        checks.projectEditable = true;
+      }
+      // The editable version tracks pyproject.toml, so a version difference here
+      // is lockfile drift and is reported by the manifest check instead.
+      continue;
+    }
+
+    if (entry.version && actual.version !== entry.version) {
+      counts.mismatched += 1;
+      findings.push({
+        code: 'INSTALLED_VERSION_MISMATCH',
+        name: entry.name,
+        expected: entry.version,
+        actual: actual.version,
+        message: `"${entry.name}" is locked at ${entry.version} but ${actual.version} is installed in .venv.`,
+      });
+    }
+  }
+
+  const untrackedCandidates = (installed?.distributions ?? []).filter(
+    (entry) => !entry.bootstrap && !lockByNormalized.has(entry.normalized),
+  );
+  const nonBootstrap = (installed?.distributions ?? []).filter((entry) => !entry.bootstrap).length;
+
+  if (
+    untrackedCandidates.length >= INDEPENDENT_ENVIRONMENT_MIN &&
+    nonBootstrap > 0 &&
+    untrackedCandidates.length / nonBootstrap > INDEPENDENT_ENVIRONMENT_RATIO
+  ) {
+    counts.untracked = untrackedCandidates.length;
+    findings.push({
+      code: 'INSTALLED_ENVIRONMENT_INDEPENDENT',
+      name: installed?.sitePackages ?? '',
+      actual: String(untrackedCandidates.length),
+      message: `${untrackedCandidates.length} of ${nonBootstrap} installed distributions are absent from uv.lock, which suggests .venv was not created by uv for this project.`,
+    });
+  } else {
+    for (const entry of untrackedCandidates) {
+      counts.untracked += 1;
+      findings.push({
+        code: 'INSTALLED_PACKAGE_UNTRACKED',
+        name: entry.name,
+        actual: entry.version,
+        message: `"${entry.name}" ${entry.version} is installed in .venv but is absent from uv.lock (${entry.source === 'editable' ? 'editable install' : 'installed copy'}).`,
+      });
+    }
+  }
+
+  if (conditionalAbsent.length > 0) {
+    notes.push({
+      code: 'CONDITIONAL_PACKAGES_ABSENT',
+      message: `${conditionalAbsent.length} locked distribution(s) are guarded by a platform or version marker and are correctly absent here: ${conditionalAbsent.slice(0, 8).join(', ')}${conditionalAbsent.length > 8 ? ', …' : ''}.`,
+      severity: 'info',
+    });
+  }
+
+  const bootstrapCount = (installed?.distributions ?? []).filter((entry) => entry.bootstrap).length;
+  if (bootstrapCount > 0) {
+    notes.push({
+      code: 'BOOTSTRAP_DISTRIBUTIONS_SKIPPED',
+      message: `${bootstrapCount} interpreter-seeded distribution(s) (pip/setuptools and similar) were excluded from the comparison.`,
+      severity: 'info',
+    });
+  }
+  const recovered = (installed?.distributions ?? []).filter(
+    (entry) => entry.recoveredFromDirectory,
+  ).length;
+  if (recovered > 0) {
+    notes.push({
+      code: 'VERSION_FROM_DIRECTORY_NAME',
+      message: `${recovered} distribution(s) had no readable METADATA version; the version came from the dist-info directory name.`,
+      severity: 'info',
+    });
+  }
+
+  for (const finding of findings) {
+    warnings.push(warn(finding.code, finding.message));
+  }
+
+  const complete = !(installed?.truncated ?? false);
+  if (!complete) {
+    notes.push({
+      code: 'CONFORMANCE_INCOMPLETE',
+      message:
+        'The installed-distribution scan was truncated, so the comparison does not cover the whole environment.',
+      severity: 'info',
+    });
+  }
+
+  const drifted = findings.length > 0;
+  return {
+    verdict: drifted ? 'drifted' : complete ? 'consistent' : 'unverifiable',
+    complete,
+    reason: drifted
+      ? `${findings.length} environment conformance problem(s) found: ${counts.mismatched} version mismatch(es), ${counts.missing} missing, ${counts.untracked} untracked.`
+      : complete
+        ? `All ${counts.lockPackages - counts.conditional} unconditional locked distribution(s) match the ${installedPackages} installed distribution(s)${counts.conditional > 0 ? ` (${counts.conditional} conditional entry/entries correctly absent)` : ''}.`
+        : 'The lock and installed distributions agree where they could be compared, but the scan was truncated.',
+    checks,
+    counts,
+    findings,
+    warnings,
+    notes,
+  };
+}

package/src/project/inspect.ts

@@ -0,0 +1,351 @@
+import { type Diagnostic, type Suggestion, warn } from '../core/result.ts';
+import {
+  compareInstalledConformance,
+  requiredDeclarationsFrom,
+  type ConformanceReport,
+} from './conformance.ts';
+import type { InstalledEnvironment } from './installed.ts';
+import type { ScanPayload } from './scanner.ts';
+
+export interface ProjectInspection {
+  root: string;
+  pyproject?: string;
+  uvLock?: string;
+  venvDir?: string;
+  name?: string;
+  version?: string;
+  requiresPython?: string;
+  layout: 'src' | 'flat';
+  modules: string[];
+  importName?: string;
+  buildBackend?: string;
+  entryPoints: string[];
+  toolConfiguration: Record<string, boolean>;
+  uvWorkspaceMembers: string[];
+  uvSources: string[];
+  requirementsFiles: string[];
+  dependencyCounts: {
+    runtime: number;
+    optional: Record<string, number>;
+    groups: Record<string, number>;
+  };
+  lock: { present: boolean; path?: string; packageCount: number };
+  /** Lock-versus-installed comparison; `undefined` when no environment was scanned. */
+  conformance?: ConformanceReport;
+  installed?: { sitePackages: string; count: number; editableCount: number };
+  warnings: Diagnostic[];
+  notes: Diagnostic[];
+  suggestions: Suggestion[];
+}
+
+export interface InspectInput {
+  payload: ScanPayload;
+  venvDir?: string;
+  /** `undefined` when no .gitignore exists, so the check stays honest. */
+  venvIgnored?: boolean;
+  hasTestsDirectory: boolean;
+  /** Distributions read from `.venv`; omit to skip the conformance comparison. */
+  installed?: InstalledEnvironment;
+}
+
+/**
+ * Turn a scanner payload into a project model plus diagnostics. Pure so the
+ * whole diagnostic surface is unit-testable without touching a filesystem.
+ */
+export function inspectProject(input: InspectInput): ProjectInspection {
+  const { payload, venvDir, venvIgnored, hasTestsDirectory, installed } = input;
+  const manifest = payload.manifest;
+  const lock = payload.lock;
+  const comparison = payload.lockComparison;
+  const warnings: Diagnostic[] = [];
+  const notes: Diagnostic[] = [];
+  const suggestions: Suggestion[] = [];
+
+  const root = payload.root;
+  if (manifest?.tomlError) {
+    warnings.push(
+      warn('TOML_PARSE_ERROR', manifest.tomlError, manifest.pyprojectPath ?? undefined),
+    );
+  }
+  for (const message of manifest?.warnings ?? []) {
+    warnings.push(warn('MANIFEST_WARNING', message, manifest?.pyprojectPath ?? undefined));
+  }
+  for (const message of lock?.warnings ?? []) {
+    notes.push({ code: 'LOCKFILE_NOTE', message, severity: 'info' });
+  }
+
+  if (!manifest?.pyprojectPath) {
+    warnings.push(
+      warn(
+        'PYPROJECT_MISSING',
+        'pyproject.toml was not found; dependencies, layout, and tool configuration cannot be verified.',
+      ),
+    );
+    suggestions.push({
+      message: 'Run uv init to create a pyproject.toml, then uv add the runtime dependencies.',
+      confidence: 'high',
+      command: 'uv init',
+    });
+  } else if (!manifest.name) {
+    warnings.push(
+      warn(
+        'PROJECT_NAME_MISSING',
+        'pyproject.toml has no [project] name, so the installed distribution name is unknown.',
+        manifest.pyprojectPath ?? undefined,
+      ),
+    );
+    suggestions.push({
+      message: 'Add a [project] table with name and version to pyproject.toml.',
+      confidence: 'high',
+    });
+  }
+
+  if (manifest?.legacySetupPy || manifest?.legacySetupCfg) {
+    warnings.push(
+      warn(
+        'LEGACY_PACKAGING',
+        `The project still uses ${[
+          manifest.legacySetupPy ? 'setup.py' : '',
+          manifest.legacySetupCfg ? 'setup.cfg' : '',
+        ]
+          .filter(Boolean)
+          .join(' and ')}; uv reads dependency metadata from pyproject.toml only.`,
+        root,
+      ),
+    );
+    suggestions.push({
+      message: 'Move dependency metadata from setup.py/setup.cfg into [project] in pyproject.toml.',
+      confidence: 'medium',
+    });
+  }
+
+  if (manifest?.requirementsFiles.length && manifest.pyprojectPath) {
+    warnings.push(
+      warn(
+        'DUPLICATE_DEPENDENCY_SOURCE',
+        `${manifest.requirementsFiles.join(', ')} also declares dependencies; uv resolves from pyproject.toml and uv.lock only.`,
+        root,
+      ),
+    );
+  }
+
+  if (!lock?.present) {
+    notes.push({
+      code: 'LOCKFILE_MISSING',
+      message:
+        'uv.lock was not found, so dependency drift and exact resolved versions cannot be verified.',
+      severity: 'info',
+    });
+    suggestions.push({
+      message: 'Run uv lock to record resolved versions in uv.lock.',
+      confidence: 'high',
+      command: 'uv lock',
+    });
+  }
+
+  if (comparison?.requiresPythonMismatch) {
+    warnings.push(
+      warn(
+        'REQUIRES_PYTHON_MISMATCH',
+        `pyproject.toml requires-python is "${comparison.requiresPythonMismatch.manifest}" but uv.lock records "${comparison.requiresPythonMismatch.lock}".`,
+        lock?.path ?? undefined,
+      ),
+    );
+    suggestions.push({
+      message: 'Run uv lock so the lockfile reflects the current requires-python constraint.',
+      confidence: 'high',
+      command: 'uv lock',
+    });
+  }
+
+  for (const name of comparison?.missingFromLock ?? []) {
+    warnings.push(
+      warn(
+        'LOCKFILE_MISSING_DEPENDENCY',
+        `"${name}" is declared in pyproject.toml but absent from uv.lock.`,
+        lock?.path ?? undefined,
+      ),
+    );
+  }
+  if (comparison?.missingFromLock.length) {
+    suggestions.push({
+      message: 'Run uv lock to add the missing declarations to the lockfile.',
+      confidence: 'high',
+      command: 'uv lock',
+    });
+  }
+
+  for (const entry of comparison?.unsatisfiedInLock ?? []) {
+    warnings.push(
+      warn(
+        'LOCKFILE_UNSATISFIED_DEPENDENCY',
+        `"${entry.name}" is locked at ${entry.locked} which does not satisfy "${entry.specifier}".`,
+        lock?.path ?? undefined,
+      ),
+    );
+  }
+
+  if (lock?.present && comparison && !comparison.specifierCheckAvailable) {
+    notes.push({
+      code: 'SPECIFIER_CHECK_UNAVAILABLE',
+      message:
+        'The packaging library was unavailable, so only declared-versus-locked names were compared, not version constraints.',
+      severity: 'info',
+    });
+    suggestions.push({
+      message:
+        'Install the packaging library in the analysing interpreter to compare declared version constraints against uv.lock.',
+      confidence: 'medium',
+      command: 'python3 -m pip install packaging',
+    });
+  }
+
+  if (!venvDir) {
+    notes.push({
+      code: 'VENV_MISSING',
+      message: 'No .venv directory exists at the project root; run uv sync before running tests.',
+      severity: 'info',
+    });
+  } else if (venvIgnored === false) {
+    warnings.push(
+      warn(
+        'VENV_NOT_IGNORED',
+        '.venv exists but is not listed in .gitignore.',
+        `${root}/.gitignore`,
+      ),
+    );
+    suggestions.push({
+      message: 'Add .venv/ to .gitignore so the environment is never committed.',
+      confidence: 'high',
+    });
+  }
+
+  if (!hasTestsDirectory) {
+    notes.push({
+      code: 'TESTS_DIRECTORY_MISSING',
+      message:
+        'No tests/ directory was found; test selection and TDD gates cannot match changed sources.',
+      severity: 'info',
+    });
+  }
+
+  if (manifest?.pyprojectPath && manifest.toolConfiguration && !manifest.toolConfiguration.pytest) {
+    notes.push({
+      code: 'PYTEST_NOT_CONFIGURED',
+      message: 'pyproject.toml has no [tool.pytest.ini_options] table.',
+      severity: 'info',
+    });
+  }
+
+  if (manifest?.layout === 'src' && manifest.modules.length === 0) {
+    warnings.push(
+      warn(
+        'EMPTY_SRC_LAYOUT',
+        'The src/ directory exists but contains no importable module directories or modules.',
+        `${root}/src`,
+      ),
+    );
+  }
+
+  if (manifest?.legacySetupPy && manifest.buildBackend === null && !manifest.pyprojectPath) {
+    suggestions.push({
+      message: 'uv manages dependencies from pyproject.toml; migrate before running uv sync.',
+      confidence: 'medium',
+    });
+  }
+
+  if (manifest?.uvWorkspaceMembers.length) {
+    notes.push({
+      code: 'UV_WORKSPACE',
+      message: `This is a uv workspace with ${manifest.uvWorkspaceMembers.length} member(s); scope build and test tools per member.`,
+      severity: 'info',
+    });
+  }
+
+  const conformance =
+    installed !== undefined
+      ? compareInstalledConformance({
+          lock,
+          installed,
+          projectName: manifest?.name ?? undefined,
+          requiredDeclarations: requiredDeclarationsFrom(manifest),
+        })
+      : undefined;
+  if (conformance) {
+    warnings.push(...conformance.warnings);
+    notes.push(...conformance.notes);
+    if (conformance.findings.some((finding) => finding.code === 'PROJECT_NOT_INSTALLED')) {
+      suggestions.push({
+        message:
+          'The project is not installed in .venv. Run uv sync; if that fails, the build backend could not find the package (check that the module directory name matches [project] name).',
+        confidence: 'high',
+        command: 'uv sync',
+      });
+    }
+    if (
+      conformance.findings.some(
+        (finding) =>
+          finding.code === 'INSTALLED_VERSION_MISMATCH' ||
+          finding.code === 'INSTALLED_PACKAGE_MISSING' ||
+          finding.code === 'PROJECT_INSTALLED_NOT_EDITABLE',
+      )
+    ) {
+      suggestions.push({
+        message: 'Synchronise .venv with the lockfile so tests run against the locked versions.',
+        confidence: 'high',
+        command: 'uv sync --frozen',
+      });
+    }
+  }
+
+  const optionalCounts: Record<string, number> = {};
+  for (const [key, value] of Object.entries(manifest?.optionalDependencies ?? {})) {
+    optionalCounts[key] = value.length;
+  }
+  const groupCounts: Record<string, number> = {};
+  for (const [key, value] of Object.entries(manifest?.dependencyGroups ?? {})) {
+    groupCounts[key] = value.length;
+  }
+
+  return {
+    root,
+    pyproject: manifest?.pyprojectPath ?? undefined,
+    uvLock: lock?.present ? (lock.path ?? undefined) : undefined,
+    venvDir,
+    name: manifest?.name ?? undefined,
+    version: manifest?.version ?? undefined,
+    requiresPython: manifest?.requiresPython ?? undefined,
+    layout: manifest?.layout ?? 'flat',
+    modules: manifest?.modules ?? [],
+    importName: manifest?.importName,
+    buildBackend: manifest?.buildBackend ?? undefined,
+    entryPoints: manifest?.entryPoints ?? [],
+    toolConfiguration: manifest?.toolConfiguration ?? {},
+    uvWorkspaceMembers: manifest?.uvWorkspaceMembers ?? [],
+    uvSources: manifest?.uvSources ?? [],
+    requirementsFiles: manifest?.requirementsFiles ?? [],
+    dependencyCounts: {
+      runtime: manifest?.dependencies.length ?? 0,
+      optional: optionalCounts,
+      groups: groupCounts,
+    },
+    lock: {
+      present: lock?.present ?? false,
+      path: lock?.path ?? undefined,
+      packageCount: lock?.packages.length ?? 0,
+    },
+    conformance,
+    installed:
+      installed !== undefined
+        ? {
+            sitePackages: installed.sitePackages,
+            count: installed.count,
+            editableCount: installed.distributions.filter((entry) => entry.source === 'editable')
+              .length,
+          }
+        : undefined,
+    warnings,
+    notes,
+    suggestions,
+  };
+}