@creately/rdm-mcp 0.2.0 → 0.3.0

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@creately/rdm-mcp",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "MCP server for RDM — parse, validate, render, and manipulate diagrams via AI agents",
   "type": "module",
   "main": "src/index.ts",
   "bin": {
-    "rdm-mcp": "src/index.ts"
+    "rdm-mcp": "src/cli.js"
   },
   "scripts": {
     "start": "bun run src/index.ts",
@@ -13,10 +13,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
-    "@creately/rdm-core": ">=0.3.0"
-  },
-  "publishConfig": {
-    "access": "public"
+    "@creately/rdm-core": ">=0.4.0"
   },
   "license": "MIT",
   "repository": {

package/src/cli.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+/**
+ * rdm-mcp CLI wrapper — delegates to bun for TypeScript execution.
+ */
+
+import { execFileSync } from 'node:child_process';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const impl = join(__dirname, 'index.ts');
+
+try {
+  execFileSync('bun', ['run', impl, ...process.argv.slice(2)], {
+    stdio: 'inherit',
+    env: process.env,
+  });
+} catch (e) {
+  if (e.status) process.exit(e.status);
+  console.error('rdm-mcp requires bun. Install it: curl -fsSL https://bun.sh/install | bash');
+  process.exit(1);
+}

package/src/index.ts

@@ -62,7 +62,7 @@ const TOOL_EXECUTORS: Record<string, (args: Record<string, unknown>) => Promise<
 
 async function main() {
   const server = new Server(
-    { name: 'rdm-mcp', version: '0.2.0' },
+    { name: 'rdm-mcp', version: '0.3.0' },
     { capabilities: { tools: {} } }
   );
 

package/src/tools/rdm_schema.ts

@@ -104,20 +104,22 @@ const SCHEMAS: Record<string, DomainSchema> = {
   },
   flowchart: {
     domain: 'flowchart',
-    description: 'Simple flowchart diagrams with steps, decisions, and flows.',
+    description: 'Simple flowcharts. NOTE: flowcharts use the same syntax as process diagrams. Use frontmatter type: process and block keyword: process. There is NO flowchart block keyword.',
     nodeTypes: {
-      step: {
+      node: {
         fields: [
-          { name: 'type', type: 'enum', values: ['process', 'decision', 'start', 'end', 'subprocess', 'document', 'database'] },
+          { name: 'type', type: 'enum', values: ['task', 'gateway', 'start-event', 'end-event'], required: true, description: 'Node role in the flow' },
+          { name: 'label', type: 'string', description: 'Display label' },
+          { name: 'assignee', type: 'string', description: 'Role or person responsible' },
         ],
       },
     },
     relationships: [
-      { syntax: 'flow source -> target', description: 'Sequential flow' },
-      { syntax: 'flow source -> target { label: "Yes" }', description: 'Labeled flow' },
+      { syntax: 'source -> target', description: 'Sequential flow' },
+      { syntax: 'source -> target { label: "Yes" }', description: 'Labeled flow (for gateways)' },
     ],
-    structure: 'flowchart Name {\n  start begin "Start"\n  step id "Label" { type: process }\n  end done "End"\n  flow begin -> id\n  flow id -> done\n}',
-    example: '---\ntype: flowchart\ntitle: "Approval"\n---\n\nflowchart Approval {\n  start begin "Start"\n  step submit "Submit Request" { type: process }\n  step check "Approved?" { type: decision }\n  end done "Done"\n\n  flow begin -> submit\n  flow submit -> check\n  flow check -> done { label: "Yes" }\n}',
+    structure: 'process Name {\n  begin { type: "start-event", label: "Start" }\n  step1 { type: "task", label: "Do Something" }\n  done { type: "end-event", label: "End" }\n  begin -> step1\n  step1 -> done\n}',
+    example: '---\ntype: process\ntitle: "Simple Flow"\n---\n\nprocess SimpleFlow {\n  begin { type: "start-event", label: "Start" }\n  submit { type: "task", label: "Submit", assignee: "User" }\n  check { type: "exclusive-gateway", label: "OK?" }\n  done { type: "end-event", label: "End" }\n\n  begin -> submit\n  submit -> check\n  check -> done { label: "Yes" }\n}',
   },
   table: {
     domain: 'table',

package/src/tools/rdm_validate.ts

@@ -1,7 +1,10 @@
 /**
- * rdm_validate — Validate RDM text and return diagnostics
+ * rdm_validate — Validate RDM text with auto-fix.
+ *
+ * Auto-corrects common agent mistakes (wrong block keywords, invalid syntax)
+ * before parsing. Returns both the validation result and the corrected text.
  */
-import { readFileSync, existsSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
 import { resolve } from 'path';
 import { RdmService } from '@creately/rdm-core';
 
@@ -10,8 +13,9 @@ const rdmService = new RdmService();
 export const rdmValidateTool = {
   name: 'rdm_validate',
   description:
-    'Validate an .rdm file or RDM text. Returns parse errors and warnings ' +
-    'with line numbers. Use this to check correctness before applying changes.',
+    'Validate an .rdm file or RDM text. Auto-fixes common mistakes (wrong block keywords, ' +
+    'invalid syntax) and returns the corrected text along with any remaining errors. ' +
+    'If autoFix is true (default), writes the fixed text back to the file.',
   inputSchema: {
     type: 'object' as const,
     properties: {
@@ -23,17 +27,22 @@ export const rdmValidateTool = {
         type: 'string',
         description: 'RDM text to validate directly (alternative to path)',
       },
+      autoFix: {
+        type: 'boolean',
+        description: 'If true (default), auto-fix mistakes and write corrected file back. Set to false for dry-run.',
+      },
     },
   },
 };
 
 export async function executeRdmValidate(args: Record<string, unknown>): Promise<unknown> {
   let rdmText: string;
+  const filePath = args.path ? resolve(String(args.path)) : null;
+  const autoFix = args.autoFix !== false; // default true
 
   if (args.rdmText) {
     rdmText = String(args.rdmText);
-  } else if (args.path) {
-    const filePath = resolve(String(args.path));
+  } else if (filePath) {
     if (!existsSync(filePath)) {
       return { error: `File not found: ${filePath}` };
     }
@@ -42,10 +51,24 @@ export async function executeRdmValidate(args: Record<string, unknown>): Promise
     return { error: 'Either path or rdmText must be provided' };
   }
 
-  const result = rdmService.parseAndValidate(rdmText);
+  const result = rdmService.parseAndFix(rdmText);
+
+  // Auto-fix: write corrected text back to file
+  if (autoFix && result.wasFixed && filePath) {
+    writeFileSync(filePath, result.fixedText, 'utf-8');
+  }
 
   return {
     valid: result.success,
+    wasFixed: result.wasFixed,
+    fixedText: result.wasFixed ? result.fixedText : undefined,
+    fixes: result.fixes.map((f) => ({
+      line: f.line,
+      rule: f.rule,
+      description: f.description,
+      before: f.before,
+      after: f.after,
+    })),
     errors: result.errors.map((e) => ({
       code: e.code,
       message: e.message,

package/src/tools/rdm_write.ts

@@ -68,32 +68,39 @@ export async function executeRdmWrite(args: Record<string, unknown>): Promise<un
     rdmText = existing.slice(0, lastBrace) + '\n  ' + fragment!.trim() + '\n' + existing.slice(lastBrace);
   }
 
-  // Validate before writing
-  const validation = rdmService.parseAndValidate(rdmText);
-  if (!validation.success) {
+  // Auto-lint and validate before writing
+  const result = rdmService.parseAndFix(rdmText);
+  if (!result.success) {
     return {
       error: 'Validation failed — not written',
-      errors: validation.errors,
+      errors: result.errors,
+      fixes: result.fixes,
+      fixedText: result.wasFixed ? result.fixedText : undefined,
     };
   }
 
+  // Use the fixed text
+  const finalText = result.fixedText;
+
   // Ensure directory exists
   const dir = dirname(filePath);
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true });
   }
 
-  writeFileSync(filePath, rdmText, 'utf-8');
+  writeFileSync(filePath, finalText, 'utf-8');
 
-  const nodeCount = countType(validation.document!.structure.declarations, 'node');
-  const edgeCount = countType(validation.document!.structure.declarations, 'edge');
+  const nodeCount = countType(result.document!.structure.declarations, 'node');
+  const edgeCount = countType(result.document!.structure.declarations, 'edge');
 
   return {
     path: filePath,
     written: true,
+    wasFixed: result.wasFixed,
+    fixes: result.fixes,
     nodeCount,
     edgeCount,
-    sizeBytes: Buffer.byteLength(rdmText, 'utf-8'),
+    sizeBytes: Buffer.byteLength(finalText, 'utf-8'),
   };
 }