@arrieta1/mcp-server 2.0.0

package/README.md

@@ -0,0 +1,69 @@
+# Project Graphite MCP Server
+
+Packaged MCP server for transformations tooling.
+
+## Install and run
+
+Use the package without installing globally:
+
+```bash
+npx -y @dayanaarrieta-graphite/mcp-server
+```
+
+For npmjs publishing/install, authenticate first:
+
+```bash
+npm login
+```
+
+The server starts on `http://localhost:3333` by default.
+
+## Configuration
+
+Environment variables:
+
+- `MCP_PORT` (default: `3333`)
+- `MCP_HOST` (default: `localhost`)
+
+Example:
+
+```bash
+MCP_HOST=127.0.0.1 MCP_PORT=3333 npx -y @dayanaarrieta-graphite/mcp-server
+```
+
+## MCP client configuration example
+
+```json
+{
+  "mcpServers": {
+    "graphite-transformations": {
+      "command": "npx",
+      "args": ["-y", "@dayanaarrieta-graphite/mcp-server"],
+      "env": {
+        "MCP_HOST": "localhost",
+        "MCP_PORT": "3333"
+      }
+    }
+  }
+}
+```
+
+## Local development
+
+```bash
+yarn --cwd mcp-server
+yarn --cwd mcp-server build
+yarn --cwd mcp-server start
+```
+
+## Publish (public)
+
+```bash
+npm publish --access public
+```
+
+## Quick health check
+
+```bash
+curl -s "http://localhost:${MCP_PORT:-3333}/health"
+```

package/bin/project-graphite-mcp.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("../dist/server.js");

package/dist/server.js

@@ -0,0 +1,185 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// ============================================================
+// MCP Server - Project Graphite
+// All orchestration happens here. OpenCode/Claude only generate.
+// ============================================================
+const express_1 = __importDefault(require("express"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const analyzeMapping_1 = require("./tools/analyzeMapping");
+const buildGenerationContext_1 = require("./tools/buildGenerationContext");
+const callCodeGenerator_1 = require("./tools/callCodeGenerator");
+const downloadApiData_1 = require("./tools/downloadApiData");
+const getMetadata_1 = require("./tools/getMetadata");
+const listTransformations_1 = require("./tools/listTransformations");
+const readFile_1 = require("./tools/readFile");
+const readFolder_1 = require("./tools/readFolder");
+const validateTransformation_1 = require("./tools/validateTransformation");
+const writeTransformation_1 = require("./tools/writeTransformation");
+const logger_1 = require("./utils/logger");
+const pathResolver_1 = require("./utils/pathResolver");
+const app = (0, express_1.default)();
+app.use(express_1.default.json({ limit: "50mb" }));
+const PORT = parseInt(process.env.MCP_PORT ?? "3333", 10);
+const HOST = process.env.MCP_HOST ?? "localhost";
+const TOOLS = {
+    // File I/O
+    readFile: (a) => (0, readFile_1.readFile)(a),
+    readFolder: (a) => (0, readFolder_1.readFolder)(a),
+    // Data acquisition
+    downloadApiData: (a) => (0, downloadApiData_1.downloadApiData)(a),
+    // Analysis
+    analyzeMapping: (a) => (0, analyzeMapping_1.analyzeMapping)(a),
+    getTransformationMetadata: (a) => (0, getMetadata_1.getTransformationMetadata)(a),
+    listTransformations: (a) => (0, listTransformations_1.listTransformations)(a),
+    // Generation context
+    buildGenerationContext: (a) => (0, buildGenerationContext_1.buildGenerationContext)(a),
+    callCodeGenerator: (a) => (0, callCodeGenerator_1.callCodeGenerator)(a),
+    // Write
+    writeTransformation: (a) => (0, writeTransformation_1.writeTransformation)(a),
+    writeGoldenFiles: (a) => (0, writeTransformation_1.writeGoldenFiles)(a),
+    // Validate
+    validateTransformation: (a) => (0, validateTransformation_1.validateTransformation)(a),
+    // -- High-level orchestration (full port in one call) --
+    portTransformation: async (a) => {
+        const { customerId, erpType } = a;
+        const steps = [];
+        const errors = [];
+        const step = (label) => {
+            steps.push(label);
+            (0, logger_1.log)("info", label);
+        };
+        const fail = (label) => {
+            errors.push(label);
+            (0, logger_1.log)("error", label);
+        };
+        // 1. Download API data
+        step(`[1/7] Downloading API data for ${customerId}/${erpType}`);
+        const download = (await (0, downloadApiData_1.downloadApiData)({ customerId, erpType }));
+        if (!download.success) {
+            fail("Download failed - using local files");
+        }
+        // 2. Analyze mapping + build reference context
+        step("[2/7] Analyzing mapping and reference transformer");
+        const analysis = (await (0, analyzeMapping_1.analyzeMapping)({ customerId, erpType }));
+        if (!analysis.success) {
+            return { success: false, steps, error: "Analysis failed" };
+        }
+        const analysisData = analysis.data;
+        const results = {};
+        for (const targetType of ["enum", "class", "test"]) {
+            // 3. Build generation context
+            step(`[${targetType === "enum" ? 3 : targetType === "class" ? 4 : 5}/7] Building ${targetType} generation context`);
+            const ctxResult = (await (0, buildGenerationContext_1.buildGenerationContext)({
+                analysisData: analysisData,
+                targetType,
+            }));
+            if (!ctxResult.success) {
+                fail(`Context build failed for ${targetType}`);
+                continue;
+            }
+            // 4. Call code generator
+            step(`Calling code generator for ${targetType}`);
+            const referenceFiles = targetType === "class"
+                ? (() => {
+                    const refPath = path_1.default.join(pathResolver_1.REPO_ROOT, "src/transformers/customers/US1206/US1206_sap.ts");
+                    return fs_1.default.existsSync(refPath) ? [refPath] : [];
+                })()
+                : [];
+            const genResult = (await (0, callCodeGenerator_1.callCodeGenerator)({
+                context: ctxResult.data,
+                referenceFiles,
+            }));
+            if (!genResult.success || !genResult.data?.code) {
+                fail(`Code generation failed for ${targetType}`);
+                continue;
+            }
+            // 5. Write generated code
+            step(`Writing ${targetType} file`);
+            const writeResult = (await (0, writeTransformation_1.writeTransformation)({
+                customerId,
+                erpType,
+                type: targetType,
+                content: genResult.data.code,
+            }));
+            results[targetType] = writeResult.data;
+            if (!writeResult.success) {
+                fail(`Write failed for ${targetType}`);
+            }
+        }
+        // 6. Validate
+        step("[6/7] Running tests");
+        const validation = (await (0, validateTransformation_1.validateTransformation)({ customerId, erpType }));
+        // 7. List to confirm
+        step("[7/7] Verifying transformation is listed");
+        const list = (await (0, listTransformations_1.listTransformations)({ filter: customerId }));
+        return {
+            success: errors.length === 0 && validation.success,
+            data: {
+                customerId,
+                erpType,
+                steps,
+                errors,
+                files: results,
+                validation: validation.data,
+                listed: list.data,
+            },
+        };
+    },
+};
+// -- Health --
+app.get("/health", (_req, res) => {
+    res.json({
+        status: "ok",
+        tools: Object.keys(TOOLS),
+        toolCount: Object.keys(TOOLS).length,
+        port: PORT,
+        timestamp: new Date().toISOString(),
+    });
+});
+// -- JSON-RPC Endpoint --
+app.post("/", async (req, res) => {
+    const rpc = req.body;
+    const respond = (result, error) => {
+        const response = { jsonrpc: "2.0", id: rpc.id };
+        if (error) {
+            response.error = error;
+        }
+        else {
+            response.result = result;
+        }
+        res.json(response);
+    };
+    if (rpc.method !== "tools/call") {
+        return respond(undefined, { code: -32601, message: `Method not found: ${rpc.method}` });
+    }
+    const toolName = rpc.params?.name;
+    const toolArgs = (rpc.params?.arguments ?? {});
+    const tool = toolName ? TOOLS[toolName] : undefined;
+    if (!tool) {
+        return respond(undefined, {
+            code: -32602,
+            message: `Unknown tool: ${toolName}. Available: ${Object.keys(TOOLS).join(", ")}`,
+        });
+    }
+    (0, logger_1.log)("info", `▶ Tool: ${toolName}`, { customerId: toolArgs.customerId, erpType: toolArgs.erpType });
+    try {
+        const result = await tool(toolArgs);
+        return respond(result);
+    }
+    catch (err) {
+        (0, logger_1.log)("error", `Tool error: ${toolName}`, err);
+        return respond(undefined, { code: -32603, message: String(err) });
+    }
+});
+app.listen(PORT, HOST, () => {
+    (0, logger_1.log)("info", `✅ MCP Server ready on port ${PORT}`);
+    // eslint-disable-next-line no-console -- CLI startup output is intentional
+    console.log(`\n✅ MCP Server ready - ${Object.keys(TOOLS).length} tools available on port ${PORT}\n`);
+    // eslint-disable-next-line no-console -- CLI startup output is intentional
+    console.log("Tools:", Object.keys(TOOLS).join(", "));
+});

package/dist/tools/analyzeMapping.js

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeMapping = analyzeMapping;
+// ============================================================
+// analyzeMapping — Analiza los mappings reales de Graphite.
+// Estructura real: array de objetos con fieldName, mapping
+// (grupo), sourceExpressionRaw, mappingCondition,
+// translationTable, sourceExpression (JSON logic).
+// ============================================================
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../utils/logger");
+const pathResolver_1 = require("../utils/pathResolver");
+async function analyzeMapping(args) {
+    const { customerId, erpType } = args;
+    const refCustomer = (0, pathResolver_1.getReferenceCustomer)(erpType);
+    const erp = erpType.toLowerCase();
+    const apiDir = (0, pathResolver_1.getApiDataDir)(customerId);
+    (0, logger_1.log)("info", `Analyzing ${customerId}/${erpType} - reference: ${refCustomer}`);
+    // -- 1. Load real mappings from API download --
+    const mappingsRaw = loadJson(path_1.default.join(apiDir, "mappings.json"), []);
+    const mappingsByGroup = loadJson(path_1.default.join(apiDir, "mappings-by-group.json"), {});
+    const translationTables = loadJson(path_1.default.join(apiDir, "translation-tables.json"), {});
+    const schema = loadJson(path_1.default.join(apiDir, "schema.json"), {});
+    const connection = loadJson(path_1.default.join(apiDir, "connection.json"), {});
+    const templates = loadJson(path_1.default.join(apiDir, "templates.json"), {});
+    const goldenProfile = loadJson(path_1.default.join(apiDir, "golden-profile.json"), {});
+    // -- 2. Load reference transformer code --
+    const refDir = (0, pathResolver_1.getCustomerDir)(refCustomer);
+    const referenceTransformerCode = readFile(path_1.default.join(refDir, `${refCustomer}_${erp}.ts`)) || readFirstTs(refDir);
+    const referenceEnumsCode = readFile(path_1.default.join(refDir, "enums.ts"));
+    const referenceTestPath = resolveReferenceTestPath(erp, refCustomer);
+    const referenceTestCode = referenceTestPath ? readFile(referenceTestPath) : "";
+    const baseClassCode = readFile((0, pathResolver_1.resolveSafePath)(`src/transformers/standard/${erp}-base.ts`)) ||
+        readFile((0, pathResolver_1.resolveSafePath)(`src/transformers/standard/${erp}.ts`));
+    // -- 3. Extract translation table names used --
+    const usedTranslationTables = [
+        ...new Set(mappingsRaw.filter((m) => m.translationTable).map((m) => m.translationTable)),
+    ];
+    // -- 4. Extract conditional rules --
+    const conditionalRules = mappingsRaw
+        .filter((m) => m.mappingConditionRaw || m.mappingCondition)
+        .map((m) => ({
+        field: m.fieldName,
+        condition: m.mappingConditionRaw ?? JSON.stringify(m.mappingCondition),
+        values: extractConditionValues(m.mappingCondition),
+    }));
+    // -- 5. Extract all field keys from sourceExpressionRaw --
+    const allFieldKeys = [...new Set(mappingsRaw.flatMap((m) => extractFieldKeys(m.sourceExpressionRaw ?? "")))];
+    // -- 6. Extract enums from reference code --
+    const existingEnums = extractEnums(referenceEnumsCode);
+    // -- 7. Extract base classes --
+    const baseClasses = extractBaseClasses(referenceTransformerCode);
+    // -- 8. Build mapping sections summary --
+    const mappingSections = Object.entries(mappingsByGroup).map(([group, fields]) => ({
+        group,
+        fieldCount: fields.length,
+        fields: fields.map((f) => f.fieldName),
+    }));
+    // -- 9. Build structured mapping for prompt --
+    const structuredMapping = buildStructuredMapping(mappingsRaw);
+    const context = {
+        customerId,
+        erpType,
+        referenceTransformerCode,
+        referenceEnumsCode,
+        referenceTestCode,
+        mappingJson: JSON.stringify(structuredMapping, null, 2),
+        templateJson: JSON.stringify(templates, null, 2),
+        fieldCount: mappingsRaw.length,
+        translationTables: usedTranslationTables,
+        conditionalRules,
+        baseClasses,
+        existingEnums,
+    };
+    return {
+        success: true,
+        data: {
+            ...context,
+            rawMappingsCount: mappingsRaw.length,
+            mappingSections,
+            allFieldKeys,
+            translationTablesData: translationTables,
+            schema,
+            connection,
+            goldenProfile,
+            baseClassCode,
+            summary: {
+                fieldCount: mappingsRaw.length,
+                translationTableCount: usedTranslationTables.length,
+                conditionalRuleCount: conditionalRules.length,
+                mappingSectionCount: Object.keys(mappingsByGroup).length,
+                mappingSections: Object.keys(mappingsByGroup),
+                hasReferenceCode: referenceTransformerCode.length > 0,
+                hasReferenceTest: referenceTestCode.length > 0,
+                hasGoldenFiles: Object.keys(goldenProfile).length > 0,
+                hasTranslationTables: usedTranslationTables.length > 0,
+                complexity: mappingsRaw.length > 100 ? "high" : mappingsRaw.length > 50 ? "medium" : "low",
+                erpType,
+                referenceCustomer: refCustomer,
+                referenceTestPath,
+            },
+        },
+    };
+}
+// -- Helpers --
+function loadJson(filePath, fallback) {
+    try {
+        if (!fs_1.default.existsSync(filePath)) {
+            return fallback;
+        }
+        return JSON.parse(fs_1.default.readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return fallback;
+    }
+}
+function readFile(filePath) {
+    try {
+        return fs_1.default.existsSync(filePath) ? fs_1.default.readFileSync(filePath, "utf-8") : "";
+    }
+    catch {
+        return "";
+    }
+}
+function readFirstTs(dir) {
+    if (!fs_1.default.existsSync(dir)) {
+        return "";
+    }
+    const files = fs_1.default.readdirSync(dir).filter((f) => f.endsWith(".ts") && !f.includes("enum"));
+    return files.length ? readFile(path_1.default.join(dir, files[0])) : "";
+}
+function resolveReferenceTestPath(erp, refCustomer) {
+    const candidates = [
+        path_1.default.join(pathResolver_1.REPO_ROOT, "tests/transformers/standard", erp, "erp.test.ts"),
+        path_1.default.join(pathResolver_1.REPO_ROOT, "tests/transformers/customers", `${refCustomer}.test.ts`),
+        path_1.default.join(pathResolver_1.REPO_ROOT, "tests/transformers", `${refCustomer}_${erp}.test.ts`),
+    ];
+    if (erp === "sap") {
+        candidates.push(path_1.default.join(pathResolver_1.REPO_ROOT, "tests/transformers/customers", "US47815.test.ts"));
+    }
+    for (const candidate of candidates) {
+        if (fs_1.default.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return "";
+}
+function extractFieldKeys(expr) {
+    const matches = expr.match(/<([^>]+)>/g) ?? [];
+    return matches.map((m) => m.replace(/[<>]/g, "").trim());
+}
+function extractConditionValues(condition) {
+    if (!condition) {
+        return [];
+    }
+    const str = JSON.stringify(condition);
+    const matches = str.match(/"([^"]{1,50})"/g) ?? [];
+    return [...new Set(matches.map((m) => m.replace(/"/g, "")))].slice(0, 20);
+}
+function extractEnums(code) {
+    const enums = [];
+    for (const match of code.matchAll(/export enum (\w+)\s*\{([^}]+)\}/g)) {
+        const values = {};
+        for (const line of match[2]
+            .split("\n")
+            .map((l) => l.trim())
+            .filter(Boolean)) {
+            const kv = line
+                .replace(",", "")
+                .split("=")
+                .map((s) => s.trim());
+            if (kv.length === 2) {
+                values[kv[0]] = kv[1].replace(/'/g, "");
+            }
+        }
+        enums.push({ name: match[1], values });
+    }
+    return enums;
+}
+function extractBaseClasses(code) {
+    return [...new Set((code.match(/extends\s+(\w+)/g) ?? []).map((m) => m.replace("extends ", "").trim()))];
+}
+function buildStructuredMapping(mappings) {
+    const result = {};
+    for (const m of mappings) {
+        const group = m.mapping ?? "unknown";
+        if (!result[group]) {
+            result[group] = {};
+        }
+        result[group][m.fieldName] = {
+            sourceExpression: m.sourceExpressionRaw,
+            ...(m.mappingConditionRaw ? { condition: m.mappingConditionRaw } : {}),
+            ...(m.translationTable ? { translationTable: m.translationTable } : {}),
+            ...(m.defaultValue ? { defaultValue: m.defaultValue } : {}),
+            ...(m.characterLimit ? { characterLimit: m.characterLimit } : {}),
+            logic: m.sourceExpression,
+        };
+    }
+    return result;
+}

package/dist/tools/buildGenerationContext.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGenerationContext = buildGenerationContext;
+const logger_1 = require("../utils/logger");
+async function buildGenerationContext(args) {
+    const { analysisData: ctx, targetType } = args;
+    (0, logger_1.log)("info", `Building ${targetType} context for ${ctx.customerId}/${ctx.erpType}`);
+    let prompt = "";
+    let promptParts;
+    if (targetType === "enum") {
+        prompt = buildEnumPrompt(ctx);
+    }
+    else if (targetType === "class") {
+        prompt = buildClassPrompt(ctx);
+    }
+    else if (targetType === "test") {
+        prompt = buildTestPrompt(ctx);
+    }
+    const context = {
+        customerId: ctx.customerId,
+        erpType: ctx.erpType,
+        referenceCode: ctx.referenceTransformerCode,
+        mappingData: JSON.parse(ctx.mappingJson || "{}"),
+        enumContext: ctx.referenceEnumsCode,
+        testGoldenProfile: ctx.mappingJson,
+        testGoldenPayload: ctx.templateJson,
+        baseClassCode: "",
+        prompt,
+        promptParts,
+    };
+    return { success: true, data: context };
+}
+// -- Enum Prompt --
+function buildEnumPrompt(ctx) {
+    return `You are a TypeScript expert working on Project Graphite ERP transformations.
+
+Generate enums.ts for customer ${ctx.customerId} (${ctx.erpType}).
+
+COPY THIS EXACT FILE — replace every "US1206" with "${ctx.customerId}":
+
+${ctx.referenceEnumsCode}
+
+RULES:
+- Replace every "US1206" → "${ctx.customerId}"
+- Keep EXACTLY the same enum names: ${ctx.customerId}Vendor and ${ctx.customerId}Body
+- Replace the enum VALUES with the actual field keys from this customer's mappings:
+${ctx.mappingJson.slice(0, 3000)}
+- Output ONLY TypeScript code, no explanation, no markdown fences
+
+Generate enums.ts now:`;
+}
+function buildClassPrompt(ctx) {
+    return `Replace every "US1206" with "${ctx.customerId}" in the attached file. Output only TypeScript code.`;
+}
+// -- Test Prompt --
+function buildTestPrompt(ctx) {
+    const refTest = ctx.referenceTestCode.slice(0, 3000);
+    return `You are a TypeScript expert working on Project Graphite ERP transformations.
+
+Generate a complete Jest test file for ${ctx.customerId} ${ctx.erpType} transformer.
+
+RULES:
+- Import: import { transformer, ${ctx.customerId}Sap } from '../../../src/transformers/customers/${ctx.customerId}/${ctx.customerId}_sap'
+- Minimum 10 test cases
+- Test each mapping section (0110, 0120, 0130, 0310, 0510, cc)
+- Test conditional rules
+- Use realistic field values
+- No TODOs — all tests fully implemented
+- Output ONLY TypeScript code, no explanation, no markdown fences
+
+REFERENCE TEST (follow this structure):
+${refTest}
+
+MAPPING SECTIONS AVAILABLE:
+${ctx.mappingJson.slice(0, 3000)}
+
+Generate ${ctx.customerId}_sap.test.ts now:`;
+}

package/dist/tools/callCodeGenerator.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callCodeGenerator = callCodeGenerator;
+const child_process_1 = require("child_process");
+const logger_1 = require("../utils/logger");
+const OPENCODE_BIN = "/opt/homebrew/bin/opencode";
+async function callCodeGenerator(args) {
+    const { context, referenceFiles = [] } = args;
+    (0, logger_1.log)("info", `Calling opencode for ${context.customerId}/${context.erpType} (${context.prompt.length} chars)`);
+    // Use exact same pattern that works on command line:
+    // opencode run "message" -f file1 -f file2
+    const spawnArgs = ["run", context.prompt, ...referenceFiles.flatMap((f) => ["-f", f])];
+    (0, logger_1.log)("info", `spawn: opencode ${spawnArgs.slice(0, 3).join(" ")} ... (${referenceFiles.length} files)`);
+    const result = (0, child_process_1.spawnSync)(OPENCODE_BIN, spawnArgs, {
+        encoding: "utf-8",
+        timeout: 180000,
+        maxBuffer: 1024 * 1024 * 20,
+    });
+    if (result.error) {
+        return { success: false, error: `opencode error: ${result.error.message}` };
+    }
+    if (result.status !== 0) {
+        return { success: false, error: `opencode exited ${result.status}: ${(result.stderr || "").slice(0, 500)}` };
+    }
+    const output = result.stdout?.trim() ?? "";
+    if (output.length < 100) {
+        return { success: false, error: `opencode returned too little output (${output.length} chars)` };
+    }
+    (0, logger_1.log)("info", `opencode returned ${output.length} chars`);
+    return {
+        success: true,
+        data: { code: stripFences(output), source: "opencode" },
+    };
+}
+function stripFences(code) {
+    return code
+        .replace(/^```typescript\n?/gm, "")
+        .replace(/^```ts\n?/gm, "")
+        .replace(/^```\n?/gm, "")
+        .replace(/```$/gm, "")
+        .trim();
+}

package/dist/tools/downloadApiData.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadApiData = downloadApiData;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const https_1 = __importDefault(require("https"));
+const http_1 = __importDefault(require("http"));
+const pathResolver_1 = require("../utils/pathResolver");
+const logger_1 = require("../utils/logger");
+const API_BASE = process.env.GRAPHITE_API_URL ?? "https://poc.projectgraphite.com/api/public/api/v1";
+const API_TOKEN = process.env.GRAPHITE_API_TOKEN ?? "";
+function fetchJson(url) {
+    return new Promise((resolve, reject) => {
+        const client = url.startsWith("https") ? https_1.default : http_1.default;
+        const req = client.get(url, {
+            headers: {
+                Authorization: `Bearer ${API_TOKEN}`,
+                Accept: "application/json",
+            },
+        }, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk;
+            });
+            res.on("end", () => {
+                if (res.statusCode && res.statusCode >= 400) {
+                    reject(new Error(`HTTP ${res.statusCode} -> ${url}\n${data}`));
+                    return;
+                }
+                try {
+                    resolve(JSON.parse(data));
+                }
+                catch (e) {
+                    reject(new Error(`Invalid JSON from ${url}: ${String(e)}`));
+                }
+            });
+        });
+        req.on("error", reject);
+        req.setTimeout(30000, () => {
+            req.destroy();
+            reject(new Error(`Timeout: ${url}`));
+        });
+    });
+}
+async function downloadApiData(args) {
+    const { customerId, erpType } = args;
+    if (!API_TOKEN) {
+        return { success: false, error: "GRAPHITE_API_TOKEN not set" };
+    }
+    const dir = (0, pathResolver_1.getApiDataDir)(customerId);
+    (0, pathResolver_1.ensureDir)(path_1.default.join(dir, ".keep"));
+    const saved = [];
+    const errors = [];
+    // -- Core endpoints (no customer ID in path — Bearer defines the customer) --
+    const endpoints = [
+        {
+            key: "mappings",
+            url: `${API_BASE}/mappings/transformation-mappings`,
+            filename: "mappings.json",
+        },
+        {
+            key: "templates",
+            url: `${API_BASE}/mappings/transformation-templates`,
+            filename: "templates.json",
+        },
+        {
+            key: "tables",
+            url: `${API_BASE}/mappings/transformation-tables`,
+            filename: "translation-tables.json",
+        },
+        {
+            // Schema — publicId can be empty for own customer schema
+            key: "schema",
+            url: `${API_BASE}/schema/${customerId}`,
+            filename: "schema.json",
+        },
+    ];
+    // NOTE: /connections/{connectionId} expects a MongoDB ObjectId — skip it.
+    // The Bearer token already identifies the connection. Everything we need
+    // comes from the mappings, templates, tables, and schema endpoints.
+    for (const ep of endpoints) {
+        try {
+            (0, logger_1.log)("info", `Downloading ${ep.key}...`);
+            const data = await fetchJson(ep.url);
+            const filePath = path_1.default.join(dir, ep.filename);
+            fs_1.default.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+            saved.push(ep.filename);
+            const count = Array.isArray(data) ? ` (${data.length} items)` : "";
+            (0, logger_1.log)("info", `Saved ${ep.filename}${count}`);
+        }
+        catch (err) {
+            const msg = `${ep.key}: ${String(err)}`;
+            errors.push(msg);
+            (0, logger_1.log)("warn", msg);
+        }
+    }
+    // -- Post-process: group mappings by section --
+    const mappingsPath = path_1.default.join(dir, "mappings.json");
+    if (fs_1.default.existsSync(mappingsPath)) {
+        try {
+            const allMappings = JSON.parse(fs_1.default.readFileSync(mappingsPath, "utf-8"));
+            // Group by mapping section (0110, 0120, cc, etc.)
+            const byGroup = {};
+            for (const m of allMappings) {
+                const group = m.mapping ?? "unknown";
+                if (!byGroup[group]) {
+                    byGroup[group] = [];
+                }
+                byGroup[group].push(m);
+            }
+            fs_1.default.writeFileSync(path_1.default.join(dir, "mappings-by-group.json"), JSON.stringify(byGroup, null, 2), "utf-8");
+            saved.push("mappings-by-group.json");
+            fs_1.default.writeFileSync(path_1.default.join(dir, "field-list.json"), JSON.stringify(allMappings.map((m) => ({
+                fieldName: m.fieldName,
+                group: m.mapping,
+            })), null, 2), "utf-8");
+            saved.push("field-list.json");
+            const groups = Object.keys(byGroup);
+            (0, logger_1.log)("info", `${groups.length} mapping sections: ${groups.join(", ")}`);
+        }
+        catch (err) {
+            (0, logger_1.log)("warn", `Post-process error: ${String(err)}`);
+        }
+    }
+    return {
+        success: saved.length > 0,
+        data: {
+            customerId,
+            erpType,
+            mappingJson: {},
+            templateJson: {},
+            savedPaths: saved,
+            savedFiles: saved,
+            savedCount: saved.length,
+            errorCount: errors.length,
+            errors,
+            note: errors.length === 0
+                ? "All files downloaded successfully"
+                : `${errors.length} endpoint(s) failed - non-critical`,
+        },
+    };
+}

package/dist/tools/getMetadata.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTransformationMetadata = getTransformationMetadata;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const pathResolver_1 = require("../utils/pathResolver");
+async function getTransformationMetadata(args) {
+    try {
+        const dir = (0, pathResolver_1.getCustomerDir)(args.customerId);
+        const exists = fs_1.default.existsSync(dir);
+        const files = exists ? fs_1.default.readdirSync(dir) : [];
+        const erp = args.erpType.toLowerCase();
+        const mainFile = `${args.customerId}_${erp}.ts`;
+        const testFile = path_1.default.join((0, pathResolver_1.resolveSafePath)("tests/transformers"), `${args.customerId}_${erp}.test.ts`);
+        let lineCount = 0;
+        let methodCount = 0;
+        if (files.includes(mainFile)) {
+            const content = fs_1.default.readFileSync(path_1.default.join(dir, mainFile), "utf-8");
+            lineCount = content.split("\n").length;
+            methodCount = (content.match(/^\s+(public|private|protected)?\s+\w+\s*\(/gm) ?? []).length;
+        }
+        return {
+            success: true,
+            data: {
+                customerId: args.customerId,
+                erpType: args.erpType,
+                exists,
+                files,
+                mainFile,
+                hasEnums: files.includes("enums.ts"),
+                hasTests: fs_1.default.existsSync(testFile),
+                lineCount,
+                methodCount,
+                directory: dir,
+            },
+        };
+    }
+    catch (err) {
+        return { success: false, error: String(err) };
+    }
+}

package/dist/tools/listTransformations.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listTransformations = listTransformations;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const pathResolver_1 = require("../utils/pathResolver");
+async function listTransformations(args) {
+    try {
+        const customersPath = (0, pathResolver_1.resolveSafePath)("src/transformers/customers");
+        if (!fs_1.default.existsSync(customersPath)) {
+            return { success: true, data: { transformations: [], count: 0 } };
+        }
+        const customers = fs_1.default
+            .readdirSync(customersPath, { withFileTypes: true })
+            .filter((e) => e.isDirectory())
+            .map((e) => e.name)
+            .filter((c) => !args.filter || c.toLowerCase().includes(args.filter.toLowerCase()));
+        const transformations = customers.map((customerId) => {
+            const dir = path_1.default.join(customersPath, customerId);
+            const files = fs_1.default.readdirSync(dir);
+            const tsFiles = files.filter((f) => f.endsWith(".ts"));
+            const hasEnums = files.includes("enums.ts");
+            const hasTests = fs_1.default.existsSync(path_1.default.join((0, pathResolver_1.resolveSafePath)("tests/transformers"), `${customerId.toLowerCase()}.test.ts`));
+            return { customerId, files, tsFiles, hasEnums, hasTests, fileCount: files.length };
+        });
+        return { success: true, data: { transformations, count: transformations.length } };
+    }
+    catch (err) {
+        return { success: false, error: String(err) };
+    }
+}

package/dist/tools/readFile.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFile = readFile;
+const fs_1 = __importDefault(require("fs"));
+const pathResolver_1 = require("../utils/pathResolver");
+async function readFile(args) {
+    try {
+        const fullPath = (0, pathResolver_1.resolveSafePath)(args.path);
+        if (!fs_1.default.existsSync(fullPath)) {
+            return { success: false, error: `File not found: ${args.path}` };
+        }
+        const content = fs_1.default.readFileSync(fullPath, "utf-8");
+        return { success: true, data: { path: args.path, content, size: content.length } };
+    }
+    catch (err) {
+        return { success: false, error: String(err) };
+    }
+}

package/dist/tools/readFolder.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFolder = readFolder;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const pathResolver_1 = require("../utils/pathResolver");
+async function readFolder(args) {
+    try {
+        const fullPath = (0, pathResolver_1.resolveSafePath)(args.path);
+        if (!fs_1.default.existsSync(fullPath)) {
+            return { success: false, error: `Folder not found: ${args.path}` };
+        }
+        const entries = fs_1.default.readdirSync(fullPath, { withFileTypes: true }).map((e) => ({
+            name: e.name,
+            type: e.isDirectory() ? "directory" : "file",
+            path: path_1.default.join(args.path, e.name),
+        }));
+        const filtered = args.pattern ? entries.filter((f) => f.name.includes(args.pattern)) : entries;
+        return { success: true, data: { path: args.path, entries: filtered, count: filtered.length } };
+    }
+    catch (err) {
+        return { success: false, error: String(err) };
+    }
+}

package/dist/tools/validateTransformation.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTransformation = validateTransformation;
+const child_process_1 = require("child_process");
+const logger_1 = require("../utils/logger");
+const pathResolver_1 = require("../utils/pathResolver");
+async function validateTransformation(args) {
+    const pattern = `${args.customerId}_${args.erpType.toLowerCase()}`;
+    (0, logger_1.log)("info", `Running tests for pattern: ${pattern}`);
+    try {
+        const output = (0, child_process_1.execSync)(`yarn test --testPathPatterns="${pattern}" --passWithNoTests --forceExit`, {
+            encoding: "utf-8",
+            timeout: 90000,
+            cwd: pathResolver_1.REPO_ROOT,
+        });
+        const passed = parseInt((output.match(/(\d+) passed/) || [])[1] ?? "0", 10);
+        const failed = parseInt((output.match(/(\d+) failed/) || [])[1] ?? "0", 10);
+        return {
+            success: failed === 0,
+            data: { passed, failed, pattern, output: output.slice(-2000) },
+        };
+    }
+    catch (err) {
+        const stdout = err.stdout ?? "";
+        const stderr = err.stderr ?? "";
+        const combined = stdout + stderr;
+        const passed = parseInt((combined.match(/(\d+) passed/) || [])[1] ?? "0", 10);
+        const failed = parseInt((combined.match(/(\d+) failed/) || [])[1] ?? "1", 10);
+        return {
+            success: false,
+            data: { passed, failed, pattern, output: combined.slice(-2000) },
+            error: "Tests failed",
+        };
+    }
+}

package/dist/tools/writeTransformation.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeTransformation = writeTransformation;
+exports.writeGoldenFiles = writeGoldenFiles;
+// ============================================================
+// writeTransformation - Writes generated code to disk.
+// Content is ALWAYS provided by the code generator.
+// This tool NEVER generates code itself.
+// ============================================================
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../utils/logger");
+const pathResolver_1 = require("../utils/pathResolver");
+async function writeTransformation(args) {
+    if (args.dryRun) {
+        return {
+            success: true,
+            data: { dryRun: true, wouldWrite: args.type, contentLength: args.content?.length ?? 0 },
+        };
+    }
+    if (!args.content || args.content.trim().length < 50) {
+        return { success: false, error: "Content is empty or too short - code generator must provide full content" };
+    }
+    const { customerId: id, erpType: erp, type, content } = args;
+    try {
+        const pathMap = {
+            class: (0, pathResolver_1.getTransformerPath)(id, erp),
+            enum: (0, pathResolver_1.getEnumsPath)(id),
+            test: (0, pathResolver_1.getTestPath)(id, erp),
+        };
+        const filePath = pathMap[type];
+        if (!filePath) {
+            return { success: false, error: `Unknown file type: ${type}` };
+        }
+        (0, pathResolver_1.ensureDir)(filePath);
+        // Backup existing file if present
+        if (fs_1.default.existsSync(filePath)) {
+            const backup = `${filePath}.bak.${Date.now()}`;
+            fs_1.default.copyFileSync(filePath, backup);
+            (0, logger_1.log)("info", `Backed up existing file to ${path_1.default.basename(backup)}`);
+        }
+        fs_1.default.writeFileSync(filePath, content, "utf-8");
+        const lines = content.split("\n").length;
+        if (type === "class") {
+            copyRequiredDataDependencies(id, erp, content);
+        }
+        (0, logger_1.log)("info", `Written ${type} for ${id}/${erp}: ${filePath} (${lines} lines)`);
+        return {
+            success: true,
+            data: { path: filePath, type, lines, size: content.length },
+        };
+    }
+    catch (err) {
+        return { success: false, error: String(err) };
+    }
+}
+function copyRequiredDataDependencies(customerId, erpType, content) {
+    const erp = erpType.toLowerCase();
+    if (erp !== "sap") {
+        return;
+    }
+    if (!content.includes("./data/sapSubsidiaries")) {
+        return;
+    }
+    const refCustomer = (0, pathResolver_1.getReferenceCustomer)(erpType);
+    const sourceFile = path_1.default.join((0, pathResolver_1.getCustomerDir)(refCustomer), "data", "sapSubsidiaries.ts");
+    const targetFile = path_1.default.join((0, pathResolver_1.getCustomerDir)(customerId), "data", "sapSubsidiaries.ts");
+    if (!fs_1.default.existsSync(sourceFile)) {
+        (0, logger_1.log)("warn", `Missing reference dependency file: ${sourceFile}`);
+        return;
+    }
+    (0, pathResolver_1.ensureDir)(targetFile);
+    fs_1.default.copyFileSync(sourceFile, targetFile);
+    (0, logger_1.log)("info", `Copied data dependency for ${customerId}/${erpType}: ${targetFile}`);
+}
+async function writeGoldenFiles(args) {
+    const dir = (0, pathResolver_1.getGoldenDir)(args.customerId);
+    (0, pathResolver_1.ensureDir)(path_1.default.join(dir, ".keep"));
+    const written = [];
+    try {
+        if (args.profileContent) {
+            const p = path_1.default.join(dir, "profile.json");
+            fs_1.default.writeFileSync(p, args.profileContent, "utf-8");
+            written.push(p);
+        }
+        if (args.payloadContent) {
+            const p = path_1.default.join(dir, "payload.json");
+            fs_1.default.writeFileSync(p, args.payloadContent, "utf-8");
+            written.push(p);
+        }
+        return { success: true, data: { written } };
+    }
+    catch (err) {
+        return { success: false, error: String(err) };
+    }
+}

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+// ============================================================
+// MCP Server Types - Project Graphite
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/logger.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = log;
+function log(level, message, data) {
+    const entry = {
+        timestamp: new Date().toISOString(),
+        level,
+        message,
+        ...(data !== undefined ? { data } : {}),
+    };
+    (level === "error" ? process.stderr : process.stdout).write(JSON.stringify(entry) + "\n");
+}

package/dist/utils/pathResolver.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERP_REFERENCES = exports.REPO_ROOT = void 0;
+exports.resolveSafePath = resolveSafePath;
+exports.getCustomerDir = getCustomerDir;
+exports.getTransformerPath = getTransformerPath;
+exports.getEnumsPath = getEnumsPath;
+exports.getTestPath = getTestPath;
+exports.getGoldenDir = getGoldenDir;
+exports.getApiDataDir = getApiDataDir;
+exports.ensureDir = ensureDir;
+exports.getReferenceCustomer = getReferenceCustomer;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const expectedRepoSubpaths = [path_1.default.join("src", "transformers"), path_1.default.join("tests", "golden"), "package.json"];
+function isRepoRoot(candidate) {
+    return expectedRepoSubpaths.every((entry) => fs_1.default.existsSync(path_1.default.join(candidate, entry)));
+}
+function detectRepoRoot() {
+    const configuredRoot = process.env.GRAPHITE_REPO_ROOT;
+    if (configuredRoot) {
+        const resolvedConfiguredRoot = path_1.default.resolve(configuredRoot);
+        if (!isRepoRoot(resolvedConfiguredRoot)) {
+            throw new Error(`GRAPHITE_REPO_ROOT does not look like repository root: ${resolvedConfiguredRoot}`);
+        }
+        return resolvedConfiguredRoot;
+    }
+    const currentWorkingDirectory = process.cwd();
+    if (isRepoRoot(currentWorkingDirectory)) {
+        return currentWorkingDirectory;
+    }
+    const builtInRoot = path_1.default.resolve(__dirname, "../../..");
+    if (isRepoRoot(builtInRoot)) {
+        return builtInRoot;
+    }
+    throw new Error("Could not detect repository root. Run from the transformations repo root or set GRAPHITE_REPO_ROOT.");
+}
+exports.REPO_ROOT = detectRepoRoot();
+function resolveSafePath(relativePath) {
+    const resolved = path_1.default.resolve(exports.REPO_ROOT, relativePath);
+    if (!resolved.startsWith(exports.REPO_ROOT)) {
+        throw new Error(`Path traversal detected: ${relativePath}`);
+    }
+    return resolved;
+}
+function getCustomerDir(customerId) {
+    return path_1.default.join(exports.REPO_ROOT, "src/transformers/customers", customerId);
+}
+function getTransformerPath(customerId, erpType) {
+    return path_1.default.join(getCustomerDir(customerId), `${customerId}_${erpType.toLowerCase()}.ts`);
+}
+function getEnumsPath(customerId) {
+    return path_1.default.join(getCustomerDir(customerId), "enums.ts");
+}
+function getTestPath(customerId, erpType) {
+    return path_1.default.join(exports.REPO_ROOT, "tests/transformers", `${customerId}_${erpType.toLowerCase()}.test.ts`);
+}
+function getGoldenDir(customerId) {
+    return path_1.default.join(exports.REPO_ROOT, "tests/golden", customerId);
+}
+function getApiDataDir(customerId) {
+    return path_1.default.join(exports.REPO_ROOT, "api-data", customerId);
+}
+function ensureDir(filePath) {
+    const dir = path_1.default.dirname(filePath);
+    if (!fs_1.default.existsSync(dir)) {
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    }
+}
+// ERP -> reference customer mapping
+exports.ERP_REFERENCES = {
+    SAP: "US1206",
+    ORACLE: "US17104",
+    S4: "US47815",
+    NETSUITE: "US18162",
+};
+function getReferenceCustomer(erpType) {
+    return exports.ERP_REFERENCES[erpType.toUpperCase()] ?? "US1206";
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@arrieta1/mcp-server",
+  "version": "2.0.0",
+  "description": "Project Graphite MCP server package",
+  "main": "dist/server.js",
+  "bin": {
+    "project-graphite-mcp": "bin/project-graphite-mcp.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/server.js",
+    "dev": "ts-node src/server.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "json-rpc",
+    "graphite"
+  ],
+  "license": "UNLICENSED",
+  "dependencies": {
+    "express": "^4.21.2"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^22.15.30",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
+  }
+}