c64bridge 0.9.0 → 0.9.2

package/mcp.json

@@ -1,6 +1,6 @@
 {
   "name": "c64bridge",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Stdio-based Model Context Protocol (MCP) server that bridges Commodore 64 Ultimate hardware with AI agents.",
   "entry": "dist/index.js",
   "type": "stdio",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c64bridge",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "mcpName": "io.github.chrisgleissner/c64bridge",
   "description": "C64 Bridge MCP server for Commodore 64 Ultimate hardware and VICE emulator control",
   "type": "module",
@@ -18,7 +18,7 @@
     "mcp": "node scripts/invoke-bun.mjs src/mcp-server.ts",
     "mcp:node": "node dist/mcp-server.js",
     "mcp:build": "npm run build && node dist/mcp-server.js",
-    "build": "node scripts/prebuild.mjs && tsc -p tsconfig.json && node scripts/postbuild.mjs && node scripts/invoke-bun.mjs scripts/update-readme.ts && node scripts/invoke-bun.mjs scripts/generate-mcp-interface.ts",
+    "build": "VICE_VISIBLE=false node scripts/prebuild.mjs && VICE_VISIBLE=false tsc -p tsconfig.json && VICE_VISIBLE=false node scripts/postbuild.mjs && VICE_VISIBLE=false node scripts/invoke-bun.mjs scripts/update-readme.ts && VICE_VISIBLE=false node scripts/invoke-bun.mjs scripts/generate-mcp-interface.ts",
     "lint": "npm run check",
     "test": "node scripts/invoke-bun.mjs scripts/run-tests.ts",
     "test:node": "node scripts/run-tests.mjs",

package/scripts/c64-cli.mjs

@@ -18,7 +18,7 @@ async function loadCoreModules() {
   }
 
   if (typeof globalThis.Bun !== "undefined") {
-    ({ basicToPrg } = await import("../src/basicConverter.ts"));
+    ({ basicToPrg } = await import("../src/tools/translation/basicTokenizer.ts"));
     ({ loadConfig } = await import("../src/config.ts"));
     ({ C64Client } = await import("../src/c64Client.ts"));
     return;
@@ -26,7 +26,7 @@ async function loadCoreModules() {
 
   const distPath = resolve(projectRoot, "dist");
   try {
-    ({ basicToPrg } = await import(pathToFileURL(resolve(distPath, "basicConverter.js")).href));
+    ({ basicToPrg } = await import(pathToFileURL(resolve(distPath, "tools/translation/basicTokenizer.js")).href));
     ({ loadConfig } = await import(pathToFileURL(resolve(distPath, "config.js")).href));
     ({ C64Client } = await import(pathToFileURL(resolve(distPath, "c64Client.js")).href));
   } catch (error) {

package/scripts/run-coverage.mjs

@@ -18,6 +18,8 @@ const DEFAULT_VICE_MOCK_TEST_FILES = [
   "test/viceIntegration.test.mjs",
   "test/viceModule.test.mjs",
   "test/groupedToolsShims.test.mjs",
+  "test/inputModule.test.mjs",
+  "test/batchAndDisplayState.test.mjs",
   "test/toolsTypes.test.mjs",
   "test/platformRegistry.test.mjs",
   "test/meta/program.test.mjs",
@@ -40,6 +42,11 @@ const supplementalTests = [
   "test/toolsCoverage.test.mjs",
   "test/audioModule.test.mjs",
   "test/updateReadme.test.mjs",
+  "test/toolsSchema.test.mjs",
+  "test/symbolRegistry.test.mjs",
+  "test/programRunnersModule.test.mjs",
+  "test/batchAndDisplayState.test.mjs",
+  "test/inputModule.test.mjs",
   "test/viceIntegration.test.mjs",
 ];
 
@@ -155,7 +162,8 @@ async function listRepoTestFiles(root) {
   return files;
 }
 
-function runCoverageLeg(leg, legDir, label, files) {
+async function runCoverageLeg(leg, legDir, label, files) {
+  const knownTempFiles = new Set(await listCoverageTempFiles(coverageDir));
   return new Promise((resolve, reject) => {
     const outputPath = path.join(legDir, `${label}.lcov.info`);
     const args = [runner, "scripts/run-tests.ts", "--coverage", ...leg.args, ...files];
@@ -171,7 +179,7 @@ function runCoverageLeg(leg, legDir, label, files) {
         return;
       }
       try {
-        await fs.copyFile(path.join(coverageDir, "lcov.info"), outputPath);
+        await copyCoverageOutput(coverageDir, outputPath, knownTempFiles);
         resolve(outputPath);
       } catch (error) {
         reject(error);
@@ -180,6 +188,56 @@ function runCoverageLeg(leg, legDir, label, files) {
   });
 }
 
+export async function copyCoverageOutput(sourceDir, outputPath, knownTempFiles = new Set()) {
+  const stablePath = path.join(sourceDir, "lcov.info");
+  try {
+    await fs.copyFile(stablePath, outputPath);
+    return outputPath;
+  } catch (error) {
+    if (!isNodeErrorCode(error, "ENOENT")) {
+      throw error;
+    }
+  }
+
+  const tempFiles = await listCoverageTempFiles(sourceDir);
+  const newTempFiles = tempFiles.filter((filePath) => !knownTempFiles.has(filePath));
+  if (newTempFiles.length === 0) {
+    throw new Error(`Coverage run completed but no LCOV report was produced in ${sourceDir}`);
+  }
+
+  const newest = await newestFile(newTempFiles);
+  await fs.copyFile(newest, outputPath);
+  return outputPath;
+}
+
+async function listCoverageTempFiles(dir) {
+  let entries;
+  try {
+    entries = await fs.readdir(dir);
+  } catch (error) {
+    if (isNodeErrorCode(error, "ENOENT")) {
+      return [];
+    }
+    throw error;
+  }
+  return entries
+    .filter((entry) => /^\.lcov\.info\.[^.]+\.tmp$/.test(entry))
+    .map((entry) => path.join(dir, entry));
+}
+
+async function newestFile(filePaths) {
+  const stats = await Promise.all(filePaths.map(async (filePath) => ({
+    filePath,
+    mtimeMs: (await fs.stat(filePath)).mtimeMs,
+  })));
+  stats.sort((a, b) => b.mtimeMs - a.mtimeMs || a.filePath.localeCompare(b.filePath));
+  return stats[0].filePath;
+}
+
+function isNodeErrorCode(error, code) {
+  return Boolean(error && typeof error === "object" && error.code === code);
+}
+
 async function readReport(filePath) {
   const text = await fs.readFile(filePath, "utf8");
   return parseReport(text);
@@ -306,4 +364,4 @@ function globToRegExp(glob) {
   }
   regex += "$";
   return new RegExp(regex);
-}
+}

package/scripts/run-tests.mjs

@@ -18,6 +18,7 @@ if (!fs.existsSync(defaultEmbeddingsDir)) {
 const env = {
   ...process.env,
   C64_TEST_TARGET: target,
+  VICE_VISIBLE: "false",
 };
 
 if (!env.RAG_EMBEDDINGS_DIR) {

package/scripts/run-tests.ts

@@ -16,6 +16,8 @@ const DEFAULT_VICE_MOCK_TEST_FILES = [
   "test/viceIntegration.test.mjs",
   "test/viceModule.test.mjs",
   "test/groupedToolsShims.test.mjs",
+  "test/inputModule.test.mjs",
+  "test/batchAndDisplayState.test.mjs",
   "test/toolsTypes.test.mjs",
   "test/platformRegistry.test.mjs",
   "test/meta/program.test.mjs",
@@ -140,6 +142,7 @@ export function buildMatrixEnv(
   const env: Record<string, string> = { ...envSource } as Record<string, string>;
   env.C64_MODE = platform;
   env.C64_TEST_TARGET = target === "device" ? "real" : "mock";
+  env.VICE_VISIBLE = "false";
 
   if (platform === "vice") {
     const useViceMock = target !== "device";

package/scripts/update-readme.ts

@@ -142,6 +142,8 @@ type GroupedOperation = {
   readonly op: string;
   readonly description: string;
   readonly required: readonly string[];
+  readonly optional: readonly string[];
+  readonly properties: Readonly<Record<string, JsonSchema | undefined>>;
   readonly notes: readonly string[];
 };
 
@@ -165,11 +167,27 @@ function toTableValue(values: readonly string[]): string {
   return values.join(", ");
 }
 
+function formatInputName(name: string, schema?: JsonSchema): string {
+  const defaultSuffix = schema && Object.prototype.hasOwnProperty.call(schema, "default")
+    ? `=${JSON.stringify(schema.default)}`
+    : "";
+  return `\`${name}${defaultSuffix}\``;
+}
+
+function formatInputs(names: readonly string[], properties: Readonly<Record<string, JsonSchema | undefined>>): string {
+  return toTableValue(names.map((name) => formatInputName(name, properties[name])));
+}
+
 function collectGroupedOperations(schema?: JsonSchema): readonly GroupedOperation[] {
   if (!schema || !isObject(schema)) {
     return [];
   }
 
+  const metadataOperations = collectFromOperationMetadata(schema);
+  if (metadataOperations.length > 0) {
+    return metadataOperations;
+  }
+
   const discriminator = (schema as JsonSchema & { discriminator?: { propertyName?: string } }).discriminator;
   const variants = (schema as JsonSchema & { oneOf?: readonly JsonSchema[] }).oneOf;
 
@@ -180,6 +198,57 @@ function collectGroupedOperations(schema?: JsonSchema): readonly GroupedOperatio
   return collectFromFlattenedSchema(schema);
 }
 
+function collectFromOperationMetadata(schema: JsonSchema): readonly GroupedOperation[] {
+  const metadata = (schema as JsonSchema & {
+    readonly "x-c64bridge-operations"?: readonly unknown[];
+  })["x-c64bridge-operations"];
+
+  if (!Array.isArray(metadata)) {
+    return [];
+  }
+
+  const operations: GroupedOperation[] = [];
+
+  for (const entry of metadata) {
+    if (!isObject(entry)) {
+      continue;
+    }
+
+    const opName = getString(entry.op);
+    if (!opName) {
+      continue;
+    }
+
+    const inputSchema = isObject(entry.inputSchema) ? (entry.inputSchema as JsonSchema) : undefined;
+    const properties = (inputSchema?.properties ?? {}) as Record<string, JsonSchema | undefined>;
+    const requiredProps = Array.isArray(entry.required)
+      ? entry.required.filter((name): name is string => typeof name === "string" && name !== "op")
+      : [];
+    const optionalProps = Array.isArray(entry.optional)
+      ? entry.optional.filter((name): name is string => typeof name === "string" && name !== "op")
+      : Object.keys(properties).filter((name) => name !== "op" && !requiredProps.includes(name));
+
+    const notes: string[] = [];
+    const hasVerificationProperty = Object.keys(properties).some((name) =>
+      name.toLowerCase().startsWith("verify"),
+    );
+    if (hasVerificationProperty) {
+      notes.push("supports verify");
+    }
+
+    operations.push({
+      op: opName,
+      description: getString(entry.description, `Operation ${opName}`),
+      required: requiredProps,
+      optional: optionalProps,
+      properties,
+      notes,
+    });
+  }
+
+  return operations;
+}
+
 function collectFromVariantList(variants: readonly JsonSchema[]): readonly GroupedOperation[] {
   const operations: GroupedOperation[] = [];
 
@@ -224,6 +293,8 @@ function collectFromVariantList(variants: readonly JsonSchema[]): readonly Group
       op: opName,
       description,
       required: requiredProps,
+      optional: Object.keys(properties).filter((name) => name !== "op" && !requiredProps.includes(name)),
+      properties,
       notes,
     });
   }
@@ -258,6 +329,8 @@ function collectFromFlattenedSchema(schema: JsonSchema): readonly GroupedOperati
     op: opName,
     description: descriptionMap.get(opName) ?? `Operation ${opName}`,
     required: [] as readonly string[],
+    optional: Object.keys(properties).filter((name) => name !== "op"),
+    properties,
     notes,
   }));
 }
@@ -302,6 +375,9 @@ export function renderToolsSection(modules: readonly ToolModuleDescriptor[] = de
       if (operations.length === 0) {
         lines.push("_No operations defined._");
       } else {
+        if (!lines.includes("_Address range convention: `address` + `length` means start address plus byte count; `startAddress` + `endAddress` means inclusive bounds._")) {
+          lines.splice(2, 0, "_Address range convention: `address` + `length` means start address plus byte count; `startAddress` + `endAddress` means inclusive bounds._", "");
+        }
         const toolPlatforms: readonly string[] = tool.metadata.platforms ?? ["c64u"];
         const opPlatformOverrides: Record<string, readonly string[]> = tool.metadata.operationPlatforms ?? {};
         const operationRows = operations
@@ -312,14 +388,15 @@ export function renderToolsSection(modules: readonly ToolModuleDescriptor[] = de
             return [
               `\`${operation.op}\``,
               escapeCell(operation.description),
-              escapeCell(toTableValue(operation.required.map((name) => `\`${name}\``))),
+              escapeCell(formatInputs(operation.required, operation.properties)),
+              escapeCell(formatInputs(operation.optional, operation.properties)),
               operation.notes.length ? escapeCell(operation.notes.join(", ")) : "—",
               effectivePlatforms.includes("c64u") ? "✅" : "",
               effectivePlatforms.includes("vice") ? "✅" : "",
             ];
           });
 
-        lines.push(renderTable(["Operation", "Description", "Required Inputs", "Notes", "C64U", "VICE"], operationRows));
+        lines.push(renderTable(["Operation", "Description", "Required Inputs", "Optional Inputs", "Notes", "C64U", "VICE"], operationRows));
       }
 
       lines.push("");

package/server.json

@@ -8,12 +8,12 @@
     "source": "github"
   },
   "websiteUrl": "https://github.com/chrisgleissner/c64bridge",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "c64bridge",
-      "version": "0.9.0",
+      "version": "0.9.2",
       "transport": {
         "type": "stdio"
       },