c64bridge 0.5.1 → 0.6.0

package/data/video/petscii-style-guide.md

@@ -0,0 +1,105 @@
+# PETSCII Style Guide
+
+Colour presets and character codes for C64 PETSCII art. Target: LLM optimization.
+
+## C64 Colour Palette (0-15)
+
+| Index | Name | Luminance | Common Use |
+|-------|------|-----------|------------|
+| 0 | Black | Low | Background, shadows |
+| 1 | White | High | Text, highlights |
+| 2 | Red | Medium | Accents |
+| 3 | Cyan | High | Water, sky |
+| 4 | Purple | Medium | Decorative |
+| 5 | Green | Medium | Nature |
+| 6 | Blue | Low | Sky, UI |
+| 7 | Yellow | High | Highlights |
+| 8 | Orange | Medium | Warm tones |
+| 9 | Brown | Low | Earth |
+| 10 | Light Red | Medium | Soft accents |
+| 11 | Dark Grey | Low | Depth |
+| 12 | Grey | Medium | Neutral |
+| 13 | Light Green | High | Nature highlights |
+| 14 | Light Blue | Medium | UI |
+| 15 | Light Grey | Medium | Borders |
+
+## Recommended Colour Presets
+
+| Preset | Border | Background | Foreground | Use Case |
+|--------|--------|------------|------------|----------|
+| High Contrast | 0 | 0 | 1 | Text, menus, maximum readability |
+| Green Terminal | 0 | 0 | 5 | Retro terminal aesthetic |
+| Ocean | 6 | 6 | 3 | Water scenes |
+| Sunset | 2 | 8 | 7 | Warm scenes |
+| Nature | 5 | 0 | 13 | Outdoor, forest |
+| Professional UI | 6 | 0 | 14 | Applications, tools |
+
+## Contrast Guidelines
+
+**Readable combinations** (luminance difference ≥3):
+- 0/1 (Black/White), 0/7 (Black/Yellow), 0/13 (Black/Lt.Green)
+- 6/1 (Blue/White), 6/7 (Blue/Yellow), 11/1 (Dk.Grey/White)
+
+**Marginal** (luminance difference 2):
+- 0/3 (Black/Cyan), 6/14 (Blue/Lt.Blue), 12/1 (Grey/White)
+
+**Unreadable** (insufficient contrast):
+- 12/15 (Grey/Lt.Grey), 11/12 (Dk.Grey/Grey), 2/4 (Red/Purple)
+- 6/11 (Blue/Dk.Grey), 9/11 (Brown/Dk.Grey)
+
+Border matching: Set border=background for seamless look.
+
+## PETSCII vs Screen Codes
+
+**PETSCII codes** ($00-$FF): Used in BASIC strings, CHR$(), keyboard input, PRINT statements
+**Screen codes** ($00-$FF): Values directly written to screen memory ($0400-$07E7)
+
+Conversion: Screen code ≠ PETSCII code. Use charset reference (c64://specs/charset) for mapping.
+
+**Usage**:
+- BASIC/printing: Use PETSCII codes with CHR$() or PRINT
+- Direct screen memory: Use screen codes with POKE to $0400+offset
+- Tools: `create_petscii_image` returns both `petsciiCodes` array and screen memory data
+
+## Essential PETSCII Symbols
+
+| PETSCII | Char | Name | Use |
+|---------|------|------|-----|
+| 32 | (space) | Space | Empty cell |
+| 160 | █ | Full block | Solid fill (reverse space) |
+| 65-90 | A-Z | Uppercase | Text |
+| 193-218 | a-z | Lowercase | Text (shifted mode) |
+| 48-57 | 0-9 | Digits | Numbers |
+| 115 | ♥ | Heart | Decoration, life |
+| 122 | ♦ | Diamond | Suit, decoration |
+| 120 | ♣ | Club | Suit, decoration |
+| 97 | ♠ | Spade | Suit, decoration |
+| 94 | ↑ | Up arrow | Direction, pointer |
+| 95 | ← | Left arrow | Direction |
+| 96 | ─ | Horizontal line | Borders, dividers |
+| 125 | │ | Vertical line | Borders |
+| 117 | ╭ | Arc top-left | Rounded corners |
+| 105 | ╮ | Arc top-right | Rounded corners |
+| 106 | ╰ | Arc bottom-left | Rounded corners |
+| 107 | ╯ | Arc bottom-right | Rounded corners |
+| 123 | ┼ | Cross | Grid intersection |
+| 66-82 | Various | Block fractions | Dithering, gradients |
+
+## Tool Integration
+
+```javascript
+create_petscii_image({
+  prompt: "cat",
+  borderColor: 0,
+  backgroundColor: 6,
+  foregroundColor: 1
+})
+```
+
+Returns: `petsciiCodes[]`, `bitmapHex`, `rowHex`, `program`, dimensions
+
+## Related Resources
+
+- `c64://specs/charset` - Full PETSCII/screen code mappings
+- `c64://specs/vic` - VIC-II registers, colour RAM
+- `c64://specs/basic` - BASIC screen commands

package/data/video/sprite-charset-best-practices.md

@@ -0,0 +1,292 @@
+# Sprite and Charset Workflows Best Practices
+
+This guide provides proven workflows and best practices for creating, managing, and deploying sprites and custom character sets on the Commodore 64.
+
+## Sprite Workflow Overview
+
+Sprites are hardware-accelerated movable graphics objects. Each sprite is 24×21 pixels with support for multicolour or hires modes.
+
+### Basic Sprite Workflow
+
+1. **Design**: Create 24×21 pixel bitmap (monochrome or multicolour)
+2. **Encode**: Convert to 63-byte sprite data format
+3. **Upload**: Place sprite data in memory ($0340-$07FF recommended for safety)
+4. **Configure**: Set sprite pointer, position, colour, and enable flags
+5. **Verify**: Read screen or sprite registers to confirm appearance
+
+### Sprite Memory Layout
+
+Each sprite requires 63 bytes (24×21 pixels / 8 bits per byte):
+- 21 rows of 3 bytes each
+- Bit 1 = pixel on, Bit 0 = pixel off (hires mode)
+- In multicolour mode, 2 bits per pixel define 4 colours
+
+### Sprite Pointer Configuration
+
+Sprites are enabled via VIC-II registers:
+- `$D015` - Sprite enable (bits 0-7 for sprites 0-7)
+- `$D010` - Sprite X MSB for horizontal positioning beyond 255
+- `$D000-$D00F` - X/Y coordinates for sprites 0-7
+- `$07F8-$07FF` - Sprite data pointers (screen memory + $03F8)
+
+### Safe Sprite Data Locations
+
+Use these memory ranges to avoid conflicts:
+- `$0340-$03FF` - Cassette buffer (192 bytes, safe when not using tape)
+- `$C000-$CFFF` - RAM under BASIC ROM (4KB, requires bank switching)
+- `$2000-$3FFF` - Screen/bitmap alternatives (8KB when not displaying there)
+
+### Sprite Colour Selection
+
+- Individual sprite colour: `$D027-$D02E` (one per sprite)
+- Multicolour shared colours: `$D025` (shared 1), `$D026` (shared 2)
+- Background colour: `$D021`
+
+Choose high-contrast colours for visibility:
+- White (1) on black (0) background
+- Yellow (7) or cyan (3) for highlights
+- Avoid grey on grey or similar-hue combinations
+
+## Character Set (Charset) Workflow Overview
+
+Custom charsets allow you to redefine the 256 character glyphs displayed on screen.
+
+### Basic Charset Workflow
+
+1. **Design**: Create 8×8 pixel bitmaps for each character
+2. **Encode**: Convert to 8-byte character definitions
+3. **Upload**: Place charset in 2KB memory block ($2000, $2800, $3000, or $3800)
+4. **Configure**: Point VIC-II to custom charset via `$D018`
+5. **Test**: POKE characters to screen and verify appearance
+
+### Character Definition Format
+
+Each character uses 8 bytes (8 rows × 8 pixels):
+```
+Byte 0: Row 0 bitmap (MSB = leftmost pixel)
+Byte 1: Row 1 bitmap
+...
+Byte 7: Row 7 bitmap
+```
+
+Example: 'A' character
+```
+00111100  ($3C) - Row 0
+01100110  ($66) - Row 1
+01100110  ($66) - Row 2
+01111110  ($7E) - Row 3
+01100110  ($66) - Row 4
+01100110  ($66) - Row 5
+01100110  ($66) - Row 6
+00000000  ($00) - Row 7
+```
+
+### Charset Memory Alignment
+
+Custom charsets must be aligned to 2KB boundaries:
+- `$2000` (8192) - VIC bank 0, offset $0000
+- `$2800` (10240) - VIC bank 0, offset $0800
+- `$3000` (12288) - VIC bank 0, offset $1000
+- `$3800` (14336) - VIC bank 0, offset $1800
+
+### Switching Charsets
+
+Configure VIC-II register `$D018`:
+- Bits 1-3 control charset pointer
+- Formula: (charset_address / 2048) << 1
+- Example: For charset at $2000, POKE 53272, (53272 AND 240) OR ((8192/2048) << 1)
+
+### Partial Charset Updates
+
+You don't need to redefine all 256 characters:
+- Only redefine characters you actually use
+- Leave standard characters (A-Z, 0-9) unchanged for debugging
+- Focus on block graphics (160-255) for custom effects
+
+## Advanced Techniques
+
+### Sprite Multiplexing
+
+**Technical implementation**: Once VIC-II completes drawing a sprite (after scanline Y+21), the same physical sprite can be repositioned and redrawn. This maps one physical sprite definition to multiple logical sprite instances across different scanlines.
+
+**Mechanism**:
+- VIC-II fetches sprite data during raster lines Y to Y+20 (21 lines)
+- After line Y+20 completes, sprite registers ($D000-$D00F, $D015, $D027-$D02E) can be modified
+- Same sprite pointer ($07F8-$07FF) reused by updating position/colour for next instance
+- Raster IRQ at Y+21 triggers repositioning code
+- Typical: 20-24 multiplexed sprites achievable with careful timing
+
+**Requirements**:
+- Precise raster interrupt timing (see c64://specs/vic)
+- Fast register updates (< 63 cycles between sprite positions)
+- Pre-calculated Y-coordinate tables for performance
+
+### Multicolour vs Hires Sprites
+
+**Hires (default)**:
+- 24×21 pixels, one colour per sprite
+- Better detail and sharpness
+- Ideal for detailed characters or objects
+
+**Multicolour**:
+- 12×21 effective resolution (2 bits per pixel)
+- 4 colours: background, sprite colour, shared 1, shared 2
+- Better for colourful, less detailed objects
+- Enable via bit in `$D01C`
+
+### Character Animation
+
+Animate by rapidly switching between character definitions:
+- Pre-load multiple frames into charset memory
+- Switch displayed character code or charset pointer
+- Use raster interrupts for smooth timing
+
+### Mixed Charset/Bitmap Modes
+
+Combine text and graphics:
+- Use charset for UI elements and text
+- Use sprites for player characters and bullets
+- Use bitmap mode for detailed backgrounds
+
+## Performance Considerations
+
+### Sprite Priorities
+
+- Sprites 0-7 have priority order (0 = front, 7 = back)
+- Sprite-to-background priority controlled by `$D01B`
+- Sprite-to-sprite collisions detected via `$D01E`
+- Sprite-to-background collisions via `$D01F`
+
+### Memory Bandwidth and VIC-II Cycles
+
+**VIC-II "bad lines"** (every 8th raster, lines $30-$F7):
+- VIC-II fetches 40 bytes of screen data + 40 bytes of character data
+- CPU halted for ~40-43 cycles (exact depends on sprite activity)
+- Bad lines occur when lower 3 bits of $D011 match lower 3 bits of raster counter
+
+**Sprite DMA cycles**:
+- Each active sprite costs 2 cycles per raster line for data fetch
+- Sprite X-coordinate at DMA fetch point determines if CPU is blocked
+- 8 sprites active: CPU loses 16 cycles per line
+- Sprite display starts at cycle 11-12 of raster line
+
+**Border timing and precision**:
+- Upper border: Open at raster $30 by writing $D011 bit 3=0 at cycle 56
+- Lower border: Open at raster $F7 by writing $D011 bit 3=1 at cycle 56  
+- Side borders: $D016 bit 3 controls, must write at precise X-coordinate
+- **NOP instruction** ($EA): Used for cycle-exact timing delays in border opening routines
+- Typical pattern: `NOP; NOP; STA $D011` to hit exact cycle 56
+
+**CPU availability**:
+- Normal line: ~63 cycles available
+- Bad line + 8 sprites: ~20 cycles available
+- Critical code: Use raster lines outside $30-$F7 range or disable screen ($D011 bit 4=0)
+
+### Charset Performance
+
+Custom charsets have minimal performance impact:
+- One-time memory copy during setup
+- No runtime overhead compared to ROM charset
+- Screen updates (POKE to screen memory) are the bottleneck
+
+## Common Pitfalls and Solutions
+
+### Sprite Not Appearing
+1. Check sprite enable bit in `$D015`
+2. Verify sprite pointer at `$07F8-$07FF`
+3. Confirm sprite data is in correct memory location
+4. Check X/Y coordinates are on screen (0-320, 0-200)
+5. Verify sprite colour is different from background
+
+### Charset Not Displaying
+1. Confirm charset is at 2KB boundary
+2. Check VIC-II bank selection (default is bank 0)
+3. Verify `$D018` charset pointer bits
+4. Ensure characters are POKEd to screen memory
+5. Check that BASIC/KERNAL ROMs aren't blocking access
+
+### Sprite Flicker
+1. Reduce number of active sprites
+2. Use sprite multiplexing carefully
+3. Synchronize updates with raster beam
+4. Consider double-buffering techniques
+
+### Colour Clashing
+1. Use PETSCII style guide for colour selection
+2. Test on both PAL and NTSC if possible
+3. Maintain sufficient contrast (see c64://docs/petscii-style)
+4. Avoid adjacent similar-hue colours
+
+## Tool Integration
+
+### Using generate_sprite_prg
+
+```javascript
+{
+  spriteData: "base64-encoded-63-bytes",
+  x: 160,           // Center horizontally
+  y: 100,           // Center vertically  
+  colour: 1,        // White
+  multicolour: false
+}
+```
+
+The tool:
+- Validates 63-byte sprite format
+- Generates BASIC program to display sprite
+- Handles sprite pointer and VIC-II register setup
+- Returns structured metadata for follow-up operations
+
+### Memory Safety
+
+When working with sprites and charsets:
+1. Use memory ranges documented in c64://specs/memory-map
+2. Avoid BASIC program area ($0801-$9FFF) unless controlling it
+3. Preserve zero page ($0000-$00FF) and stack ($0100-$01FF)
+4. Use `read_memory` and `write_memory` tools for safe access
+
+## Example Workflows
+
+### Simple Sprite Display
+
+1. Prepare 24×21 sprite bitmap
+2. Call `generate_sprite_prg` with sprite data
+3. Tool returns PRG that sets up sprite automatically
+4. Use `read_screen` to verify appearance
+5. Optionally `write_memory` to adjust position/colour
+
+### Custom Charset Installation
+
+1. Design character set (full or partial)
+2. Encode to 8-byte-per-char format
+3. Use `write_memory` to copy charset to $2000
+4. POKE $D018 to point VIC-II at new charset
+5. Use `upload_and_run_basic` to test character display
+6. Verify with `read_screen`
+
+### Animated Sprite Sequence
+
+1. Create multiple sprite frames (3-8 frames typical)
+2. Upload all frames to consecutive memory locations
+3. Generate BASIC program that cycles sprite pointer
+4. Use raster timing for smooth animation
+5. Verify frame timing with `read_memory` checks
+
+## Best Practices Summary
+
+1. **Plan Memory Layout**: Map out sprite and charset locations before coding
+2. **Test Incrementally**: Display one sprite/char before adding more
+3. **Use Tools**: Leverage `generate_sprite_prg` and memory tools
+4. **Document State**: Note which sprites/chars are active
+5. **Handle Errors**: Check return values and screen output
+6. **Optimize Last**: Get it working, then optimize if needed
+7. **Verify Hardware**: Test on real C64 or accurate emulator
+8. **Read Resources**: Consult c64://specs/vic for register details
+
+## Related Resources
+
+- `c64://specs/vic` - Complete VIC-II register reference
+- `c64://specs/charset` - Character code mappings
+- `c64://docs/petscii-style` - Colour and style guidelines
+- `c64://specs/memory-map` - Memory layout and safe ranges
+- `c64://context/bootstrap` - Safety and workflow rules

package/dist/c64Client.js

@@ -666,6 +666,7 @@ export class C64Client {
     /**
      * Low-level memory read that transparently handles devices returning either
      * raw binary bytes or JSON with a base64 payload.
+     * Public to allow advanced polling and monitoring use cases.
      */
     async readMemoryRaw(address, length) {
         try {

package/dist/prompts/registry.js

@@ -303,7 +303,7 @@ export function createPromptRegistry() {
                     "c64://specs/sid",
                     "c64://context/bootstrap",
                 ],
-                optionalResources: [],
+                optionalResources: ["c64://docs/sid/best-practices"],
                 tools: ["upload_and_run_asm", "write_memory", "read_memory", "read_screen"],
                 tags: ["assembly", "program"],
             },
@@ -315,6 +315,13 @@ export function createPromptRegistry() {
                 },
             ],
             prepareArgs: prepareAssemblyArgs,
+            selectOptionalResources: (args) => {
+                const hardware = args.hardware;
+                if (hardware === "sid" || hardware === "multi") {
+                    return ["c64://docs/sid/best-practices"];
+                }
+                return [];
+            },
             buildMessages: (args) => {
                 const hardware = args.hardware;
                 return [
@@ -335,6 +342,7 @@ export function createPromptRegistry() {
                     "c64://specs/sid",
                     "c64://specs/sidwave",
                     "c64://docs/sid/file-structure",
+                    "c64://docs/sid/best-practices",
                 ],
                 optionalResources: [],
                 tools: ["music_generate", "analyze_audio", "sid_note_on", "sid_volume", "sidplay_file"],
@@ -356,7 +364,7 @@ export function createPromptRegistry() {
                     "c64://specs/vic",
                     "c64://context/bootstrap",
                 ],
-                optionalResources: ["c64://specs/assembly"],
+                optionalResources: ["c64://specs/assembly", "c64://specs/charset", "c64://docs/petscii-style"],
                 tools: ["upload_and_run_basic", "upload_and_run_asm", "render_petscii_screen"],
                 tags: ["graphics", "vic"],
             },

package/dist/rag/knowledgeIndex.js

@@ -1,5 +1,37 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+function generateCharsetQuickref() {
+    const csvPath = join(process.cwd(), "data/video/character-set.csv");
+    const csvContent = readFileSync(csvPath, "utf-8");
+    const lines = csvContent.trim().split("\n");
+    const headers = lines[0].split(",");
+    let markdown = "# PETSCII Character Set Reference\n\n";
+    markdown += "Complete reference of C64 character codes, screen codes, and glyphs.\n\n";
+    markdown += "## Character Code Table\n\n";
+    markdown += "| Screen Code | PETSCII | Char | Name | Keyboard |\n";
+    markdown += "|-------------|---------|------|------|----------|\n";
+    for (let i = 1; i < lines.length; i++) {
+        const parts = lines[i].split(",");
+        if (parts.length < 8)
+            continue;
+        const screenCode = parts[0];
+        const petsciiCode = parts[2];
+        const char = parts[4] || " ";
+        const name = parts[6] || "";
+        const keyboard = parts[7] || "";
+        markdown += `| ${screenCode} | ${petsciiCode} | ${char} | ${name} | ${keyboard} |\n`;
+    }
+    markdown += "\n## Usage Notes\n\n";
+    markdown += "- **Screen Code**: Value used in screen memory ($0400-$07E7)\n";
+    markdown += "- **PETSCII Code**: Value used in BASIC strings and CHR$() function\n";
+    markdown += "- **Keyboard**: Key combination to type the character\n";
+    markdown += "\n## Common Patterns\n\n";
+    markdown += "- Uppercase letters: PETSCII $41-$5A (A-Z)\n";
+    markdown += "- Lowercase letters: PETSCII $61-$7A (a-z) in graphics mode\n";
+    markdown += "- Digits: PETSCII $30-$39 (0-9)\n";
+    markdown += "- Graphics characters: Screen codes $60-$7F and $E0-$FF\n";
+    return markdown;
+}
 const KNOWLEDGE_BUNDLES = [
     {
         id: "orientation",
@@ -37,9 +69,21 @@ const KNOWLEDGE_BUNDLES = [
                 summary: "Token definitions, syntax rules, and device I/O guidance for BASIC v2.",
                 prompts: ["basic-program"],
                 tools: ["upload_and_run_basic", "read_screen"],
-                relatedResources: ["c64://context/bootstrap"],
+                relatedResources: ["c64://context/bootstrap", "c64://docs/basic/pitfalls"],
                 tags: ["basic", "language"],
             },
+            {
+                uri: "c64://docs/basic/pitfalls",
+                name: "BASIC Pitfalls & Gotchas",
+                description: "Common mistakes and gotchas when writing Commodore BASIC v2 programs",
+                relativePath: "data/basic/basic-pitfalls.md",
+                priority: "reference",
+                summary: "Quickref covering quotation handling, line length, tokenization, variable names, and other BASIC traps.",
+                prompts: ["basic-program"],
+                tools: ["upload_and_run_basic"],
+                relatedResources: ["c64://specs/basic"],
+                tags: ["basic", "pitfalls", "quickref"],
+            },
             {
                 uri: "c64://specs/assembly",
                 name: "6502/6510 Assembly Reference",
@@ -127,9 +171,45 @@ const KNOWLEDGE_BUNDLES = [
                 summary: "Covers raster timing, sprite control, colour RAM, and bitmap modes on the VIC-II.",
                 prompts: ["graphics-demo"],
                 tools: ["render_petscii_screen", "generate_sprite_prg", "write_memory"],
-                relatedResources: ["c64://specs/assembly"],
+                relatedResources: ["c64://specs/assembly", "c64://specs/charset", "c64://docs/petscii-style"],
                 tags: ["vic", "graphics"],
             },
+            {
+                uri: "c64://specs/charset",
+                name: "PETSCII Character Set Reference",
+                description: "Complete PETSCII character codes, screen codes, and glyph mappings",
+                relativePath: "data/video/character-set.csv",
+                priority: "reference",
+                summary: "Character code table mapping PETSCII codes to screen codes, glyphs, and keyboard input.",
+                prompts: ["graphics-demo"],
+                tools: ["render_petscii_screen", "create_petscii_image"],
+                relatedResources: ["c64://specs/vic", "c64://docs/petscii-style"],
+                tags: ["petscii", "charset", "graphics"],
+            },
+            {
+                uri: "c64://docs/petscii-style",
+                name: "PETSCII Style Guide and Presets",
+                description: "Colour combinations, contrast guidelines, and recommended presets for PETSCII art",
+                relativePath: "data/video/petscii-style-guide.md",
+                priority: "reference",
+                summary: "Documents colour palette, readability presets, dithering patterns, and best practices for creating artistic and readable PETSCII displays.",
+                prompts: ["graphics-demo"],
+                tools: ["create_petscii_image", "render_petscii_screen"],
+                relatedResources: ["c64://specs/vic", "c64://specs/charset", "c64://docs/sprite-charset-workflows"],
+                tags: ["petscii", "style", "colours", "graphics"],
+            },
+            {
+                uri: "c64://docs/sprite-charset-workflows",
+                name: "Sprite & Charset Workflows Best Practices",
+                description: "Comprehensive guide to creating, managing, and deploying sprites and custom character sets",
+                relativePath: "data/video/sprite-charset-best-practices.md",
+                priority: "reference",
+                summary: "Documents sprite and charset workflows, memory layout, VIC-II configuration, common pitfalls, and proven techniques for hardware-accelerated graphics.",
+                prompts: ["graphics-demo"],
+                tools: ["generate_sprite_prg", "write_memory", "read_memory", "upload_and_run_basic"],
+                relatedResources: ["c64://specs/vic", "c64://specs/charset", "c64://docs/petscii-style", "c64://specs/memory-map"],
+                tags: ["sprites", "charset", "graphics", "workflows"],
+            },
         ],
     },
     {
@@ -326,29 +406,36 @@ const KNOWLEDGE_BUNDLES = [
         ],
     },
 ];
-const BASE_RESOURCES = KNOWLEDGE_BUNDLES.flatMap((bundle, bundleIndex) => bundle.resources.map((resource, resourceIndex) => ({
-    uri: resource.uri,
-    name: resource.name,
-    description: resource.description,
-    mimeType: "text/markdown",
-    relativePath: resource.relativePath,
-    metadata: {
-        domain: bundle.id,
-        priority: resource.priority,
-        summary: resource.summary,
-        prompts: resource.prompts,
-        tools: resource.tools,
-        tags: resource.tags ?? [],
-        bundle: {
-            id: bundle.id,
-            title: bundle.title,
-            summary: bundle.summary,
-            order: bundleIndex,
+const BASE_RESOURCES = KNOWLEDGE_BUNDLES.flatMap((bundle, bundleIndex) => bundle.resources.map((resource, resourceIndex) => {
+    const baseResource = {
+        uri: resource.uri,
+        name: resource.name,
+        description: resource.description,
+        mimeType: "text/markdown",
+        relativePath: resource.relativePath,
+        metadata: {
+            domain: bundle.id,
+            priority: resource.priority,
+            summary: resource.summary,
+            prompts: resource.prompts,
+            tools: resource.tools,
+            tags: resource.tags ?? [],
+            bundle: {
+                id: bundle.id,
+                title: bundle.title,
+                summary: bundle.summary,
+                order: bundleIndex,
+            },
+            order: resourceIndex,
+            relatedResources: resource.relatedResources ?? [],
         },
-        order: resourceIndex,
-        relatedResources: resource.relatedResources ?? [],
-    },
-})));
+    };
+    // Add buildContent for resources that need dynamic generation
+    if (resource.uri === "c64://specs/charset") {
+        return { ...baseResource, buildContent: generateCharsetQuickref };
+    }
+    return baseResource;
+}));
 const INDEX_RESOURCE = {
     uri: "c64://docs/index",
     name: "C64 Knowledge Map",