tinker-mcp 1.0.0

package/dist/__tests__/tools.test.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../tools/index");
+const api_1 = require("../api");
+// Mock the API client
+jest.mock('../api', () => ({
+    api: {
+        get: jest.fn(),
+        post: jest.fn()
+    }
+}));
+describe('MCP Tools (Dynamic Loader)', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('Tool Loading', () => {
+        it('loads tools from Rails API on initialization', async () => {
+            const mockTools = [
+                {
+                    name: 'list_tickets',
+                    description: 'List tickets',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            status: { type: 'string' }
+                        }
+                    }
+                },
+                {
+                    name: 'transition_ticket',
+                    description: 'Transition ticket',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            ticket_id: { type: 'integer' },
+                            event: { type: 'string' }
+                        },
+                        required: ['ticket_id', 'event']
+                    }
+                }
+            ];
+            api_1.api.get.mockResolvedValue({
+                data: { tools: mockTools }
+            });
+            await (0, index_1.initializeTools)();
+            expect(api_1.api.get).toHaveBeenCalledWith('/mcp/tools');
+        });
+        it('handles tool loading errors gracefully', async () => {
+            const error = new Error('Rails API unavailable');
+            api_1.api.get.mockRejectedValue(error);
+            await expect((0, index_1.initializeTools)()).rejects.toThrow('Rails API unavailable');
+        });
+    });
+    describe('Tool Execution', () => {
+        beforeEach(async () => {
+            // Initialize tools before each execution test
+            const mockTools = [
+                {
+                    name: 'list_tickets',
+                    description: 'List tickets',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            status: { type: 'string' }
+                        }
+                    }
+                },
+                {
+                    name: 'transition_ticket',
+                    description: 'Transition ticket',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            ticket_id: { type: 'integer' },
+                            event: { type: 'string' }
+                        },
+                        required: ['ticket_id', 'event']
+                    }
+                }
+            ];
+            api_1.api.get.mockResolvedValue({
+                data: { tools: mockTools }
+            });
+            await (0, index_1.initializeTools)();
+        });
+        it('executes list_tickets tool', async () => {
+            const mockResponse = {
+                data: [{ id: 1, title: 'Ticket 1' }],
+                meta: { total_count: 150, offset: 0, limit: 20, has_more: true }
+            };
+            api_1.api.post.mockResolvedValue({ data: { result: mockResponse } });
+            const result = await (0, index_1.executeToolWrapper)('list_tickets', { status: 'todo' });
+            const parsed = JSON.parse(result.content[0].text);
+            expect(api_1.api.post).toHaveBeenCalledWith('/mcp/execute', {
+                tool: 'list_tickets',
+                params: { status: 'todo' }
+            });
+            expect(parsed).toEqual(mockResponse);
+        });
+        it('executes transition_ticket tool', async () => {
+            const mockTicket = { id: 1, status: 'in_progress' };
+            api_1.api.post.mockResolvedValue({ data: { result: mockTicket } });
+            const result = await (0, index_1.executeToolWrapper)('transition_ticket', { ticket_id: 1, event: 'start_work' });
+            expect(api_1.api.post).toHaveBeenCalledWith('/mcp/execute', {
+                tool: 'transition_ticket',
+                params: { ticket_id: 1, event: 'start_work' }
+            });
+            expect(JSON.parse(result.content[0].text)).toEqual(mockTicket);
+        });
+        it('handles tool execution errors', async () => {
+            const error = new Error('Network Error');
+            api_1.api.post.mockRejectedValue(error);
+            const result = await (0, index_1.executeToolWrapper)('list_tickets', {});
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toContain('Network Error');
+        });
+        it('handles API response errors', async () => {
+            const error = {
+                response: {
+                    status: 500,
+                    data: { error: 'Internal Server Error' }
+                }
+            };
+            api_1.api.post.mockRejectedValue(error);
+            const result = await (0, index_1.executeToolWrapper)('list_tickets', {});
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toContain('500');
+        });
+        it('handles network errors (no response)', async () => {
+            const error = {
+                request: {}
+            };
+            api_1.api.post.mockRejectedValue(error);
+            const result = await (0, index_1.executeToolWrapper)('list_tickets', {});
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toContain('Network Error');
+        });
+    });
+});

package/dist/api.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.api = void 0;
+const axios_1 = __importDefault(require("axios"));
+const API_BASE_URL = process.env.RAILS_API_URL || 'http://localhost:3000/api/v1';
+const API_KEY = process.env.RAILS_API_KEY;
+if (!API_KEY) {
+    console.error("Warning: RAILS_API_KEY not found in environment variables.");
+}
+exports.api = axios_1.default.create({
+    baseURL: API_BASE_URL,
+    headers: {
+        'Content-Type': 'application/json',
+        'X-API-Key': API_KEY,
+        'Accept': 'application/json'
+    }
+});

package/dist/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const index_js_2 = require("./tools/index.js");
+const server = new index_js_1.Server({
+    name: "tinker-bridge",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// List tools - dynamically loaded from Rails
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+    return {
+        tools: index_js_2.tools.map(t => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema
+        })),
+    };
+});
+// Execute tool - route all calls through Rails
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const toolName = request.params.name;
+    // Verify tool exists
+    const toolExists = index_js_2.tools.some((t) => t.name === toolName);
+    if (!toolExists) {
+        throw new Error(`Tool not found: ${toolName}`);
+    }
+    // Execute via Rails
+    return await (0, index_js_2.executeToolWrapper)(toolName, request.params.arguments);
+});
+async function main() {
+    // Load tools from Rails before starting server
+    console.error("Loading tools from Rails API...");
+    await (0, index_js_2.initializeTools)();
+    console.error(`Loaded ${index_js_2.tools.length} tools`);
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error("Tinker MCP Bridge running on stdio");
+}
+main().catch((error) => {
+    console.error("Server error:", error);
+    process.exit(1);
+});

package/dist/tools/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tools = void 0;
+exports.initializeTools = initializeTools;
+exports.executeToolWrapper = executeToolWrapper;
+const loader_js_1 = require("./loader.js");
+// Export tools dynamically loaded from Rails
+// This ensures Rails is the single source of truth for tool definitions
+exports.tools = [];
+// Export load function to be called during server initialization
+async function initializeTools() {
+    const loadedTools = await (0, loader_js_1.loadTools)();
+    // Clear existing tools and load from Rails
+    exports.tools.length = 0;
+    exports.tools.push(...loadedTools);
+    console.log(`Loaded ${exports.tools.length} tools from Rails API`);
+}
+// Export a generic tool executor that routes all tool calls through Rails
+async function executeToolWrapper(toolName, args) {
+    return (0, loader_js_1.executeTool)(toolName, args);
+}

package/dist/tools/loader.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTools = loadTools;
+exports.executeTool = executeTool;
+const api_js_1 = require("../api.js");
+// Fetch tool definitions dynamically from Rails
+async function loadTools() {
+    try {
+        const response = await api_js_1.api.get('/mcp/tools');
+        // Transform Rails format to MCP Tool format
+        const tools = response.data.tools.map((railsTool) => ({
+            name: railsTool.name,
+            description: railsTool.description,
+            inputSchema: railsTool.parameters
+        }));
+        return tools;
+    }
+    catch (error) {
+        console.error('Failed to load tools from Rails:', error);
+        throw error;
+    }
+}
+// Generic execute function that calls Rails /mcp/execute
+async function executeTool(toolName, args) {
+    try {
+        const response = await api_js_1.api.post('/mcp/execute', {
+            tool: toolName,
+            params: args
+        });
+        return {
+            content: [{ type: "text", text: JSON.stringify(response.data.result, null, 2) }]
+        };
+    }
+    catch (error) {
+        // Format error consistently
+        let errorMessage = `Error: ${error.message}`;
+        if (error.response) {
+            errorMessage = `API Error (${error.response.status}): ${JSON.stringify(error.response.data, null, 2)}`;
+        }
+        else if (error.request) {
+            errorMessage = `Network Error: No response received from API. Is Rails running?`;
+        }
+        return {
+            content: [{ type: "text", text: errorMessage }],
+            isError: true
+        };
+    }
+}

package/dist/verify.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("./tools/index.js");
+async function verify() {
+    console.log("=== Verification Started ===");
+    // Initialize tools from Rails
+    await (0, index_js_1.initializeTools)();
+    // Helper to execute tools
+    const execute = async (toolName, args) => {
+        return await (0, index_js_1.executeToolWrapper)(toolName, args);
+    };
+    // 1. List Tickets (renamed from list_tasks)
+    console.log("\n[1] Listing Tickets...");
+    const listResult = await execute("list_tickets", { status: "todo" });
+    if (listResult.isError) {
+        console.error("List Tickets Failed:", listResult.content[0].text);
+        return;
+    }
+    let tickets;
+    try {
+        const parsed = JSON.parse(listResult.content[0].text);
+        tickets = parsed.data || parsed; // Handle JSON:API or raw array
+    }
+    catch (e) {
+        console.error("Failed to parse list response:", listResult.content[0].text.substring(0, 200));
+        return;
+    }
+    console.log(`Found ${tickets?.length || 0} tickets.`);
+    if (!tickets || tickets.length === 0) {
+        console.error("No tickets found to start work on. Seed data missing?");
+        return;
+    }
+    const ticketId = tickets[0].id;
+    console.log(`Target Ticket ID: ${ticketId}`);
+    // 2. Start Work (Transition ticket)
+    console.log("\n[2] Starting Work...");
+    const startResult = await execute("transition_ticket", { ticket_id: parseInt(ticketId), event: "start_work" });
+    if (startResult.isError) {
+        console.error("Start Work Failed:", startResult.content[0].text);
+        return;
+    }
+    console.log("Start Work Successful:", startResult.content[0].text.substring(0, 100) + "...");
+    // 3. Submit Review (Transition ticket)
+    console.log("\n[3] Submitting for Review...");
+    const submitResult = await execute("transition_ticket", { ticket_id: parseInt(ticketId), event: "submit_review" });
+    if (submitResult.isError) {
+        console.error("Submit Review Failed:", submitResult.content[0].text);
+    }
+    else {
+        console.log("Submit Review Result:", submitResult.content[0].text.substring(0, 100) + "...");
+    }
+    // 4. Search Memory
+    console.log("\n[4] Searching Memory...");
+    const searchResult = await execute("search_memory", { query: "Verified" });
+    console.log("Search Result:", searchResult.content[0].text);
+    console.log("\n=== Verification Completed ===");
+}
+verify().catch(error => {
+    console.error("Verification Script Error:", error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "tinker-mcp",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "bin": {
+    "tinker-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.1",
+    "axios": "^1.13.2",
+    "dotenv": "^17.2.3",
+    "zod": "^4.2.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.0.3",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}