@henols/c64-re-tools 2.0.1 → 2.1.0-rc.2

package/skills/c64-assembler/scripts/assemble.ts

@@ -1,138 +0,0 @@
-// The c64-assembler script: assembles project source with ACME, which it runs
-// itself, and writes the program into the project.
-
-import { mkdirSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
-import { parseArgs } from "node:util";
-
-import { formatC64Address, parseC64Address } from "#src/c64.ts";
-import { readProjectTree } from "#src/host-client/transfer.ts";
-import { assemble } from "#src/native/acme.ts";
-import { localToolContext } from "#src/native/local.ts";
-import type { AcmeParams } from "#src/native/types.ts";
-import { resolveProjectPath } from "#src/project.ts";
-import { runScript, UsageError } from "#src/script.ts";
-import { compareBuild } from "./lib/compare.ts";
-import { KnowledgeError, openForRead } from "#src/knowledge/database.ts";
-import { requireProgram, type ProgramImage } from "#src/knowledge/program.ts";
-import { DEFAULT_SPACE, SPACE } from "#src/knowledge/schema.ts";
-
-const USAGE = `assemble.ts --source-root <dir> --entry <file> --out <file.prg> [options]
-
-  --source-root <dir>      folder in the project to assemble from; all of it is sent
-  --entry <file>           the main source file, relative to the source root
-  --out <file.prg>         where to write the program, relative to the project
-  --include <dir>          include directory relative to the source root (repeatable)
-  --define NAME=VALUE      assembler symbol: an integer ($hex allowed) or true/false (repeatable)
-  --set-pc <address>       start address when the source sets none, for example '$0801'
-  --compare                check the program byte by byte against the program in the
-                           knowledge, each segment; put it in with knowledge.ts
-                           image of the c64-knowledge skill
-  --space <space>          with --compare: the knowledge space of the program, c64 (the
-                           default), drive8, or bank0 to bank255
-  --plain                  write the bytes only, without the 2-byte load address of a PRG
-  --all-symbols            list also the constants that the source does not use
-
-The result is one JSON object. Addresses and symbol values are $ and at least four hex digits.`;
-
-function parseDefine(text: string): [string, number | boolean] {
-  const match = /^([A-Za-z_][A-Za-z0-9_]*)=(.+)$/.exec(text);
-  if (match === null) throw new UsageError(`--define needs NAME=VALUE, not ${text}`);
-  const value = match[2]!;
-  if (value === "true" || value === "false") return [match[1]!, value === "true"];
-  if (/^\$[0-9a-fA-F]+$/.test(value)) return [match[1]!, Number.parseInt(value.slice(1), 16)];
-  if (/^-?\d+$/.test(value)) return [match[1]!, Number(value)];
-  throw new UsageError(`--define ${match[1]} needs an integer or true/false, not ${value}`);
-}
-
-async function run(argv: string[]): Promise<{ output: unknown; failed: boolean }> {
-  const { values } = parseArgs({
-    args: argv,
-    strict: true,
-    options: {
-      "source-root": { type: "string" },
-      entry: { type: "string" },
-      out: { type: "string" },
-      include: { type: "string", multiple: true },
-      define: { type: "string", multiple: true },
-      "set-pc": { type: "string" },
-      compare: { type: "boolean" },
-      space: { type: "string" },
-      plain: { type: "boolean" },
-      "all-symbols": { type: "boolean" },
-      help: { type: "boolean" },
-    },
-  });
-  if (values.help) throw new UsageError("");
-  const sourceRoot = values["source-root"];
-  const entry = values.entry;
-  const out = values.out;
-  if (sourceRoot === undefined || entry === undefined || out === undefined) throw new UsageError("--source-root, --entry and --out are necessary");
-  let outPath: string;
-  try {
-    outPath = resolveProjectPath(out);
-  } catch {
-    throw new UsageError(`--out must be a path relative to the project folder that stays inside it, not ${out}`);
-  }
-  if (values.space !== undefined && !values.compare) throw new UsageError("--space works only with --compare");
-  const space = values.space ?? DEFAULT_SPACE;
-  if (!SPACE.test(space)) throw new UsageError("--space must be c64, drive8, or bank0 to bank255");
-  // Read the program before ACME runs, so a project without it stops at once.
-  let program: ProgramImage | undefined;
-  if (values.compare) {
-    const db = openForRead();
-    try {
-      program = requireProgram(db, space);
-    } finally {
-      db?.close();
-    }
-  }
-  const defines = Object.fromEntries((values.define ?? []).map(parseDefine));
-  let setPc: number | undefined;
-  if (values["set-pc"] !== undefined) {
-    try {
-      setPc = parseC64Address(values["set-pc"]);
-    } catch {
-      throw new UsageError(`--set-pc must be $ followed by four hex digits, not ${values["set-pc"]}`);
-    }
-  }
-  const tree = readProjectTree(sourceRoot);
-  if (!tree.files.some((file) => file.path === entry)) throw new UsageError(`--entry ${entry} is not a file in ${sourceRoot}`);
-  const params: AcmeParams = { files: tree.files, entrySource: entry, includeDirs: values.include ?? [], defines, ...(setPc === undefined ? {} : { setPc }) };
-
-  const { result, attachments } = await assemble(params, tree.contents, localToolContext());
-  if (!result.assembled) return { output: { assembled: false, diagnostics: result.diagnostics }, failed: true };
-  mkdirSync(dirname(outPath), { recursive: true });
-  writeFileSync(outPath, values.plain ? attachments![0]!.subarray(2) : attachments![0]!);
-  const range = result.loadRange!;
-  const compared = program === undefined ? undefined : compareBuild(attachments![0]!, program);
-  // An include file of platform names gives many constants that the program does not use.
-  const listed = result.symbols!.filter((symbol) => values["all-symbols"] || symbol.kind === "address" || symbol.used);
-  return {
-    output: {
-      assembled: true,
-      output: out,
-      ...(values.plain ? { plain: true } : {}),
-      loadRange: { start: formatC64Address(range.start), end: formatC64Address(range.end), bytes: range.bytes },
-      symbols: listed.map((symbol) =>
-        symbol.kind === "address"
-          ? { name: symbol.name, kind: "address", address: formatC64Address(symbol.address), used: symbol.used }
-          : { name: symbol.name, kind: "constant", value: `$${symbol.value.toString(16).padStart(4, "0")}`, used: symbol.used },
-      ),
-      ...(values["all-symbols"] ? {} : { unusedConstants: result.symbols!.length - listed.length }),
-      diagnostics: result.diagnostics,
-      ...(compared === undefined ? {} : { compare: compared }),
-    },
-    // A build that differs from its reference is a failed check.
-    failed: compared !== undefined && !compared.identical,
-  };
-}
-
-await runScript(
-  async (argv) => {
-    const { output, failed } = await run(argv);
-    if (failed) process.exitCode = 1;
-    return output;
-  },
-  { usage: USAGE, refusals: [KnowledgeError] },
-);

package/skills/c64-docs/scripts/generate.ts

@@ -1,109 +0,0 @@
-// c64-docs generate.ts: the reference pages of a program from the
-// knowledge, the source map of c64-source and the program in the knowledge. The pages are
-// generated and never edited; the pages of a person link to them.
-
-import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
-import { join, posix } from "node:path";
-import { parseArgs } from "node:util";
-
-import { WireFailure } from "#src/host-client/tools.ts";
-import { writeProjectFile } from "#src/host-client/transfer.ts";
-import { conflicts } from "#src/knowledge/conflicts.ts";
-import { KnowledgeError, openForRead } from "#src/knowledge/database.ts";
-import { currentRevision, listComments, listModules, listReferences, listRegions, listSymbols } from "#src/knowledge/read.ts";
-import { resolveProjectFile, resolveProjectPath } from "#src/project.ts";
-import { runScript, UsageError } from "#src/script.ts";
-import { buildReference, GENERATED_MARK } from "./lib/reference.ts";
-import { readSourceMap } from "./lib/source-map.ts";
-import { programImage, type ProgramImage } from "#src/knowledge/program.ts";
-
-const USAGE = `generate.ts --source <dir> --out <dir>
-
-  --source <dir>   the source directory of c64-source, with its source-map.json,
-                   relative to the project folder
-  --out <dir>      the directory for the reference pages, relative to the project
-                   folder, for example docs/reference; generate.ts writes only
-                   there and refuses a page in it that it did not write
-When the knowledge has the program of the source (knowledge.ts image of the
-c64-knowledge skill), the reference decodes the tables and shows the
-graphics. The result is one JSON object.`;
-
-/** The files of an earlier run in `directory`, the real folder of --out, or a refusal that names a file of a person. */
-function oldFiles(out: string, directory: string): string[] {
-  if (!existsSync(directory)) return [];
-  const found: string[] = [];
-  const walk = (relative: string) => {
-    for (const entry of readdirSync(join(directory, relative), { withFileTypes: true })) {
-      const path = posix.join(relative, entry.name);
-      if (entry.isDirectory()) {
-        walk(path);
-        continue;
-      }
-      const generated = path.endsWith(".md") ? readFileSync(join(directory, path), "utf8").startsWith(GENERATED_MARK) : path.startsWith("images/") && path.endsWith(".png");
-      if (!generated) throw new WireFailure("invalid-input", `${posix.join(out, path)} is not a page of generate.ts. Nothing was written. Give --out a directory that holds only the reference, and keep the pages of a person outside it.`);
-      found.push(path);
-    }
-  };
-  walk("");
-  return found;
-}
-
-function run(argv: string[]): Record<string, unknown> {
-  const { values, positionals } = parseArgs({ args: argv, strict: true, allowPositionals: true, options: { source: { type: "string" }, out: { type: "string" }, help: { type: "boolean" } } });
-  if (values.help) throw new UsageError("");
-  if (positionals.length > 0) throw new UsageError(`generate.ts takes no positional arguments, not ${positionals[0]}`);
-  if (values.source === undefined) throw new UsageError("give --source <dir>: the source directory of c64-source");
-  if (values.out === undefined) throw new UsageError("give --out <dir>: the directory for the reference pages");
-  for (const [option, path] of [["--source", values.source], ["--out", values.out]] as const) {
-    try {
-      resolveProjectPath(path);
-    } catch {
-      throw new UsageError(`${option} must be a path relative to the project folder that stays inside it, not ${path}`);
-    }
-  }
-  // The files of an earlier run are deleted: only in a folder that is inside the project, also after its symbolic links.
-  let directory = resolveProjectPath(values.out);
-  if (existsSync(directory)) {
-    try {
-      directory = resolveProjectFile(values.out);
-    } catch {
-      throw new UsageError(`--out must be a path relative to the project folder that stays inside it, also through symbolic links, not ${values.out}`);
-    }
-  }
-  const map = readSourceMap(values.source);
-  const db = openForRead();
-  let knowledge;
-  let image: ProgramImage | undefined;
-  try {
-    image = programImage(db, map.space);
-    const found = conflicts(db).length;
-    if (found > 0) throw new KnowledgeError("conflict", `The knowledge has ${found} conflict${found === 1 ? "" : "s"} from a git merge. Nothing was written. Run c64-knowledge's knowledge.ts merge, then generate the source and the reference again.`);
-    const revision = currentRevision(db);
-    // A source of another revision has other lines: the links would point to the wrong code.
-    if (map.revision !== revision) {
-      throw new WireFailure("invalid-input", `${map.pathOf("source-map.json")} is from knowledge revision ${map.revision}, and the knowledge is at revision ${revision}. Nothing was written. Generate the source again with c64-source, then run generate.ts.`);
-    }
-    knowledge = {
-      revision,
-      symbols: listSymbols(db, undefined, undefined, undefined, map.space),
-      regions: listRegions(db, undefined, undefined, undefined, map.space),
-      comments: listComments(db, undefined, undefined, map.space),
-      references: listReferences(db, undefined, undefined, undefined, map.space),
-      modules: listModules(db, undefined, undefined, map.space),
-    };
-  } finally {
-    db?.close();
-  }
-  const old = oldFiles(values.out, directory);
-  const built = buildReference({
-    out: posix.normalize(values.out),
-    map,
-    ...knowledge,
-    ...(image === undefined ? {} : { image: { byteAt: image.byteAt, inImage: (address: number) => image.segments.some((segment) => address >= segment.start && address <= segment.end) } }),
-  });
-  for (const path of old) rmSync(join(directory, path), { force: true });
-  for (const file of built.files) writeProjectFile(file.path, file.bytes, { what: "--out" });
-  return { out: values.out, revision: knowledge.revision, index: posix.join(posix.normalize(values.out), "index.md"), ...built.counts, program: image === undefined ? "none: put the program into the knowledge with knowledge.ts image to decode the tables and show the graphics" : "the knowledge" };
-}
-
-await runScript(run, { usage: USAGE, refusals: [KnowledgeError] });

package/skills/c64-docs/scripts/link.ts

@@ -1,239 +0,0 @@
-// c64-docs link.ts: links the name mentions of the documentation to the
-// source and the reference, and checks every link and image of the pages.
-// With --check it writes nothing and fails when a page is not up to date.
-
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { join, posix } from "node:path";
-import { parseArgs } from "node:util";
-
-import { WireFailure } from "#src/host-client/tools.ts";
-import { writeProjectFile } from "#src/host-client/transfer.ts";
-import { KnowledgeError, openForRead } from "#src/knowledge/database.ts";
-import { currentRevision, listSymbols } from "#src/knowledge/read.ts";
-import { resolveProjectFile, resolveProjectPath } from "#src/project.ts";
-import { runScript, UsageError } from "#src/script.ts";
-import { checkLinks, linkPage, type Files, type Problem } from "./lib/links.ts";
-import { GENERATED_MARK } from "./lib/reference.ts";
-import { readSourceMap } from "./lib/source-map.ts";
-
-const USAGE = `link.ts <pages>... --source <dir> [--reference <dir>] [--check]
-
-  <pages>...         .md files and directories of the documentation, relative to
-                     the project folder, for example README.md docs; link.ts reads
-                     each file and every .md file below each directory
-  --source <dir>     the source directory of c64-source, with its source-map.json
-  --reference <dir>  the reference pages of generate.ts; the default is the
-                     reference/ folder of the first directory that has one
-  --check            write nothing; fail when a link is not up to date or a page
-                     has a problem
-
-A name in backticks gets a link to its line in the source. An address in
-backticks after the name gets a link to the entry of the name in the reference.
-The result is one JSON object.`;
-
-const MAX_LISTED = 50;
-/** A name outside the image covers the addresses up to the next name, at most this many. */
-const MAX_BODY = 256;
-
-const isDirectory = (path: string) => {
-  const real = resolveProjectPath(path);
-  return existsSync(real) && statSync(real).isDirectory();
-};
-
-function markdownFiles(directory: string): string[] {
-  if (!isDirectory(directory)) throw new WireFailure("not-found", `There is no directory ${directory} in the project folder.`);
-  let root: string;
-  try {
-    root = resolveProjectFile(directory);
-  } catch {
-    throw new WireFailure("invalid-input", `${directory} leads out of the project folder through a symbolic link.`);
-  }
-  const found: string[] = [];
-  const walk = (relative: string) => {
-    for (const entry of readdirSync(join(root, relative), { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-      const path = posix.join(relative, entry.name);
-      if (entry.isDirectory()) walk(path);
-      else if (entry.name.endsWith(".md")) found.push(posix.join(directory, path));
-    }
-  };
-  walk("");
-  return found;
-}
-
-/** The text of each file that the run read: a page, a source file or a reference page is read once. */
-const texts = new Map<string, string | undefined>();
-
-const files: Files = {
-  inside: (path) => {
-    try {
-      resolveProjectPath(path);
-      return true;
-    } catch {
-      return false;
-    }
-  },
-  exists: (path) => {
-    try {
-      resolveProjectFile(path);
-      return true;
-    } catch {
-      return false;
-    }
-  },
-  text: (path) => {
-    if (texts.has(path)) return texts.get(path);
-    let text: string | undefined;
-    try {
-      const real = resolveProjectFile(path);
-      text = statSync(real).isFile() ? readFileSync(real, "utf8") : undefined;
-    } catch {
-      text = undefined;
-    }
-    texts.set(path, text);
-    return text;
-  },
-};
-
-/** A .md entry of a directory that is a symbolic link to no file, or to a file outside the project. */
-const unreadable = (page: string): Problem => ({ page, line: 1, kind: "missing-file", message: `${page} is a symbolic link to no file or to a file outside the project folder.` });
-
-function run(argv: string[]): { output: Record<string, unknown>; failed: boolean } {
-  const { values, positionals } = parseArgs({ args: argv, strict: true, allowPositionals: true, options: { source: { type: "string" }, reference: { type: "string" }, check: { type: "boolean" }, help: { type: "boolean" } } });
-  if (values.help) throw new UsageError("");
-  if (positionals.length === 0) throw new UsageError("give the pages: .md files and directories of the documentation, for example README.md docs");
-  if (values.source === undefined) throw new UsageError("give --source <dir>: the source directory of c64-source");
-  const given = [...new Set(positionals.map((path) => posix.normalize(path)))];
-  for (const [option, path] of [...given.map((path) => ["<pages>", path] as const), ["--source", values.source], ["--reference", values.reference]] as const) {
-    if (path === undefined) continue;
-    if (!files.inside(path)) throw new UsageError(`${option} must be a path relative to the project folder that stays inside it, not ${path}`);
-  }
-  for (const path of given) {
-    if (!path.endsWith(".md") && files.exists(path) && !isDirectory(path)) throw new UsageError(`<pages> takes .md files and directories, not ${path}`);
-  }
-  const directories = given.filter((path) => !path.endsWith(".md") || isDirectory(path));
-  const map = readSourceMap(values.source);
-  const reference = values.reference === undefined ? directories.map((path) => posix.join(path, "reference")).find((path) => isDirectory(path)) : posix.normalize(values.reference);
-  const problems: Problem[] = [];
-  const db = openForRead();
-  let symbols;
-  let revision;
-  try {
-    revision = currentRevision(db);
-    symbols = listSymbols(db, undefined, undefined, undefined, map.space);
-  } finally {
-    db?.close();
-  }
-  if (map.revision !== revision) {
-    problems.push({ page: map.pathOf("source-map.json"), line: 1, kind: "stale-reference", message: `The source is from knowledge revision ${map.revision}, and the knowledge is at ${revision}. Generate the source and the reference again, then run link.ts.` });
-  }
-  const addresses = new Map<string, number>();
-  for (const label of map.labels) addresses.set(label.name, label.address);
-  for (const symbol of symbols) addresses.set(symbol.name, symbol.address);
-  // A routine runs to the next routine; any other name to the next name of the knowledge, in its file, and outside the image at most MAX_BODY bytes.
-  const routines = symbols.filter((symbol) => symbol.kind === "routine").map((symbol) => symbol.address).sort((a, b) => a - b);
-  const named = [...new Set(symbols.map((symbol) => symbol.address))].sort((a, b) => a - b);
-  const kinds = new Map(symbols.map((symbol) => [symbol.name, symbol.kind]));
-  const bodyEnds = new Map<string, number | undefined>();
-  const bodyEnd = (name: string) => {
-    if (bodyEnds.has(name)) return bodyEnds.get(name);
-    const address = addresses.get(name);
-    let end: number | undefined;
-    if (address !== undefined) {
-      const next = ((kinds.get(name) === "routine" ? routines : named).find((other) => other > address) ?? 0x10000) - 1;
-      const file = map.lineOf(address)?.file;
-      if (file === undefined) end = Math.min(next, address + MAX_BODY - 1);
-      else {
-        end = address;
-        while (end < next && map.lineOf(end + 1)?.file === file) end++;
-      }
-    }
-    bodyEnds.set(name, end);
-    return end;
-  };
-  const nameAt = new Map(symbols.map((symbol) => [symbol.address, symbol.name]));
-  /** The routine, else the name, whose body holds an address. */
-  const placeOf = (address: number) => {
-    for (const list of [routines, named]) {
-      let start: number | undefined;
-      for (const other of list) if (other <= address) start = other;
-      const name = start === undefined ? undefined : nameAt.get(start);
-      if (name !== undefined && (bodyEnd(name) ?? start!) >= address) return name;
-    }
-    return undefined;
-  };
-
-  // The entries of the reference: each <a id> that is a name.
-  const entries = new Map<string, string>();
-  const referencePages = reference === undefined ? [] : markdownFiles(reference);
-  for (const page of referencePages) {
-    const text = files.text(page);
-    if (text === undefined) {
-      problems.push(unreadable(page));
-      continue;
-    }
-    const stamp = /^<!-- Generated by c64-docs from knowledge revision (\S+) /.exec(text);
-    if (text.startsWith(GENERATED_MARK) && stamp !== null && stamp[1] !== map.revision) {
-      problems.push({ page, line: 1, kind: "stale-reference", message: `${page} is from knowledge revision ${stamp[1]}, and the source from ${map.revision}. Run generate.ts again.` });
-    }
-    for (const match of text.matchAll(/<a id="([^"]+)"><\/a>/g)) if (addresses.has(match[1]!) && !entries.has(match[1]!)) entries.set(match[1]!, `${page}#${match[1]}`);
-  }
-  const inside = (path: string, directory: string | undefined) => directory !== undefined && (path === directory || path.startsWith(`${directory}/`));
-  const context = {
-    addressOf: (name: string) => addresses.get(name),
-    codeOf: (name: string) => {
-      const label = map.labelOf(name);
-      return label === undefined ? undefined : `${map.pathOf(label.file)}#L${label.line}`;
-    },
-    entryOf: (name: string) => entries.get(name),
-    bodyEnd,
-    placeOf,
-    lineOf: (address: number) => {
-      const line = map.lineOf(address);
-      return line === undefined ? undefined : `${map.pathOf(line.file)}#L${line.line}`;
-    },
-    managed: (path: string) => inside(path, posix.normalize(map.directory)) || inside(path, reference),
-  };
-
-  const pages = [...new Set(given.flatMap((path) => {
-    if (directories.includes(path)) return markdownFiles(path);
-    if (files.text(path) === undefined) throw new WireFailure("not-found", `There is no file ${path} in the project folder.`);
-    return [path];
-  }))];
-  const changedPages: string[] = [];
-  let links = 0;
-  for (const page of pages) {
-    const text = files.text(page);
-    if (text === undefined) {
-      problems.push(unreadable(page));
-      continue;
-    }
-    // A generated page is right by its making: it is only checked.
-    const generated = text.startsWith(GENERATED_MARK);
-    const linked = generated ? { text, changed: 0, problems: [] } : linkPage(text, { page, ...context });
-    problems.push(...linked.problems, ...checkLinks(page, linked.text, files));
-    if (linked.changed === 0) continue;
-    links += linked.changed;
-    changedPages.push(page);
-    if (values.check) continue;
-    writeProjectFile(page, Buffer.from(linked.text, "utf8"));
-    texts.set(page, linked.text);
-  }
-  const byKind: Record<string, number> = {};
-  for (const problem of problems) byKind[problem.kind] = (byKind[problem.kind] ?? 0) + 1;
-  const output: Record<string, unknown> = {
-    pages: pages.length,
-    ...(reference === undefined ? { reference: "none: run generate.ts for links to the entries" } : { reference }),
-    ...(values.check ? { notUpToDate: { links, pages: changedPages } } : { linked: { links, pages: changedPages } }),
-    problems: { count: problems.length, byKind, listed: problems.slice(0, MAX_LISTED).map((problem) => ({ at: `${problem.page}:${problem.line}`, kind: problem.kind, message: problem.message })) },
-  };
-  return { output, failed: problems.length > 0 || (values.check === true && links > 0) };
-}
-
-await runScript(
-  (argv) => {
-    const { output, failed } = run(argv);
-    if (failed) process.exitCode = 1;
-    return output;
-  },
-  { usage: USAGE, refusals: [KnowledgeError] },
-);

package/skills/c64-memory-map/scripts/memmap.ts

@@ -1,92 +0,0 @@
-// The c64-memory-map script: the platform meaning of C64 addresses and of
-// values in platform registers. Local lookup only; nothing is stored. export
-// writes the platform names to a project file as an ACME include.
-
-import { parseArgs } from "node:util";
-
-import { writeProjectFile } from "#src/host-client/transfer.ts";
-import { decode, IO, lookup, platformNames, ROM, SYSTEM, type Entry } from "#src/platform.ts";
-import { runScript, UsageError } from "#src/script.ts";
-
-const USAGE = `memmap.ts at <address> [<address> ...]
-memmap.ts decode <register> <value> [--bank <$dd00 value>]
-memmap.ts list <vic|sid|cia1|cia2|kernal|system>
-memmap.ts export --out <file>     the platform names as an ACME include (NAME = $xxxx)
-
-Addresses and values are $ and hex digits, decimal, or % and binary digits.
-The result is one JSON object.`;
-
-const hex = (value: number, digits = 4) => `$${value.toString(16).padStart(digits, "0")}`;
-
-function number(text: string, max: number, what: string): number {
-  let value = Number.NaN;
-  if (/^\$[0-9a-f]{1,4}$/i.test(text)) value = Number.parseInt(text.slice(1), 16);
-  else if (/^%[01]{1,16}$/.test(text)) value = Number.parseInt(text.slice(1), 2);
-  else if (/^\d{1,5}$/.test(text)) value = Number(text);
-  if (!(value >= 0 && value <= max)) throw new UsageError(`${what} must be from 0 to ${hex(max, max > 0xff ? 4 : 2)}, not ${text}`);
-  return value;
-}
-
-const show = (entry: Entry) => ({ start: hex(entry.start), ...(entry.end !== entry.start ? { end: hex(entry.end) } : {}), name: entry.name, meaning: entry.meaning });
-
-function run(argv: string[]): unknown {
-  const { values, positionals } = parseArgs({ args: argv, strict: true, allowPositionals: true, options: { bank: { type: "string" }, out: { type: "string" }, help: { type: "boolean" } } });
-  if (values.help || positionals.length === 0) throw new UsageError("");
-  const [command, ...rest] = positionals;
-  switch (command) {
-    case "at": {
-      if (rest.length === 0) throw new UsageError("give at least one address");
-      return {
-        addresses: rest.map((text) => {
-          const found = lookup(number(text, 0xffff, "an address"));
-          // The chip registers, color RAM and the cartridge I/O areas show only while $01 maps I/O in.
-          const io = found.address >= 0xd000 && found.address <= 0xdfff;
-          return {
-            ...found,
-            address: hex(found.address),
-            ...(found.mirrorOf === undefined ? {} : { mirrorOf: hex(found.mirrorOf) }),
-            ...(found.entryStart === undefined ? {} : { entryStart: hex(found.entryStart) }),
-            ...(io ? { visible: "when $01 shows I/O at $D000 (the default)" } : {}),
-          };
-        }),
-      };
-    }
-    case "decode": {
-      if (rest.length !== 2) throw new UsageError("decode takes a register and a value");
-      const register = number(rest[0]!, 0xffff, "the register");
-      const value = number(rest[1]!, 0xff, "the value");
-      const bank = values.bank === undefined ? undefined : number(values.bank, 0xff, "--bank");
-      try {
-        return { register: hex(register), value: hex(value, 2), name: lookup(register).name, ...decode(register, value, bank) };
-      } catch (error) {
-        if (error instanceof RangeError) throw new UsageError(error.message);
-        throw error;
-      }
-    }
-    case "list": {
-      const lists: Record<string, Entry[]> = {
-        vic: IO[0]!.registers,
-        sid: IO[1]!.registers,
-        cia1: IO[2]!.registers,
-        cia2: IO[3]!.registers,
-        kernal: ROM,
-        system: SYSTEM,
-      };
-      const list = lists[rest[0] ?? ""];
-      if (list === undefined || rest.length !== 1) throw new UsageError(`list takes one of ${Object.keys(lists).join(", ")}`);
-      return { entries: list.map(show) };
-    }
-    case "export": {
-      if (rest.length !== 0 || values.out === undefined) throw new UsageError("export takes --out <file> and nothing else");
-      const names = platformNames();
-      const lines = ["; C64 platform names from the c64-memory-map skill, for ACME.", ...names.map((item) => `${item.name} = ${hex(item.address, item.address < 0x100 ? 2 : 4)}`.padEnd(24) + `; ${item.meaning}`)];
-      const bytes = Buffer.from(`${lines.join("\n")}\n`, "utf8");
-      writeProjectFile(values.out, bytes, { what: "--out" });
-      return { out: values.out, names: names.length, bytes: bytes.length };
-    }
-    default:
-      throw new UsageError(`unknown command ${command}`);
-  }
-}
-
-await runScript((argv) => run(argv), { usage: USAGE });

package/skills/c64-testing/scripts/checklist.ts

@@ -1,51 +0,0 @@
-// The c64-testing playtest checklist: a Markdown list for a human tester,
-// made from the scenarios' checkpoints and the behavior that automated
-// scenarios cannot check. Nothing is stored.
-
-import { parseArgs } from "node:util";
-
-import { runScript, UsageError } from "#src/script.ts";
-import { readScenario, ScenarioError, type Scenario } from "./lib/scenario.ts";
-
-const USAGE = `checklist.ts <scenario.json> [<scenario.json> ...] [--item <text> ...]
-
-Prints a Markdown checklist. --item adds an application-specific line.`;
-
-/** Behavior that only a person can judge. */
-const ALWAYS = [
-  "The controls respond as fast as in the original.",
-  "The animation is smooth and has no glitches.",
-  "The music and the sound effects sound the same as in the original.",
-  "The game flow and the level changes work from start to end.",
-  "Nothing unexpected happens outside the tested scenarios.",
-];
-
-function run(argv: string[]): string {
-  const { values, positionals } = parseArgs({ args: argv, strict: true, allowPositionals: true, options: { item: { type: "string", multiple: true }, help: { type: "boolean" } } });
-  if (values.help) throw new UsageError("");
-  if (positionals.length === 0) throw new UsageError("give at least one scenario file");
-  const lines = ["# Playtest checklist", ""];
-  for (const path of positionals) {
-    let scenario: Scenario;
-    try {
-      scenario = readScenario(path);
-    } catch (error) {
-      if (error instanceof ScenarioError) throw new UsageError(error.message);
-      throw error;
-    }
-    lines.push(`## ${scenario.name}`, "");
-    for (const step of scenario.steps) if ("observe" in step) lines.push(`- [ ] At "${step.observe}", the rebuild looks and behaves as the original.`);
-    lines.push("");
-  }
-  lines.push("## Application", "");
-  for (const item of values.item ?? []) lines.push(`- [ ] ${item}`);
-  for (const item of ALWAYS) lines.push(`- [ ] ${item}`);
-  return `${lines.join("\n")}\n`;
-}
-
-await runScript(
-  (argv) => {
-    process.stdout.write(run(argv));
-  },
-  { usage: USAGE },
-);