@askmesh/mcp 0.1.0 → 0.2.0

package/README.md

@@ -0,0 +1,87 @@
+# @askmesh/mcp
+
+MCP server for [AskMesh](https://askmesh.dev) — connect your AI coding agent to your team's mesh network.
+
+Your agent answers questions from teammates automatically using your project context.
+
+## Install
+
+```bash
+npx -y @askmesh/mcp
+```
+
+## Setup for Claude Code
+
+Add to `~/.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "askmesh": {
+      "command": "npx",
+      "args": ["-y", "@askmesh/mcp"],
+      "env": {
+        "ASKMESH_TOKEN": "your_token",
+        "ASKMESH_URL": "https://api.askmesh.dev",
+        "ANTHROPIC_API_KEY": "sk-ant-..."
+      }
+    }
+  }
+}
+```
+
+Restart Claude Code. Your agent goes online and the 5 tools appear.
+
+## Get your token
+
+1. Sign up at [askmesh.dev](https://askmesh.dev)
+2. Go to **Settings** → copy your API token
+
+## Tools
+
+| Tool | 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 |
+
+## 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**
+
+Without the API key, questions are queued and you respond manually via `answer_pending`.
+
+## Environment variables
+
+| Variable | Required | Description |
+|---|---|---|
+| `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 |
+
+## How it works
+
+```
+You (Claude Code)          AskMesh Cloud          Teammate (Claude Code)
+      |                         |                         |
+      |--- SSE connect -------->|                         |
+      |    (agent online)       |                         |
+      |                         |<--- ask @you "question" |
+      |<-- SSE: request --------|                         |
+      |                         |                         |
+      |  [reads CLAUDE.md +     |                         |
+      |   memories, calls       |                         |
+      |   Claude API]           |                         |
+      |                         |                         |
+      |--- answer ------------->|--- SSE: answer -------->|
+```
+
+## License
+
+MIT

package/dist/agent/auto_responder.d.ts

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

package/dist/agent/auto_responder.js

@@ -0,0 +1,61 @@
+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;
+    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)');
+        }
+    }
+    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}` : ''}`,
+                    },
+                ],
+            });
+            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}`);
+            }
+        }
+        catch (err) {
+            console.error(`[AskMesh] Auto-response failed:`, err);
+        }
+    }
+}

package/dist/agent/context_reader.d.ts

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

package/dist/agent/context_reader.js

@@ -0,0 +1,68 @@
+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 '';
+    }
+}

package/dist/index.js

@@ -3,6 +3,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 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';
@@ -15,9 +16,10 @@ if (!TOKEN) {
     process.exit(1);
 }
 const client = new AskMeshClient(URL, TOKEN);
+const autoResponder = new AutoResponder(client);
 const server = new McpServer({
     name: 'askmesh',
-    version: '0.1.0',
+    version: '0.2.0',
 });
 // Register all tools
 registerAskAgent(server, client);
@@ -25,10 +27,11 @@ registerListAgents(server, client);
 registerGetStatus(server, client);
 registerAnswerPending(server, client);
 registerSetContext(server, client);
-// Start SSE listener (marks agent online + receives incoming requests)
+// Start SSE listener — auto-respond to incoming questions
 const sse = new SseListener();
-sse.start(URL, TOKEN, (request) => {
+sse.start(URL, TOKEN, async (request) => {
     console.error(`[AskMesh] Incoming request from @${request.fromUsername}: "${request.question}"`);
+    await autoResponder.handleRequest(request);
 });
 // Cleanup on exit
 process.on('SIGINT', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askmesh/mcp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "AskMesh MCP server — connect your AI coding agent to your team's mesh network",
   "type": "module",
   "bin": {
@@ -32,6 +32,7 @@
   "homepage": "https://askmesh.dev",
   "license": "MIT",
   "dependencies": {
+    "@anthropic-ai/sdk": "^0.80.0",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "eventsource": "^2.0.2",
     "zod": "^4.3.6"