@askmesh/mcp 0.2.0 → 0.3.0

package/dist/agent/auto_responder.d.ts

@@ -1,9 +1,10 @@
 import type { AskMeshClient } from '../client/askmesh_client.js';
 import type { IncomingRequest } from '../sse/sse_listener.js';
+import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
 export declare class AutoResponder {
-    private anthropic;
     private client;
-    private enabled;
+    private mcpServer;
     constructor(client: AskMeshClient);
+    setServer(server: Server): void;
     handleRequest(request: IncomingRequest): Promise<void>;
 }

package/dist/agent/auto_responder.js

@@ -1,61 +1,51 @@
-import Anthropic from '@anthropic-ai/sdk';
-import { readLocalContext } from './context_reader.js';
-const SYSTEM_PROMPT = `You are an AI coding agent responding on behalf of a developer through AskMesh.
-You have access to the developer's project context, CLAUDE.md, and memories below.
-Use this context to answer the question as if you were the developer's agent.
-
-Rules:
-- Answer concisely and technically
-- Reference specific files, conventions, or decisions from the context when relevant
-- If the context doesn't contain enough info to answer, say so honestly
-- Keep responses under 500 words unless the question requires more detail
-- Answer in the same language as the question`;
 export class AutoResponder {
-    anthropic;
     client;
-    enabled;
+    mcpServer = null;
     constructor(client) {
         this.client = client;
-        this.enabled = !!process.env.ANTHROPIC_API_KEY;
-        if (this.enabled) {
-            this.anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
-            console.error('[AskMesh] Auto-responder enabled');
-        }
-        else {
-            this.anthropic = null;
-            console.error('[AskMesh] Auto-responder disabled (no ANTHROPIC_API_KEY)');
-        }
+    }
+    setServer(server) {
+        this.mcpServer = server;
     }
     async handleRequest(request) {
-        if (!this.enabled) {
-            console.error(`[AskMesh] Question from @${request.fromUsername} — manual response needed (no API key)`);
-            return;
-        }
-        console.error(`[AskMesh] Auto-responding to @${request.fromUsername}: "${request.question}"`);
-        try {
-            const context = readLocalContext();
-            const response = await this.anthropic.messages.create({
-                model: 'claude-sonnet-4-20250514',
-                max_tokens: 2048,
-                system: SYSTEM_PROMPT,
-                messages: [
-                    {
-                        role: 'user',
-                        content: `Here is my project context:\n\n${context}\n\n---\n\nQuestion from @${request.fromUsername}:\n${request.question}${request.context ? `\n\nAdditional context: ${request.context}` : ''}`,
+        console.error(`[AskMesh] Question from @${request.fromUsername}: "${request.question}"`);
+        // Try MCP sampling — asks the active Claude Code to generate a response
+        if (this.mcpServer) {
+            try {
+                const result = (await this.mcpServer.request({
+                    method: 'sampling/createMessage',
+                    params: {
+                        messages: [
+                            {
+                                role: 'user',
+                                content: {
+                                    type: 'text',
+                                    text: [
+                                        `A teammate @${request.fromUsername} is asking you a question via AskMesh.`,
+                                        ``,
+                                        `Question: "${request.question}"`,
+                                        request.context ? `\nContext: ${request.context}` : '',
+                                        ``,
+                                        `Answer based on your knowledge of this project. Be concise and technical.`,
+                                        `Answer in the same language as the question.`,
+                                    ].join('\n'),
+                                },
+                            },
+                        ],
+                        maxTokens: 2048,
                     },
-                ],
-            });
-            const answer = response.content
-                .filter((block) => block.type === 'text')
-                .map((block) => block.text)
-                .join('\n');
-            if (answer) {
-                await this.client.answerRequest(request.id, answer);
-                console.error(`[AskMesh] Auto-responded to request #${request.id}`);
+                }, {}));
+                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`);
+                    return;
+                }
+            }
+            catch {
+                console.error('[AskMesh] Sampling not available — question queued');
             }
         }
-        catch (err) {
-            console.error(`[AskMesh] Auto-response failed:`, err);
-        }
+        console.error(`[AskMesh] Question queued — use answer_pending to respond`);
     }
 }

package/dist/client/askmesh_client.d.ts

@@ -7,6 +7,12 @@ export declare class AskMeshClient {
         requestId: number;
         status: string;
     }>;
+    getRequest(requestId: number): Promise<{
+        id: number;
+        status: string;
+        answer: string | null;
+        question: string;
+    }>;
     getPendingRequests(): Promise<{
         requests: Array<{
             id: number;

package/dist/client/askmesh_client.js

@@ -21,6 +21,14 @@ export class AskMeshClient {
             throw new Error(`askAgent failed: ${res.status} ${await res.text()}`);
         return res.json();
     }
+    async getRequest(requestId) {
+        const res = await fetch(`${this.baseUrl}/api/v1/requests/${requestId}`, {
+            headers: this.headers(),
+        });
+        if (!res.ok)
+            throw new Error(`getRequest failed: ${res.status}`);
+        return res.json();
+    }
     async getPendingRequests() {
         const res = await fetch(`${this.baseUrl}/api/v1/requests/pending`, {
             headers: this.headers(),

package/dist/index.js

@@ -4,11 +4,7 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { AskMeshClient } from './client/askmesh_client.js';
 import { SseListener } from './sse/sse_listener.js';
 import { AutoResponder } from './agent/auto_responder.js';
-import { registerAskAgent } from './tools/ask_agent.js';
-import { registerListAgents } from './tools/list_agents.js';
-import { registerGetStatus } from './tools/get_status.js';
-import { registerAnswerPending } from './tools/answer_pending.js';
-import { registerSetContext } from './tools/set_context.js';
+import { registerAskMesh } from './tools/askmesh.js';
 const TOKEN = process.env.ASKMESH_TOKEN;
 const URL = process.env.ASKMESH_URL || 'https://api.askmesh.dev';
 if (!TOKEN) {
@@ -19,19 +15,18 @@ const client = new AskMeshClient(URL, TOKEN);
 const autoResponder = new AutoResponder(client);
 const server = new McpServer({
     name: 'askmesh',
-    version: '0.2.0',
+    version: '0.3.0',
 });
-// Register all tools
-registerAskAgent(server, client);
-registerListAgents(server, client);
-registerGetStatus(server, client);
-registerAnswerPending(server, client);
-registerSetContext(server, client);
-// Start SSE listener — auto-respond to incoming questions
+// Single unified tool
+registerAskMesh(server, client);
+// Give the auto-responder access to the underlying MCP server for sampling
+autoResponder.setServer(server.server);
+// Start SSE listener — auto-respond to incoming questions + receive answers
 const sse = new SseListener();
 sse.start(URL, TOKEN, async (request) => {
-    console.error(`[AskMesh] Incoming request from @${request.fromUsername}: "${request.question}"`);
     await autoResponder.handleRequest(request);
+}, (answer) => {
+    console.error(`[AskMesh] Answer received for request #${answer.id}: "${answer.answer.slice(0, 100)}${answer.answer.length > 100 ? '...' : ''}"`);
 });
 // Cleanup on exit
 process.on('SIGINT', () => {

package/dist/sse/sse_listener.d.ts

@@ -5,8 +5,12 @@ export interface IncomingRequest {
     question: string;
     context: string | null;
 }
+export interface IncomingAnswer {
+    id: number;
+    answer: string;
+}
 export declare class SseListener {
     private es;
-    start(baseUrl: string, token: string, onRequest: (req: IncomingRequest) => void): void;
+    start(baseUrl: string, token: string, onRequest: (req: IncomingRequest) => void, onAnswer?: (ans: IncomingAnswer) => void): void;
     stop(): void;
 }

package/dist/sse/sse_listener.js

@@ -1,7 +1,7 @@
 import EventSource from 'eventsource';
 export class SseListener {
     es = null;
-    start(baseUrl, token, onRequest) {
+    start(baseUrl, token, onRequest, onAnswer) {
         this.es = new EventSource(`${baseUrl}/api/v1/sse/subscribe`, {
             headers: { Authorization: `Bearer ${token}` },
         });
@@ -10,15 +10,19 @@ export class SseListener {
                 const payload = JSON.parse(e.data);
                 onRequest(payload);
             }
-            catch {
-                // ignore parse errors
+            catch { }
+        }));
+        this.es.addEventListener('answer_ready', ((e) => {
+            try {
+                const payload = JSON.parse(e.data);
+                if (onAnswer)
+                    onAnswer(payload);
+                console.error(`[AskMesh] Answer received for request #${payload.id}`);
             }
+            catch { }
         }));
-        this.es.addEventListener('ping', () => {
-            // keepalive — nothing to do
-        });
+        this.es.addEventListener('ping', () => { });
         this.es.onerror = () => {
-            // EventSource handles automatic reconnection
             console.error('[AskMesh SSE] Connection error — will reconnect');
         };
     }

package/dist/tools/ask_agent.js

@@ -1,17 +1,36 @@
 import { z } from 'zod';
 export function registerAskAgent(server, client) {
-    server.tool('ask_agent', 'Pose une question à un agent de ton équipe par son username', {
+    server.tool('ask_agent', 'Pose une question à un agent de ton équipe. Attend la réponse (max 60s).', {
         username: z.string().describe("Username de l'agent cible (ex: manu)"),
         question: z.string().describe('La question à poser'),
         context: z.string().optional().describe('Contexte additionnel (optionnel)'),
     }, async ({ username, question, context }) => {
         const target = username.replace(/^@/, '');
         const result = await client.askAgent(target, question, context);
+        const requestId = result.requestId;
+        // Poll for the answer (max 60s, check every 3s)
+        for (let i = 0; i < 20; i++) {
+            await new Promise((r) => setTimeout(r, 3000));
+            try {
+                const req = await client.getRequest(requestId);
+                if (req.status === 'answered' && req.answer) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `@${target} a répondu :\n\n${req.answer}`,
+                            },
+                        ],
+                    };
+                }
+            }
+            catch { }
+        }
         return {
             content: [
                 {
                     type: 'text',
-                    text: `Question envoyée à @${target} (request #${result.requestId})\nStatut: ${result.status}`,
+                    text: `Question envoyée à @${target} (request #${requestId}). L'agent n'a pas encore répondu (timeout 60s). La réponse arrivera plus tard — vérifie avec answer_pending.`,
                 },
             ],
         };

package/dist/tools/askmesh.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { AskMeshClient } from '../client/askmesh_client.js';
+export declare function registerAskMesh(server: McpServer, client: AskMeshClient): void;

package/dist/tools/askmesh.js

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+export function registerAskMesh(server, client) {
+    server.tool('askmesh', `AskMesh — communique avec les agents de ton équipe.
+
+Actions:
+- "ask" : pose une question à un agent (attend la réponse max 60s)
+- "list" : liste les agents de tes teams et leur statut
+- "status" : vérifie si un agent est disponible
+- "pending" : voir les questions qu'on t'a posées
+- "answer" : répondre à une question en attente
+- "context" : partager ton contexte projet avec ta team`, {
+        action: z.enum(['ask', 'list', 'status', 'pending', 'answer', 'context']).describe('Action à effectuer'),
+        username: z.string().optional().describe("Username de l'agent cible (pour ask/status)"),
+        question: z.string().optional().describe('Question à poser (pour ask)'),
+        requestId: z.number().optional().describe('ID de la requête (pour answer)'),
+        message: z.string().optional().describe('Réponse ou contexte à envoyer (pour answer/context)'),
+    }, async ({ action, username, question, requestId, message }) => {
+        switch (action) {
+            case 'ask': {
+                if (!username || !question) {
+                    return text("Paramètres requis : username et question");
+                }
+                const target = username.replace(/^@/, '');
+                const result = await client.askAgent(target, question);
+                const reqId = result.requestId;
+                // Poll for answer (max 60s)
+                for (let i = 0; i < 20; i++) {
+                    await new Promise((r) => setTimeout(r, 3000));
+                    try {
+                        const req = await client.getRequest(reqId);
+                        if (req.status === 'answered' && req.answer) {
+                            return text(`@${target} a répondu :\n\n${req.answer}`);
+                        }
+                    }
+                    catch { }
+                }
+                return text(`Question envoyée à @${target} (#${reqId}). Pas de réponse dans les 60s — utilise "pending" pour vérifier plus tard.`);
+            }
+            case 'list': {
+                const { agents } = await client.listAgents();
+                if (agents.length === 0)
+                    return text('Aucun agent dans tes teams.');
+                const lines = agents.map((a) => {
+                    const icon = a.status === 'online' ? '🟢' : '⚫';
+                    return `${icon} @${a.username} — ${a.status}`;
+                });
+                return text(lines.join('\n'));
+            }
+            case 'status': {
+                if (!username)
+                    return text("Paramètre requis : username");
+                const target = username.replace(/^@/, '');
+                const result = await client.getAgentStatus(target);
+                const icon = result.status === 'online' ? '🟢' : '⚫';
+                return text(`${icon} @${result.username} — ${result.status}${result.lastSeenAt ? `\nDernière activité: ${result.lastSeenAt}` : ''}`);
+            }
+            case 'pending': {
+                const { requests } = await client.getPendingRequests();
+                if (requests.length === 0)
+                    return text('Aucune question en attente.');
+                const lines = requests.map((r) => `#${r.id} — "${r.question}"`);
+                return text(`Questions en attente:\n${lines.join('\n')}\n\nUtilise action "answer" avec requestId et message pour répondre.`);
+            }
+            case 'answer': {
+                if (!requestId || !message) {
+                    return text("Paramètres requis : requestId et message");
+                }
+                const result = await client.answerRequest(requestId, message);
+                return text(`Réponse envoyée pour la requête #${result.id}.`);
+            }
+            case 'context': {
+                if (!message)
+                    return text("Paramètre requis : message (le contenu du contexte)");
+                await client.setContext(message);
+                return text(`Contexte mis à jour (${message.length} caractères).`);
+            }
+            default:
+                return text('Action inconnue. Actions disponibles : ask, list, status, pending, answer, context');
+        }
+    });
+}
+function text(t) {
+    return { content: [{ type: 'text', text: t }] };
+}

package/package.json

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

package/dist/agent/context_reader.d.ts

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

package/dist/agent/context_reader.js

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