@panagos/jojoscript 0.9.1 → 0.9.3

package/README.md

@@ -1,4 +1,4 @@
-# JojoScript 0.9.1
+# JojoScript 0.9.3
 
 JojoScript is a small JavaScript-compatible language and runtime for
 expressive, composable pipelines. It adds lightweight syntax for declarations,
@@ -6,8 +6,8 @@ functions, pattern matching, type annotations, and pipelines while preserving
 ordinary JavaScript. Its compiler uses a lightweight lexer and source
 transformations rather than a full AST, keeping the toolchain compact. The
 project also provides lazy and async collection operators, checkpointing,
-retries, metrics, pipeline graphing, CLI workflows, effect handlers, and
-VS Code editor support.
+retries, metrics, pipeline graphing, CLI workflows, effect handlers, MCP
+support, and VS Code editor support.
 
 See [CHANGELOG.md](CHANGELOG.md) for release history and
 [example/](example/) for a complete runnable application that exercises
@@ -739,6 +739,29 @@ never through `|>`) and also uses pipeline syntax with overlapping names,
 the compiler merges the auto-imported names into the existing import
 instead of emitting a second, colliding import declaration.
 
+### MCP support
+
+JojoScript includes a small MCP-style JSON-RPC runtime for Node.js. It does
+not add MCP-specific language syntax; tool implementations remain ordinary
+JavaScript functions.
+
+```js
+import { createMcpServer, runMcpStdioServer } from "jojoscript/runtime"
+
+const server = createMcpServer({
+  tools: {
+    echo: args => ({ content: [{ type: "text", text: args.value }] })
+  }
+})
+
+await runMcpStdioServer(server)
+```
+
+The server accepts `tools/call` requests and returns JSON-RPC responses on
+standard output. It is intentionally minimal: supporting tool registration,
+request dispatch, structured errors, and the stdin/stdout transport without any
+external NPM packages.
+
 ## Example
 
 See [example/](example/). It is a complete runnable project covering every

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@panagos/jojoscript",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "A tiny JavaScript-compatible language layer with Jojo syntax and pipelines.",
   "license": "Unlicense",
   "type": "module",

package/src/pipeline-parser.js

@@ -327,6 +327,14 @@ export function emitPipeline(pipeline, options = {}) {
       continue
     }
 
+    if (stage.name === 'pass') {
+      if (stage.args.length === 0) continue
+      if (stage.args.length === 1 && stage.args[0] === '_') {
+        continue
+      }
+      throw new SyntaxError('the `pass` pipeline stage takes no arguments or a single `_` placeholder')
+    }
+
     if (stage.name.startsWith('.')) {
       const args = stage.args.slice()
       const placeholderIndex = args.indexOf('_')

package/src/runtime/index.js

@@ -67,4 +67,9 @@ export {
   MemoryEffectLog,
   FileEffectLog
 } from './effect-log.js'
+export {
+  McpServer,
+  createMcpServer,
+  runMcpStdioServer
+} from './mcp.js'
 

package/src/runtime/mcp.js

@@ -0,0 +1,93 @@
+/*
+ * Minimal MCP-style JSON-RPC transport for Node.js. The server is protocol-
+ * focused rather than introducing MCP-specific JojoScript syntax; tool
+ * implementations remain ordinary JavaScript functions.
+ */
+
+import { createInterface } from 'node:readline'
+
+export class McpServer {
+  constructor({ tools = {} } = {}) {
+    this.tools = new Map(Object.entries(tools))
+  }
+
+  async handleRequest(message) {
+    if (!message || typeof message !== 'object') {
+      return {
+        jsonrpc: '2.0',
+        id: null,
+        error: {
+          code: -32600,
+          message: 'Invalid Request'
+        }
+      }
+    }
+
+    if (message.method !== 'tools/call') {
+      return {
+        jsonrpc: '2.0',
+        id: message.id ?? null,
+        error: {
+          code: -32601,
+          message: 'Method not found'
+        }
+      }
+    }
+
+    const toolName = message.params?.name
+    const toolArgs = message.params?.arguments ?? {}
+    const tool = this.tools.get(toolName)
+
+    if (!tool || typeof tool !== 'function') {
+      return {
+        jsonrpc: '2.0',
+        id: message.id ?? null,
+        error: {
+          code: -32602,
+          message: `Unknown tool: ${toolName}`
+        }
+      }
+    }
+
+    try {
+      const result = await tool(toolArgs)
+      return {
+        jsonrpc: '2.0',
+        id: message.id ?? null,
+        result
+      }
+    } catch (error) {
+      return {
+        jsonrpc: '2.0',
+        id: message.id ?? null,
+        error: {
+          code: -32603,
+          message: error instanceof Error ? error.message : String(error)
+        }
+      }
+    }
+  }
+}
+
+export function createMcpServer(options = {}) {
+  return new McpServer(options)
+}
+
+export async function runMcpStdioServer(server, options = {}) {
+  const input = options.input ?? process.stdin
+  const output = options.output ?? process.stdout
+
+  const lines = Array.isArray(input)
+    ? input.values()
+    : createInterface({ input, crlfDelay: Infinity })
+
+  for await (const line of lines) {
+    if (!line.trim()) continue
+
+    const message = JSON.parse(line)
+    const response = await server.handleRequest(message)
+    output.write(`${JSON.stringify(response)}\n`)
+  }
+
+  return 0
+}