@mrfentmen/openedge-abl-mcp 1.0.0 → 1.0.1

package/dist/format.d.ts

@@ -0,0 +1,2 @@
+import type { FormatModule } from "./types.js";
+export declare const format: FormatModule;

package/dist/format.js

@@ -0,0 +1,105 @@
+function stripComments(text) {
+    return text.replace(/\/\*[\s\S]*?\*\//g, "");
+}
+function parse(text) {
+    const issues = [];
+    const records = [];
+    const source = stripComments(text);
+    const variables = new Set();
+    const tables = new Set();
+    let openers = 0;
+    let closers = 0;
+    source.split(/\r?\n/).forEach((raw, index) => {
+        const number = index + 1;
+        const line = raw.replace(/\/\/.*$/, "").replace(/^\s*\*.*$/, "").trim();
+        if (line.length === 0)
+            return;
+        const variable = /^DEFINE\s+(?:NEW\s+)?(?:SHARED\s+)?(?:GLOBAL\s+)?VARIABLE\s+([\w-]+)(?:\s+AS\s+([\w.-]+))?/i.exec(line);
+        if (variable) {
+            const name = variable[1];
+            if (!variable[2]) {
+                issues.push({ code: "variable-without-type", severity: "error", message: `DEFINE VARIABLE ${name} has no AS type`, line: number });
+            }
+            if (variables.has(name)) {
+                issues.push({ code: "duplicate-variable", severity: "error", message: `Variable ${name} is defined twice`, line: number });
+            }
+            variables.add(name);
+            records.push({ id: `variable:${name}`, kind: "variable", fields: { name, type: variable[2] ?? "", line: number } });
+            return;
+        }
+        const procedure = /^(?:PROCEDURE|FUNCTION|METHOD)\s+([\w-]+)\s*:/i.exec(line);
+        if (procedure) {
+            openers += 1;
+            records.push({ id: `procedure:${procedure[1]}`, kind: "procedure", fields: { name: procedure[1], line: number } });
+            return;
+        }
+        if (/^END\s+PROCEDURE\.?\s*$/i.test(line) || /^END\s+FUNCTION\.?\s*$/i.test(line) || /^END\s+METHOD\.?\s*$/i.test(line)) {
+            closers += 1;
+            return;
+        }
+        if (/^END\.?\s*$/i.test(line)) {
+            closers += 1;
+            return;
+        }
+        const block = /^(FOR\s+EACH|FOR\s+FIRST|REPEAT|DO|CASE)\b/i.exec(line);
+        if (block) {
+            openers += 1;
+            records.push({ id: `block:${number}`, kind: "block", fields: { kind: block[1].toUpperCase(), line: number } });
+            return;
+        }
+        const table = /^(?:FOR\s+EACH|FOR\s+FIRST)\s+([\w.]+)/i.exec(line);
+        if (table) {
+            tables.add(table[1]);
+        }
+        if (!line.endsWith(".") && !line.endsWith(":") && !line.endsWith("{")) {
+            issues.push({ code: "missing-period", severity: "warning", message: `Statement does not end with a period: ${line.slice(0, 40)}`, line: number });
+        }
+        records.push({ id: `stmt:${number}`, kind: "statement", fields: { text: line.slice(0, 120), line: number } });
+    });
+    if (openers !== closers) {
+        issues.push({ code: "unbalanced-blocks", severity: "error", message: `${openers} block opener(s) but ${closers} END statement(s)` });
+    }
+    return {
+        format: "OpenEdge ABL",
+        records,
+        meta: {
+            variables: variables.size,
+            procedures: records.filter((record) => record.kind === "procedure").length,
+            blocks: records.filter((record) => record.kind === "block").length,
+            statements: records.filter((record) => record.kind === "statement").length,
+        },
+        issues,
+    };
+}
+const reference = [
+    "OpenEdge ABL source",
+    "",
+    "DEFINE VARIABLE cName AS CHARACTER NO-UNDO.",
+    "",
+    "PROCEDURE LoadData:",
+    "    FOR EACH Customer NO-LOCK:",
+    "        DISPLAY Customer.Name.",
+    "    END.",
+    "END PROCEDURE.",
+    "",
+    "Statements end with a period.",
+    "PROCEDURE, FUNCTION, FOR EACH and DO open a block closed by END.",
+    "/* */ and // are comments.",
+].join("\n");
+export const format = {
+    slug: "openedge-abl",
+    displayName: "OpenEdge ABL",
+    extensions: [".p", ".cls", ".i"],
+    description: "Parse OpenEdge ABL source, validate variables, blocks and periods.",
+    reference,
+    parse,
+    sample: () => [
+        "DEFINE VARIABLE cName AS CHARACTER NO-UNDO.",
+        "",
+        "PROCEDURE LoadData:",
+        "    FOR EACH Customer NO-LOCK:",
+        "        DISPLAY Customer.Name.",
+        "    END.",
+        "END PROCEDURE.",
+    ].join("\n") + "\n",
+};

package/dist/index.js

@@ -5,9 +5,9 @@ async function main() {
     const server = createServer();
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error(`${process.env.npm_package_name ?? "language-mcp"} running on stdio`);
 }
 main().catch((error) => {
-    console.error("Fatal error:", error);
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}\n`);
     process.exit(1);
 });

package/dist/run.d.ts

@@ -1,28 +1,17 @@
 export declare class ToolError extends Error {
+    constructor(message: string);
 }
-export interface RunResult {
-    stdout: string;
-    stderr: string;
-    code: number;
-}
-export interface RunOptions {
-    input?: string;
-    timeoutMs?: number;
-    cwd?: string;
-}
-/** Run a command without a shell and capture both streams. */
-export declare function run(command: string, args: string[], options?: RunOptions): Promise<RunResult>;
+export declare function errorMessage(error: unknown): string;
 export declare function text(value: string): {
     content: {
         type: "text";
         text: string;
     }[];
 };
-export declare function fail(value: string): {
+export declare function fail(message: string): {
+    isError: boolean;
     content: {
         type: "text";
         text: string;
     }[];
-    isError: boolean;
 };
-export declare function errorMessage(error: unknown): string;

package/dist/run.js

@@ -1,56 +1,15 @@
-import { spawn } from "node:child_process";
 export class ToolError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ToolError";
+    }
 }
-/** Run a command without a shell and capture both streams. */
-export function run(command, args, options = {}) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(command, args, {
-            cwd: options.cwd,
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        let stdout = "";
-        let stderr = "";
-        let settled = false;
-        const timeoutMs = options.timeoutMs ?? 30_000;
-        const timer = setTimeout(() => {
-            if (settled)
-                return;
-            settled = true;
-            child.kill("SIGKILL");
-            reject(new ToolError(`${command} timed out after ${timeoutMs}ms`));
-        }, timeoutMs);
-        child.on("error", (error) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            reject(new ToolError(`${command} could not start: ${error.message}`));
-        });
-        child.stdout.on("data", (chunk) => {
-            stdout += chunk.toString();
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr += chunk.toString();
-        });
-        child.stdin.on("error", () => { });
-        child.on("close", (code) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            resolve({ stdout, stderr, code: code ?? 0 });
-        });
-        if (options.input !== undefined)
-            child.stdin.write(options.input);
-        child.stdin.end();
-    });
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
 }
 export function text(value) {
     return { content: [{ type: "text", text: value }] };
 }
-export function fail(value) {
-    return { content: [{ type: "text", text: value }], isError: true };
-}
-export function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
+export function fail(message) {
+    return { isError: true, content: [{ type: "text", text: message }] };
 }

package/dist/server.d.ts

@@ -1,2 +1,3 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const VERSION = "1.0.0";
 export declare function createServer(): McpServer;

package/dist/server.js

@@ -1,8 +1,9 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { config } from "./config.js";
-import { registerLanguageTools } from "./core.js";
+import { format } from "./format.js";
+import { registerFormatTools } from "./core.js";
+export const VERSION = "1.0.0";
 export function createServer() {
-    const server = new McpServer({ name: `${config.slug}-mcp`, version: config.version });
-    registerLanguageTools(server, config);
+    const server = new McpServer({ name: `${format.slug}-mcp`, version: VERSION });
+    registerFormatTools(server, format);
     return server;
 }

package/dist/types.d.ts

@@ -1,47 +1,31 @@
-export interface CommandSpec {
-    command: string;
-    args: string[];
-    timeoutMs?: number;
+export type Severity = "error" | "warning";
+export interface Issue {
+    code: string;
+    severity: Severity;
+    message: string;
+    line?: number;
 }
-export interface SymbolRule {
+export interface ParsedRecord {
+    id: string;
     kind: string;
-    pattern: string;
-    flags?: string;
+    fields: Record<string, string | number | boolean | null>;
 }
-export interface ImportRule {
-    kind: string;
-    pattern: string;
-    flags?: string;
-}
-export interface Snippet {
-    description: string;
-    body: string;
+export interface Parsed {
+    format: string;
+    records: ParsedRecord[];
+    meta: Record<string, string | number | boolean | null>;
+    issues: Issue[];
 }
-export interface ScaffoldFile {
-    path: string;
-    content: string;
-}
-export interface LanguageConfig {
+export interface FormatModule {
     slug: string;
     displayName: string;
-    version: string;
     extensions: string[];
-    markers: string[];
-    comment: string;
-    blockComment?: {
-        start: string;
-        end: string;
-    };
-    stringQuotes?: string[];
-    allowTabs?: boolean;
-    buildDir?: string;
-    symbols: SymbolRule[];
-    imports: ImportRule[];
-    runner?: CommandSpec[];
-    syntax?: CommandSpec;
-    build?: CommandSpec[];
-    test?: CommandSpec[];
-    scaffold: ScaffoldFile[];
-    snippets: Record<string, Snippet>;
+    description: string;
     reference: string;
+    parse(text: string): Parsed;
+    sample(): string;
+    regressions?: Array<{
+        doc: string;
+        expectError: string;
+    }>;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mrfentmen/openedge-abl-mcp",
-  "version": "1.0.0",
-  "description": "OpenEdge ABL MCP: 20 real tools to read, check, lint, scaffold, build and run OpenEdge ABL code.",
+  "version": "1.0.1",
+  "description": "OpenEdge MCP: parse ABL source, validate variables, blocks and statements.",
   "type": "module",
   "mcpName": "io.github.mrfentmen/openedge-abl-mcp",
   "repository": {
@@ -25,9 +25,11 @@
   "keywords": [
     "mcp",
     "model-context-protocol",
-    "openedge-abl",
-    "language",
-    "toolchain"
+    "openedge",
+    "progress",
+    "abl",
+    "erp",
+    "4gl"
   ],
   "license": "MIT",
   "dependencies": {

package/server.json

@@ -1,17 +1,17 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.mrfentmen/openedge-abl-mcp",
-  "description": "OpenEdge ABL MCP: 20 real tools to read, check, lint, scaffold, build and run OpenEdge ABL code.",
+  "description": "OpenEdge MCP: parse ABL source, validate variables, blocks and statements.",
   "repository": {
-    "url": "https://github.com/mrfentmen/awesome-servers/tree/main/mcp/servers/openedge-abl-mcp",
+    "url": "https://github.com/mrfentmen/awesome-servers",
     "source": "github"
   },
-  "version": "1.0.0",
+  "version": "1.0.1",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@mrfentmen/openedge-abl-mcp",
-      "version": "1.0.0",
+      "version": "1.0.1",
       "transport": {
         "type": "stdio"
       }

package/dist/config.d.ts

@@ -1,2 +0,0 @@
-import type { LanguageConfig } from "./types.js";
-export declare const config: LanguageConfig;

package/dist/config.js

@@ -1,47 +0,0 @@
-export const config = {
-    "slug": "openedge-abl",
-    "displayName": "OpenEdge ABL",
-    "version": "1.0.0",
-    "extensions": [
-        ".p",
-        ".cls",
-        ".w"
-    ],
-    "markers": [],
-    "comment": "/*",
-    "stringQuotes": [
-        "\""
-    ],
-    "symbols": [
-        {
-            "kind": "function",
-            "pattern": "\\b(?:function|def|fn|fun|func|proc|procedure|sub|method|class|struct|enum|module|namespace|type|interface|trait|record|object)\\s+([A-Za-z_]\\w*)"
-        },
-        {
-            "kind": "function",
-            "pattern": "^\\s*(?:[A-Za-z_][\\w<>\\[\\]]*\\s+)+([A-Za-z_]\\w*)\\s*\\("
-        },
-        {
-            "kind": "value",
-            "pattern": "^([A-Za-z_]\\w*)\\s*(?::=|=|:)"
-        }
-    ],
-    "imports": [],
-    "scaffold": [
-        {
-            "path": "src/demo.p",
-            "content": "DEFINE VARIABLE x AS INTEGER NO-UNDO.\n"
-        },
-        {
-            "path": "tests/run.p",
-            "content": "DEFINE VARIABLE x AS INTEGER NO-UNDO.\n"
-        }
-    ],
-    "snippets": {
-        "function": {
-            "description": "function",
-            "body": "DEFINE VARIABLE x AS INTEGER NO-UNDO.\n"
-        }
-    },
-    "reference": "OpenEdge ABL syntax reference\n- Example: DEFINE VARIABLE x AS INTEGER NO-UNDO.\n- Comment: /*\n- No CLI runner configured"
-};