@codai/axiom-mcp 1.0.6 → 1.0.8

package/src/mcp-stdio.ts

@@ -1,374 +0,0 @@
-#!/usr/bin/env node
-
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-
-import { parseAxiomSource } from "@codai/axiom-core/dist/parser.js";
-import { validateIR } from "@codai/axiom-core/dist/validator.js";
-import { AxiomIR } from "@codai/axiom-core/dist/ir.js";
-import { generate } from "@codai/axiom-engine/dist/generate.js";
-import { check } from "@codai/axiom-engine/dist/check.js";
-import { reverseIR } from "@codai/axiom-engine/dist/reverse-ir.js";
-import { diff } from "@codai/axiom-engine/dist/axpatch.js";
-import { apply } from "@codai/axiom-engine/dist/apply.js";
-
-const server = new Server(
-  {
-    name: "axiom-mcp",
-    version: "1.0.2",
-  },
-  {
-    capabilities: {
-      tools: {},
-    },
-  }
-);
-
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return {
-    tools: [
-      {
-        name: "axiom_parse",
-        description: "Parse .axm source code to IR (Intermediate Representation)",
-        inputSchema: {
-          type: "object",
-          properties: {
-            source: {
-              type: "string",
-              description: "AXIOM source code (.axm)",
-            },
-          },
-          required: ["source"],
-        },
-      },
-      {
-        name: "axiom_validate",
-        description: "Validate IR semantics and constraints",
-        inputSchema: {
-          type: "object",
-          properties: {
-            ir: {
-              type: "object",
-              description: "AXIOM IR object",
-            },
-          },
-          required: ["ir"],
-        },
-      },
-      {
-        name: "axiom_generate",
-        description: "Generate artifacts and manifest from IR",
-        inputSchema: {
-          type: "object",
-          properties: {
-            ir: {
-              type: "object",
-              description: "AXIOM IR object",
-            },
-            profile: {
-              type: "string",
-              description: "Profile name (e.g., 'edge', 'budget')",
-            },
-          },
-          required: ["ir"],
-        },
-      },
-      {
-        name: "axiom_check",
-        description: "Run policy checks on manifest",
-        inputSchema: {
-          type: "object",
-          properties: {
-            manifest: {
-              type: "object",
-              description: "Generated manifest",
-            },
-            ir: {
-              type: "object",
-              description: "Optional IR for context",
-            },
-          },
-          required: ["manifest"],
-        },
-      },
-      {
-        name: "axiom_reverse",
-        description: "Reverse engineer IR from existing repository",
-        inputSchema: {
-          type: "object",
-          properties: {
-            repoPath: {
-              type: "string",
-              description: "Path to repository",
-            },
-            outDir: {
-              type: "string",
-              description: "Output directory to scan",
-              default: "out",
-            },
-          },
-        },
-      },
-      {
-        name: "axiom_diff",
-        description: "Generate diff patches between two IR versions",
-        inputSchema: {
-          type: "object",
-          properties: {
-            oldIr: {
-              type: "object",
-              description: "Old IR version",
-            },
-            newIr: {
-              type: "object",
-              description: "New IR version",
-            },
-          },
-          required: ["oldIr", "newIr"],
-        },
-      },
-      {
-        name: "axiom_apply",
-        description: "Apply manifest changes to filesystem",
-        inputSchema: {
-          type: "object",
-          properties: {
-            manifest: {
-              type: "object",
-              description: "Manifest to apply",
-            },
-            mode: {
-              type: "string",
-              enum: ["fs", "pr"],
-              description: "Application mode: 'fs' for direct filesystem, 'pr' for pull request",
-              default: "fs",
-            },
-            repoPath: {
-              type: "string",
-              description: "Repository path",
-            },
-            branchName: {
-              type: "string",
-              description: "Branch name for PR mode",
-            },
-            commitMessage: {
-              type: "string",
-              description: "Commit message for PR mode",
-            },
-          },
-          required: ["manifest"],
-        },
-      },
-    ],
-  };
-});
-
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  try {
-    const { name, arguments: args } = request.params;
-
-    switch (name) {
-      case "axiom_parse": {
-        const { source } = args as { source: string };
-        const { ir, diagnostics } = parseAxiomSource(source);
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({ ir, diagnostics }, null, 2),
-            },
-          ],
-        };
-      }
-
-      case "axiom_validate": {
-        const { ir } = args as { ir: any };
-        const parse = AxiomIR.safeParse(ir);
-        if (!parse.success) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify(
-                  { ok: false, diagnostics: parse.error.issues },
-                  null,
-                  2
-                ),
-              },
-            ],
-          };
-        }
-        const result = validateIR(parse.data);
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
-
-      case "axiom_generate": {
-        const { ir, profile } = args as { ir: any; profile?: string };
-        const parse = AxiomIR.safeParse(ir);
-        if (!parse.success) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({ error: parse.error.issues }, null, 2),
-              },
-            ],
-            isError: true,
-          };
-        }
-        const { artifacts, manifest } = await generate(
-          parse.data,
-          process.cwd(),
-          profile
-        );
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({ artifacts, manifest }, null, 2),
-            },
-          ],
-        };
-      }
-
-      case "axiom_check": {
-        const { manifest, ir } = args as { manifest: any; ir?: any };
-        const irParsed = ir ? AxiomIR.safeParse(ir) : null;
-        const result = await check(
-          manifest,
-          irParsed?.success ? irParsed.data : undefined,
-          process.cwd()
-        );
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
-
-      case "axiom_reverse": {
-        const { repoPath, outDir } = args as {
-          repoPath?: string;
-          outDir?: string;
-        };
-        const ir = await reverseIR({
-          repoPath: repoPath || process.cwd(),
-          outDir: outDir || "out",
-        });
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({ ir, diagnostics: [] }, null, 2),
-            },
-          ],
-        };
-      }
-
-      case "axiom_diff": {
-        const { oldIr, newIr } = args as { oldIr: any; newIr: any };
-        const oldParse = AxiomIR.safeParse(oldIr);
-        const newParse = AxiomIR.safeParse(newIr);
-        if (!oldParse.success || !newParse.success) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify(
-                  {
-                    error: "Invalid IR",
-                    oldIr: oldParse.success ? null : oldParse.error.issues,
-                    newIr: newParse.success ? null : newParse.error.issues,
-                  },
-                  null,
-                  2
-                ),
-              },
-            ],
-            isError: true,
-          };
-        }
-        const patch = diff(oldParse.data, newParse.data);
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({ patch }, null, 2),
-            },
-          ],
-        };
-      }
-
-      case "axiom_apply": {
-        const { manifest, mode, repoPath, branchName, commitMessage } = args as {
-          manifest: any;
-          mode?: string;
-          repoPath?: string;
-          branchName?: string;
-          commitMessage?: string;
-        };
-        const result = await apply({
-          manifest,
-          mode: (mode as "fs" | "pr") || "fs",
-          repoPath: repoPath || process.cwd(),
-          branchName,
-          commitMessage,
-        });
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
-
-      default:
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Unknown tool: ${name}`,
-            },
-          ],
-          isError: true,
-        };
-    }
-  } catch (error: any) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Error: ${error.message || String(error)}`,
-        },
-      ],
-      isError: true,
-    };
-  }
-});
-
-async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.error("AXIOM MCP Server running on stdio");
-}
-
-main().catch((error) => {
-  console.error("Fatal error:", error);
-  process.exit(1);
-});

package/src/postinstall.ts

@@ -1,40 +0,0 @@
-
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-// Skip postinstall if running via npx (to avoid mutex issues)
-if (process.env.npm_command === 'exec' || process.env.npm_execpath?.includes('npx')) {
-  console.log("⏭️  Skipping MCP config install (npx mode)");
-  process.exit(0);
-}
-
-const mcpDir = path.join(os.homedir(), ".mcp", "servers");
-fs.mkdirSync(mcpDir, { recursive: true });
-
-const mcpConfig = {
-  command: "npx",
-  args: ["@codai/axiom-mcp"],
-  env: {
-    AXIOM_MCP_PORT: "3411"
-  },
-  description: "AXIOM - AI-native intention language with deterministic manifest generation",
-  endpoints: [
-    "/parse - Parse .axm source to IR",
-    "/validate - Validate IR semantics",
-    "/generate - Generate artifacts from IR",
-    "/check - Run policy checks",
-    "/reverse - Reverse engineer IR from repo",
-    "/diff - Generate IR diff patches",
-    "/apply - Apply patches to filesystem"
-  ]
-};
-
-fs.writeFileSync(
-  path.join(mcpDir, "axiom.json"),
-  JSON.stringify(mcpConfig, null, 2)
-);
-
-console.log("✅ AXIOM MCP config installed at ~/.mcp/servers/axiom.json");
-console.log("   Start server: npx axiom-mcp");
-console.log("   Default port: 3411");

package/src/server.ts

@@ -1,85 +0,0 @@
-
-import http from "node:http";
-import { parseAxiomSource } from "@codai/axiom-core/dist/parser.js";
-import { validateIR } from "@codai/axiom-core/dist/validator.js";
-import { AxiomIR } from "@codai/axiom-core/dist/ir.js";
-import { generate } from "@codai/axiom-engine/dist/generate.js";
-import { check } from "@codai/axiom-engine/dist/check.js";
-import { reverseIR } from "@codai/axiom-engine/dist/reverse-ir.js";
-import { diff, applyPatch } from "@codai/axiom-engine/dist/axpatch.js";
-import { apply } from "@codai/axiom-engine/dist/apply.js";
-
-const PORT = Number(process.env.AXIOM_MCP_PORT || 3411);
-
-function send(res: http.ServerResponse, code: number, obj: any) {
-  const body = JSON.stringify(obj, null, 2);
-  res.writeHead(code, { "content-type": "application/json" });
-  res.end(body);
-}
-
-const server = http.createServer(async (req, res) => {
-  try {
-    const chunks: Buffer[] = [];
-    req.on("data", (c) => chunks.push(c));
-    req.on("end", async () => {
-      const input = chunks.length ? JSON.parse(Buffer.concat(chunks).toString("utf-8")) : {};
-      if (req.method === "POST" && req.url === "/parse") {
-        const { source } = input;
-        const { ir, diagnostics } = parseAxiomSource(String(source ?? ""));
-        return send(res, 200, { ir, diagnostics });
-      }
-      if (req.method === "POST" && req.url === "/validate") {
-        const parse = AxiomIR.safeParse(input.ir);
-        if (!parse.success) return send(res, 400, { ok: false, diagnostics: parse.error.issues });
-        const result = validateIR(parse.data);
-        return send(res, 200, result);
-      }
-      if (req.method === "POST" && req.url === "/generate") {
-        const parse = AxiomIR.safeParse(input.ir);
-        if (!parse.success) return send(res, 400, { error: parse.error.issues });
-        const { artifacts, manifest } = await generate(parse.data, process.cwd(), input.profile);
-        return send(res, 200, { artifacts, manifest });
-      }
-      if (req.method === "POST" && req.url === "/check") {
-        const parse = input.ir ? AxiomIR.safeParse(input.ir) : null;
-        const ir = parse?.success ? parse.data : undefined;
-        const result = await check(input.manifest, ir, input.outRoot || process.cwd());
-        return send(res, 200, result);
-      }
-      if (req.method === "POST" && req.url === "/reverse") {
-        const ir = await reverseIR({
-          repoPath: input.repoPath || process.cwd(),
-          outDir: input.outDir || "out",
-        });
-        return send(res, 200, { ir, diagnostics: [] });
-      }
-      if (req.method === "POST" && req.url === "/diff") {
-        const oldParse = AxiomIR.safeParse(input.oldIr);
-        const newParse = AxiomIR.safeParse(input.newIr);
-        if (!oldParse.success) return send(res, 400, { error: "Invalid oldIr", details: oldParse.error.issues });
-        if (!newParse.success) return send(res, 400, { error: "Invalid newIr", details: newParse.error.issues });
-        const patch = diff(oldParse.data, newParse.data);
-        return send(res, 200, { patch });
-      }
-      if (req.method === "POST" && req.url === "/apply") {
-        if (!input.manifest) return send(res, 400, { error: "Missing manifest" });
-        const mode = input.mode || "fs";
-        const result = await apply({
-          manifest: input.manifest,
-          mode: mode as "fs" | "pr",
-          repoPath: input.repoPath || process.cwd(),
-          branchName: input.branchName,
-          commitMessage: input.commitMessage,
-        });
-        return send(res, 200, result);
-      }
-      send(res, 404, { error: "Not found" });
-    });
-  } catch (e: any) {
-    send(res, 500, { error: String(e?.message || e) });
-  }
-});
-
-server.listen(PORT, () => {
-  console.log(`[axiom-mcp] listening on http://localhost:${PORT}`);
-});

package/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "include": [
-    "src"
-  ],
-  "compilerOptions": {
-    "outDir": "dist",
-    "declaration": false
-  }
-}