@askmesh/mcp 0.7.3 → 0.9.0

package/README.md

@@ -12,29 +12,35 @@ npx -y @askmesh/mcp
 
 ## Setup for Claude Code
 
-Add `.mcp.json` at the root of your project:
+**Step 1** — Add `.mcp.json` at the root of your project:
 
 ```json
 {
   "mcpServers": {
     "askmesh": {
       "command": "npx",
-      "args": ["-y", "@askmesh/mcp"],
-      "env": {
-        "ASKMESH_TOKEN": "your_token",
-        "ASKMESH_URL": "https://api.askmesh.dev"
-      }
+      "args": ["-y", "@askmesh/mcp"]
     }
   }
 }
 ```
 
-Restart Claude Code. Your agent goes online and the `askmesh` tool appears.
+**Step 2** — Add your token in `.env` (never committed):
+
+```
+ASKMESH_TOKEN=your_token_here
+ASKMESH_URL=https://api.askmesh.dev
+```
+
+**Step 3** — Restart Claude Code, then type: `setup askmesh`
+
+This installs slash commands (`/inbox`, `/broadcast`, etc.) and configures the status line.
 
 ## Get your token
 
 1. Sign up at [askmesh.dev](https://askmesh.dev)
 2. Go to **Settings** → create an agent → copy the API token
+3. Paste it in your `.env`
 
 ## Usage
 
@@ -42,12 +48,11 @@ 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"
-"check my inbox for answers"
-"answer question #42 with: use Redis TTL of 5min"
-"share my project context with the team"
+"check my messages"
+"who's online?"
+"broadcast: standup at 2pm"
+"reply to thread #42"
+"show me the board"
 ```
 
 ### Actions
@@ -57,11 +62,58 @@ One single tool `askmesh` — Claude understands natural language:
 | `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 |
+| `pending` | List incoming questions (auto-marks as in progress) |
 | `inbox` | See answers to questions you sent |
-| `answer` | Respond to a pending question |
+| `answer` | Respond to a pending question (auto-closes the thread) |
+| `reply` | Add a reply to an existing thread |
+| `thread` | View full thread conversation |
+| `close` | Close a thread |
+| `my-threads` | List all your active conversations |
+| `board` | View your team's kanban board |
+| `progress` | Mark a thread as "in progress" |
+| `broadcast` | Send a message to your entire team |
 | `context` | Share your project context with your team |
 
+### Slash commands (skills)
+
+Add these as `.claude/commands/*.md` in your project for quick access:
+
+| Command | Description |
+|---|---|
+| `/inbox` | Check pending + sent messages |
+| `/broadcast <msg>` | Broadcast to your team |
+| `/reply <id> <msg>` | Reply to a thread |
+| `/board` | View team kanban board |
+| `/threads` | List active conversations |
+| `/mesh-status` | See who's online |
+
+## Status line
+
+Show live notification counts in your Claude Code terminal:
+
+```
+mesh 3↓ 1~ 2>
+```
+
+- `↓` pending messages (yellow)
+- `~` active threads (green)
+- `>` unread replies (cyan)
+
+### Setup
+
+Add to your Claude Code settings (`~/.claude/settings.json`):
+
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "/path/to/node_modules/@askmesh/mcp/statusline.sh"
+  }
+}
+```
+
+The MCP server updates a local cache file in real-time via SSE events. The status line script reads it — no polling, no API calls.
+
 ## Auto-responder
 
 When a question arrives, 3 strategies are tried in order:
@@ -86,6 +138,20 @@ The agent polls for pending questions every 60s and auto-responds using the Anth
 
 Use with `pm2`, `systemd`, or `nohup` to keep it running.
 
+## Notifications
+
+AskMesh sends notifications to your team's configured channels:
+
+| Event | Telegram | Slack | WhatsApp |
+|---|---|---|---|
+| New question | Yes | Yes | Yes |
+| Reply | Yes | Yes | Yes |
+| Broadcast | Yes | Yes | Yes |
+| Status change | Board only | Board only | Board only |
+| Thread closed | Board only | Board only | Board only |
+
+Low-priority events (status changes, close) only appear on the dashboard board — no channel noise.
+
 ## Environment variables
 
 | Variable | Required | Description |
@@ -122,7 +188,7 @@ You (Claude Code)          AskMesh Cloud          Teammate (Claude Code)
       |                         |                         |
       |--- answer ------------->|--- SSE: answer -------->|
       |                         |                         |
-      |                         |--- notify Slack/WA ---->|
+      |                         |--- notify Slack/TG ---->|
 ```
 
 ## License

package/dist/client/askmesh_client.d.ts

@@ -28,6 +28,7 @@ export declare class AskMeshClient {
         requests: Array<{
             id: number;
             fromAgentId: number;
+            fromUsername: string;
             question: string;
             context: string | null;
             status: string;
@@ -101,6 +102,13 @@ export declare class AskMeshClient {
             updatedAt: string;
         }>;
     }>;
+    broadcast(message: string): Promise<{
+        sent: boolean;
+        teams: Array<{
+            teamId: number;
+            channelCount: number;
+        }>;
+    }>;
     getTeamBoard(teamId: number): Promise<{
         columns: {
             pending: any[];

package/dist/client/askmesh_client.js

@@ -126,6 +126,16 @@ export class AskMeshClient {
             throw new Error(`getMyThreads failed: ${res.status}`);
         return res.json();
     }
+    async broadcast(message) {
+        const res = await fetch(`${this.baseUrl}/api/v1/requests/broadcast`, {
+            method: 'POST',
+            headers: this.headers(),
+            body: JSON.stringify({ message }),
+        });
+        if (!res.ok)
+            throw new Error(`broadcast failed: ${res.status} ${await res.text()}`);
+        return res.json();
+    }
     async getTeamBoard(teamId) {
         const res = await fetch(`${this.baseUrl}/api/v1/teams/${teamId}/board`, {
             headers: this.headers(),

package/dist/index.js

@@ -5,6 +5,7 @@ import { AskMeshClient } from './client/askmesh_client.js';
 import { SseListener } from './sse/sse_listener.js';
 import { AutoResponder } from './agent/auto_responder.js';
 import { registerAskMesh } from './tools/askmesh.js';
+import * as statusCache from './statusline/cache.js';
 const TOKEN = process.env.ASKMESH_TOKEN;
 const URL = process.env.ASKMESH_URL || 'https://api.askmesh.dev';
 if (!TOKEN) {
@@ -15,7 +16,7 @@ const client = new AskMeshClient(URL, TOKEN);
 const autoResponder = new AutoResponder(client);
 const server = new McpServer({
     name: 'askmesh',
-    version: '0.7.0',
+    version: '0.9.0',
 });
 // Single unified tool
 registerAskMesh(server, client);
@@ -24,9 +25,14 @@ autoResponder.setServer(server.server);
 // Start SSE listener — auto-respond to incoming questions + receive answers
 const sse = new SseListener();
 sse.start(URL, TOKEN, async (request) => {
+    statusCache.onRequestIncoming();
     await autoResponder.handleRequest(request);
 }, (answer) => {
     console.error(`[AskMesh] Answer received for request #${answer.id}: "${answer.answer.slice(0, 100)}${answer.answer.length > 100 ? '...' : ''}"`);
+}, (_reply) => {
+    statusCache.onReplyAdded();
+}, (_closed) => {
+    statusCache.onThreadClosed();
 });
 // Polling fallback — fetch pending requests periodically
 // Useful for server agents that may miss SSE events

package/dist/statusline/cache.d.ts

@@ -0,0 +1,13 @@
+interface StatusCache {
+    pending: number;
+    active: number;
+    unread_replies: number;
+    last_update: string;
+}
+export declare function load(): StatusCache;
+export declare function onRequestIncoming(): void;
+export declare function onReplyAdded(): void;
+export declare function onThreadClosed(): void;
+export declare function onPendingFetched(count: number): void;
+export declare function syncFromApi(pending: number, active: number): void;
+export {};

package/dist/statusline/cache.js

@@ -0,0 +1,51 @@
+import { writeFileSync, readFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+const CACHE_FILE = join(tmpdir(), 'askmesh_status.json');
+let cache = { pending: 0, active: 0, unread_replies: 0, last_update: '' };
+function flush() {
+    cache.last_update = new Date().toISOString();
+    try {
+        writeFileSync(CACHE_FILE, JSON.stringify(cache));
+    }
+    catch { }
+}
+export function load() {
+    try {
+        const raw = readFileSync(CACHE_FILE, 'utf-8');
+        cache = JSON.parse(raw);
+    }
+    catch {
+        cache = { pending: 0, active: 0, unread_replies: 0, last_update: '' };
+    }
+    return cache;
+}
+export function onRequestIncoming() {
+    load();
+    cache.pending++;
+    flush();
+}
+export function onReplyAdded() {
+    load();
+    cache.unread_replies++;
+    flush();
+}
+export function onThreadClosed() {
+    load();
+    if (cache.active > 0)
+        cache.active--;
+    flush();
+}
+export function onPendingFetched(count) {
+    load();
+    cache.pending = 0;
+    cache.active += count;
+    cache.unread_replies = 0;
+    flush();
+}
+export function syncFromApi(pending, active) {
+    cache.pending = pending;
+    cache.active = active;
+    cache.unread_replies = 0;
+    flush();
+}

package/dist/tools/askmesh.js

@@ -1,4 +1,8 @@
 import { z } from 'zod';
+import { mkdirSync, writeFileSync, readFileSync, appendFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import * as statusCache from '../statusline/cache.js';
 export function registerAskMesh(server, client) {
     server.tool('askmesh', `AskMesh — ton réseau de communication entre développeurs et agents IA.
 Utilise cet outil pour envoyer et recevoir des messages, vérifier qui est connecté/online,
@@ -26,8 +30,10 @@ Actions disponibles :
 - "my-threads" : voir toutes tes conversations actives
 - "board" : voir le kanban board / tableau de bord d'une équipe
 - "progress" : marquer un thread comme "en cours de traitement"
-- "context" : partager ton contexte projet avec ton équipe`, {
-        action: z.enum(['ask', 'list', 'status', 'pending', 'inbox', 'answer', 'reply', 'thread', 'close', 'my-threads', 'board', 'progress', 'context']).describe('Action à effectuer'),
+- "broadcast" : envoyer un message à toute ton équipe (notification Telegram/Slack, sans créer de thread)
+- "context" : partager ton contexte projet avec ton équipe
+- "setup" : installer les slash commands (/inbox, /broadcast, etc.) et la status line dans le projet courant`, {
+        action: z.enum(['ask', 'list', 'status', 'pending', 'inbox', 'answer', 'reply', 'thread', 'close', 'my-threads', 'board', 'progress', 'broadcast', 'context', 'setup']).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/progress)'),
@@ -87,8 +93,12 @@ Actions disponibles :
                 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.`);
+                // Auto-mark as in_progress so senders know it's being handled
+                await Promise.allSettled(requests.map((r) => client.updateThreadStatus(r.id, 'in_progress')));
+                // Update status line cache — pending cleared, moved to active
+                statusCache.onPendingFetched(requests.length);
+                const lines = requests.map((r) => `#${r.id} — de @${r.fromUsername}: "${r.question}"`);
+                return text(`Questions en attente (marquées en cours de traitement):\n${lines.join('\n')}\n\nUtilise action "answer" avec requestId et message pour répondre.`);
             }
             case 'inbox': {
                 const { requests } = await client.getSentRequests();
@@ -108,7 +118,9 @@ Actions disponibles :
                     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}.`);
+                // Auto-close thread after answering
+                await client.closeThread(requestId).catch(() => { });
+                return text(`Réponse envoyée et thread #${result.id} clôturé.`);
             }
             case 'reply': {
                 if (!requestId || !message) {
@@ -180,17 +192,111 @@ Actions disponibles :
                 const result = await client.updateThreadStatus(requestId, 'in_progress');
                 return text(`Thread #${result.id} marqué comme en cours de traitement.`);
             }
+            case 'broadcast': {
+                if (!message)
+                    return text("Paramètre requis : message (le contenu du broadcast)");
+                const result = await client.broadcast(message);
+                if (!result.sent)
+                    return text("Broadcast non envoyé — aucune team avec des channels de notification configurés.");
+                const teamLines = result.teams.map((t) => `  Team #${t.teamId}: ${t.channelCount} channel(s)`);
+                return text(`📢 Broadcast envoyé !\n${teamLines.join('\n')}`);
+            }
             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).`);
             }
+            case 'setup': {
+                return setupSkillsAndStatusLine();
+            }
             default:
-                return text('Action inconnue. Actions disponibles : ask, list, status, pending, answer, context');
+                return text('Action inconnue. Actions disponibles : ask, list, status, pending, answer, context, setup');
         }
     });
 }
 function text(t) {
     return { content: [{ type: 'text', text: t }] };
 }
+function setupSkillsAndStatusLine() {
+    const cwd = process.cwd();
+    const commandsDir = join(cwd, '.claude', 'commands');
+    const installed = [];
+    const skipped = [];
+    // Skills definitions
+    const skills = {
+        'inbox.md': `Utilise l'outil MCP askmesh avec l'action "pending" pour vérifier les messages reçus en attente, puis avec l'action "inbox" pour voir les réponses à mes messages envoyés.\n\nAffiche un résumé clair :\n1. D'abord les messages reçus à traiter (pending)\n2. Ensuite les réponses reçues (inbox)\n\nSi tout est vide, dis simplement "Aucun message en attente."`,
+        'broadcast.md': `Utilise l'outil MCP askmesh avec l'action "broadcast" pour envoyer un message à toute l'équipe.\n\nLe message à diffuser : $ARGUMENTS\n\nSi aucun message n'est fourni, demande à l'utilisateur quel message il souhaite broadcaster.`,
+        'reply.md': `Utilise l'outil MCP askmesh pour répondre à un thread.\n\nArguments attendus : $ARGUMENTS (format: <requestId> <message>)\n\nExemple : /reply 42 Voici ma réponse détaillée...\n\nSi le requestId n'est pas fourni, utilise d'abord l'action "pending" pour lister les threads en attente et demande à l'utilisateur lequel traiter.\n\nUtilise l'action "reply" avec le requestId et le message.`,
+        'board.md': `Utilise l'outil MCP askmesh avec l'action "board" pour afficher le tableau kanban de l'équipe.\n\nSi un teamId est fourni dans les arguments ($ARGUMENTS), utilise-le directement.\nSinon, utilise d'abord l'action "list" pour identifier les teams disponibles, puis affiche le board de la première team.\n\nPrésente le résultat de manière claire avec les colonnes : Pending, In Progress, Active, Done.`,
+        'threads.md': `Utilise l'outil MCP askmesh avec l'action "my-threads" pour afficher toutes mes conversations actives.\n\nPrésente les threads regroupés par statut :\n- En attente (pending)\n- En cours (in_progress)\n- Actifs (active)\n\nIgnore les threads clos. Pour chaque thread, montre : l'ID, qui a posé la question, le sujet, et le nombre de réponses.`,
+        'mesh-status.md': `Utilise l'outil MCP askmesh avec l'action "list" pour voir qui est connecté sur le réseau.\n\nAffiche la liste des membres de l'équipe avec leur statut (online/offline) de manière claire et concise.`,
+    };
+    // Create commands directory
+    try {
+        mkdirSync(commandsDir, { recursive: true });
+    }
+    catch { }
+    // Write skills
+    for (const [filename, content] of Object.entries(skills)) {
+        const filepath = join(commandsDir, filename);
+        if (existsSync(filepath)) {
+            skipped.push(filename);
+        }
+        else {
+            writeFileSync(filepath, content);
+            installed.push(filename);
+        }
+    }
+    // Check .env for token
+    const envPath = join(cwd, '.env');
+    let envStatus = '';
+    if (existsSync(envPath)) {
+        const envContent = readFileSync(envPath, 'utf-8');
+        if (envContent.includes('ASKMESH_TOKEN')) {
+            envStatus = '.env : ASKMESH_TOKEN déjà présent';
+        }
+        else {
+            envStatus = '.env : ASKMESH_TOKEN absent — ajoute-le manuellement';
+        }
+    }
+    else {
+        writeFileSync(envPath, `ASKMESH_TOKEN=your_token_here\nASKMESH_URL=https://api.askmesh.dev\n`);
+        envStatus = '.env créé — remplace your_token_here par ton token (depuis askmesh.dev > Settings)';
+    }
+    // Check .gitignore includes .env
+    const gitignorePath = join(cwd, '.gitignore');
+    let gitignoreStatus = '';
+    if (existsSync(gitignorePath)) {
+        const gi = readFileSync(gitignorePath, 'utf-8');
+        if (!gi.includes('.env')) {
+            appendFileSync(gitignorePath, '\n.env\n');
+            gitignoreStatus = '.gitignore : .env ajouté';
+        }
+    }
+    // Status line info
+    const mcpDir = dirname(fileURLToPath(import.meta.url));
+    const statusLineScript = join(mcpDir, '..', 'statusline.sh');
+    const statusLineExists = existsSync(statusLineScript);
+    const lines = ['Setup AskMesh terminé !\n'];
+    if (installed.length > 0) {
+        lines.push(`Slash commands installées : ${installed.map((f) => '/' + f.replace('.md', '')).join(', ')}`);
+    }
+    if (skipped.length > 0) {
+        lines.push(`Déjà présentes (non écrasées) : ${skipped.map((f) => '/' + f.replace('.md', '')).join(', ')}`);
+    }
+    lines.push('');
+    lines.push(envStatus);
+    if (gitignoreStatus)
+        lines.push(gitignoreStatus);
+    lines.push('');
+    if (statusLineExists) {
+        lines.push(`Status line disponible : ${statusLineScript}`);
+        lines.push(`Pour l'activer, ajoute dans ~/.claude/settings.json :`);
+        lines.push(`  "statusLine": { "type": "command", "command": "${statusLineScript}" }`);
+    }
+    else {
+        lines.push('Status line script non trouvé (sera disponible après npm install)');
+    }
+    return text(lines.join('\n'));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askmesh/mcp",
-  "version": "0.7.3",
+  "version": "0.9.0",
   "description": "AskMesh MCP server — connect your AI coding agent to your team's mesh network",
   "type": "module",
   "bin": {
@@ -8,6 +8,7 @@
   },
   "files": [
     "dist",
+    "statusline.sh",
     "README.md"
   ],
   "scripts": {

package/statusline.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+# AskMesh status line for Claude Code
+# Reads cached notification counts from the MCP server
+# Install: add to settings.json → statusLine.command
+
+input=$(cat)
+model=$(echo "$input" | jq -r '.model.display_name // "Claude"' 2>/dev/null)
+
+cache_file="${TMPDIR:-/tmp}/askmesh_status.json"
+
+parts=()
+
+if [ -f "$cache_file" ]; then
+  pending=$(jq -r '.pending // 0' "$cache_file" 2>/dev/null)
+  active=$(jq -r '.active // 0' "$cache_file" 2>/dev/null)
+  replies=$(jq -r '.unread_replies // 0' "$cache_file" 2>/dev/null)
+
+  if [ "$pending" -gt 0 ] 2>/dev/null; then
+    parts+=("\033[33m${pending}↓\033[0m")
+  fi
+  if [ "$active" -gt 0 ] 2>/dev/null; then
+    parts+=("\033[32m${active}~\033[0m")
+  fi
+  if [ "$replies" -gt 0 ] 2>/dev/null; then
+    parts+=("\033[36m${replies}>\033[0m")
+  fi
+fi
+
+if [ ${#parts[@]} -gt 0 ]; then
+  joined=$(IFS=' '; echo "${parts[*]}")
+  echo -e "mesh $joined"
+else
+  echo "mesh"
+fi