c64bridge 0.7.4 → 0.8.1

package/scripts/prepare-release.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { execSync } from 'node:child_process';
-import { readFile, writeFile } from 'node:fs/promises';
+import { access, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import process from 'node:process';
 
@@ -16,6 +16,27 @@ const updateJsonFile = async (relativePath, updater) => {
   await writeFile(filePath, JSON.stringify(updated, null, 2) + '\n');
 };
 
+const fileExists = async (relativePath) => {
+  try {
+    await access(path.resolve(relativePath));
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const getRepositoryMetadata = (repository) => {
+  const url = typeof repository === 'string' ? repository : repository?.url;
+  if (!url) {
+    return undefined;
+  }
+
+  return {
+    url,
+    source: url.includes('github.com') ? 'github' : undefined,
+  };
+};
+
 const normaliseVersion = (value) => value.replace(/^v/, '');
 
 const isExactVersion = (value) => /^v?\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(value);
@@ -72,6 +93,42 @@ await updateJsonFile('mcp.json', async (data) => ({
   version: newVersion,
 }));
 
+if (await fileExists('server.json')) {
+  await updateJsonFile('server.json', async (data) => {
+    const packages = Array.isArray(data.packages) ? [...data.packages] : [];
+    const primaryPackage = packages[0] ?? {
+      registryType: 'npm',
+      transport: {
+        type: 'stdio',
+      },
+    };
+
+    packages[0] = {
+      ...primaryPackage,
+      identifier: pkg.name,
+      version: newVersion,
+      transport: primaryPackage.transport ?? {
+        type: 'stdio',
+      },
+    };
+
+    const repository = getRepositoryMetadata(pkg.repository);
+
+    return {
+      ...data,
+      name: pkg.mcpName ?? data.name,
+      version: newVersion,
+      repository: repository
+        ? {
+            ...(data.repository ?? {}),
+            ...repository,
+          }
+        : data.repository,
+      packages,
+    };
+  });
+}
+
 // Manifest generation removed (runtime discovery via MCP stdio)
 
 // Update CHANGELOG.md from commits since last tag using Conventional Commits subjects.
@@ -88,4 +145,4 @@ if (skippedVersionBump && hasExistingChangelogEntry) {
 }
 
 console.log(`Release metadata updated to ${newVersion}.`);
-console.log('Next steps: commit the changes, open a PR, and tag the merged commit.');
+console.log('Next steps: commit and push the changes, then create the release tag from GitHub once main is ready.');

package/scripts/run-coverage.mjs

@@ -0,0 +1,284 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = path.resolve(__dirname, "..");
+const coverageDir = path.join(repoRoot, "coverage");
+const runner = path.join(repoRoot, "scripts", "invoke-bun.mjs");
+const configPath = path.join(repoRoot, ".c8rc.json");
+const testRoot = path.join(repoRoot, "test");
+const DEFAULT_COVERAGE_SHARD_SIZE = 12;
+
+const legs = [
+  { name: "c64u-mock", args: ["--platform=c64u", "--target=mock"] },
+  { name: "vice-mock", args: ["--platform=vice", "--target=mock"] },
+  { name: "vice-device", args: ["--platform=vice", "--target=device"] },
+];
+
+const supplementalTests = [
+  "test/toolsCoverage.test.mjs",
+  "test/audioModule.test.mjs",
+  "test/updateReadme.test.mjs",
+  "test/viceIntegration.test.mjs",
+];
+
+// Tests that use mock.module() must run in isolation to prevent the module
+// mock from leaking into concurrently-executing test files.
+const isolatedTests = [
+  "test/audioRuntime.test.mjs",
+];
+
+const coverageConfig = JSON.parse(await fs.readFile(configPath, "utf8"));
+const includeMatchers = (coverageConfig.include ?? []).map(globToRegExp);
+const excludeMatchers = (coverageConfig.exclude ?? []).map(globToRegExp);
+
+if (import.meta.main) {
+  await main();
+}
+
+export async function main() {
+  await fs.mkdir(coverageDir, { recursive: true });
+  await fs.rm(path.join(coverageDir, "matrix"), { recursive: true, force: true });
+  await fs.mkdir(path.join(coverageDir, "matrix"), { recursive: true });
+
+  const legOutputs = [];
+  const allTestFiles = await listRepoTestFiles(testRoot);
+  const isolatedTestSet = new Set(isolatedTests);
+  const defaultTestFiles = allTestFiles.filter((f) => !isolatedTestSet.has(f));
+  const coverageBatches = buildCoverageBatches(defaultTestFiles, [...supplementalTests, ...isolatedTests], process.env);
+  for (const leg of legs) {
+    const legDir = path.join(coverageDir, "matrix", leg.name);
+    await fs.mkdir(legDir, { recursive: true });
+
+    const reports = [];
+    for (const batch of coverageBatches) {
+      reports.push(await runCoverageLeg(leg, legDir, batch.label, batch.files));
+    }
+
+    const mergedLeg = mergeReports(await Promise.all(reports.map(readReport)));
+    const legPath = path.join(coverageDir, `${leg.name}.lcov.info`);
+    await fs.writeFile(legPath, serializeReport(mergedLeg), "utf8");
+    legOutputs.push(legPath);
+  }
+
+  const finalReport = mergeReports(await Promise.all(legOutputs.map(readReport)));
+  const finalPath = path.join(coverageDir, "lcov.info");
+  await fs.writeFile(finalPath, serializeReport(finalReport), "utf8");
+
+  const summary = summariseReport(finalReport);
+  console.log(JSON.stringify({ lines: summary }, null, 2));
+}
+
+export function buildCoverageBatches(testFiles, extraTests, env = process.env) {
+  const shardSize = resolveCoverageShardSize(env.C64BRIDGE_COVERAGE_SHARD_SIZE);
+  const batches = chunkFiles(testFiles, shardSize).map((files, index, all) => ({
+    label: all.length === 1 ? "all" : `all-${String(index + 1).padStart(2, "0")}`,
+    files,
+  }));
+
+  for (const testFile of extraTests) {
+    batches.push({
+      label: path.basename(testFile, path.extname(testFile)),
+      files: [testFile],
+    });
+  }
+
+  return batches;
+}
+
+export function resolveCoverageShardSize(raw) {
+  const parsed = Number(raw ?? "");
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_COVERAGE_SHARD_SIZE;
+}
+
+export function chunkFiles(files, chunkSize) {
+  if (files.length === 0) {
+    return [[]];
+  }
+
+  const chunks = [];
+  for (let index = 0; index < files.length; index += chunkSize) {
+    chunks.push(files.slice(index, index + chunkSize));
+  }
+  return chunks;
+}
+
+async function listRepoTestFiles(root) {
+  const files = [];
+
+  async function walk(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+        continue;
+      }
+      if (entry.isFile() && /\.test\.(mjs|ts)$/i.test(entry.name)) {
+        files.push(path.relative(repoRoot, fullPath));
+      }
+    }
+  }
+
+  await walk(root);
+  files.sort((a, b) => a.localeCompare(b));
+  return files;
+}
+
+function runCoverageLeg(leg, legDir, label, files) {
+  return new Promise((resolve, reject) => {
+    const outputPath = path.join(legDir, `${label}.lcov.info`);
+    const args = [runner, "scripts/run-tests.ts", "--coverage", ...leg.args, ...files];
+    const child = spawn(process.execPath, args, {
+      cwd: repoRoot,
+      env: process.env,
+      stdio: "inherit",
+    });
+    child.on("error", reject);
+    child.on("exit", async (code) => {
+      if (code !== 0) {
+        reject(new Error(`Coverage run failed for ${leg.name}/${label} with exit code ${code ?? 1}`));
+        return;
+      }
+      try {
+        await fs.copyFile(path.join(coverageDir, "lcov.info"), outputPath);
+        resolve(outputPath);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}
+
+async function readReport(filePath) {
+  const text = await fs.readFile(filePath, "utf8");
+  return parseReport(text);
+}
+
+function parseReport(text) {
+  const report = new Map();
+  let current = null;
+  for (const line of text.split(/\r?\n/)) {
+    if (!line) continue;
+    if (line.startsWith("SF:")) {
+      const filePath = line.slice(3).trim();
+      const relative = toRelativeSourcePath(filePath);
+      current = relative ? getOrCreate(report, relative) : null;
+      continue;
+    }
+    if (!current) continue;
+    if (line.startsWith("DA:")) {
+      const [lineNoRaw, hitsRaw] = line.slice(3).split(",", 2);
+      const lineNo = Number(lineNoRaw);
+      const hits = Number(hitsRaw);
+      current.lines.set(lineNo, Math.max(current.lines.get(lineNo) ?? 0, Number.isFinite(hits) ? hits : 0));
+    }
+  }
+  return report;
+}
+
+function mergeReports(reports) {
+  const merged = new Map();
+  for (const report of reports) {
+    for (const [filePath, record] of report.entries()) {
+      const target = getOrCreate(merged, filePath);
+      for (const [lineNo, hits] of record.lines.entries()) {
+        target.lines.set(lineNo, Math.max(target.lines.get(lineNo) ?? 0, hits));
+      }
+    }
+  }
+  return merged;
+}
+
+function serializeReport(report) {
+  const lines = [];
+  for (const [filePath, record] of [...report.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+    let lf = 0;
+    let lh = 0;
+    lines.push("TN:");
+    lines.push(`SF:${filePath}`);
+    for (const [lineNo, hits] of [...record.lines.entries()].sort((a, b) => a[0] - b[0])) {
+      lines.push(`DA:${lineNo},${hits}`);
+      lf += 1;
+      if (hits > 0) lh += 1;
+    }
+    lines.push(`LF:${lf}`);
+    lines.push(`LH:${lh}`);
+    lines.push("end_of_record");
+  }
+  return `${lines.join("\n")}\n`;
+}
+
+function summariseReport(report) {
+  let covered = 0;
+  let total = 0;
+  for (const record of report.values()) {
+    for (const hits of record.lines.values()) {
+      total += 1;
+      if (hits > 0) covered += 1;
+    }
+  }
+  return {
+    covered,
+    total,
+    pct: total === 0 ? "0.00" : ((covered * 100) / total).toFixed(2),
+  };
+}
+
+function getOrCreate(report, filePath) {
+  let record = report.get(filePath);
+  if (!record) {
+    record = { lines: new Map() };
+    report.set(filePath, record);
+  }
+  return record;
+}
+
+function toRelativeSourcePath(filePath) {
+  const absolute = path.isAbsolute(filePath) ? filePath : path.resolve(repoRoot, filePath);
+  const relative = path.relative(repoRoot, absolute).split(path.sep).join("/");
+  if (relative.startsWith("..")) {
+    return null;
+  }
+  if (!includeMatchers.some((matcher) => matcher.test(relative))) {
+    return null;
+  }
+  if (excludeMatchers.some((matcher) => matcher.test(relative))) {
+    return null;
+  }
+  return relative;
+}
+
+function globToRegExp(glob) {
+  const normalized = glob.split(path.sep).join("/");
+  let regex = "^";
+  for (let index = 0; index < normalized.length; index += 1) {
+    const char = normalized[index];
+    const next = normalized[index + 1];
+    if (char === "*" && next === "*") {
+      regex += ".*";
+      index += 1;
+      continue;
+    }
+    if (char === "*") {
+      regex += "[^/]*";
+      continue;
+    }
+    if (char === "?") {
+      regex += ".";
+      continue;
+    }
+    if ("\\.^$+{}()|[]".includes(char)) {
+      regex += `\\${char}`;
+      continue;
+    }
+    regex += char;
+  }
+  regex += "$";
+  return new RegExp(regex);
+}

package/scripts/run-tests.mjs

@@ -5,37 +5,11 @@ import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
-const DEFAULT_TARGET = "mock";
+export const DEFAULT_TARGET = "mock";
 
-let target = DEFAULT_TARGET;
-let explicitBaseUrl = null;
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const registerDataUri = "data:text/javascript,import { register } from \"node:module\"; import { pathToFileURL } from \"node:url\"; register(\"ts-node/esm\", pathToFileURL(\"./\"));";
-const nodeArgs = ["--import", registerDataUri, "--test"];
-
-for (const arg of process.argv.slice(2)) {
-  if (arg === "--mock") {
-    target = "mock";
-    continue;
-  }
-
-  if (arg === "--real") {
-    target = "real";
-    continue;
-  }
-
-  if (arg.startsWith("--target=")) {
-    target = arg.split("=", 2)[1] ?? DEFAULT_TARGET;
-    continue;
-  }
-
-  if (arg.startsWith("--base-url=")) {
-    explicitBaseUrl = arg.split("=", 2)[1] ?? null;
-    continue;
-  }
-
-  nodeArgs.push(arg);
-}
+const { nodeArgs, target, explicitBaseUrl } = buildNodeTestArgs(process.argv.slice(2));
 const defaultEmbeddingsDir = path.join(repoRoot, "artifacts", "test-embeddings");
 if (!fs.existsSync(defaultEmbeddingsDir)) {
   fs.mkdirSync(defaultEmbeddingsDir, { recursive: true });
@@ -62,18 +36,20 @@ if (target === "real" && !env.C64_TEST_BASE_URL) {
   env.C64_TEST_BASE_URL = resolveBaseUrlFromConfig() ?? "http://c64u";
 }
 
-const child = spawn(process.execPath, nodeArgs, {
-  stdio: "inherit",
-  env,
-});
+if (isMainModule(import.meta.url)) {
+  const child = spawn(process.execPath, nodeArgs, {
+    stdio: "inherit",
+    env,
+  });
 
-child.on("close", (code, signal) => {
-  if (signal) {
-    process.kill(process.pid, signal);
-    return;
-  }
-  process.exit(code ?? 1);
-});
+  child.on("close", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code ?? 1);
+  });
+}
 
 function resolveBaseUrlFromConfig() {
   const configPathEnv = process.env.C64BRIDGE_CONFIG;
@@ -193,3 +169,83 @@ function firstDefined(...values) {
   }
   return undefined;
 }
+
+function isMainModule(moduleUrl) {
+  const entry = process.argv[1];
+  if (!entry) {
+    return false;
+  }
+  return fileURLToPath(moduleUrl) === path.resolve(entry);
+}
+
+export function buildNodeTestArgs(args, root = repoRoot) {
+  const defaultTestFiles = listRepoTestFiles(path.join(root, "test"), root);
+  const nodeArgs = ["--import", registerDataUri, "--test"];
+  let target = DEFAULT_TARGET;
+  let explicitBaseUrl = null;
+  let hasExplicitTestFiles = false;
+
+  for (const arg of args) {
+    if (arg === "--mock") {
+      target = "mock";
+      continue;
+    }
+
+    if (arg === "--real") {
+      target = "real";
+      continue;
+    }
+
+    if (arg.startsWith("--target=")) {
+      target = arg.split("=", 2)[1] ?? DEFAULT_TARGET;
+      continue;
+    }
+
+    if (arg.startsWith("--base-url=")) {
+      explicitBaseUrl = arg.split("=", 2)[1] ?? null;
+      continue;
+    }
+
+    if (looksLikeTestFileArg(arg)) {
+      hasExplicitTestFiles = true;
+    }
+    nodeArgs.push(arg);
+  }
+
+  if (!hasExplicitTestFiles) {
+    nodeArgs.push(...defaultTestFiles);
+  }
+
+  return { nodeArgs, target, explicitBaseUrl };
+}
+
+export function looksLikeTestFileArg(arg) {
+  return typeof arg === "string" && /\.(c|m)?(j|t)sx?$/.test(arg) && !arg.startsWith("--");
+}
+
+export function listRepoTestFiles(root, base = repoRoot) {
+  if (!fs.existsSync(root)) {
+    return [];
+  }
+
+  const files = [];
+  walkDirectory(root, files);
+  return files
+    .filter((file) => looksLikeTestFileArg(file))
+    .map((file) => path.relative(base, file).split(path.sep).join("/"))
+    .sort();
+}
+
+function walkDirectory(dir, files) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkDirectory(fullPath, files);
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push(fullPath);
+    }
+  }
+}