@codai/axiom-mcp 1.0.23 → 2.0.0

package/dist/mcp-stdio.js

@@ -1,368 +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";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-// Read version from package.json
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
-const MCP_VERSION = packageJson.version;
-// Helper to add version metadata to all responses
-function addVersionMetadata(result) {
-    return {
-        ...result,
-        _axiom_mcp_version: MCP_VERSION,
-        _axiom_engine_version: packageJson.dependencies?.["@codai/axiom-engine"] || "unknown"
-    };
-}
-const server = new Server({
-    name: "axiom-mcp",
-    version: MCP_VERSION, // Use dynamic version from package.json
-}, {
-    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;
-                const { ir, diagnostics } = parseAxiomSource(source);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(addVersionMetadata({ ir, diagnostics }), null, 2),
-                        },
-                    ],
-                };
-            }
-            case "axiom_validate": {
-                const { ir } = args;
-                const parse = AxiomIR.safeParse(ir);
-                if (!parse.success) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify(addVersionMetadata({ ok: false, diagnostics: parse.error.issues }), null, 2),
-                            },
-                        ],
-                    };
-                }
-                const result = validateIR(parse.data);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(addVersionMetadata(result), null, 2),
-                        },
-                    ],
-                };
-            }
-            case "axiom_generate": {
-                const { ir, profile } = args;
-                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);
-                // DEBUG: Log artifact paths to stderr for debugging
-                console.error("[MCP DEBUG] artifacts from generate():", JSON.stringify(artifacts.map(a => a.path)));
-                console.error("[MCP DEBUG] manifest.artifacts:", JSON.stringify(manifest.artifacts.map(a => a.path)));
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(addVersionMetadata({ artifacts, manifest }), null, 2),
-                        },
-                    ],
-                };
-            }
-            case "axiom_check": {
-                const { manifest, ir } = args;
-                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(addVersionMetadata(result), null, 2),
-                        },
-                    ],
-                };
-            }
-            case "axiom_reverse": {
-                const { repoPath, outDir } = args;
-                const ir = await reverseIR({
-                    repoPath: repoPath || process.cwd(),
-                    outDir: outDir || "out",
-                });
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(addVersionMetadata({ ir, diagnostics: [] }), null, 2),
-                        },
-                    ],
-                };
-            }
-            case "axiom_diff": {
-                const { oldIr, newIr } = args;
-                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 = await diff(oldParse.data, newParse.data);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(addVersionMetadata({ patch }), null, 2),
-                        },
-                    ],
-                };
-            }
-            case "axiom_apply": {
-                const { manifest, mode, repoPath, branchName, commitMessage } = args;
-                const result = await apply({
-                    manifest,
-                    mode: mode || "fs",
-                    repoPath: repoPath || process.cwd(),
-                    branchName,
-                    commitMessage,
-                });
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(addVersionMetadata(result), null, 2),
-                        },
-                    ],
-                };
-            }
-            default:
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Unknown tool: ${name}`,
-                        },
-                    ],
-                    isError: true,
-                };
-        }
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error: ${error.message || String(error)}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-});
-async function main() {
-    console.error("[AXIOM MCP] Starting server initialization...");
-    console.error(`[AXIOM MCP] Process: Node ${process.version}, PID ${process.pid}`);
-    console.error(`[AXIOM MCP] Working directory: ${process.cwd()}`);
-    // CRITICAL: Give VS Code time to attach stdio pipes
-    // Without this delay, VS Code may miss early stderr output
-    await new Promise(resolve => setTimeout(resolve, 100));
-    console.error("[AXIOM MCP] Stdio pipes ready, proceeding with initialization...");
-    try {
-        const transport = new StdioServerTransport();
-        console.error("[AXIOM MCP] Transport created, connecting...");
-        await server.connect(transport);
-        console.error("[AXIOM MCP] Server connected successfully");
-        console.error(`[AXIOM MCP] Version ${MCP_VERSION}, Engine ${packageJson.dependencies?.["@codai/axiom-engine"]}`);
-        console.error("[AXIOM MCP] Ready to receive requests via stdio");
-        console.error("[AXIOM MCP] Waiting for initialize request from client...");
-        // Keep process alive - MCP SDK handles stdin/stdout
-        // No explicit exit - let MCP SDK manage lifecycle
-    }
-    catch (error) {
-        console.error("[AXIOM MCP] FATAL - Initialization failed:", error.message || String(error));
-        console.error("[AXIOM MCP] Stack trace:", error.stack);
-        process.exit(1);
-    }
-}
-main().catch((error) => {
-    console.error("[AXIOM MCP] FATAL - Uncaught error in main():", error);
-    process.exit(1);
-});

package/dist/postinstall.js

@@ -1,31 +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/dist/server.js

@@ -1,115 +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 } 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, code, obj) {
-    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 = [];
-        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";
-                try {
-                    const result = await apply({
-                        manifest: input.manifest,
-                        mode: mode,
-                        repoPath: input.repoPath, // Optional - va folosi process.cwd() dacă lipsește
-                        branchName: input.branchName,
-                        commitMessage: input.commitMessage,
-                    });
-                    // Check for ERR_REPOPATH_RELATIVE_UNSAFE and provide friendly guidance
-                    if (!result.success && result.error?.includes("ERR_REPOPATH_RELATIVE_UNSAFE")) {
-                        return send(res, 200, {
-                            ...result,
-                            errorCode: "ERR_REPOPATH_RELATIVE_UNSAFE",
-                            hint: "Furnizează repoPath absolut sau setează AXIOM_REPO_ROOT la rădăcina repo-ului."
-                        });
-                    }
-                    return send(res, 200, result);
-                }
-                catch (err) {
-                    // Catch any other apply errors
-                    return send(res, 500, {
-                        success: false,
-                        mode,
-                        filesWritten: [],
-                        error: err.message
-                    });
-                }
-            }
-            if (req.method === "POST" && req.url === "/fs-probe-write") {
-                // Independent cross-drive write testing
-                const { fs_probe_write } = await import("./tools/fs-probe-write.js");
-                const result = await fs_probe_write({
-                    destAbs: input.destAbs,
-                    contentUtf8: input.contentUtf8,
-                    contentBase64: input.contentBase64
-                });
-                return send(res, 200, result);
-            }
-            send(res, 404, { error: "Not found" });
-        });
-    }
-    catch (e) {
-        send(res, 500, { error: String(e?.message || e) });
-    }
-});
-server.listen(PORT, () => {
-    console.log(`[axiom-mcp] listening on http://localhost:${PORT}`);
-});

package/dist/tools/fs-probe-write.js

@@ -1,81 +0,0 @@
-import fs from "node:fs";
-import crypto from "node:crypto";
-import path from "node:path";
-/**
- * fs_probe_write - Independent cross-drive write testing tool
- *
- * Tests filesystem write capabilities independently of AXIOM manifest logic.
- * Useful for validating cross-drive writes and arbitrary path support.
- */
-export async function fs_probe_write(args) {
-    const { destAbs, contentUtf8, contentBase64 } = args;
-    try {
-        console.error(`[fs-probe-write] Testing write to: ${destAbs}`);
-        // Determine content source
-        let content;
-        if (contentBase64) {
-            console.error(`[fs-probe-write]   Source: contentBase64 (${contentBase64.length} chars)`);
-            content = Buffer.from(contentBase64, "base64");
-        }
-        else if (contentUtf8) {
-            console.error(`[fs-probe-write]   Source: contentUtf8 (${contentUtf8.length} chars)`);
-            content = Buffer.from(contentUtf8, "utf8");
-        }
-        else {
-            throw new Error("ERR_NO_CONTENT: Must provide either contentUtf8 or contentBase64");
-        }
-        console.error(`[fs-probe-write]   Buffer size: ${content.length} bytes`);
-        // Create parent directory
-        const dir = path.dirname(destAbs);
-        console.error(`[fs-probe-write]   mkdir: ${dir}`);
-        await fs.promises.mkdir(dir, { recursive: true });
-        // Write file
-        console.error(`[fs-probe-write]   Writing...`);
-        await fs.promises.writeFile(destAbs, content);
-        // Read back and verify
-        console.error(`[fs-probe-write]   Reading back...`);
-        const readBack = fs.readFileSync(destAbs);
-        const hash = crypto.createHash("sha256").update(readBack).digest("hex");
-        const size = readBack.length;
-        console.error(`[fs-probe-write]   ✓ Read-back size: ${size} bytes`);
-        console.error(`[fs-probe-write]   ✓ Read-back SHA256: ${hash}`);
-        return {
-            success: true,
-            absPath: destAbs,
-            hash,
-            size
-        };
-    }
-    catch (error) {
-        console.error(`[fs-probe-write]   ✗ ERROR: ${error.message}`);
-        return {
-            success: false,
-            absPath: destAbs,
-            hash: "",
-            size: 0,
-            error: error.message
-        };
-    }
-}
-export const fs_probe_write_def = {
-    name: "fs_probe_write",
-    description: "Independent cross-drive write testing tool for validating filesystem capabilities",
-    inputSchema: {
-        type: "object",
-        properties: {
-            destAbs: {
-                type: "string",
-                description: "Absolute destination path (can be on any drive)"
-            },
-            contentUtf8: {
-                type: "string",
-                description: "Optional UTF-8 content to write"
-            },
-            contentBase64: {
-                type: "string",
-                description: "Optional Base64-encoded content to write"
-            }
-        },
-        required: ["destAbs"]
-    }
-};

package/scripts/prepublish.js

@@ -1,52 +0,0 @@
-#!/usr/bin/env node
-/**
- * AXIOM MCP Prepublish Script
- * 
- * Bundles all internal workspace dependencies into axiom-mcp dist/
- * so that the published package is self-contained and doesn't require workspace:* protocol.
- */
-
-import { copyFileSync, mkdirSync, readdirSync, statSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-const INTERNAL_PACKAGES = [
-    'axiom-core',
-    'axiom-engine',
-    'axiom-policies',
-    'axiom-emitter-apiservice',
-    'axiom-emitter-batchjob',
-    'axiom-emitter-docker',
-    'axiom-emitter-webapp'
-];
-
-function copyDir(src, dest) {
-    mkdirSync(dest, { recursive: true });
-
-    for (const file of readdirSync(src)) {
-        const srcPath = join(src, file);
-        const destPath = join(dest, file);
-
-        if (statSync(srcPath).isDirectory()) {
-            copyDir(srcPath, destPath);
-        } else if (file.endsWith('.js') || file.endsWith('.d.ts')) {
-            copyFileSync(srcPath, destPath);
-            console.log(`  ✓ ${file}`);
-        }
-    }
-}
-
-console.log('📦 Bundling internal dependencies...\n');
-
-for (const pkg of INTERNAL_PACKAGES) {
-    const srcDir = join(__dirname, '..', '..', pkg, 'dist');
-    const destDir = join(__dirname, '..', 'dist', 'vendor', pkg);
-
-    console.log(`Bundling @codai/${pkg}:`);
-    copyDir(srcDir, destDir);
-    console.log('');
-}
-
-console.log('✅ Bundle complete! Package is self-contained.\n');