@weave-framework/mcp 0.2.162

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aidas Josas
+
+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,46 @@
+# @weave-framework/mcp
+
+A **Model Context Protocol** server that exposes the Weave toolchain to MCP-capable AI agents and
+editors — so your AI assistant can compile-check a template, type-check the project, resolve
+file-based routes, and scaffold a component through structured tools instead of guessing at the CLI.
+
+Part of [Weave](https://weaveframework.dev).
+
+## Tools
+
+| Tool | What it does |
+|------|--------------|
+| `weave_compile_template` | Compile a Weave template string → emitted code, or the real compiler error. Validate markup before shipping it. |
+| `weave_check` | Type-check a Weave project (templates + child-props) → diagnostics with file/line/col/message. |
+| `weave_routes` | Turn a list of page files into Weave's file-based route tree (`[id]`→`:id`, `index`→`""`, `_layout`→nested). |
+| `weave_scaffold_component` | Generate a component's boilerplate files (`.ts` + `.html` [+ stylesheet]). Returns the files — never writes without you. |
+
+## Usage
+
+Configure your MCP client to launch the server over **stdio**:
+
+```jsonc
+{
+  "mcpServers": {
+    "weave": {
+      "command": "weave-mcp",
+      "cwd": "/path/to/your/weave/project"
+    }
+  }
+}
+```
+
+Equivalently, `weave mcp` (from `@weave-framework/cli`) starts the same server. The server's working
+directory should be your project root so `weave_check` resolves the right files.
+
+## Zero-dependency by design
+
+MCP is JSON-RPC 2.0 over a transport. This package implements the protocol **in-house** (a small
+JSON-RPC framing + a newline-delimited stdio loop) rather than pulling a third-party MCP SDK —
+keeping Weave's zero-runtime-dependency rule. The tools thin-wrap the existing
+`@weave-framework/compiler`, `@weave-framework/check`, and `@weave-framework/router` — no
+re-implementation.
+
+## License
+
+MIT

package/bin/weave-mcp-dist.mjs

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * PUBLISHED bin: a thin launcher over the prebuilt dist/index.js — starts the Weave MCP
+ * server over stdio. Selected via package.json `publishConfig.bin`.
+ */
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(here, '../package.json'), 'utf8'));
+
+const { runStdioServer } = await import('../dist/index.js');
+await runStdioServer({ version: pkg.version });

package/bin/weave-mcp.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+/**
+ * DEV bin (monorepo): bundle the typed MCP server source on the fly (esbuild inlines
+ * @weave-framework/compiler/check/router; typescript/sass/esbuild stay external) and run it
+ * over stdio. Lets `weave-mcp` run from live `src/` with no build step during development.
+ *
+ * For the PUBLISHED package, package.json `publishConfig.bin` swaps this for
+ * bin/weave-mcp-dist.mjs (a thin launcher over the prebuilt dist/index.js).
+ */
+import { build as esbuild } from 'esbuild';
+import { mkdirSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(here, '../package.json'), 'utf8'));
+const cacheDir = join(resolve(here, '../../..'), 'node_modules', '.weave');
+mkdirSync(cacheDir, { recursive: true });
+const out = join(cacheDir, 'mcp.mjs');
+
+await esbuild({
+  entryPoints: [join(here, '../src/index.ts')],
+  bundle: true,
+  format: 'esm',
+  platform: 'node',
+  target: 'node18',
+  external: ['typescript', 'sass', 'esbuild'],
+  outfile: out,
+});
+
+const { runStdioServer } = await import(pathToFileURL(out).href);
+await runStdioServer({ version: pkg.version });

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @weave-framework/mcp — a Model Context Protocol server that exposes the Weave toolchain
+ * to AI agents & editors as MCP tools. In-house JSON-RPC over stdio, zero third-party deps
+ * (RFC 0006; [[weave-zero-dependencies]]).
+ *
+ * Tools (v1): weave_compile_template · weave_check · weave_routes · weave_scaffold_component.
+ * Launch with the `weave-mcp` bin (or `weave mcp`), or embed via {@link createServer} /
+ * {@link runStdioServer}.
+ */
+import { McpServer, type McpServerOptions } from './server.js';
+import { type StdioOptions } from './stdio.js';
+/** Build a Weave MCP server with all v1 tools registered. */
+export declare function createServer(opts?: McpServerOptions): McpServer;
+/** Build the server and run it over the stdio transport (the `weave-mcp` entry point). */
+export declare function runStdioServer(opts?: McpServerOptions & StdioOptions): Promise<void>;
+export { McpServer, PROTOCOL_VERSION, type McpServerOptions } from './server.js';
+export { runStdio, type StdioOptions } from './stdio.js';
+export { textResult, jsonResult, type JsonRpcRequest, type JsonRpcResponse, type JsonRpcError, type McpTool, type McpToolResult, } from './jsonrpc.js';
+export { compileTemplateTool } from './tools/compile-template.js';
+export { checkTool } from './tools/check.js';
+export { routesTool } from './tools/routes.js';
+export { scaffoldComponentTool, generateComponent, type GeneratedFile } from './tools/scaffold-component.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,EAAY,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAMzD,6DAA6D;AAC7D,wBAAgB,YAAY,CAAC,IAAI,GAAE,gBAAqB,GAAG,SAAS,CAMnE;AAED,0FAA0F;AAC1F,wBAAgB,cAAc,CAAC,IAAI,GAAE,gBAAgB,GAAG,YAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAExF;AAED,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACjF,OAAO,EAAE,QAAQ,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,EACL,UAAU,EACV,UAAU,EACV,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,OAAO,EACZ,KAAK,aAAa,GACnB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,KAAK,aAAa,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/index.js

@@ -0,0 +1,35 @@
+/**
+ * @weave-framework/mcp — a Model Context Protocol server that exposes the Weave toolchain
+ * to AI agents & editors as MCP tools. In-house JSON-RPC over stdio, zero third-party deps
+ * (RFC 0006; [[weave-zero-dependencies]]).
+ *
+ * Tools (v1): weave_compile_template · weave_check · weave_routes · weave_scaffold_component.
+ * Launch with the `weave-mcp` bin (or `weave mcp`), or embed via {@link createServer} /
+ * {@link runStdioServer}.
+ */
+import { McpServer } from './server.js';
+import { runStdio } from './stdio.js';
+import { compileTemplateTool } from './tools/compile-template.js';
+import { checkTool } from './tools/check.js';
+import { routesTool } from './tools/routes.js';
+import { scaffoldComponentTool } from './tools/scaffold-component.js';
+/** Build a Weave MCP server with all v1 tools registered. */
+export function createServer(opts = {}) {
+    return new McpServer(opts)
+        .registerTool(compileTemplateTool)
+        .registerTool(checkTool)
+        .registerTool(routesTool)
+        .registerTool(scaffoldComponentTool);
+}
+/** Build the server and run it over the stdio transport (the `weave-mcp` entry point). */
+export function runStdioServer(opts = {}) {
+    return runStdio(createServer(opts), opts);
+}
+export { McpServer, PROTOCOL_VERSION } from './server.js';
+export { runStdio } from './stdio.js';
+export { textResult, jsonResult, } from './jsonrpc.js';
+export { compileTemplateTool } from './tools/compile-template.js';
+export { checkTool } from './tools/check.js';
+export { routesTool } from './tools/routes.js';
+export { scaffoldComponentTool, generateComponent } from './tools/scaffold-component.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,SAAS,EAAyB,MAAM,aAAa,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAqB,MAAM,YAAY,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAEtE,6DAA6D;AAC7D,MAAM,UAAU,YAAY,CAAC,OAAyB,EAAE;IACtD,OAAO,IAAI,SAAS,CAAC,IAAI,CAAC;SACvB,YAAY,CAAC,mBAAmB,CAAC;SACjC,YAAY,CAAC,SAAS,CAAC;SACvB,YAAY,CAAC,UAAU,CAAC;SACxB,YAAY,CAAC,qBAAqB,CAAC,CAAC;AACzC,CAAC;AAED,0FAA0F;AAC1F,MAAM,UAAU,cAAc,CAAC,OAAwC,EAAE;IACvE,OAAO,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;AAC5C,CAAC;AAED,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAyB,MAAM,aAAa,CAAC;AACjF,OAAO,EAAE,QAAQ,EAAqB,MAAM,YAAY,CAAC;AACzD,OAAO,EACL,UAAU,EACV,UAAU,GAMX,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,qBAAqB,EAAE,iBAAiB,EAAsB,MAAM,+BAA+B,CAAC"}

package/dist/jsonrpc.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Minimal JSON-RPC 2.0 types + an MCP tool shape. Zero-dep: MCP is JSON-RPC over a
+ * transport (stdio here), and the protocol is small enough to own in-house rather than
+ * pull a third-party SDK ([[weave-zero-dependencies]] / RFC 0006).
+ */
+/** A JSON-RPC 2.0 request. A request with no `id` is a notification (no response). */
+export interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    id?: number | string | null;
+    method: string;
+    params?: unknown;
+}
+/** A JSON-RPC 2.0 response — exactly one of `result` / `error`. */
+export interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: number | string | null;
+    result?: unknown;
+    error?: JsonRpcError;
+}
+export interface JsonRpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+/** Standard JSON-RPC error codes used by the server. */
+export declare const RPC_METHOD_NOT_FOUND: number;
+export declare const RPC_INVALID_PARAMS: number;
+export declare const RPC_INTERNAL_ERROR: number;
+/** An MCP tool: a name, a JSON-Schema for its input, and an async handler. */
+export interface McpTool {
+    name: string;
+    description: string;
+    /** JSON Schema describing the tool's `arguments` object. */
+    inputSchema: object;
+    handler: (args: Record<string, unknown>) => Promise<McpToolResult> | McpToolResult;
+}
+/** The MCP `tools/call` result shape — text content, optionally flagged as an error. */
+export interface McpToolResult {
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}
+/** Convenience: wrap a string (or JSON-serialisable value) as a text tool result. */
+export declare function textResult(text: string, isError?: boolean): McpToolResult;
+/** Convenience: wrap a value as pretty JSON text content. */
+export declare function jsonResult(value: unknown): McpToolResult;
+//# sourceMappingURL=jsonrpc.d.ts.map

package/dist/jsonrpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonrpc.d.ts","sourceRoot":"","sources":["../src/jsonrpc.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,sFAAsF;AACtF,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,KAAK,CAAC;IACf,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,mEAAmE;AACnE,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,KAAK,CAAC;IACf,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAC3B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,wDAAwD;AACxD,eAAO,MAAM,oBAAoB,EAAE,MAAe,CAAC;AACnD,eAAO,MAAM,kBAAkB,EAAE,MAAe,CAAC;AACjD,eAAO,MAAM,kBAAkB,EAAE,MAAe,CAAC;AAEjD,8EAA8E;AAC9E,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,4DAA4D;IAC5D,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,aAAa,CAAC,GAAG,aAAa,CAAC;CACpF;AAED,wFAAwF;AACxF,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,qFAAqF;AACrF,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,OAAe,GAAG,aAAa,CAEhF;AAED,6DAA6D;AAC7D,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,CAExD"}

package/dist/jsonrpc.js

@@ -0,0 +1,18 @@
+/**
+ * Minimal JSON-RPC 2.0 types + an MCP tool shape. Zero-dep: MCP is JSON-RPC over a
+ * transport (stdio here), and the protocol is small enough to own in-house rather than
+ * pull a third-party SDK ([[weave-zero-dependencies]] / RFC 0006).
+ */
+/** Standard JSON-RPC error codes used by the server. */
+export const RPC_METHOD_NOT_FOUND = -32601;
+export const RPC_INVALID_PARAMS = -32602;
+export const RPC_INTERNAL_ERROR = -32603;
+/** Convenience: wrap a string (or JSON-serialisable value) as a text tool result. */
+export function textResult(text, isError = false) {
+    return { content: [{ type: 'text', text }], isError };
+}
+/** Convenience: wrap a value as pretty JSON text content. */
+export function jsonResult(value) {
+    return textResult(JSON.stringify(value, null, 2));
+}
+//# sourceMappingURL=jsonrpc.js.map

package/dist/jsonrpc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonrpc.js","sourceRoot":"","sources":["../src/jsonrpc.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAwBH,wDAAwD;AACxD,MAAM,CAAC,MAAM,oBAAoB,GAAW,CAAC,KAAK,CAAC;AACnD,MAAM,CAAC,MAAM,kBAAkB,GAAW,CAAC,KAAK,CAAC;AACjD,MAAM,CAAC,MAAM,kBAAkB,GAAW,CAAC,KAAK,CAAC;AAiBjD,qFAAqF;AACrF,MAAM,UAAU,UAAU,CAAC,IAAY,EAAE,UAAmB,KAAK;IAC/D,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC;AACxD,CAAC;AAED,6DAA6D;AAC7D,MAAM,UAAU,UAAU,CAAC,KAAc;IACvC,OAAO,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;AACpD,CAAC"}

package/dist/server.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The MCP server core — pure request→response dispatch, no transport, no Node APIs.
+ * A transport (see `./stdio.ts`) feeds it parsed {@link JsonRpcRequest}s and writes back
+ * the {@link JsonRpcResponse}s. Kept Node-free so it is unit-testable in the browser harness.
+ */
+import { RPC_INTERNAL_ERROR, type JsonRpcRequest, type JsonRpcResponse, type McpTool } from './jsonrpc.js';
+/** The MCP protocol revision this server speaks. */
+export declare const PROTOCOL_VERSION: string;
+export interface McpServerOptions {
+    name?: string;
+    version?: string;
+}
+/**
+ * A minimal MCP server: register tools, then `handle()` each JSON-RPC request. Implements
+ * `initialize`, `tools/list`, `tools/call`, and swallows `notifications/*` (returns null,
+ * i.e. no response). Tool *execution* failures are returned as `isError` results (MCP
+ * convention); protocol failures (unknown method / unknown tool) are JSON-RPC errors.
+ */
+export declare class McpServer {
+    private readonly tools;
+    private readonly name;
+    private readonly version;
+    constructor(opts?: McpServerOptions);
+    /** Register a tool (last registration of a name wins). Chainable. */
+    registerTool(tool: McpTool): this;
+    /** The public tool descriptors (no handlers) — the `tools/list` payload. */
+    listTools(): Array<{
+        name: string;
+        description: string;
+        inputSchema: object;
+    }>;
+    /**
+     * Handle one request. Returns the response, or `null` for a notification (a request with
+     * no `id`, e.g. `notifications/initialized`) which must not be answered.
+     */
+    handle(req: JsonRpcRequest): Promise<JsonRpcResponse | null>;
+    private ok;
+    private err;
+}
+export { RPC_INTERNAL_ERROR };
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,kBAAkB,EAIlB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,OAAO,EAEb,MAAM,cAAc,CAAC;AAEtB,oDAAoD;AACpD,eAAO,MAAM,gBAAgB,EAAE,MAAqB,CAAC;AAErD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;GAKG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoD;IAC1E,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAErB,IAAI,GAAE,gBAAqB;IAKvC,qEAAqE;IACrE,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAKjC,4EAA4E;IAC5E,SAAS,IAAI,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;IAQ9E;;;OAGG;IACG,MAAM,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IA0ClE,OAAO,CAAC,EAAE;IAIV,OAAO,CAAC,GAAG;CAGZ;AAGD,OAAO,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/server.js

@@ -0,0 +1,84 @@
+/**
+ * The MCP server core — pure request→response dispatch, no transport, no Node APIs.
+ * A transport (see `./stdio.ts`) feeds it parsed {@link JsonRpcRequest}s and writes back
+ * the {@link JsonRpcResponse}s. Kept Node-free so it is unit-testable in the browser harness.
+ */
+import { RPC_INTERNAL_ERROR, RPC_INVALID_PARAMS, RPC_METHOD_NOT_FOUND, textResult, } from './jsonrpc.js';
+/** The MCP protocol revision this server speaks. */
+export const PROTOCOL_VERSION = '2024-11-05';
+/**
+ * A minimal MCP server: register tools, then `handle()` each JSON-RPC request. Implements
+ * `initialize`, `tools/list`, `tools/call`, and swallows `notifications/*` (returns null,
+ * i.e. no response). Tool *execution* failures are returned as `isError` results (MCP
+ * convention); protocol failures (unknown method / unknown tool) are JSON-RPC errors.
+ */
+export class McpServer {
+    tools = new Map();
+    name;
+    version;
+    constructor(opts = {}) {
+        this.name = opts.name ?? '@weave-framework/mcp';
+        this.version = opts.version ?? 'dev';
+    }
+    /** Register a tool (last registration of a name wins). Chainable. */
+    registerTool(tool) {
+        this.tools.set(tool.name, tool);
+        return this;
+    }
+    /** The public tool descriptors (no handlers) — the `tools/list` payload. */
+    listTools() {
+        return [...this.tools.values()].map((t) => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema,
+        }));
+    }
+    /**
+     * Handle one request. Returns the response, or `null` for a notification (a request with
+     * no `id`, e.g. `notifications/initialized`) which must not be answered.
+     */
+    async handle(req) {
+        const id = req.id ?? null;
+        const isNotification = req.id === undefined || req.id === null;
+        if (req.method === 'initialize') {
+            return this.ok(id, {
+                protocolVersion: PROTOCOL_VERSION,
+                capabilities: { tools: {} },
+                serverInfo: { name: this.name, version: this.version },
+            });
+        }
+        if (req.method.startsWith('notifications/')) {
+            return null; // notifications get no response
+        }
+        if (req.method === 'tools/list') {
+            return this.ok(id, { tools: this.listTools() });
+        }
+        if (req.method === 'tools/call') {
+            const params = (req.params ?? {});
+            const tool = params.name ? this.tools.get(params.name) : undefined;
+            if (!tool) {
+                return this.err(id, RPC_INVALID_PARAMS, `unknown tool: ${String(params.name)}`);
+            }
+            try {
+                const result = await tool.handler(params.arguments ?? {});
+                return this.ok(id, result);
+            }
+            catch (e) {
+                // A tool that throws → an isError result (the agent sees the message, keeps the session).
+                return this.ok(id, textResult(`${e?.message ?? String(e)}`, true));
+            }
+        }
+        if (isNotification)
+            return null;
+        return this.err(id, RPC_METHOD_NOT_FOUND, `method not found: ${req.method}`);
+    }
+    ok(id, result) {
+        return { jsonrpc: '2.0', id, result };
+    }
+    err(id, code, message) {
+        return { jsonrpc: '2.0', id, error: { code, message } };
+    }
+}
+// Re-export so consumers can build a server without reaching into ./jsonrpc.
+export { RPC_INTERNAL_ERROR };
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"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"}

package/dist/stdio.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The stdio transport: newline-delimited JSON-RPC on stdin/stdout — the standard MCP stdio
+ * framing (one JSON message per line). Reads requests, dispatches to the {@link McpServer},
+ * writes responses. Requests are processed strictly in order (responses never interleave).
+ * Node-only.
+ */
+import type { Readable, Writable } from 'node:stream';
+import type { McpServer } from './server.js';
+export interface StdioOptions {
+    input?: Readable;
+    output?: Writable;
+}
+/**
+ * Run `server` over a newline-delimited JSON-RPC stdio loop. Resolves when the input stream
+ * closes. Lines are handled sequentially via a promise chain so responses stay in request order.
+ */
+export declare function runStdio(server: McpServer, opts?: StdioOptions): Promise<void>;
+//# sourceMappingURL=stdio.d.ts.map

package/dist/stdio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../src/stdio.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAK7C,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,MAAM,CAAC,EAAE,QAAQ,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,GAAE,YAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6BlF"}

package/dist/stdio.js

@@ -0,0 +1,44 @@
+/**
+ * The stdio transport: newline-delimited JSON-RPC on stdin/stdout — the standard MCP stdio
+ * framing (one JSON message per line). Reads requests, dispatches to the {@link McpServer},
+ * writes responses. Requests are processed strictly in order (responses never interleave).
+ * Node-only.
+ */
+import { createInterface } from 'node:readline';
+const RPC_PARSE_ERROR = -32700;
+/**
+ * Run `server` over a newline-delimited JSON-RPC stdio loop. Resolves when the input stream
+ * closes. Lines are handled sequentially via a promise chain so responses stay in request order.
+ */
+export function runStdio(server, opts = {}) {
+    const input = opts.input ?? process.stdin;
+    const output = opts.output ?? process.stdout;
+    const rl = createInterface({ input, crlfDelay: Infinity });
+    let chain = Promise.resolve();
+    const write = (obj) => void output.write(JSON.stringify(obj) + '\n');
+    return new Promise((resolve) => {
+        rl.on('line', (line) => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            chain = chain.then(async () => {
+                let req;
+                try {
+                    req = JSON.parse(trimmed);
+                }
+                catch {
+                    write({ jsonrpc: '2.0', id: null, error: { code: RPC_PARSE_ERROR, message: 'parse error' } });
+                    return;
+                }
+                const res = await server.handle(req);
+                if (res)
+                    write(res);
+            });
+        });
+        rl.on('close', () => {
+            // drain the chain, then resolve
+            void chain.then(resolve);
+        });
+    });
+}
+//# sourceMappingURL=stdio.js.map

package/dist/stdio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.js","sourceRoot":"","sources":["../src/stdio.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,eAAe,EAAkB,MAAM,eAAe,CAAC;AAKhE,MAAM,eAAe,GAAW,CAAC,KAAK,CAAC;AAOvC;;;GAGG;AACH,MAAM,UAAU,QAAQ,CAAC,MAAiB,EAAE,OAAqB,EAAE;IACjE,MAAM,KAAK,GAAa,IAAI,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC;IACpD,MAAM,MAAM,GAAa,IAAI,CAAC,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC;IACvD,MAAM,EAAE,GAAc,eAAe,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,CAAC;IAEtE,IAAI,KAAK,GAAkB,OAAO,CAAC,OAAO,EAAE,CAAC;IAC7C,MAAM,KAAK,GAAG,CAAC,GAAY,EAAQ,EAAE,CAAC,KAAK,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;IAEpF,OAAO,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;QACnC,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAY,EAAE,EAAE;YAC7B,MAAM,OAAO,GAAW,IAAI,CAAC,IAAI,EAAE,CAAC;YACpC,IAAI,CAAC,OAAO;gBAAE,OAAO;YACrB,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE;gBAC5B,IAAI,GAAmB,CAAC;gBACxB,IAAI,CAAC;oBACH,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAmB,CAAC;gBAC9C,CAAC;gBAAC,MAAM,CAAC;oBACP,KAAK,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,aAAa,EAAE,EAAE,CAAC,CAAC;oBAC9F,OAAO;gBACT,CAAC;gBACD,MAAM,GAAG,GAA2B,MAAM,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBAC7D,IAAI,GAAG;oBAAE,KAAK,CAAC,GAAG,CAAC,CAAC;YACtB,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QACH,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;YAClB,gCAAgC;YAChC,KAAK,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC3B,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/tools/check.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `weave_check` — type-check a Weave project (template + child-prop diagnostics) and return
+ * the diagnostics. Wraps `@weave-framework/check`'s `checkProject`, which walks the given
+ * directories relative to the server's cwd (the target project). Node-only (filesystem).
+ */
+import { type McpTool } from '../jsonrpc.js';
+export declare const checkTool: McpTool;
+//# sourceMappingURL=check.d.ts.map

package/dist/tools/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../src/tools/check.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAc,KAAK,OAAO,EAAsB,MAAM,eAAe,CAAC;AAE7E,eAAO,MAAM,SAAS,EAAE,OAqBvB,CAAC"}

package/dist/tools/check.js

@@ -0,0 +1,28 @@
+/**
+ * `weave_check` — type-check a Weave project (template + child-prop diagnostics) and return
+ * the diagnostics. Wraps `@weave-framework/check`'s `checkProject`, which walks the given
+ * directories relative to the server's cwd (the target project). Node-only (filesystem).
+ */
+import { checkProject } from '@weave-framework/check';
+import { jsonResult } from '../jsonrpc.js';
+export const checkTool = {
+    name: 'weave_check',
+    description: 'Type-check a Weave project — template expressions and child-prop usage included. Returns diagnostics { file, line, col, code, message, category }. Runs against the server working directory.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            roots: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Directories to check, relative to the project root. Default ["src"].',
+            },
+        },
+    },
+    handler: (args) => {
+        const roots = Array.isArray(args.roots) && args.roots.length ? args.roots.map(String) : ['src'];
+        const diagnostics = checkProject(roots);
+        const errorCount = diagnostics.filter((d) => d.category === 'error').length;
+        return jsonResult({ ok: errorCount === 0, errorCount, diagnostics });
+    },
+};
+//# sourceMappingURL=check.js.map

package/dist/tools/check.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.js","sourceRoot":"","sources":["../../src/tools/check.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,YAAY,EAAmB,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,UAAU,EAAoC,MAAM,eAAe,CAAC;AAE7E,MAAM,CAAC,MAAM,SAAS,GAAY;IAChC,IAAI,EAAE,aAAa;IACnB,WAAW,EACT,+LAA+L;IACjM,WAAW,EAAE;QACX,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE;YACV,KAAK,EAAE;gBACL,IAAI,EAAE,OAAO;gBACb,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;gBACzB,WAAW,EAAE,sEAAsE;aACpF;SACF;KACF;IACD,OAAO,EAAE,CAAC,IAA6B,EAAiB,EAAE;QACxD,MAAM,KAAK,GACT,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAE,IAAI,CAAC,KAAkB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAClG,MAAM,WAAW,GAAiB,YAAY,CAAC,KAAK,CAAC,CAAC;QACtD,MAAM,UAAU,GAAW,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,MAAM,CAAC;QACpF,OAAO,UAAU,CAAC,EAAE,EAAE,EAAE,UAAU,KAAK,CAAC,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC,CAAC;IACvE,CAAC;CACF,CAAC"}

package/dist/tools/compile-template.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `weave_compile_template` — compile a Weave template string and return the emitted code,
+ * or the parse/codegen error. The highest-value MCP tool: an agent that just wrote template
+ * markup can *validate* it against the real Weave compiler (real errors, not guesses) before
+ * shipping it. Purely functional — no filesystem, no project resolution.
+ */
+import { type McpTool } from '../jsonrpc.js';
+export declare const compileTemplateTool: McpTool;
+//# sourceMappingURL=compile-template.d.ts.map

package/dist/tools/compile-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-template.d.ts","sourceRoot":"","sources":["../../src/tools/compile-template.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAA0B,KAAK,OAAO,EAAsB,MAAM,eAAe,CAAC;AAEzF,eAAO,MAAM,mBAAmB,EAAE,OAiCjC,CAAC"}

package/dist/tools/compile-template.js

@@ -0,0 +1,42 @@
+/**
+ * `weave_compile_template` — compile a Weave template string and return the emitted code,
+ * or the parse/codegen error. The highest-value MCP tool: an agent that just wrote template
+ * markup can *validate* it against the real Weave compiler (real errors, not guesses) before
+ * shipping it. Purely functional — no filesystem, no project resolution.
+ */
+import { compileTemplate } from '@weave-framework/compiler';
+import { jsonResult, textResult } from '../jsonrpc.js';
+export const compileTemplateTool = {
+    name: 'weave_compile_template',
+    description: 'Compile a Weave template string to runtime code, or return the compiler error. Use this to VALIDATE Weave template markup you wrote before shipping it — you get the real parse/codegen error rather than guessing.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            template: { type: 'string', description: 'The Weave template source (the markup) to compile.' },
+            mode: {
+                type: 'string',
+                enum: ['module', 'function'],
+                description: 'Codegen mode (default "module").',
+            },
+            scope: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Names of identifiers already in scope (component fields/imports), so references resolve.',
+            },
+        },
+        required: ['template'],
+    },
+    handler: (args) => {
+        const template = String(args.template ?? '');
+        const mode = args.mode === 'function' || args.mode === 'module' ? args.mode : undefined;
+        const scope = Array.isArray(args.scope) ? args.scope : undefined;
+        try {
+            const res = compileTemplate(template, { mode, scope });
+            return jsonResult({ ok: true, code: res.code, components: res.components });
+        }
+        catch (e) {
+            return textResult(`Compile error: ${e?.message ?? String(e)}`, true);
+        }
+    },
+};
+//# sourceMappingURL=compile-template.js.map

package/dist/tools/compile-template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-template.js","sourceRoot":"","sources":["../../src/tools/compile-template.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,eAAe,EAAsB,MAAM,2BAA2B,CAAC;AAChF,OAAO,EAAE,UAAU,EAAE,UAAU,EAAoC,MAAM,eAAe,CAAC;AAEzF,MAAM,CAAC,MAAM,mBAAmB,GAAY;IAC1C,IAAI,EAAE,wBAAwB;IAC9B,WAAW,EACT,qNAAqN;IACvN,WAAW,EAAE;QACX,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE;YACV,QAAQ,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,oDAAoD,EAAE;YAC/F,IAAI,EAAE;gBACJ,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,CAAC,QAAQ,EAAE,UAAU,CAAC;gBAC5B,WAAW,EAAE,kCAAkC;aAChD;YACD,KAAK,EAAE;gBACL,IAAI,EAAE,OAAO;gBACb,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;gBACzB,WAAW,EAAE,0FAA0F;aACxG;SACF;QACD,QAAQ,EAAE,CAAC,UAAU,CAAC;KACvB;IACD,OAAO,EAAE,CAAC,IAA6B,EAAiB,EAAE;QACxD,MAAM,QAAQ,GAAW,MAAM,CAAC,IAAI,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC;QACrD,MAAM,IAAI,GACR,IAAI,CAAC,IAAI,KAAK,UAAU,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;QAC7E,MAAM,KAAK,GAAyB,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAE,IAAI,CAAC,KAAkB,CAAC,CAAC,CAAC,SAAS,CAAC;QACrG,IAAI,CAAC;YACH,MAAM,GAAG,GAAkB,eAAe,CAAC,QAAQ,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;YACtE,OAAO,UAAU,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC;QAC9E,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,UAAU,CAAC,kBAAmB,CAAW,EAAE,OAAO,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;QAClF,CAAC;IACH,CAAC;CACF,CAAC"}

package/dist/tools/routes.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `weave_routes` — turn a list of page-file paths into Weave's file-based route tree, so an
+ * agent can see how files map to routes (`[id]`→`:id`, `index`→`""`, `_layout`→nested wrapper)
+ * without running the CLI. Pure over the DOM-free `@weave-framework/router/files` helper.
+ */
+import { type McpTool } from '../jsonrpc.js';
+export declare const routesTool: McpTool;
+//# sourceMappingURL=routes.d.ts.map

package/dist/tools/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/tools/routes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAc,KAAK,OAAO,EAAsB,MAAM,eAAe,CAAC;AAE7E,eAAO,MAAM,UAAU,EAAE,OAoBxB,CAAC"}

package/dist/tools/routes.js

@@ -0,0 +1,28 @@
+/**
+ * `weave_routes` — turn a list of page-file paths into Weave's file-based route tree, so an
+ * agent can see how files map to routes (`[id]`→`:id`, `index`→`""`, `_layout`→nested wrapper)
+ * without running the CLI. Pure over the DOM-free `@weave-framework/router/files` helper.
+ */
+import { fileToRoutes } from '@weave-framework/router/files';
+import { jsonResult } from '../jsonrpc.js';
+export const routesTool = {
+    name: 'weave_routes',
+    description: "Build Weave's file-based route tree from a list of page file paths (relative to the pages dir). Shows the resolved routes: [id]→:id, [...rest]→*, index→\"\", _layout→a nested wrapper route.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            files: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Page file paths relative to the pages directory, e.g. ["index.ts","user/[id].ts","_layout.ts"].',
+            },
+        },
+        required: ['files'],
+    },
+    handler: (args) => {
+        const files = Array.isArray(args.files) ? args.files.map(String) : [];
+        const routes = fileToRoutes(files);
+        return jsonResult({ routes });
+    },
+};
+//# sourceMappingURL=routes.js.map

package/dist/tools/routes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.js","sourceRoot":"","sources":["../../src/tools/routes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,YAAY,EAAkB,MAAM,+BAA+B,CAAC;AAC7E,OAAO,EAAE,UAAU,EAAoC,MAAM,eAAe,CAAC;AAE7E,MAAM,CAAC,MAAM,UAAU,GAAY;IACjC,IAAI,EAAE,cAAc;IACpB,WAAW,EACT,+LAA+L;IACjM,WAAW,EAAE;QACX,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE;YACV,KAAK,EAAE;gBACL,IAAI,EAAE,OAAO;gBACb,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;gBACzB,WAAW,EAAE,iGAAiG;aAC/G;SACF;QACD,QAAQ,EAAE,CAAC,OAAO,CAAC;KACpB;IACD,OAAO,EAAE,CAAC,IAA6B,EAAiB,EAAE;QACxD,MAAM,KAAK,GAAa,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAE,IAAI,CAAC,KAAkB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9F,MAAM,MAAM,GAAgB,YAAY,CAAC,KAAK,CAAC,CAAC;QAChD,OAAO,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;IAChC,CAAC;CACF,CAAC"}

package/dist/tools/scaffold-component.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `weave_scaffold_component` — generate the boilerplate for a new Weave component (the
+ * sibling-convention `.ts` + `.html` [+ style] trio), following the create-weave idiom. Pure:
+ * it RETURNS the files (path + content) rather than writing them, so the agent/editor stays in
+ * control of the filesystem (RFC 0006 §Unresolved #3 — no unsolicited writes).
+ */
+import { type McpTool } from '../jsonrpc.js';
+/** One generated file. */
+export interface GeneratedFile {
+    path: string;
+    content: string;
+}
+/** Generate a component's files. `styleLang` of `'none'` omits the stylesheet. */
+export declare function generateComponent(name: string, styleLang?: 'css' | 'scss' | 'none'): GeneratedFile[];
+export declare const scaffoldComponentTool: McpTool;
+//# sourceMappingURL=scaffold-component.d.ts.map

package/dist/tools/scaffold-component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaffold-component.d.ts","sourceRoot":"","sources":["../../src/tools/scaffold-component.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAc,KAAK,OAAO,EAAsB,MAAM,eAAe,CAAC;AAE7E,0BAA0B;AAC1B,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AASD,kFAAkF;AAClF,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,KAAK,GAAG,MAAM,GAAG,MAAc,GACzC,aAAa,EAAE,CAgCjB;AAED,eAAO,MAAM,qBAAqB,EAAE,OAsBnC,CAAC"}

package/dist/tools/scaffold-component.js

@@ -0,0 +1,62 @@
+/**
+ * `weave_scaffold_component` — generate the boilerplate for a new Weave component (the
+ * sibling-convention `.ts` + `.html` [+ style] trio), following the create-weave idiom. Pure:
+ * it RETURNS the files (path + content) rather than writing them, so the agent/editor stays in
+ * control of the filesystem (RFC 0006 §Unresolved #3 — no unsolicited writes).
+ */
+import { jsonResult } from '../jsonrpc.js';
+const kebab = (s) => s
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+    .replace(/[\s_]+/g, '-')
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '');
+/** Generate a component's files. `styleLang` of `'none'` omits the stylesheet. */
+export function generateComponent(name, styleLang = 'css') {
+    const base = kebab(name) || 'component';
+    const files = [];
+    const styleImport = styleLang === 'none' ? '' : `\n// styles: ./${base}.${styleLang}`;
+    files.push({
+        path: `${base}/${base}.ts`,
+        content: `import { signal, type Signal } from '@weave-framework/runtime';\n\n` +
+            `export function setup(): { count: Signal<number>; inc: () => void } {\n` +
+            `  const count: Signal<number> = signal(0);\n` +
+            `  const inc = (): void => count.set((n) => n + 1);\n` +
+            `  return { count, inc };\n` +
+            `}${styleImport}\n`,
+    });
+    files.push({
+        path: `${base}/${base}.html`,
+        content: `<section class="${base}">\n` +
+            `  <button on:click={{ inc }}>clicked {{ count() }} times</button>\n` +
+            `</section>\n`,
+    });
+    if (styleLang !== 'none') {
+        files.push({
+            path: `${base}/${base}.${styleLang}`,
+            content: `.${base} {\n  display: block;\n}\n`,
+        });
+    }
+    return files;
+}
+export const scaffoldComponentTool = {
+    name: 'weave_scaffold_component',
+    description: 'Generate the boilerplate files for a new Weave component (a .ts + .html [+ stylesheet], the sibling-convention trio). Returns the files (path + content) WITHOUT writing them — write them yourself.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            name: { type: 'string', description: 'Component name (PascalCase or kebab-case), e.g. "UserCard".' },
+            styleLang: {
+                type: 'string',
+                enum: ['css', 'scss', 'none'],
+                description: 'Stylesheet language, or "none" to skip the stylesheet. Default "css".',
+            },
+        },
+        required: ['name'],
+    },
+    handler: (args) => {
+        const name = String(args.name ?? '');
+        const styleLang = args.styleLang === 'scss' || args.styleLang === 'none' ? args.styleLang : 'css';
+        return jsonResult({ files: generateComponent(name, styleLang) });
+    },
+};
+//# sourceMappingURL=scaffold-component.js.map

package/dist/tools/scaffold-component.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaffold-component.js","sourceRoot":"","sources":["../../src/tools/scaffold-component.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,UAAU,EAAoC,MAAM,eAAe,CAAC;AAQ7E,MAAM,KAAK,GAAG,CAAC,CAAS,EAAU,EAAE,CAClC,CAAC;KACE,OAAO,CAAC,oBAAoB,EAAE,OAAO,CAAC;KACtC,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC;KACvB,WAAW,EAAE;KACb,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC;AAEhC,kFAAkF;AAClF,MAAM,UAAU,iBAAiB,CAC/B,IAAY,EACZ,YAAqC,KAAK;IAE1C,MAAM,IAAI,GAAW,KAAK,CAAC,IAAI,CAAC,IAAI,WAAW,CAAC;IAChD,MAAM,KAAK,GAAoB,EAAE,CAAC;IAElC,MAAM,WAAW,GAAW,SAAS,KAAK,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,kBAAkB,IAAI,IAAI,SAAS,EAAE,CAAC;IAC9F,KAAK,CAAC,IAAI,CAAC;QACT,IAAI,EAAE,GAAG,IAAI,IAAI,IAAI,KAAK;QAC1B,OAAO,EACL,qEAAqE;YACrE,yEAAyE;YACzE,8CAA8C;YAC9C,sDAAsD;YACtD,4BAA4B;YAC5B,IAAI,WAAW,IAAI;KACtB,CAAC,CAAC;IAEH,KAAK,CAAC,IAAI,CAAC;QACT,IAAI,EAAE,GAAG,IAAI,IAAI,IAAI,OAAO;QAC5B,OAAO,EACL,mBAAmB,IAAI,MAAM;YAC7B,qEAAqE;YACrE,cAAc;KACjB,CAAC,CAAC;IAEH,IAAI,SAAS,KAAK,MAAM,EAAE,CAAC;QACzB,KAAK,CAAC,IAAI,CAAC;YACT,IAAI,EAAE,GAAG,IAAI,IAAI,IAAI,IAAI,SAAS,EAAE;YACpC,OAAO,EAAE,IAAI,IAAI,4BAA4B;SAC9C,CAAC,CAAC;IACL,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED,MAAM,CAAC,MAAM,qBAAqB,GAAY;IAC5C,IAAI,EAAE,0BAA0B;IAChC,WAAW,EACT,sMAAsM;IACxM,WAAW,EAAE;QACX,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE;YACV,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,6DAA6D,EAAE;YACpG,SAAS,EAAE;gBACT,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC;gBAC7B,WAAW,EAAE,uEAAuE;aACrF;SACF;QACD,QAAQ,EAAE,CAAC,MAAM,CAAC;KACnB;IACD,OAAO,EAAE,CAAC,IAA6B,EAAiB,EAAE;QACxD,MAAM,IAAI,GAAW,MAAM,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;QAC7C,MAAM,SAAS,GACb,IAAI,CAAC,SAAS,KAAK,MAAM,IAAI,IAAI,CAAC,SAAS,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC;QAClF,OAAO,UAAU,CAAC,EAAE,KAAK,EAAE,iBAAiB,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC;IACnE,CAAC;CACF,CAAC"}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@weave-framework/mcp",
+  "version": "0.2.162",
+  "description": "Weave MCP server — exposes the Weave toolchain (compile/check/routes/scaffold) to AI agents & editors as Model Context Protocol tools. In-house JSON-RPC over stdio, zero third-party deps.",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "weave-mcp": "./bin/weave-mcp-dist.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/weave-framework/weave.git",
+    "directory": "packages/mcp"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@weave-framework/compiler": "0.2.162",
+    "@weave-framework/check": "0.2.162",
+    "@weave-framework/router": "0.2.162"
+  },
+  "license": "MIT"
+}