@askmesh/mcp 0.6.0 → 0.7.1

package/dist/agent/auto_responder.js

@@ -17,6 +17,11 @@ export class AutoResponder {
     }
     async handleRequest(request) {
         console.error(`[AskMesh] Question from @${request.fromUsername}: "${request.question}"`);
+        // Mark thread as in_progress before processing
+        try {
+            await this.client.updateThreadStatus(request.id, 'in_progress');
+        }
+        catch { }
         // Strategy 1: MCP sampling — asks the active Claude Code to respond
         // Uses the user's existing Claude subscription, no API key needed
         if (this.mcpServer) {
@@ -57,11 +62,11 @@ export class AutoResponder {
                     return;
                 }
             }
-            catch {
-                console.error('[AskMesh] MCP sampling not available');
+            catch (err) {
+                console.error('[AskMesh] MCP sampling failed:', err instanceof Error ? err.message : err);
             }
         }
-        // Strategy 2: Anthropic API fallback (optional — for standalone/server mode)
+        // Strategy 2: Anthropic API fallback (optional)
         const apiKey = process.env.ANTHROPIC_API_KEY;
         if (apiKey) {
             try {
@@ -77,8 +82,23 @@ export class AutoResponder {
                 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 respond`);
+        // Strategy 3: Notify Claude Code and revert to pending
+        // Revert status so the message can be answered manually
+        try {
+            await this.client.updateThreadStatus(request.id, 'pending');
+        }
+        catch { }
+        // Send logging notification to Claude Code
+        if (this.mcpServer) {
+            try {
+                await this.mcpServer.sendLoggingMessage({
+                    level: 'warning',
+                    data: `📩 AskMesh — @${request.fromUsername} asks: "${request.question.slice(0, 200)}" → Use askmesh(action:"pending") to see and reply.`,
+                });
+            }
+            catch { }
+        }
+        console.error(`[AskMesh] Question #${request.id} from @${request.fromUsername} — auto-response failed, use askmesh(action:"pending") to respond`);
     }
     async callAnthropicAPI(apiKey, request, context) {
         const model = process.env.ANTHROPIC_MODEL || 'claude-sonnet-4-20250514';

package/dist/client/askmesh_client.d.ts

@@ -3,7 +3,7 @@ export declare class AskMeshClient {
     private token;
     constructor(baseUrl: string, token: string);
     private headers;
-    askAgent(toUsername: string, question: string, context?: string): Promise<{
+    askAgent(toUsername: string, question: string, context?: string, parentThreadId?: number): Promise<{
         requestId: number;
         status: string;
     }>;
@@ -84,4 +84,29 @@ export declare class AskMeshClient {
             createdAt: string;
         }>;
     }>;
+    updateThreadStatus(requestId: number, status: 'pending' | 'in_progress' | 'delegated'): Promise<{
+        id: number;
+        status: string;
+    }>;
+    getMyThreads(): Promise<{
+        threads: Array<{
+            id: number;
+            fromUsername: string;
+            toUsername: string;
+            question: string;
+            status: string;
+            replyCount: number;
+            parentThreadId: number | null;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    }>;
+    getTeamBoard(teamId: number): Promise<{
+        columns: {
+            pending: any[];
+            in_progress: any[];
+            active: any[];
+            closed: any[];
+        };
+    }>;
 }

package/dist/client/askmesh_client.js

@@ -11,11 +11,11 @@ export class AskMeshClient {
             'Content-Type': 'application/json',
         };
     }
-    async askAgent(toUsername, question, context) {
+    async askAgent(toUsername, question, context, parentThreadId) {
         const res = await fetch(`${this.baseUrl}/api/v1/requests`, {
             method: 'POST',
             headers: this.headers(),
-            body: JSON.stringify({ toUsername, question, context }),
+            body: JSON.stringify({ toUsername, question, context, parentThreadId }),
         });
         if (!res.ok)
             throw new Error(`askAgent failed: ${res.status} ${await res.text()}`);
@@ -108,4 +108,30 @@ export class AskMeshClient {
             throw new Error(`getThread failed: ${res.status}`);
         return res.json();
     }
+    async updateThreadStatus(requestId, status) {
+        const res = await fetch(`${this.baseUrl}/api/v1/requests/${requestId}/status`, {
+            method: 'PUT',
+            headers: this.headers(),
+            body: JSON.stringify({ status }),
+        });
+        if (!res.ok)
+            throw new Error(`updateThreadStatus failed: ${res.status} ${await res.text()}`);
+        return res.json();
+    }
+    async getMyThreads() {
+        const res = await fetch(`${this.baseUrl}/api/v1/requests/my-threads`, {
+            headers: this.headers(),
+        });
+        if (!res.ok)
+            throw new Error(`getMyThreads failed: ${res.status}`);
+        return res.json();
+    }
+    async getTeamBoard(teamId) {
+        const res = await fetch(`${this.baseUrl}/api/v1/teams/${teamId}/board`, {
+            headers: this.headers(),
+        });
+        if (!res.ok)
+            throw new Error(`getTeamBoard failed: ${res.status}`);
+        return res.json();
+    }
 }

package/dist/index.js

@@ -15,7 +15,7 @@ const client = new AskMeshClient(URL, TOKEN);
 const autoResponder = new AutoResponder(client);
 const server = new McpServer({
     name: 'askmesh',
-    version: '0.3.0',
+    version: '0.7.0',
 });
 // Single unified tool
 registerAskMesh(server, client);

package/dist/tools/askmesh.js

@@ -12,20 +12,25 @@ Actions:
 - "reply" : ajouter une réponse à un thread existant
 - "thread" : voir le thread complet d'une question
 - "close" : clôturer un thread
+- "my-threads" : voir tous tes threads actifs
+- "board" : voir le kanban board d'une team
+- "progress" : marquer un thread comme "en cours de traitement"
 - "context" : partager ton contexte projet avec ta team`, {
-        action: z.enum(['ask', 'list', 'status', 'pending', 'inbox', 'answer', 'reply', 'thread', 'close', 'context']).describe('Action à effectuer'),
+        action: z.enum(['ask', 'list', 'status', 'pending', 'inbox', 'answer', 'reply', 'thread', 'close', 'my-threads', 'board', 'progress', '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/reply/thread/close)'),
+        requestId: z.number().optional().describe('ID de la requête (pour answer/reply/thread/close/progress)'),
         message: z.string().optional().describe('Réponse ou contexte à envoyer (pour answer/reply/context)'),
-    }, async ({ action, username, question, requestId, message }) => {
+        parentThreadId: z.number().optional().describe('ID du thread parent (pour ask, lie les threads entre eux)'),
+        teamId: z.number().optional().describe('ID de la team (pour board)'),
+    }, async ({ action, username, question, requestId, message, parentThreadId, teamId }) => {
         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 result = await client.askAgent(target, question, undefined, parentThreadId);
                 const reqId = result.requestId;
                 // Poll for answer (max 60s)
                 for (let i = 0; i < 20; i++) {
@@ -123,6 +128,47 @@ Actions:
                 const result = await client.closeThread(requestId);
                 return text(`Thread #${result.id} clôturé.`);
             }
+            case 'my-threads': {
+                const { threads } = await client.getMyThreads();
+                if (threads.length === 0)
+                    return text('Aucun thread actif.');
+                const statusIcons = {
+                    pending: '⏳', in_progress: '🔧', active: '💬', delegated: '📤', closed: '✅',
+                };
+                const lines = threads.map((t) => {
+                    const icon = statusIcons[t.status] || '❓';
+                    let line = `${icon} #${t.id} [${t.status}] @${t.fromUsername} → @${t.toUsername}: "${t.question}"`;
+                    if (t.replyCount > 0)
+                        line += ` (${t.replyCount} replies)`;
+                    if (t.parentThreadId)
+                        line += ` [lié au thread #${t.parentThreadId}]`;
+                    return line;
+                });
+                return text(`Mes threads:\n\n${lines.join('\n')}`);
+            }
+            case 'board': {
+                if (!teamId)
+                    return text("Paramètre requis : teamId");
+                const board = await client.getTeamBoard(teamId);
+                const formatCol = (name, items) => {
+                    if (items.length === 0)
+                        return `**${name}**: (vide)`;
+                    return `**${name}** (${items.length}):\n${items.map((t) => `  #${t.id} @${t.fromUsername}→@${t.toUsername}: "${t.question}" [${t.replyCount} replies]`).join('\n')}`;
+                };
+                const lines = [
+                    formatCol('Pending', board.columns.pending),
+                    formatCol('In Progress', board.columns.in_progress),
+                    formatCol('Active', board.columns.active),
+                    formatCol('Closed (24h)', board.columns.closed),
+                ];
+                return text(`Team Board:\n\n${lines.join('\n\n')}`);
+            }
+            case 'progress': {
+                if (!requestId)
+                    return text("Paramètre requis : requestId");
+                const result = await client.updateThreadStatus(requestId, 'in_progress');
+                return text(`Thread #${result.id} marqué comme en cours de traitement.`);
+            }
             case 'context': {
                 if (!message)
                     return text("Paramètre requis : message (le contenu du contexte)");

package/package.json

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