@blueprint-chart/mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pirhoo and Blueprint Chart contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,240 @@
+<p align="center">
+  <a href="https://blueprintchart.com" align="center">
+    <img src="https://raw.githubusercontent.com/blueprint-chart/blueprint-chart/main/packages/editor/src/assets/images/blueprint-chart-logo.svg" width="120" alt="blueprint-chart">
+  </a>
+</p>
+<p align="center"><strong>Model Context Protocol server for authoring Blueprint Chart <code>.bpc</code> files with LLMs — grounded in real dataviz pedagogy with a tight parse + render feedback loop.</strong></p>
+
+<div align="center">
+
+|      | Status |
+| ---: | :--- |
+| **CI checks** | [![Github Actions](https://img.shields.io/github/actions/workflow/status/blueprint-chart/mcp/ci.yml?style=flat-square)](https://github.com/blueprint-chart/mcp/actions/workflows/ci.yml) |
+| **Latest version** | [![Latest version](https://img.shields.io/npm/v/@blueprint-chart/mcp?style=flat-square&color=success)](https://www.npmjs.com/package/@blueprint-chart/mcp) |
+|   **Release date** | [![Release date](https://img.shields.io/github/release-date/blueprint-chart/mcp?style=flat-square&color=success)](https://github.com/blueprint-chart/mcp/releases/latest) |
+|    **Open issues** | [![Open issues](https://img.shields.io/github/issues/blueprint-chart/mcp?style=flat-square&color=success)](https://github.com/blueprint-chart/mcp/issues/) |
+|  **Websites** | [![Editor](https://img.shields.io/badge/Editor-2563A0?style=flat-square)](https://blueprintchart.com) [![Docs](https://img.shields.io/badge/Docs-2563A0?style=flat-square)](https://docs.blueprintchart.com) |
+
+</div>
+
+The MCP exposes Blueprint Chart's dataviz handbook, DSL grammar reference, chart-type docs, and canonical samples as MCP resources, plus four deterministic tools: `validate_dsl`, `inspect_dsl`, `recommend_chart_type`, and `render`. Your LLM writes the `.bpc`; the MCP grounds it in real dataviz pedagogy and gives it a tight feedback loop.
+
+## Install
+
+```bash
+npx @blueprint-chart/mcp           # stdio (for Claude Desktop, Claude Code, Cursor)
+npx @blueprint-chart/mcp --http    # HTTP/SSE on 127.0.0.1:4321
+```
+
+## Use with Claude Desktop
+
+Add to `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "blueprint-chart": {
+      "command": "npx",
+      "args": ["-y", "@blueprint-chart/mcp"]
+    }
+  }
+}
+```
+
+## Use with Claude Code
+
+```bash
+claude mcp add blueprint-chart -- npx -y @blueprint-chart/mcp
+```
+
+## Tools
+
+| Tool | Purpose |
+| --- | --- |
+| `validate_dsl` | Parse `.bpc`; precise errors with line/column |
+| `inspect_dsl` | Parse and summarize: chart type, scenes, series, annotations |
+| `recommend_chart_type` | Rank chart types for a given column shape |
+| `render` | Render to SVG (default) or PNG |
+
+## Resources
+
+- `bpc://grammar` — full DSL syntax reference
+- `bpc://handbook/<slug>` — dataviz pedagogy (choosing, design-principles, color, typography, annotations, accessibility, ...)
+- `bpc://guide/<slug>` — usage guides (scenes, palettes, data-transforms, ...)
+- `bpc://chart-types/<slug>` — per-chart-type docs
+- `bpc://samples/<id>` — canonical `.bpc` examples
+- `bpc://reference/dsl/<slug>`, `bpc://reference/api/<slug>` — full reference
+
+## Prompts
+
+- `author_chart` — primes the LLM end-to-end (read → write → validate → render → iterate)
+
+## Examples
+
+### Quickstart with Claude
+
+Once the MCP is connected, ask Claude to make a chart:
+
+> **You:** Make a horizontal bar chart of English letter frequencies — top 10, highlight E.
+>
+> **Claude:** *(reads `bpc://grammar`, `bpc://handbook/choosing`, `bpc://samples/letter-frequency`, writes the `.bpc`, calls `validate_dsl` to confirm it parses, calls `render` with `format: 'png'` and shows you the image and the source)*
+>
+> Here's the chart:
+>
+> ![image]
+>
+> ```
+> chart bar-horizontal {
+>   title = "E is the most frequent letter in English"
+>   sort = descending
+>   valueLabels = true
+>   highlight "E"
+>   data { "E" = 12.70; "T" = 9.06; "A" = 8.17; ... }
+> }
+> ```
+
+The MCP grounds Claude in real dataviz pedagogy (the handbook) before it writes a single line of DSL, then closes the loop with deterministic parse + render feedback.
+
+### What `.bpc` looks like
+
+```text
+chart bar-vertical {
+  title = "E is the most frequent letter in English"
+  description = "How often each letter appears in typical English text"
+  source = "Lewand, Cryptological Mathematics"
+  colorPalette = "London"
+  sort = descending
+  valueLabels = true
+  highlight "E"
+
+  data {
+    "E" = 12.70
+    "T" = 9.06
+    "A" = 8.17
+    "O" = 7.51
+    ...
+  }
+}
+```
+
+Full grammar at `bpc://grammar`; 17 canonical samples at `bpc://samples/<id>` (`letter-frequency`, `co2-emissions`, `quarterly-revenue`, `browser-market`, `temperature-anomaly`, `population-stacked-bar`, ...).
+
+### `validate_dsl` — parse with precise errors
+
+Request:
+
+```json
+{
+  "name": "validate_dsl",
+  "arguments": { "source": "chart bar-vertical {\n  title = \"oops\n}" }
+}
+```
+
+Response (note the line + column):
+
+```json
+{
+  "ok": false,
+  "code": "E_PARSE",
+  "errors": [
+    { "line": 2, "column": 19, "message": "Expected \"\\\"\" but end of input found." }
+  ]
+}
+```
+
+### `inspect_dsl` — structured summary
+
+Request:
+
+```json
+{ "name": "inspect_dsl", "arguments": { "source": "<.bpc source>" } }
+```
+
+Response:
+
+```json
+{
+  "ok": true,
+  "data": {
+    "chartType": "bar-vertical",
+    "scenes": [{ "index": 0, "hasTransition": false }],
+    "hasAnnotations": false,
+    "hasColorizes": false,
+    "hasHighlights": true,
+    "hasAreaFills": false,
+    "seriesCount": 0,
+    "rowCount": 26
+  }
+}
+```
+
+### `recommend_chart_type` — ranked suggestions
+
+Request:
+
+```json
+{
+  "name": "recommend_chart_type",
+  "arguments": { "columnTypes": ["date", "number", "number", "number"], "rowCount": 24 }
+}
+```
+
+Response:
+
+```json
+{
+  "ok": true,
+  "data": {
+    "recommendations": [
+      { "chartType": "line-multi", "label": "Multi-Line Chart", "fitness": "best",
+        "reason": "1 date + 3 numeric columns — compare trends" },
+      { "chartType": "bar-multi",  "label": "Grouped Bar Chart", "fitness": "alternative",
+        "reason": "Can also show as grouped bars" }
+    ]
+  }
+}
+```
+
+### `render` — SVG (default) or PNG
+
+Request:
+
+```json
+{
+  "name": "render",
+  "arguments": { "source": "<.bpc source>", "format": "png", "width": 800, "height": 500 }
+}
+```
+
+Response:
+
+```json
+{
+  "ok": true,
+  "data": {
+    "svg": "<svg ...>...</svg>",
+    "png": "<base64-encoded image>",
+    "mimeType": "image/png"
+  }
+}
+```
+
+If rasterization fails (rare), the response is `{ ok: false, code: "E_RENDER", … }` **and still includes** the SVG that was successfully produced — partial success is preserved.
+
+### Reading a resource
+
+```json
+{ "uri": "bpc://handbook/choosing" }
+```
+
+Returns the full Markdown of the "Choosing the Right Chart" handbook page (same content as `docs.blueprintchart.com`).
+
+```json
+{ "uri": "bpc://samples/letter-frequency" }
+```
+
+Returns the raw `.bpc` source for the letter-frequency sample as `text/plain` — exactly what the LLM should imitate.
+
+## License
+
+MIT

package/bin/blueprint-chart-mcp.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+// bin/blueprint-chart-mcp.js
+//
+// Entry point for the @blueprint-chart/mcp CLI. Registers a resolver hook
+// that fills in `.js` extensions for the extensionless relative imports
+// emitted by `tsc` (the project sources target `moduleResolution: "Bundler"`),
+// then loads the compiled `dist/cli.js`.
+import { register } from 'node:module'
+
+register(new URL('./loader.mjs', import.meta.url))
+
+import('../dist/cli.js').catch((err) => {
+  console.error(err)
+  process.exit(1)
+})

package/bin/loader.mjs

@@ -0,0 +1,36 @@
+// bin/loader.mjs
+//
+// Node ESM resolver hook that maps extensionless relative imports emitted by
+// `tsc` (because the project source targets `moduleResolution: "Bundler"`) to
+// concrete `.js` / `index.js` files in `dist/`.
+//
+// Without this hook, `node dist/cli.js` would fail with ERR_MODULE_NOT_FOUND
+// on every relative import. Registered by `bin/blueprint-chart-mcp.js`.
+import { existsSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+const CANDIDATES = ['.js', '.mjs', '/index.js', '/index.mjs']
+
+function fileExists(url) {
+  try {
+    return existsSync(fileURLToPath(url))
+  }
+  catch {
+    return false
+  }
+}
+
+export function resolve(specifier, context, nextResolve) {
+  if ((specifier.startsWith('./') || specifier.startsWith('../')) && !/\.[a-zA-Z0-9]+$/.test(specifier)) {
+    const baseUrl = context.parentURL ? new URL(context.parentURL) : null
+    if (baseUrl) {
+      for (const ext of CANDIDATES) {
+        const candidate = new URL(specifier + ext, baseUrl)
+        if (fileExists(candidate)) {
+          return nextResolve(specifier + ext, context)
+        }
+      }
+    }
+  }
+  return nextResolve(specifier, context)
+}

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,123 @@
+import { startStdio } from './transports/stdio.js';
+import { startHttp } from './transports/http.js';
+function parseBool(value) {
+    if (!value) {
+        return false;
+    }
+    return value === '1' || value.toLowerCase() === 'true';
+}
+function parseList(value) {
+    if (!value) {
+        return undefined;
+    }
+    return value.split(',').map(s => s.trim()).filter(Boolean);
+}
+function parseConfig(argv) {
+    const env = process.env;
+    const port = Number(env.PORT) || 4321;
+    const host = env.MCP_HOST || '127.0.0.1';
+    const allowedOriginsList = parseList(env.MCP_ALLOWED_ORIGINS);
+    const allowedOrigins = allowedOriginsList
+        && allowedOriginsList.length === 1 && allowedOriginsList[0] === '*'
+        ? '*'
+        : allowedOriginsList;
+    const config = {
+        http: parseBool(env.MCP_HTTP),
+        port,
+        host,
+        httpOpts: {
+            port,
+            host,
+            authToken: env.MCP_AUTH_TOKEN || undefined,
+            allowedOrigins,
+            trustProxy: parseBool(env.MCP_TRUST_PROXY),
+            maxConcurrentRequests: env.MCP_MAX_CONCURRENT_REQUESTS
+                ? Number(env.MCP_MAX_CONCURRENT_REQUESTS)
+                : undefined,
+            rateLimitPerMinute: env.MCP_RATE_LIMIT_PER_MINUTE
+                ? Number(env.MCP_RATE_LIMIT_PER_MINUTE)
+                : undefined,
+            silent: parseBool(env.MCP_SILENT),
+        },
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--http') {
+            config.http = true;
+        }
+        else if (a === '--stdio') {
+            config.http = false;
+        }
+        else if (a === '--port' && argv[i + 1]) {
+            const p = Number(argv[++i]);
+            config.port = p;
+            config.httpOpts.port = p;
+        }
+        else if (a === '--host' && argv[i + 1]) {
+            const next = argv[++i];
+            if (next) {
+                config.host = next;
+                config.httpOpts.host = next;
+            }
+        }
+        else if (a === '--help' || a === '-h') {
+            process.stderr.write(`Usage: blueprint-chart-mcp [--http|--stdio] [--port N] [--host HOST]
+
+Stdio mode (default): for Claude Desktop, Claude Code, Cursor, etc.
+HTTP mode (--http): for hosted use (e.g. Railway, behind a reverse proxy).
+
+Environment variables (HTTP mode):
+  PORT                          HTTP port (default 4321). Railway sets this.
+  MCP_HTTP=1                    Default to HTTP mode (same as --http).
+  MCP_HOST                      Bind host (default 127.0.0.1; use 0.0.0.0 in containers).
+  MCP_AUTH_TOKEN                If set, require Authorization: Bearer <token>.
+  MCP_ALLOWED_ORIGINS           Comma-separated CORS allowlist, or "*" (default).
+  MCP_TRUST_PROXY=1             Read X-Forwarded-For (enable behind a proxy / Railway).
+  MCP_MAX_CONCURRENT_REQUESTS   Cap on concurrent POSTs (default 16).
+  MCP_RATE_LIMIT_PER_MINUTE     Per-IP rate limit (default off; e.g. 60).
+  MCP_SILENT=1                  Suppress JSON access logs to stderr.
+`);
+            process.exit(0);
+        }
+    }
+    return config;
+}
+function installSignalHandlers(close) {
+    let shuttingDown = false;
+    const handler = (signal) => {
+        if (shuttingDown) {
+            return;
+        }
+        shuttingDown = true;
+        close()
+            .catch((err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`Error during shutdown (${signal}): ${message}\n`);
+        })
+            .finally(() => {
+            process.exit(0);
+        });
+    };
+    process.on('SIGINT', handler);
+    process.on('SIGTERM', handler);
+}
+const config = parseConfig(process.argv.slice(2));
+if (config.http) {
+    startHttp(config.httpOpts)
+        .then((handle) => {
+        process.stderr.write(`MCP HTTP server listening at ${handle.url}/mcp\n`);
+        installSignalHandlers(handle.close);
+    })
+        .catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`Failed to start HTTP: ${message}\n`);
+        process.exit(1);
+    });
+}
+else {
+    startStdio().catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`Failed to start stdio: ${message}\n`);
+        process.exit(1);
+    });
+}

package/dist/errors.d.ts

@@ -0,0 +1,28 @@
+export declare const ErrorCode: {
+    readonly E_INPUT: "E_INPUT";
+    readonly E_PARSE: "E_PARSE";
+    readonly E_SEMANTIC: "E_SEMANTIC";
+    readonly E_RENDER: "E_RENDER";
+    readonly E_INTERNAL: "E_INTERNAL";
+};
+export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
+export interface ToolErrorEntry {
+    path?: string;
+    line?: number;
+    column?: number;
+    message: string;
+    snippet?: string;
+}
+export type ToolResult<T> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    code: ErrorCode;
+    errors: ToolErrorEntry[];
+};
+export declare function toolOk<T>(data: T): ToolResult<T>;
+export declare function toolError<T = never>(code: ErrorCode, errors: ToolErrorEntry[]): ToolResult<T>;
+export declare function isToolError<T>(r: ToolResult<T>): r is Extract<ToolResult<T>, {
+    ok: false;
+}>;

package/dist/errors.js

@@ -0,0 +1,16 @@
+export const ErrorCode = {
+    E_INPUT: 'E_INPUT',
+    E_PARSE: 'E_PARSE',
+    E_SEMANTIC: 'E_SEMANTIC',
+    E_RENDER: 'E_RENDER',
+    E_INTERNAL: 'E_INTERNAL',
+};
+export function toolOk(data) {
+    return { ok: true, data };
+}
+export function toolError(code, errors) {
+    return { ok: false, code, errors };
+}
+export function isToolError(r) {
+    return r.ok === false;
+}

package/dist/errors.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/errors.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import { ErrorCode, toolError, toolOk, isToolError } from './errors';
+describe('errors', () => {
+    it('toolOk wraps data', () => {
+        const r = toolOk({ x: 1 });
+        expect(r.ok).toBe(true);
+        if (r.ok) {
+            expect(r.data).toEqual({ x: 1 });
+        }
+    });
+    it('toolError wraps code + errors[]', () => {
+        const r = toolError(ErrorCode.E_PARSE, [{ line: 2, column: 3, message: 'oops' }]);
+        expect(r.ok).toBe(false);
+        if (!r.ok) {
+            expect(r.code).toBe('E_PARSE');
+            expect(r.errors[0]).toMatchObject({ line: 2, column: 3 });
+        }
+    });
+    it('isToolError narrows the union', () => {
+        const r = toolError(ErrorCode.E_INTERNAL, [{ message: 'x' }]);
+        expect(isToolError(r)).toBe(true);
+    });
+});

package/dist/lib/zodToJsonSchema.d.ts

@@ -0,0 +1,8 @@
+import type { ZodTypeAny } from 'zod';
+/**
+ * Permissive stub: returns a generic object schema that allows any properties.
+ * MCP tool handlers do the precise runtime validation via Zod. If MCP clients
+ * begin requiring precise JSON Schema for `listTools`, replace this body with
+ * the `zod-to-json-schema` package.
+ */
+export declare function zodToJsonSchema(_schema: ZodTypeAny): Record<string, unknown>;

package/dist/lib/zodToJsonSchema.js

@@ -0,0 +1,9 @@
+/**
+ * Permissive stub: returns a generic object schema that allows any properties.
+ * MCP tool handlers do the precise runtime validation via Zod. If MCP clients
+ * begin requiring precise JSON Schema for `listTools`, replace this body with
+ * the `zod-to-json-schema` package.
+ */
+export function zodToJsonSchema(_schema) {
+    return { type: 'object', additionalProperties: true };
+}

package/dist/parse.d.ts

@@ -0,0 +1,5 @@
+import type { ChartNode } from '@blueprint-chart/lib';
+import { type ToolResult } from './errors';
+export declare function parseDsl(source: unknown): ToolResult<{
+    ast: ChartNode;
+}>;

package/dist/parse.js

@@ -0,0 +1,25 @@
+import { parse as libParse } from '@blueprint-chart/lib';
+import { ErrorCode, toolError, toolOk } from './errors';
+export function parseDsl(source) {
+    if (typeof source !== 'string') {
+        return toolError(ErrorCode.E_INPUT, [{ path: 'source', message: 'expected string' }]);
+    }
+    try {
+        const ast = libParse(source);
+        return toolOk({ ast });
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            // lib's parser wraps SyntaxError with " at L:C" suffix in the message
+            const match = err.message.match(/^(.*) at (\d+):(\d+)$/);
+            if (match) {
+                const [, message, line, column] = match;
+                return toolError(ErrorCode.E_PARSE, [
+                    { line: Number(line), column: Number(column), message: message.trim() },
+                ]);
+            }
+            return toolError(ErrorCode.E_PARSE, [{ message: err.message }]);
+        }
+        return toolError(ErrorCode.E_INTERNAL, [{ message: String(err) }]);
+    }
+}

package/dist/parse.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/parse.test.js

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+import { samples } from '@blueprint-chart/lib';
+import { parseDsl } from './parse';
+describe('parseDsl', () => {
+    it('parses a real lib sample', () => {
+        const r = parseDsl(samples[0].dsl);
+        expect(r.ok).toBe(true);
+        if (r.ok) {
+            expect(r.data.ast).toBeDefined();
+        }
+    });
+    it('returns E_PARSE with line + column for a syntax error', () => {
+        const r = parseDsl('chart bogus\n  garbage at line 2');
+        expect(r.ok).toBe(false);
+        if (!r.ok) {
+            expect(r.code).toBe('E_PARSE');
+            expect(r.errors[0]).toHaveProperty('line');
+            expect(r.errors[0]).toHaveProperty('column');
+            expect(typeof r.errors[0].message).toBe('string');
+        }
+    });
+    it('returns E_INPUT for non-string input', () => {
+        const r = parseDsl(123);
+        expect(r.ok).toBe(false);
+        if (!r.ok) {
+            expect(r.code).toBe('E_INPUT');
+        }
+    });
+});

package/dist/prompts/authorChart.d.ts

@@ -0,0 +1,12 @@
+export interface AuthorChartPrompt {
+    description: string;
+    messages: Array<{
+        role: 'user';
+        content: {
+            type: 'text';
+            text: string;
+        };
+    }>;
+    [k: string]: unknown;
+}
+export declare function authorChartPrompt(): AuthorChartPrompt;

package/dist/prompts/authorChart.js

@@ -0,0 +1,35 @@
+const BODY = `You are authoring a Blueprint Chart (\`.bpc\`) file for a user.
+
+Workflow:
+1. Read \`bpc://grammar\` for the DSL syntax.
+2. Read \`bpc://handbook/choosing\` and \`bpc://handbook/design-principles\` for dataviz judgment.
+3. If unsure about the chart type, call \`recommend_chart_type\` with the user's column types and row count.
+4. Read \`bpc://chart-types/<type>\` for the specific chart you'll use.
+5. Look at \`bpc://samples/<id>\` for a working example in the same family.
+6. Write the \`.bpc\` source.
+7. Call \`validate_dsl\` on your draft. If errors, read the line/column from the response and fix them.
+8. Call \`inspect_dsl\` to sanity-check the parsed structure.
+9. Call \`render\` with format="png" to get a visual. If the chart looks wrong, iterate on the \`.bpc\` and re-render.
+10. Return the final \`.bpc\` source AND the rendered chart to the user.
+
+Resources you can read:
+- \`bpc://grammar\` — DSL syntax reference (aggregate)
+- \`bpc://handbook/{slug}\` — dataviz pedagogy (choosing, design-principles, color, typography, annotations, accessibility, ...)
+- \`bpc://guide/{slug}\` — Blueprint Chart guides (scenes, palettes, data-transforms, ...)
+- \`bpc://chart-types/{slug}\` — per-chart-type docs
+- \`bpc://samples/{id}\` — canonical \`.bpc\` examples
+- \`bpc://reference/dsl/{slug}\`, \`bpc://reference/api/{slug}\` — full reference
+
+Tools:
+- \`validate_dsl({source})\` — parse, return errors with line/column
+- \`inspect_dsl({source})\` — parsed summary (chart type, scenes, series, annotations)
+- \`recommend_chart_type({columnTypes, rowCount, goal?})\` — ranked suggestions
+- \`render({source, format, scene?, width?, height?})\` — SVG (default) or PNG
+
+Be patient with errors — the feedback loop is the point.`;
+export function authorChartPrompt() {
+    return {
+        description: 'Author a Blueprint Chart .bpc file with the LLM as the writer; the MCP as validator + renderer.',
+        messages: [{ role: 'user', content: { type: 'text', text: BODY } }],
+    };
+}

package/dist/prompts/authorChart.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/prompts/authorChart.test.js

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest';
+import { authorChartPrompt } from './authorChart';
+describe('authorChartPrompt', () => {
+    it('returns a non-empty prompt body with resource URIs', () => {
+        const p = authorChartPrompt();
+        expect(p.messages.length).toBeGreaterThan(0);
+        const first = p.messages[0];
+        expect(first.role).toBe('user');
+        expect(first.content.type).toBe('text');
+        expect(first.content.text).toMatch(/bpc:\/\/grammar/);
+        expect(first.content.text).toMatch(/validate_dsl/);
+    });
+});