c64bridge 0.7.4 → 0.8.0

package/dist/rag/init.js

@@ -4,6 +4,7 @@ GPL-2.0-only
 */
 import fs from "node:fs/promises";
 import path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
 import { LocalMiniHashEmbedding } from "./embeddings.js";
 import { buildAllIndexes, loadIndexes } from "./indexer.js";
 import { LocalRagRetriever } from "./retriever.js";
@@ -12,7 +13,7 @@ const EXTERNAL_DIR = path.resolve("external");
 const BASIC_DATA_DIR = path.resolve("data/basic/examples");
 const ASM_DATA_DIR = path.resolve("data/assembly/examples");
 const DOC_DIR = path.resolve("doc");
-const CONTEXT_DIR = path.resolve("doc/context");
+const CONTEXT_DIR = path.resolve("data/context");
 const BOOTSTRAP_PATH = path.join(CONTEXT_DIR, "bootstrap.md");
 const AGENTS_PATH = path.resolve("AGENTS.md");
 const PROMPTS_DIR = path.resolve(".github/prompts");
@@ -31,7 +32,42 @@ function embeddingIndexPaths() {
         other: path.join(dir, "embeddings_other.json"),
     };
 }
+export function createLazyRagRetriever(factory, hooks = {}) {
+    let resolved;
+    let pending;
+    const ensure = async () => {
+        if (resolved) {
+            return resolved;
+        }
+        if (!pending) {
+            hooks.onInitStart?.();
+            pending = factory().then((retriever) => {
+                resolved = retriever;
+                hooks.onInitComplete?.();
+                return retriever;
+            }).catch((error) => {
+                pending = undefined;
+                hooks.onInitError?.(error);
+                throw error;
+            });
+        }
+        return pending;
+    };
+    return {
+        async retrieve(query, topK, filterLanguage) {
+            const retriever = await ensure();
+            return retriever.retrieve(query, topK, filterLanguage);
+        },
+        async warmup() {
+            await ensure();
+        },
+    };
+}
 export async function initRag() {
+    const initDelayMs = Number(process.env.RAG_INIT_DELAY_MS ?? 0);
+    if (Number.isFinite(initDelayMs) && initDelayMs > 0) {
+        await delay(initDelayMs);
+    }
     const model = new LocalMiniHashEmbedding(384);
     // Build on start only when explicitly requested
     const buildOnStart = String(process.env.RAG_BUILD_ON_START ?? "").trim().toLowerCase();

package/dist/rag/knowledgeIndex.js

@@ -37,8 +37,8 @@ const KNOWLEDGE_BUNDLES = [
         id: "orientation",
         title: "Workflow & Orientation",
         summary: "Mandatory workflow and safety guidance before issuing any C64 commands.",
-        prompts: ["basic-program", "assembly-program", "memory-debug"],
-        tools: ["upload_run_basic", "upload_run_asm", "read_screen", "read"],
+        prompts: ["basic-program", "assembly-program", "memory-debug", "cross-platform-demo", "preset-music-demo"],
+        tools: ["upload_run_basic", "upload_run_asm", "cross_platform_greeting", "music_play_preset", "read_screen", "read"],
         resources: [
             {
                 uri: "c64://context/bootstrap",
@@ -47,10 +47,22 @@ const KNOWLEDGE_BUNDLES = [
                 relativePath: "data/context/bootstrap.md",
                 priority: "critical",
                 summary: "Step-by-step rules for safe automation, verification, and rollback on the C64.",
-                prompts: ["basic-program", "assembly-program", "memory-debug"],
-                tools: ["upload_run_basic", "upload_run_asm", "read_screen", "read"],
+                prompts: ["basic-program", "assembly-program", "memory-debug", "cross-platform-demo", "preset-music-demo"],
+                tools: ["upload_run_basic", "upload_run_asm", "cross_platform_greeting", "music_play_preset", "read_screen", "read"],
                 tags: ["workflow", "safety"],
             },
+            {
+                uri: "c64://context/fast-paths",
+                name: "Fast Path Workflows",
+                description: "Shortest reliable workflows for common C64U and VICE tasks, including dual-backend demos.",
+                relativePath: "data/context/fast-paths.md",
+                priority: "critical",
+                summary: "Condensed routing guide for one-call demos, backend switching, and when to prefer orchestration over manual tool composition.",
+                prompts: ["basic-program", "graphics-demo", "cross-platform-demo", "sid-music", "preset-music-demo"],
+                tools: ["c64_program", "c64_sound", "c64_select_backend", "c64_memory", "c64_graphics"],
+                relatedResources: ["c64://context/bootstrap", "c64://platform/status"],
+                tags: ["workflow", "fast-path", "routing"],
+            },
         ],
     },
     {
@@ -445,12 +457,12 @@ const INDEX_RESOURCE = {
         domain: "overview",
         priority: "critical",
         summary: "Explains how to approach each knowledge bundle and when to consult it.",
-        prompts: ["basic-program", "assembly-program", "sid-music", "graphics-demo", "printer-job", "memory-debug"],
+        prompts: ["basic-program", "assembly-program", "sid-music", "graphics-demo", "printer-job", "memory-debug", "cross-platform-demo", "preset-music-demo"],
         tools: [
             "upload_run_basic",
             "upload_run_asm",
             "music_generate",
-            "render_petscii_screen",
+            "render_petscii_text",
             "printer_guide",
             "read",
         ],

package/dist/rag/rateLimiter.js

@@ -25,7 +25,7 @@ export class SlidingWindowRateLimiter {
         if (!arr)
             return;
         let startIdx = 0;
-        while (startIdx < arr.length && arr[startIdx] < windowStart)
+        while (startIdx < arr.length && arr[startIdx] <= windowStart)
             startIdx++;
         if (startIdx > 0)
             arr.splice(0, startIdx);
@@ -74,7 +74,7 @@ export class AdaptiveRateLimiter {
             return;
         const cutoff = now - 1000;
         let i = 0;
-        while (i < arr.length && arr[i] < cutoff)
+        while (i < arr.length && arr[i] <= cutoff)
             i++;
         if (i > 0)
             arr.splice(0, i);

package/dist/streamCapture.js

@@ -0,0 +1,135 @@
+export const VIDEO_STREAM_HEADER_BYTES = 12;
+export const AUDIO_STREAM_HEADER_BYTES = 2;
+export const DEFAULT_VIDEO_STREAM_PORT = 11000;
+export const DEFAULT_AUDIO_STREAM_PORT = 11001;
+export const C64U_PAL_AUDIO_SAMPLE_RATE = 47982.8869047619;
+export const C64U_NTSC_AUDIO_SAMPLE_RATE = 47940.3408482143;
+export function parseVideoPacket(payload) {
+    if (payload.length < VIDEO_STREAM_HEADER_BYTES) {
+        throw new Error(`Video packet too small: ${payload.length}`);
+    }
+    const sequence = payload.readUInt16LE(0);
+    const frameNumber = payload.readUInt16LE(2);
+    const lineField = payload.readUInt16LE(4);
+    const lineNumber = lineField & 0x7fff;
+    const isLastPacket = (lineField & 0x8000) !== 0;
+    const pixelsPerLine = payload.readUInt16LE(6);
+    const linesPerPacket = payload.readUInt8(8);
+    const bitsPerPixel = payload.readUInt8(9);
+    const encodingType = payload.readUInt16LE(10);
+    return {
+        sequence,
+        frameNumber,
+        lineNumber,
+        isLastPacket,
+        pixelsPerLine,
+        linesPerPacket,
+        bitsPerPixel,
+        encodingType,
+        payload: payload.subarray(VIDEO_STREAM_HEADER_BYTES),
+    };
+}
+export function parseAudioPacket(payload) {
+    if (payload.length < AUDIO_STREAM_HEADER_BYTES) {
+        throw new Error(`Audio packet too small: ${payload.length}`);
+    }
+    const sequence = payload.readUInt16LE(0);
+    const audioBytes = payload.subarray(AUDIO_STREAM_HEADER_BYTES);
+    if (audioBytes.length % 2 !== 0) {
+        throw new Error(`Audio payload has odd byte count: ${audioBytes.length}`);
+    }
+    const samples = new Int16Array(audioBytes.length / 2);
+    for (let index = 0; index < samples.length; index += 1) {
+        samples[index] = audioBytes.readInt16LE(index * 2);
+    }
+    return { sequence, samples };
+}
+export function collectCompleteVideoFrames(packets, count) {
+    const completed = [];
+    for (const group of groupVideoPackets(packets)) {
+        if (!isVideoFrameGroupComplete(group)) {
+            continue;
+        }
+        completed.push(reconstructVideoFrame(group.packets));
+        if (completed.length >= count) {
+            break;
+        }
+    }
+    return completed;
+}
+export function reconstructVideoFrame(packets) {
+    if (packets.length === 0) {
+        throw new Error("No video packets available");
+    }
+    const reference = packets[0];
+    const width = reference.pixelsPerLine;
+    const linesPerPacket = Math.max(1, reference.linesPerPacket);
+    const bytesPerLine = Math.ceil((width * reference.bitsPerPixel) / 8);
+    const maxLine = Math.max(...packets.map((packet) => packet.lineNumber + packet.linesPerPacket));
+    const height = maxLine;
+    const pixels = new Uint8Array(width * height);
+    const filledLines = new Set();
+    for (const packet of packets) {
+        const expectedPayloadBytes = bytesPerLine * linesPerPacket;
+        const packetPayload = packet.payload.subarray(0, expectedPayloadBytes);
+        for (let lineOffset = 0; lineOffset < linesPerPacket; lineOffset += 1) {
+            const lineIndex = packet.lineNumber + lineOffset;
+            if (lineIndex >= height) {
+                continue;
+            }
+            const srcStart = lineOffset * bytesPerLine;
+            const srcLine = packetPayload.subarray(srcStart, srcStart + bytesPerLine);
+            unpack4BitPixelsToRow(srcLine, pixels, lineIndex * width, width);
+            filledLines.add(lineIndex);
+        }
+    }
+    return {
+        frameNumber: reference.frameNumber,
+        width,
+        height,
+        bitsPerPixel: 4,
+        pixels,
+        complete: height > 0 && filledLines.size === height,
+    };
+}
+function groupVideoPackets(packets) {
+    const byFrame = new Map();
+    for (const packet of packets) {
+        const framePackets = byFrame.get(packet.frameNumber) ?? [];
+        framePackets.push(packet);
+        byFrame.set(packet.frameNumber, framePackets);
+    }
+    return Array.from(byFrame.entries())
+        .sort((left, right) => left[0] - right[0])
+        .map(([frameNumber, framePackets]) => ({
+        frameNumber,
+        packets: framePackets.slice().sort((left, right) => left.lineNumber - right.lineNumber),
+    }));
+}
+function isVideoFrameGroupComplete(group) {
+    const lastPacket = group.packets.find((packet) => packet.isLastPacket);
+    if (!lastPacket) {
+        return false;
+    }
+    const expectedHeight = lastPacket.lineNumber + lastPacket.linesPerPacket;
+    if (expectedHeight <= 0) {
+        return false;
+    }
+    const coveredLines = new Set();
+    for (const packet of group.packets) {
+        for (let offset = 0; offset < packet.linesPerPacket; offset += 1) {
+            coveredLines.add(packet.lineNumber + offset);
+        }
+    }
+    return coveredLines.size >= expectedHeight;
+}
+function unpack4BitPixelsToRow(srcLine, dstPixels, dstOffset, width) {
+    let cursor = dstOffset;
+    for (let index = 0; index < srcLine.length && cursor < dstOffset + width; index += 1) {
+        const packed = srcLine[index];
+        dstPixels[cursor++] = packed & 0x0f;
+        if (cursor < dstOffset + width) {
+            dstPixels[cursor++] = (packed >> 4) & 0x0f;
+        }
+    }
+}

package/dist/tools/audio.js

@@ -403,6 +403,7 @@ export const audioModule = defineToolModule({
     ],
     prompts: ["sid-music"],
     defaultTags: ["sid", "audio"],
+    supportedPlatforms: ["c64u", "vice"],
     workflowHints: [
         "Reach for SID helpers when the user talks about sound design, playback quality, or stuck notes.",
         "After changing playback state, suggest verify-by-ear steps such as analyze_audio so the user gets concrete feedback.",
@@ -1006,7 +1007,8 @@ export const audioModule = defineToolModule({
                     }
                     const duration = parsed.durationSeconds ?? 3;
                     ctx.logger.info("Auto-analyzing SID audio", { durationSeconds: duration });
-                    const analysis = await recordAndAnalyzeAudio({
+                    const analyzer = resolveAnalyzer(ctx);
+                    const analysis = await analyzer({
                         durationSeconds: duration,
                         expectedSidwave: normaliseSidwaveInput(parsed.expectedSidwave),
                     });