@panagos/jojoscript 0.9.0 → 0.9.3

package/README.md

@@ -1,4 +1,4 @@
-# JojoScript 0.9.0
+# 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
@@ -237,6 +237,26 @@ becomes:
 divide(100, value)
 ```
 
+#### Property access stages
+
+A pipeline stage may also start with a dot to read a field or invoke a method
+on the piped value directly:
+
+```jojo
+users |> .length
+name |> .trim() |> .toUpperCase()
+```
+
+becomes:
+
+```js
+users.length
+name.trim().toUpperCase()
+```
+
+This is handy for compact pipelines where the previous value is the receiver of
+an ordinary JavaScript property or method call.
+
 #### `catch` / `orElse` control stages
 
 `catch` and `orElse` provide inline error handling without leaving pipeline
@@ -719,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.0",
+  "version": "0.9.3",
   "description": "A tiny JavaScript-compatible language layer with Jojo syntax and pipelines.",
   "license": "Unlicense",
   "type": "module",

package/src/index.js

@@ -1,33 +1,33 @@
-export {
-  compile,
-  compileFile,
-  compileDirectory
-} from './compiler.js'
-
-export {
-  transformPipelines,
-  emitPipeline,
-  findPipelineStdlibFunctions
-} from './pipeline-parser.js'
-
-export {
-  transformMatchExpressions
-} from './match-parser.js'
-
-export {
-  transformTypeAnnotations
-} from './type-annotations.js'
-
-export {
-  analyzePipelines,
-  buildGraph,
-  renderGraphText,
-  renderGraphDot
-} from './pipeline-ir.js'
-
-export {
-  transformEffectDeclarations,
-  transformHandleBlocks,
-  findEffectDeclarations,
-  findHandleBlocks
-} from './effect-parser.js'
+export {
+  compile,
+  compileFile,
+  compileDirectory
+} from './compiler.js'
+
+export {
+  transformPipelines,
+  emitPipeline,
+  findPipelineStdlibFunctions
+} from './pipeline-parser.js'
+
+export {
+  transformMatchExpressions
+} from './match-parser.js'
+
+export {
+  transformTypeAnnotations
+} from './type-annotations.js'
+
+export {
+  analyzePipelines,
+  buildGraph,
+  renderGraphText,
+  renderGraphDot
+} from './pipeline-ir.js'
+
+export {
+  transformEffectDeclarations,
+  transformHandleBlocks,
+  findEffectDeclarations,
+  findHandleBlocks
+} from './effect-parser.js'

package/src/pipeline-parser.js

@@ -112,9 +112,18 @@ function splitArguments(tokens) {
   return result
 }
 
+function isPropertyAccessName(name) {
+  return /^\.[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*$/.test(name)
+}
+
 function parseStage(source, tokens) {
   if (!tokens.length) throw new SyntaxError('Empty pipeline stage')
 
+  const bareName = text(source, tokens).trim()
+  if (isPropertyAccessName(bareName)) {
+    return { name: bareName, args: [], propertyCall: false }
+  }
+
   if (tokens.every((token, index) =>
     index % 2 === 0
       ? token.type === 'identifier'
@@ -145,6 +154,14 @@ function parseStage(source, tokens) {
 
   const name = text(source, tokens.slice(0, openIndex)).trim()
 
+  if (isPropertyAccessName(name)) {
+    const args = splitArguments(
+      tokens.slice(openIndex + 1, closeIndex)
+    ).map(argument => text(source, argument).trim())
+
+    return { name, args, propertyCall: true }
+  }
+
   if (!/^[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*$/.test(name)) {
     throw new SyntaxError(`Invalid pipeline function: ${name}`)
   }
@@ -310,6 +327,33 @@ 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('_')
+      if (placeholderIndex !== -1) {
+        args[placeholderIndex] = expression
+      }
+
+      if (stage.propertyCall || args.length > 0) {
+        expression = `${expression}${stage.name}(${args.join(', ')})`
+      } else {
+        expression = `${expression}${stage.name}`
+      }
+
+      if (options.profile) {
+        expression = `traceNode(${expression}, ${metaLiteral(pipelineId, stage.nodeId, stage.name)})`
+      }
+      continue
+    }
+
     if (stage.name === 'retry' && stage.standaloneRetry) {
       const meta = metaLiteral(pipelineId, stage.nodeId, 'retry')
       expression = `(await retry(async () => (${expression}), ${stage.args[0]}, ${meta})())`

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
+}