@test-station/core 0.1.0

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@test-station/core",
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "dependencies": {
+    "@test-station/adapter-jest": "workspace:*",
+    "@test-station/adapter-node-test": "workspace:*",
+    "@test-station/adapter-playwright": "workspace:*",
+    "@test-station/adapter-shell": "workspace:*",
+    "@test-station/adapter-vitest": "workspace:*",
+    "@test-station/plugin-source-analysis": "workspace:*"
+  },
+  "scripts": {
+    "build": "node ../../scripts/check-package.mjs ./src/index.js",
+    "lint": "node ../../scripts/lint-syntax.mjs ./src"
+  }
+}

package/src/adapters.js

@@ -0,0 +1,73 @@
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createNodeTestAdapter } from '@test-station/adapter-node-test';
+import { createVitestAdapter } from '@test-station/adapter-vitest';
+import { createPlaywrightAdapter } from '@test-station/adapter-playwright';
+import { createShellAdapter } from '@test-station/adapter-shell';
+import { createJestAdapter } from '@test-station/adapter-jest';
+
+const builtInAdapterFactories = {
+  'node-test': createNodeTestAdapter,
+  vitest: createVitestAdapter,
+  playwright: createPlaywrightAdapter,
+  shell: createShellAdapter,
+  jest: createJestAdapter,
+};
+
+export async function resolveAdapterForSuite(suite, loadedConfig) {
+  if (suite?.handler) {
+    return loadAdapterModule(resolveMaybeRelative(loadedConfig.configDir, suite.handler));
+  }
+
+  if (suite?.adapter && typeof suite.adapter === 'object' && typeof suite.adapter.run === 'function') {
+    return suite.adapter;
+  }
+
+  if (typeof suite?.adapter === 'string') {
+    const configured = resolveConfiguredAdapter(suite.adapter, loadedConfig.config?.adapters || [], loadedConfig.configDir);
+    if (configured) {
+      return configured;
+    }
+    if (builtInAdapterFactories[suite.adapter]) {
+      return builtInAdapterFactories[suite.adapter]();
+    }
+  }
+
+  throw new Error(`Unable to resolve adapter for suite ${suite?.id || '<unknown>'}`);
+}
+
+function resolveConfiguredAdapter(adapterId, configuredAdapters, configDir) {
+  for (const entry of configuredAdapters) {
+    if (!entry || entry.id !== adapterId) {
+      continue;
+    }
+    if (entry.adapter && typeof entry.adapter.run === 'function') {
+      return entry.adapter;
+    }
+    if (entry.handler) {
+      return loadAdapterModule(resolveMaybeRelative(configDir, entry.handler));
+    }
+  }
+  return null;
+}
+
+export async function loadAdapterModule(modulePath) {
+  const mod = await import(pathToFileURL(modulePath).href);
+  if (mod.default && typeof mod.default.run === 'function') {
+    return mod.default;
+  }
+  if (typeof mod.createAdapter === 'function') {
+    return mod.createAdapter();
+  }
+  if (mod.default && typeof mod.default === 'function') {
+    return mod.default();
+  }
+  throw new Error(`Adapter module ${modulePath} did not export a supported adapter contract.`);
+}
+
+function resolveMaybeRelative(baseDir, targetPath) {
+  if (path.isAbsolute(targetPath)) {
+    return targetPath;
+  }
+  return path.resolve(baseDir, targetPath);
+}

package/src/artifacts.js

@@ -0,0 +1,65 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function writeReportArtifacts(context, report, suiteResults) {
+  fs.mkdirSync(context.project.outputDir, { recursive: true });
+  fs.mkdirSync(context.project.rawDir, { recursive: true });
+
+  const reportJsonPath = path.join(context.project.outputDir, 'report.json');
+  fs.writeFileSync(reportJsonPath, `${JSON.stringify(report, null, 2)}\n`);
+
+  const rawSuitePaths = [];
+  for (const suite of suiteResults) {
+    const suiteFileName = `${slugify(suite.packageName || 'default')}-${slugify(suite.id)}.json`;
+    const suitePath = path.join(context.project.rawDir, suiteFileName);
+    const payload = {
+      id: suite.id,
+      packageName: suite.packageName,
+      status: suite.status,
+      runtime: suite.runtime,
+      command: suite.command,
+      summary: suite.summary,
+      coverage: suite.coverage,
+      warnings: suite.warnings,
+      rawArtifacts: suite.rawArtifacts,
+      output: suite.output,
+      tests: suite.tests,
+    };
+    fs.writeFileSync(suitePath, `${JSON.stringify(payload, null, 2)}\n`);
+    rawSuitePaths.push(suitePath);
+
+    for (const artifact of suite.rawArtifacts || []) {
+      const relativePath = artifact?.relativePath;
+      if (!relativePath) {
+        continue;
+      }
+      const artifactPath = path.join(context.project.rawDir, relativePath);
+      fs.mkdirSync(path.dirname(artifactPath), { recursive: true });
+      if (artifact.sourcePath) {
+        copyArtifactSource(artifact.sourcePath, artifactPath, artifact.kind);
+      } else {
+        fs.writeFileSync(artifactPath, artifact.content || '', artifact.encoding || 'utf8');
+      }
+      rawSuitePaths.push(artifactPath);
+    }
+  }
+
+  return {
+    reportJsonPath,
+    rawSuitePaths,
+  };
+}
+
+function copyArtifactSource(sourcePath, destinationPath, kind) {
+  const sourceStat = fs.statSync(sourcePath);
+  if (kind === 'directory' || sourceStat.isDirectory()) {
+    fs.rmSync(destinationPath, { recursive: true, force: true });
+    fs.cpSync(sourcePath, destinationPath, { recursive: true });
+    return;
+  }
+  fs.copyFileSync(sourcePath, destinationPath);
+}
+
+function slugify(value) {
+  return String(value || '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+}

package/src/config.js

@@ -0,0 +1,99 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+export const CONFIG_SCHEMA_VERSION = '1';
+export const REPORT_SCHEMA_VERSION = '1';
+
+export function defineConfig(config) {
+  return config;
+}
+
+export function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+export async function loadConfig(configPath, options = {}) {
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const resolved = path.resolve(cwd, configPath);
+  const mod = await import(pathToFileURL(resolved).href);
+  const config = mod.default || mod;
+  return {
+    resolvedPath: resolved,
+    config,
+    configDir: path.dirname(resolved),
+  };
+}
+
+export function applyConfigOverrides(config, configDir, overrides = {}) {
+  const nextConfig = {
+    ...config,
+    project: {
+      ...(config?.project || {}),
+    },
+    suites: Array.isArray(config?.suites) ? [...config.suites] : [],
+    adapters: Array.isArray(config?.adapters) ? [...config.adapters] : [],
+  };
+  const overrideCwd = path.resolve(overrides.cwd || process.cwd());
+  const workspaceFilters = normalizeStringList(overrides.workspaceFilters);
+
+  if (overrides.outputDir) {
+    const outputDir = resolveMaybeRelative(overrideCwd, overrides.outputDir);
+    nextConfig.project.outputDir = outputDir;
+    nextConfig.project.rawDir = path.join(outputDir, 'raw');
+  }
+
+  if (workspaceFilters.length > 0) {
+    nextConfig.suites = nextConfig.suites.filter((suite) => workspaceFilters.includes(resolveSuitePackageName(suite)));
+    if (nextConfig.suites.length === 0) {
+      throw new Error(`No suites matched workspaces: ${workspaceFilters.join(', ')}`);
+    }
+  }
+
+  return nextConfig;
+}
+
+export function summarizeConfig(config) {
+  return {
+    schemaVersion: String(config?.schemaVersion || CONFIG_SCHEMA_VERSION),
+    projectName: config?.project?.name || null,
+    workspaceProvider: config?.workspaceDiscovery?.provider || null,
+    suiteCount: Array.isArray(config?.suites) ? config.suites.length : 0,
+    adapterCount: Array.isArray(config?.adapters) ? config.adapters.length : 0,
+    manifestKeys: Object.keys(config?.manifests || {}),
+  };
+}
+
+export function resolveProjectContext(config, configDir) {
+  const rootDir = resolveMaybeRelative(configDir, config?.project?.rootDir || '.');
+  const outputDir = resolveMaybeRelative(rootDir, config?.project?.outputDir || 'artifacts/workspace-tests');
+  const rawDir = resolveMaybeRelative(rootDir, config?.project?.rawDir || path.join(path.relative(rootDir, outputDir), 'raw'));
+
+  return {
+    name: config?.project?.name || path.basename(rootDir),
+    rootDir,
+    outputDir,
+    rawDir,
+    configDir,
+  };
+}
+
+export function resolveMaybeRelative(baseDir, targetPath) {
+  if (!targetPath) {
+    return path.resolve(baseDir);
+  }
+  if (path.isAbsolute(targetPath)) {
+    return targetPath;
+  }
+  return path.resolve(baseDir, targetPath);
+}
+
+function normalizeStringList(values) {
+  return (Array.isArray(values) ? values : [])
+    .map((value) => String(value || '').trim())
+    .filter(Boolean);
+}
+
+function resolveSuitePackageName(suite) {
+  return String(suite?.package || suite?.project || 'default');
+}

package/src/console.js

@@ -0,0 +1,162 @@
+const SECTION_WIDTH = 88;
+
+export function createConsoleProgressReporter(options = {}) {
+  const stream = options.stream || process.stdout;
+  let hasPrintedHeader = false;
+  let packageCountWidth = 2;
+  let packageStarted = false;
+
+  return {
+    onEvent(event) {
+      if (!event || typeof event !== 'object') {
+        return;
+      }
+
+      if (event.type === 'run-start') {
+        packageCountWidth = Math.max(2, String(event.totalPackages || 0).length);
+        writeLine(stream, banner('Running Workspace Tests'));
+        hasPrintedHeader = true;
+        packageStarted = false;
+        return;
+      }
+
+      if (event.type === 'package-start') {
+        if (!hasPrintedHeader) {
+          writeLine(stream, banner('Running Workspace Tests'));
+          hasPrintedHeader = true;
+        }
+        if (packageStarted) {
+          writeLine(stream, '');
+        } else {
+          writeLine(stream, '');
+          packageStarted = true;
+        }
+        const label = `${padNumber(event.packageIndex || 0, packageCountWidth)}/${padNumber(event.totalPackages || 0, packageCountWidth)} PACKAGE ${event.packageName || 'default'}`;
+        writeLine(stream, `${label}${event.packageLocation ? ` (${event.packageLocation})` : ''}`);
+        return;
+      }
+
+      if (event.type === 'suite-start') {
+        writeLine(stream, `  - ${event.suiteLabel || event.suiteId || 'Suite'}: running ${event.runtime || 'custom'}`);
+        return;
+      }
+
+      if (event.type === 'suite-complete') {
+        const result = event.result || {};
+        writeLine(stream, `    ${formatStatus(result.status)} ${formatDuration(result.durationMs || 0)} ${formatSummaryInline(result.summary || zeroSummary())}`);
+        return;
+      }
+
+      if (event.type === 'package-complete') {
+        writeLine(
+          stream,
+          `${formatStatus(event.status)} ${event.packageName || 'default'} in ${formatDuration(event.durationMs || 0)} (${formatSummaryInline(event.summary || zeroSummary())})`
+        );
+      }
+    },
+  };
+}
+
+export function formatConsoleSummary(report, artifactPaths = {}, options = {}) {
+  const lines = [
+    banner('Workspace Test Report'),
+    `Packages: ${report?.summary?.totalPackages || 0}`,
+    `Suites: ${report?.summary?.totalSuites || 0}`,
+    `Tests: ${report?.summary?.totalTests || 0}`,
+    `Passed: ${report?.summary?.passedTests || 0}`,
+    `Failed: ${report?.summary?.failedTests || 0}`,
+    `Skipped: ${report?.summary?.skippedTests || 0}`,
+  ];
+
+  const coverageLine = formatCoverageLine(report?.summary?.coverage);
+  if (coverageLine) {
+    lines.push(coverageLine);
+  }
+
+  lines.push(`Duration: ${formatDuration(report?.durationMs || report?.summary?.durationMs || 0)}`);
+  if (options.htmlPath) {
+    lines.push(`HTML report: ${options.htmlPath}`);
+  } else if (artifactPaths.reportJsonPath) {
+    lines.push(`Report JSON: ${artifactPaths.reportJsonPath}`);
+  }
+
+  lines.push('-'.repeat(SECTION_WIDTH));
+
+  const packages = Array.isArray(report?.packages) ? report.packages : [];
+  const packageNameWidth = Math.max(
+    20,
+    ...packages.map((entry) => String(entry?.name || '').length + 2),
+  );
+
+  for (const pkg of packages) {
+    const prefix = [
+      formatStatus(pkg.status).padEnd(5),
+      String(pkg.name || 'default').padEnd(packageNameWidth),
+      formatDuration(pkg.durationMs || 0),
+      formatSummaryInline(pkg.summary || zeroSummary()),
+    ].join('  ');
+
+    const lineCoverage = pkg?.coverage?.lines?.pct;
+    lines.push(Number.isFinite(lineCoverage) ? `${prefix}  L ${lineCoverage.toFixed(2)}%` : prefix);
+  }
+
+  lines.push('='.repeat(SECTION_WIDTH));
+  return `${lines.join('\n')}\n`;
+}
+
+function banner(title) {
+  return `${'='.repeat(SECTION_WIDTH)}\n${title}\n${'='.repeat(SECTION_WIDTH)}`;
+}
+
+function formatCoverageLine(coverage) {
+  const metrics = [
+    ['lines', coverage?.lines?.pct],
+    ['branches', coverage?.branches?.pct],
+    ['functions', coverage?.functions?.pct],
+    ['statements', coverage?.statements?.pct],
+  ].filter(([, pct]) => Number.isFinite(pct));
+
+  if (metrics.length === 0) {
+    return null;
+  }
+
+  return `Coverage: ${metrics.map(([label, pct]) => `${label} ${pct.toFixed(2)}%`).join(' | ')}`;
+}
+
+function formatSummaryInline(summary) {
+  return `tests ${summary.total || 0} | pass ${summary.passed || 0} | fail ${summary.failed || 0} | skip ${summary.skipped || 0}`;
+}
+
+function formatStatus(status) {
+  if (status === 'failed') return 'FAIL';
+  if (status === 'skipped') return 'SKIP';
+  return 'PASS';
+}
+
+function formatDuration(durationMs) {
+  const totalSeconds = Math.max(0, Math.round((durationMs || 0) / 1000));
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) {
+    return `${padNumber(hours, 2)}:${padNumber(minutes, 2)}:${padNumber(seconds, 2)}`;
+  }
+  return `${padNumber(minutes, 2)}:${padNumber(seconds, 2)}`;
+}
+
+function padNumber(value, width) {
+  return String(Math.max(0, Number(value) || 0)).padStart(width, '0');
+}
+
+function zeroSummary() {
+  return {
+    total: 0,
+    passed: 0,
+    failed: 0,
+    skipped: 0,
+  };
+}
+
+function writeLine(stream, value) {
+  stream.write(`${value}\n`);
+}

package/src/coverage.js

@@ -0,0 +1,98 @@
+export function createCoverageMetric(covered, total) {
+  if (!Number.isFinite(total)) {
+    return null;
+  }
+  const safeTotal = Math.max(0, total);
+  const safeCovered = Number.isFinite(covered) ? Math.max(0, Math.min(safeTotal, covered)) : 0;
+  const pct = safeTotal === 0 ? 100 : Number(((safeCovered / safeTotal) * 100).toFixed(2));
+  return {
+    covered: safeCovered,
+    total: safeTotal,
+    pct,
+  };
+}
+
+export function normalizeCoverageSummary(coverage, packageName = null) {
+  if (!coverage) {
+    return null;
+  }
+
+  const files = Array.isArray(coverage.files)
+    ? coverage.files.map((file) => ({
+        path: file.path,
+        lines: file.lines || null,
+        statements: file.statements || null,
+        functions: file.functions || null,
+        branches: file.branches || null,
+        packageName: file.packageName || packageName || null,
+        module: file.module || null,
+        theme: file.theme || null,
+        shared: Boolean(file.shared),
+        attributionSource: file.attributionSource || null,
+        attributionReason: file.attributionReason || null,
+        attributionWeight: Number.isFinite(file.attributionWeight) ? file.attributionWeight : 1,
+      }))
+    : [];
+
+  return {
+    lines: coverage.lines || aggregateCoverageMetric(files, 'lines'),
+    statements: coverage.statements || aggregateCoverageMetric(files, 'statements'),
+    functions: coverage.functions || aggregateCoverageMetric(files, 'functions'),
+    branches: coverage.branches || aggregateCoverageMetric(files, 'branches'),
+    files,
+  };
+}
+
+export function aggregateCoverageMetric(files, metricKey) {
+  const valid = files
+    .map((file) => ({
+      metric: file?.[metricKey],
+      weight: Number.isFinite(file?.attributionWeight) ? file.attributionWeight : 1,
+    }))
+    .filter((entry) => entry.metric && Number.isFinite(entry.metric.total));
+
+  if (valid.length === 0) {
+    return null;
+  }
+
+  const total = valid.reduce((sum, entry) => sum + (entry.metric.total * entry.weight), 0);
+  const covered = valid.reduce((sum, entry) => sum + (entry.metric.covered * entry.weight), 0);
+  return createCoverageMetric(covered, total);
+}
+
+export function mergeCoverageMetric(left, right) {
+  if (!left) return right || null;
+  if (!right) return left;
+  return createCoverageMetric(Math.max(left.covered, right.covered), Math.max(left.total, right.total));
+}
+
+export function mergeCoverageSummaries(items) {
+  const summaries = (items || []).filter(Boolean);
+  if (summaries.length === 0) {
+    return null;
+  }
+
+  const fileMap = new Map();
+  for (const coverage of summaries) {
+    for (const file of coverage.files || []) {
+      if (!fileMap.has(file.path)) {
+        fileMap.set(file.path, { ...file });
+        continue;
+      }
+      const current = fileMap.get(file.path);
+      current.lines = mergeCoverageMetric(current.lines, file.lines);
+      current.statements = mergeCoverageMetric(current.statements, file.statements);
+      current.functions = mergeCoverageMetric(current.functions, file.functions);
+      current.branches = mergeCoverageMetric(current.branches, file.branches);
+      current.packageName = current.packageName || file.packageName || null;
+      current.module = current.module || file.module || null;
+      current.theme = current.theme || file.theme || null;
+      current.shared = current.shared || Boolean(file.shared);
+      current.attributionSource = current.attributionSource || file.attributionSource || null;
+      current.attributionReason = current.attributionReason || file.attributionReason || null;
+      current.attributionWeight = Number.isFinite(current.attributionWeight) ? current.attributionWeight : (Number.isFinite(file.attributionWeight) ? file.attributionWeight : 1);
+    }
+  }
+
+  return normalizeCoverageSummary({ files: Array.from(fileMap.values()) });
+}

package/src/index.js

@@ -0,0 +1,8 @@
+export { CONFIG_SCHEMA_VERSION, REPORT_SCHEMA_VERSION, defineConfig, loadConfig, applyConfigOverrides, summarizeConfig, resolveProjectContext, readJson } from './config.js';
+export { createPhase1ScaffoldReport, createSummary, normalizeTestResult, normalizeSuiteResult, buildReportFromSuiteResults } from './report.js';
+export { createCoverageMetric, normalizeCoverageSummary, mergeCoverageSummaries } from './coverage.js';
+export { resolveAdapterForSuite } from './adapters.js';
+export { preparePolicyContext, applyPolicyPipeline, collectCoverageAttribution, lookupOwner } from './policy.js';
+export { writeReportArtifacts } from './artifacts.js';
+export { formatConsoleSummary, createConsoleProgressReporter } from './console.js';
+export { runReport } from './run-report.js';