@dot-ai/adapter-claude 0.5.2 → 0.7.0

package/dist/mcp-server.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+/**
+ * dot-ai MCP server for Claude Code.
+ * Exposes extension tools as MCP tools via stdio transport.
+ * Zero dependencies — speaks JSON-RPC 2.0 directly.
+ *
+ * Usage in .claude/settings.json:
+ *   "mcpServers": {
+ *     "dot-ai": {
+ *       "command": "node",
+ *       "args": ["path/to/mcp-server.js"]
+ *     }
+ *   }
+ */
+import { DotAiRuntime } from '@dot-ai/core';
+// ── MCP Protocol constants ──
+const PROTOCOL_VERSION = '2024-11-05';
+const SERVER_NAME = 'dot-ai';
+const SERVER_VERSION = '0.6.0';
+// ── State ──
+let capabilities = [];
+let initialized = false;
+let initPromise = null;
+async function ensureInit() {
+    if (initialized)
+        return;
+    if (!initPromise) {
+        initPromise = initCapabilities();
+    }
+    return initPromise;
+}
+// ── Initialize runtime ──
+async function initCapabilities() {
+    if (initialized)
+        return;
+    try {
+        const workspaceRoot = process.cwd();
+        const runtime = new DotAiRuntime({ workspaceRoot });
+        await runtime.boot();
+        capabilities = runtime.capabilities;
+        initialized = true;
+    }
+    catch (err) {
+        process.stderr.write(`[dot-ai-mcp] Init error: ${err}\n`);
+    }
+}
+// ── MCP method handlers ──
+function handleInitialize(_params) {
+    return {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: {
+            tools: {},
+        },
+        serverInfo: {
+            name: SERVER_NAME,
+            version: SERVER_VERSION,
+        },
+    };
+}
+async function handleToolsList() {
+    await ensureInit();
+    return {
+        tools: capabilities.map((cap) => ({
+            name: cap.name,
+            description: cap.description,
+            inputSchema: {
+                ...cap.parameters,
+            },
+        })),
+    };
+}
+async function handleToolsCall(params) {
+    await ensureInit();
+    const name = params.name;
+    const args = (params.arguments ?? {});
+    const cap = capabilities.find((c) => c.name === name);
+    if (!cap) {
+        return {
+            content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+            isError: true,
+        };
+    }
+    try {
+        const result = await cap.execute(args);
+        return {
+            content: [{ type: 'text', text: result.text }],
+        };
+    }
+    catch (err) {
+        return {
+            content: [{ type: 'text', text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+}
+// ── Message handling ──
+function send(msg) {
+    const json = JSON.stringify(msg);
+    process.stdout.write(`Content-Length: ${Buffer.byteLength(json)}\r\n\r\n${json}`);
+}
+async function handleMessage(msg) {
+    // Notifications (no id) — just acknowledge
+    if (msg.method === 'notifications/initialized') {
+        ensureInit().catch((err) => process.stderr.write(`[dot-ai-mcp] Init error: ${err}\n`));
+        return;
+    }
+    if (msg.method === 'notifications/cancelled') {
+        return;
+    }
+    const id = msg.id;
+    try {
+        let result;
+        switch (msg.method) {
+            case 'initialize':
+                result = handleInitialize(msg.params ?? {});
+                break;
+            case 'tools/list':
+                result = await handleToolsList();
+                break;
+            case 'tools/call':
+                result = await handleToolsCall(msg.params ?? {});
+                break;
+            case 'ping':
+                result = {};
+                break;
+            default:
+                send({
+                    jsonrpc: '2.0',
+                    id,
+                    error: { code: -32601, message: `Method not found: ${msg.method}` },
+                });
+                return;
+        }
+        send({ jsonrpc: '2.0', id, result });
+    }
+    catch (err) {
+        send({
+            jsonrpc: '2.0',
+            id,
+            error: {
+                code: -32603,
+                message: err instanceof Error ? err.message : String(err),
+            },
+        });
+    }
+}
+// ── Stdio transport (Content-Length framing) ──
+function main() {
+    let buffer = '';
+    process.stdin.on('data', (chunk) => {
+        buffer += chunk.toString('utf-8');
+        // Process all complete messages in buffer
+        while (true) {
+            // Look for Content-Length header
+            const headerEnd = buffer.indexOf('\r\n\r\n');
+            if (headerEnd === -1)
+                break;
+            const header = buffer.slice(0, headerEnd);
+            const match = header.match(/Content-Length:\s*(\d+)/i);
+            if (!match) {
+                // Skip malformed header
+                buffer = buffer.slice(headerEnd + 4);
+                continue;
+            }
+            const contentLength = parseInt(match[1], 10);
+            const bodyStart = headerEnd + 4;
+            if (buffer.length < bodyStart + contentLength) {
+                // Wait for more data
+                break;
+            }
+            const body = buffer.slice(bodyStart, bodyStart + contentLength);
+            buffer = buffer.slice(bodyStart + contentLength);
+            try {
+                const msg = JSON.parse(body);
+                handleMessage(msg).catch((err) => {
+                    process.stderr.write(`[dot-ai-mcp] Handler error: ${err}\n`);
+                });
+            }
+            catch {
+                process.stderr.write('[dot-ai-mcp] Failed to parse JSON-RPC message\n');
+            }
+        }
+    });
+    process.stderr.write('[dot-ai-mcp] Server started\n');
+}
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dot-ai/adapter-claude",
-  "version": "0.5.2",
+  "version": "0.7.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/jogelin/dot-ai",
@@ -10,10 +10,11 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
-    "dot-ai-hook": "dist/hook.js"
+    "dot-ai-hook": "dist/hook.js",
+    "dot-ai-mcp": "dist/mcp-server.js"
   },
   "dependencies": {
-    "@dot-ai/core": "0.5.2"
+    "@dot-ai/core": "0.7.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",

package/plugin.json

@@ -1,15 +1,15 @@
 {
   "name": "dot-ai",
   "description": "dot-ai — deterministic context enrichment for Claude Code",
-  "version": "0.4.0",
+  "version": "0.7.0",
   "author": {
     "name": "Jonathan Gelin",
     "url": "https://smartsdlc.dev"
   },
-  "homepage": "https://github.com/smartsdlc/dot-ai-plugin",
+  "homepage": "https://github.com/jogelin/dot-ai",
   "repository": {
     "type": "git",
-    "url": "https://github.com/smartsdlc/dot-ai-plugin"
+    "url": "https://github.com/jogelin/dot-ai"
   },
   "license": "MIT",
   "hooks": "hooks/hooks.json"