c64bridge 0.5.0

package/dist/chargen.js

@@ -0,0 +1,197 @@
+/*
+C64 Bridge - An MCP Server for the Commodore 64 Ultimate
+Copyright (C) 2025 Christian Gleissner
+
+Licensed under the GNU General Public License v2.0 or later.
+See <https://www.gnu.org/licenses/> for details.
+*/
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const glyphCache = {
+    loaded: false,
+    glyphs: [],
+    byPetscii: new Map(),
+    byBasic: new Map(),
+};
+function parseCsvLine(line) {
+    const cells = [];
+    let current = "";
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i += 1) {
+        const ch = line[i];
+        if (inQuotes) {
+            if (ch === "\"") {
+                if (line[i + 1] === "\"") {
+                    current += "\"";
+                    i += 1;
+                }
+                else {
+                    inQuotes = false;
+                }
+            }
+            else {
+                current += ch;
+            }
+        }
+        else if (ch === "\"") {
+            inQuotes = true;
+        }
+        else if (ch === ",") {
+            cells.push(current);
+            current = "";
+        }
+        else {
+            current += ch;
+        }
+    }
+    cells.push(current);
+    return cells;
+}
+function parseCsv(content) {
+    const lines = content.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    if (lines.length === 0) {
+        return [];
+    }
+    const headerCells = parseCsvLine(lines[0].trim());
+    const rows = [];
+    for (let i = 1; i < lines.length; i += 1) {
+        const raw = lines[i];
+        const cells = parseCsvLine(raw.trim());
+        const row = {};
+        for (let j = 0; j < headerCells.length; j += 1) {
+            const key = headerCells[j];
+            const value = cells[j] ?? "";
+            row[key] = value;
+        }
+        rows.push(row);
+    }
+    return rows;
+}
+function parseDecimal(value) {
+    if (!value) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(trimmed, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function parseHex(value) {
+    if (!value) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    let normalized = trimmed;
+    if (normalized.startsWith("$")) {
+        normalized = normalized.slice(1);
+    }
+    else if (normalized.toLowerCase().startsWith("0x")) {
+        normalized = normalized.slice(2);
+    }
+    const parsed = Number.parseInt(normalized, 16);
+    if (Number.isNaN(parsed)) {
+        return undefined;
+    }
+    return parsed;
+}
+function parseHexByte(value) {
+    const parsed = parseHex(value);
+    if (parsed === undefined || parsed < 0 || parsed > 0xff) {
+        return undefined;
+    }
+    return parsed;
+}
+function parsePetsciiCode(row) {
+    return (parseDecimal(row.petscii_code_dec)
+        ?? parseHex(row.petscii_code)
+        ?? parseDecimal(row.petscii_code)
+        ?? parseDecimal(row.petcsii_code) // legacy typo fallback
+    );
+}
+function parseScreenCode(row) {
+    return (parseDecimal(row.screen_code_dec)
+        ?? parseHex(row.screen_code)
+        ?? parseDecimal(row.screen_code));
+}
+function readChargenCsv(baseDir) {
+    const csvPath = join(baseDir, "..", "data", "video", "character-set.csv");
+    const csv = readFileSync(csvPath, "utf8");
+    return parseCsv(csv);
+}
+function loadGlyphs() {
+    if (glyphCache.loaded) {
+        return;
+    }
+    const baseDir = dirname(fileURLToPath(import.meta.url));
+    const rows = readChargenCsv(baseDir);
+    for (const row of rows) {
+        const petsciiCode = parsePetsciiCode(row);
+        const screenCode = parseScreenCode(row);
+        if (petsciiCode === undefined || petsciiCode < 0) {
+            continue;
+        }
+        if (screenCode === undefined || screenCode < 0) {
+            continue;
+        }
+        const bytes = [];
+        for (let i = 0; i < 8; i += 1) {
+            const key = `byte${i + 1}`;
+            const legacyKey = `byte${i}`;
+            const value = row[key] ?? row[legacyKey];
+            const parsed = parseHexByte(value);
+            bytes.push(parsed ?? 0);
+        }
+        const name = (row.name ?? row.char_name)?.trim() || undefined;
+        const basicRaw = [row.basic_repr, row.char, row.keyboard, row.control_code]
+            .map((value) => value?.trim())
+            .find((value) => value && value.length > 0);
+        const basic = basicRaw && basicRaw.length > 0 ? basicRaw : undefined;
+        const glyph = {
+            petsciiCode,
+            screenCode,
+            basic,
+            name,
+            bitmap: Uint8Array.from(bytes),
+        };
+        glyphCache.glyphs.push(glyph);
+        glyphCache.byPetscii.set(petsciiCode, glyph);
+        if (basic && basic.length === 1) {
+            const setIfMissing = (key) => {
+                if (!glyphCache.byBasic.has(key)) {
+                    glyphCache.byBasic.set(key, glyph);
+                }
+            };
+            setIfMissing(basic);
+            const upper = basic.toUpperCase();
+            if (upper !== basic) {
+                setIfMissing(upper);
+            }
+            const lower = basic.toLowerCase();
+            if (lower !== basic) {
+                setIfMissing(lower);
+            }
+        }
+    }
+    glyphCache.loaded = true;
+}
+export function getChargenGlyphs() {
+    loadGlyphs();
+    return glyphCache.glyphs;
+}
+export function findGlyphByPetscii(code) {
+    loadGlyphs();
+    return glyphCache.byPetscii.get(code);
+}
+export function findGlyphByBasicChar(char) {
+    if (!char) {
+        return undefined;
+    }
+    loadGlyphs();
+    return glyphCache.byBasic.get(char);
+}

package/dist/config.js

@@ -0,0 +1,142 @@
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+const DEFAULT_HOST = "c64u";
+const DEFAULT_PORT = 80;
+const DEFAULT_CONFIG = {
+    c64_host: DEFAULT_HOST,
+    baseUrl: buildBaseUrl(DEFAULT_HOST, DEFAULT_PORT),
+    c64_port: DEFAULT_PORT,
+};
+let cachedConfig = null;
+export function loadConfig() {
+    if (cachedConfig) {
+        return cachedConfig;
+    }
+    const configPath = process.env.C64BRIDGE_CONFIG ?? `${process.env.HOME}/.c64bridge.json`;
+    const repoConfigPath = join(dirname(fileURLToPath(import.meta.url)), "..", ".c64bridge.json");
+    let rawConfig;
+    try {
+        rawConfig = JSON.parse(readFileSync(configPath, "utf-8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            try {
+                rawConfig = JSON.parse(readFileSync(repoConfigPath, "utf-8"));
+            }
+            catch (fallbackError) {
+                if (fallbackError.code === "ENOENT") {
+                    rawConfig = {};
+                }
+                else
+                    throw fallbackError;
+            }
+        }
+        else {
+            throw error;
+        }
+    }
+    // New schema: prefer c64u.{host,port,baseUrl}; keep legacy fields as fallback
+    const c64u = rawConfig?.c64u;
+    const parsedC64uHost = parseEndpoint(configuredString(c64u?.host));
+    const parsedC64uHostname = parseEndpoint(configuredString(c64u?.hostname));
+    const parsedLegacyHost = parseEndpoint(configuredString(rawConfig?.c64_host));
+    const parsedLegacyIp = parseEndpoint(configuredString(rawConfig?.c64_ip));
+    const parsedBaseOverrides = [
+        parseEndpoint(normaliseBaseUrl(c64u?.baseUrl)),
+        parseEndpoint(normaliseBaseUrl(rawConfig?.baseUrl)),
+    ];
+    const hostCandidates = [
+        parsedC64uHost.hostname,
+        parsedC64uHostname.hostname,
+        parsedLegacyHost.hostname,
+        parsedLegacyIp.hostname,
+        ...parsedBaseOverrides.map((entry) => entry.hostname),
+    ];
+    const portCandidates = [
+        configuredPort(c64u?.port),
+        parsedC64uHost.port,
+        parsedC64uHostname.port,
+        configuredPort(rawConfig?.c64_port),
+        parsedLegacyHost.port,
+        parsedLegacyIp.port,
+        ...parsedBaseOverrides.map((entry) => entry.port),
+    ];
+    const host = firstDefined(...hostCandidates) ?? DEFAULT_HOST;
+    const port = firstDefined(...portCandidates) ?? DEFAULT_PORT;
+    const baseUrl = buildBaseUrl(host, port);
+    const hostLabel = formatHost(host);
+    const hostWithPort = port === DEFAULT_PORT ? hostLabel : `${hostLabel}:${port}`;
+    const config = {
+        c64_host: hostWithPort,
+        baseUrl,
+        c64_port: port,
+    };
+    cachedConfig = config;
+    return config;
+}
+function configuredString(value) {
+    return typeof value === "string" ? value.trim() : undefined;
+}
+function configuredPort(value) {
+    if (typeof value === "number" && Number.isInteger(value) && value > 0 && value <= 65535) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Number(value.trim());
+        if (Number.isInteger(parsed) && parsed > 0 && parsed <= 65535) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function normaliseBaseUrl(value) {
+    const input = configuredString(value);
+    if (!input)
+        return undefined;
+    if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(input)) {
+        return `http://${input}`;
+    }
+    return stripTrailingSlash(input);
+}
+function parseEndpoint(value) {
+    const input = configuredString(value);
+    if (!input)
+        return {};
+    try {
+        const hasScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(input);
+        const url = new URL(hasScheme ? input : `http://${input}`);
+        const hostname = url.hostname || undefined;
+        const port = url.port ? configuredPort(url.port) : undefined;
+        const baseUrl = stripTrailingSlash(`${url.protocol}//${url.host}`);
+        return { hostname, port, baseUrl };
+    }
+    catch {
+        return {};
+    }
+}
+function stripTrailingSlash(input) {
+    return input.replace(/\/+$/, "");
+}
+function firstDefined(...values) {
+    for (const value of values) {
+        if (value !== undefined && value !== null)
+            return value;
+    }
+    return undefined;
+}
+function buildBaseUrl(host, port) {
+    const normalizedPort = Number.isInteger(port) && port > 0 ? port : DEFAULT_PORT;
+    const hostPart = formatHost(host);
+    const suffix = normalizedPort === DEFAULT_PORT ? "" : `:${normalizedPort}`;
+    return `http://${hostPart}${suffix}`;
+}
+function formatHost(host) {
+    if (host.includes(":") && !host.startsWith("[")) {
+        return `[${host}]`;
+    }
+    return host;
+}
+export function __resetConfigCacheForTests() {
+    cachedConfig = null;
+}

package/dist/context.js

@@ -0,0 +1,157 @@
+/*
+C64 Bridge - Context Loader and Utilities
+GPL-2.0-only
+*/
+import fs from "node:fs/promises";
+import path from "node:path";
+const ROOT = process.cwd();
+const BOOTSTRAP_PATH = path.resolve(ROOT, "data/context/bootstrap.md");
+const AGENTS_PATH = path.resolve(ROOT, "AGENTS.md");
+const PROMPTS_DIR = path.resolve(ROOT, ".github/prompts");
+const CHAT_PATH = path.resolve(ROOT, "data/context/chat.md");
+export async function loadBootstrapContext() {
+    const [primer, agents, prompts, chat] = await Promise.all([
+        readIfExists(BOOTSTRAP_PATH),
+        readIfExists(AGENTS_PATH),
+        loadPromptDefinitions(),
+        readIfExists(CHAT_PATH),
+    ]);
+    return {
+        primer: primer ?? "",
+        agents: agents ?? "",
+        prompts: prompts ?? [],
+        chat: chat ?? "",
+    };
+}
+async function readIfExists(file) {
+    try {
+        return await fs.readFile(file, "utf8");
+    }
+    catch (err) {
+        if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
+            return undefined;
+        }
+        throw err;
+    }
+}
+async function loadPromptDefinitions() {
+    try {
+        await fs.access(PROMPTS_DIR);
+    }
+    catch {
+        return [];
+    }
+    const dirEntries = await fs.readdir(PROMPTS_DIR, { withFileTypes: true });
+    const files = dirEntries.filter((entry) => entry.isFile() && entry.name.endsWith(".prompt.md"));
+    files.sort((a, b) => a.name.localeCompare(b.name));
+    const defs = [];
+    for (const entry of files) {
+        const filePath = path.join(PROMPTS_DIR, entry.name);
+        try {
+            const raw = await fs.readFile(filePath, "utf8");
+            const parsed = parsePromptFile(raw, entry.name, filePath);
+            defs.push(parsed);
+        }
+        catch (err) {
+            // eslint-disable-next-line no-console
+            console.warn(`Failed to load prompt ${entry.name}:`, err);
+        }
+    }
+    return defs;
+}
+function parsePromptFile(raw, fileName, filePath) {
+    const { body, metadata } = stripFrontmatterAndMetadata(raw);
+    const slug = fileName.replace(/\.prompt\.md$/, "");
+    const id = metadata.id ?? slug.replace(/[-\s]+/g, "_");
+    const title = metadata.title ?? slug
+        .split(/[-_]/)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+    const keywords = metadata.keywords ?? slug.split(/[-_]/).map((part) => part.toLowerCase());
+    const source = path.relative(ROOT, filePath).split(path.sep).join("/");
+    return {
+        id,
+        title,
+        keywords,
+        body: body.trim(),
+        source,
+    };
+}
+function stripFrontmatterAndMetadata(raw) {
+    let text = raw.trim();
+    const metadata = {};
+    const frontmatterMatch = /^---\s*\n([\s\S]*?)\n---\s*/.exec(text);
+    if (frontmatterMatch) {
+        text = text.slice(frontmatterMatch[0].length).trimStart();
+    }
+    const idMatch = text.match(/<!--\s*id:\s*([^>]+?)\s*-->/i);
+    if (idMatch) {
+        metadata.id = idMatch[1].trim();
+        text = text.replace(idMatch[0], "").trimStart();
+    }
+    const keywordMatch = text.match(/<!--\s*keywords:\s*([^>]+?)\s*-->/i);
+    if (keywordMatch) {
+        metadata.keywords = keywordMatch[1]
+            .split(/[,\s]+/)
+            .map((word) => word.trim().toLowerCase())
+            .filter(Boolean);
+        text = text.replace(keywordMatch[0], "").trimStart();
+    }
+    const titleMatch = text.match(/<!--\s*title:\s*([^>]+?)\s*-->/i);
+    if (titleMatch) {
+        metadata.title = titleMatch[1].trim();
+        text = text.replace(titleMatch[0], "").trimStart();
+    }
+    return { body: text, metadata };
+}
+export function extractSections(markdown, level = 2) {
+    const lines = markdown.split(/\r?\n/);
+    const re = new RegExp(`^${"#".repeat(level)}\\s+(.*)$`);
+    const results = [];
+    let current = null;
+    for (const line of lines) {
+        const m = re.exec(line);
+        if (m) {
+            if (current)
+                results.push(current);
+            current = { header: m[1].trim(), content: "" };
+        }
+        else if (current) {
+            current.content += (current.content ? "\n" : "") + line;
+        }
+    }
+    if (current)
+        results.push(current);
+    return results;
+}
+export function matchAgent(userText, agentsMd) {
+    const sections = extractSections(agentsMd, 2);
+    const lowered = userText.toLowerCase();
+    for (const sec of sections) {
+        const name = sec.header.toLowerCase();
+        if (lowered.includes("basic") && name.includes("basic"))
+            return sec.content.trim();
+        if ((/asm|assembly|machine\s*code/).test(lowered) && name.includes("asm"))
+            return sec.content.trim();
+        if ((/sid|music|song|compose/).test(lowered) && name.includes("sid"))
+            return sec.content.trim();
+        if ((/memory|peek|poke|disassemble|screen|color|colour/).test(lowered) && name.includes("memory"))
+            return sec.content.trim();
+        if ((/drive|d64|d71|d81|mount|disk/).test(lowered) && name.includes("drive"))
+            return sec.content.trim();
+    }
+    return undefined;
+}
+export function matchPrompt(userText, prompts) {
+    const lowered = userText.toLowerCase();
+    for (const prompt of prompts) {
+        const keywords = prompt.keywords.length > 0 ? prompt.keywords : [prompt.title.toLowerCase()];
+        if (keywords.some((keyword) => keyword && lowered.includes(keyword))) {
+            return annotated(prompt.body, prompt.source, prompt.title);
+        }
+    }
+    return undefined;
+}
+function annotated(content, source, section) {
+    return `<!-- Source: ${source} | Section: ${section} -->\n${content.trim()}`;
+}