@askmesh/mcp 0.3.0 → 0.3.1

package/README.md

@@ -12,7 +12,7 @@ npx -y @askmesh/mcp
 
 ## Setup for Claude Code
 
-Add to `~/.claude/settings.json`:
+Add `.mcp.json` at the root of your project:
 
 ```json
 {
@@ -22,40 +22,51 @@ Add to `~/.claude/settings.json`:
       "args": ["-y", "@askmesh/mcp"],
       "env": {
         "ASKMESH_TOKEN": "your_token",
-        "ASKMESH_URL": "https://api.askmesh.dev",
-        "ANTHROPIC_API_KEY": "sk-ant-..."
+        "ASKMESH_URL": "https://api.askmesh.dev"
       }
     }
   }
 }
 ```
 
-Restart Claude Code. Your agent goes online and the 5 tools appear.
+Restart Claude Code. Your agent goes online and the `askmesh` tool appears.
 
 ## Get your token
 
 1. Sign up at [askmesh.dev](https://askmesh.dev)
 2. Go to **Settings** → copy your API token
 
-## Tools
+## Usage
 
-| Tool | Description |
+One single tool `askmesh` — Claude understands natural language:
+
+```
+"ask @pierre how he structures his migrations"
+"list available agents"
+"check if @manu is online"
+"see if I have pending questions"
+"answer question #42 with: use Redis TTL of 5min"
+"share my project context with the team"
+```
+
+### Actions
+
+| Action | Description |
 |---|---|
-| `ask_agent` | Ask a question to a teammate's agent |
-| `list_agents` | See who's online in your team |
-| `get_status` | Check if a specific agent is available |
-| `answer_pending` | List and respond to incoming questions |
-| `set_context` | Share your project context with your team |
+| `ask` | Ask a question to a teammate's agent (waits 60s for answer) |
+| `list` | See who's online in your teams |
+| `status` | Check if a specific agent is available |
+| `pending` | List incoming questions waiting for your response |
+| `answer` | Respond to a pending question |
+| `context` | Share your project context with your team |
 
 ## Auto-responder
 
-When `ANTHROPIC_API_KEY` is set, your agent automatically answers incoming questions using:
-
-- Your **CLAUDE.md** (project context)
-- Your **Claude Code memories** (`~/.claude/memory/`)
-- Your **project-specific memories**
+Questions are answered automatically using 3 strategies (in order):
 
-Without the API key, questions are queued and you respond manually via `answer_pending`.
+1. **MCP Sampling** — asks your active Claude Code to respond (no extra config)
+2. **Anthropic API** — reads your CLAUDE.md + memories, calls Claude API (requires `ANTHROPIC_API_KEY`)
+3. **Manual** — question stays pending, respond via `askmesh(action:"pending")`
 
 ## Environment variables
 
@@ -63,7 +74,7 @@ Without the API key, questions are queued and you respond manually via `answer_p
 |---|---|---|
 | `ASKMESH_TOKEN` | Yes | Your agent API token from askmesh.dev |
 | `ASKMESH_URL` | No | API URL (default: `https://api.askmesh.dev`) |
-| `ANTHROPIC_API_KEY` | No | Enables auto-responses via Claude API |
+| `ANTHROPIC_API_KEY` | No | Enables auto-responses via Claude API when MCP sampling unavailable |
 
 ## How it works
 
@@ -75,9 +86,8 @@ You (Claude Code)          AskMesh Cloud          Teammate (Claude Code)
       |                         |<--- ask @you "question" |
       |<-- SSE: request --------|                         |
       |                         |                         |
-      |  [reads CLAUDE.md +     |                         |
-      |   memories, calls       |                         |
-      |   Claude API]           |                         |
+      |  [auto-respond using    |                         |
+      |   CLAUDE.md + memories] |                         |
       |                         |                         |
       |--- answer ------------->|--- SSE: answer -------->|
 ```

package/dist/agent/auto_responder.d.ts

@@ -7,4 +7,5 @@ export declare class AutoResponder {
     constructor(client: AskMeshClient);
     setServer(server: Server): void;
     handleRequest(request: IncomingRequest): Promise<void>;
+    private callAnthropicAPI;
 }

package/dist/agent/auto_responder.js

@@ -1,3 +1,4 @@
+import { readLocalContext } from './context_reader.js';
 export class AutoResponder {
     client;
     mcpServer = null;
@@ -9,7 +10,7 @@ export class AutoResponder {
     }
     async handleRequest(request) {
         console.error(`[AskMesh] Question from @${request.fromUsername}: "${request.question}"`);
-        // Try MCP sampling — asks the active Claude Code to generate a response
+        // Strategy 1: MCP sampling — asks the active Claude Code to respond
         if (this.mcpServer) {
             try {
                 const result = (await this.mcpServer.request({
@@ -38,14 +39,63 @@ export class AutoResponder {
                 const answer = result?.content?.text || result?.content?.[0]?.text;
                 if (answer) {
                     await this.client.answerRequest(request.id, answer);
-                    console.error(`[AskMesh] Responded to #${request.id} via Claude Code`);
+                    console.error(`[AskMesh] Responded to #${request.id} via MCP sampling`);
                     return;
                 }
             }
             catch {
-                console.error('[AskMesh] Sampling not available — question queued');
+                console.error('[AskMesh] MCP sampling not available, trying API fallback...');
             }
         }
-        console.error(`[AskMesh] Question queued — use answer_pending to respond`);
+        // Strategy 2: Direct Anthropic API with local context
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (apiKey) {
+            try {
+                const context = readLocalContext();
+                const answer = await this.callAnthropicAPI(apiKey, request, context);
+                if (answer) {
+                    await this.client.answerRequest(request.id, answer);
+                    console.error(`[AskMesh] Responded to #${request.id} via Anthropic API`);
+                    return;
+                }
+            }
+            catch (err) {
+                console.error('[AskMesh] Anthropic API failed:', err);
+            }
+        }
+        // Strategy 3: Manual — question stays pending
+        console.error(`[AskMesh] Question #${request.id} queued — use askmesh(action:"pending") to see and respond`);
+    }
+    async callAnthropicAPI(apiKey, request, context) {
+        const response = await fetch('https://api.anthropic.com/v1/messages', {
+            method: 'POST',
+            headers: {
+                'x-api-key': apiKey,
+                'anthropic-version': '2023-06-01',
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: 'claude-sonnet-4-20250514',
+                max_tokens: 2048,
+                system: `You are an AI coding agent responding on behalf of a developer through AskMesh.
+You have access to the developer's project context below.
+Use this context to answer the question accurately and concisely.
+Reference specific files, conventions, or decisions from the context when relevant.
+If the context doesn't contain enough info, say so honestly.
+Answer in the same language as the question.
+Keep responses under 500 words unless more detail is needed.`,
+                messages: [
+                    {
+                        role: 'user',
+                        content: `Project context:\n\n${context}\n\n---\n\nQuestion from @${request.fromUsername}:\n${request.question}${request.context ? `\n\nAdditional context: ${request.context}` : ''}`,
+                    },
+                ],
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Anthropic API ${response.status}: ${await response.text()}`);
+        }
+        const data = (await response.json());
+        return data.content?.[0]?.text || null;
     }
 }

package/dist/agent/context_reader.d.ts

@@ -0,0 +1 @@
+export declare function readLocalContext(): string;

package/dist/agent/context_reader.js

@@ -0,0 +1,65 @@
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+export function readLocalContext() {
+    const parts = [];
+    // 1. CLAUDE.md from current working directory
+    const claudeMdPath = join(process.cwd(), 'CLAUDE.md');
+    if (existsSync(claudeMdPath)) {
+        parts.push('=== CLAUDE.md ===');
+        parts.push(readSafe(claudeMdPath));
+    }
+    // 2. Global Claude Code memories
+    const globalMemDir = join(homedir(), '.claude', 'memory');
+    if (existsSync(globalMemDir)) {
+        const files = safeReadDir(globalMemDir).filter((f) => f.endsWith('.md'));
+        if (files.length > 0) {
+            parts.push('=== Global memories ===');
+            for (const file of files.slice(0, 10)) {
+                const content = readSafe(join(globalMemDir, file));
+                if (content)
+                    parts.push(`--- ${file} ---\n${content}`);
+            }
+        }
+    }
+    // 3. Project-specific memories
+    const cwd = process.cwd();
+    const projectsDir = join(homedir(), '.claude', 'projects');
+    if (existsSync(projectsDir)) {
+        const cwdKey = cwd.replace(/\//g, '-').replace(/^-/, '');
+        const dirs = safeReadDir(projectsDir);
+        for (const dir of dirs) {
+            if (dir.includes(cwdKey) || cwdKey.includes(dir)) {
+                const memDir = join(projectsDir, dir, 'memory');
+                if (existsSync(memDir)) {
+                    const files = safeReadDir(memDir).filter((f) => f.endsWith('.md'));
+                    if (files.length > 0) {
+                        parts.push('=== Project memories ===');
+                        for (const file of files.slice(0, 10)) {
+                            const content = readSafe(join(memDir, file));
+                            if (content)
+                                parts.push(`--- ${file} ---\n${content}`);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return parts.join('\n\n') || 'No local context available.';
+}
+function readSafe(path) {
+    try {
+        return readFileSync(path, 'utf-8').trim();
+    }
+    catch {
+        return '';
+    }
+}
+function safeReadDir(path) {
+    try {
+        return readdirSync(path);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/sse/sse_listener.d.ts

@@ -11,6 +11,14 @@ export interface IncomingAnswer {
 }
 export declare class SseListener {
     private es;
+    private reconnectTimer;
+    private baseUrl;
+    private token;
+    private onRequest;
+    private onAnswer;
+    private connected;
     start(baseUrl: string, token: string, onRequest: (req: IncomingRequest) => void, onAnswer?: (ans: IncomingAnswer) => void): void;
+    private connect;
+    private scheduleReconnect;
     stop(): void;
 }

package/dist/sse/sse_listener.js

@@ -1,33 +1,77 @@
 import EventSource from 'eventsource';
 export class SseListener {
     es = null;
+    reconnectTimer = null;
+    baseUrl = '';
+    token = '';
+    onRequest = null;
+    onAnswer = null;
+    connected = false;
     start(baseUrl, token, onRequest, onAnswer) {
-        this.es = new EventSource(`${baseUrl}/api/v1/sse/subscribe`, {
-            headers: { Authorization: `Bearer ${token}` },
+        this.baseUrl = baseUrl;
+        this.token = token;
+        this.onRequest = onRequest;
+        this.onAnswer = onAnswer || null;
+        this.connect();
+    }
+    connect() {
+        if (this.es) {
+            this.es.close();
+            this.es = null;
+        }
+        this.es = new EventSource(`${this.baseUrl}/api/v1/sse/subscribe`, {
+            headers: { Authorization: `Bearer ${this.token}` },
         });
+        this.es.addEventListener('open', (() => {
+            this.connected = true;
+            console.error('[AskMesh SSE] Connected');
+        }));
         this.es.addEventListener('request_incoming', ((e) => {
             try {
                 const payload = JSON.parse(e.data);
-                onRequest(payload);
+                this.onRequest?.(payload);
             }
             catch { }
         }));
         this.es.addEventListener('answer_ready', ((e) => {
             try {
                 const payload = JSON.parse(e.data);
-                if (onAnswer)
-                    onAnswer(payload);
+                this.onAnswer?.(payload);
                 console.error(`[AskMesh] Answer received for request #${payload.id}`);
             }
             catch { }
         }));
-        this.es.addEventListener('ping', () => { });
+        this.es.addEventListener('ping', () => {
+            // Keepalive — confirms connection is alive
+        });
         this.es.onerror = () => {
-            console.error('[AskMesh SSE] Connection error — will reconnect');
+            if (this.connected) {
+                this.connected = false;
+                console.error('[AskMesh SSE] Disconnected — reconnecting in 5s...');
+            }
+            // EventSource auto-reconnects, but if it fails repeatedly
+            // we force a clean reconnect after 5s
+            this.scheduleReconnect();
         };
     }
+    scheduleReconnect() {
+        if (this.reconnectTimer)
+            return;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            if (!this.connected && this.es?.readyState === 2) {
+                console.error('[AskMesh SSE] Force reconnecting...');
+                this.connect();
+            }
+        }, 5000);
+    }
     stop() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
         this.es?.close();
         this.es = null;
+        this.connected = false;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askmesh/mcp",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "AskMesh MCP server — connect your AI coding agent to your team's mesh network",
   "type": "module",
   "bin": {