lunaarc-mcp 1.2.5 → 1.2.7

package/dist/api/client.d.ts

@@ -52,10 +52,24 @@ interface AIAssignedCard {
     due_date: string | null;
     created_at: string;
     updated_at: string;
-    agent_id: string | null;
     agent_name: string | null;
-    agent_slug: string | null;
-    agent_content: string | null;
+}
+interface ProjectAgent {
+    id: string;
+    name: string;
+    description: string | null;
+    tools: string[];
+    model: string;
+    synced_at: string;
+    usage_count: number;
+}
+interface PredefinedAgent {
+    id: string;
+    name: string;
+    slug: string;
+    description: string | null;
+    content: string;
+    icon: string | null;
 }
 interface KanbanColumn {
     id: string;
@@ -175,6 +189,14 @@ export declare class LunaArcApiClient {
         id: string;
         message: string;
     }>;
+    syncAgents(agents: Array<{
+        name: string;
+        description: string;
+        tools: string[];
+        model: string;
+    }>): Promise<number>;
+    listAgents(): Promise<ProjectAgent[]>;
+    getPredefinedAgents(): Promise<PredefinedAgent[]>;
 }
 export declare function createApiClient(): LunaArcApiClient;
 export {};

package/dist/api/client.js

@@ -108,6 +108,20 @@ class LunaArcApiClient {
             body: JSON.stringify(params),
         });
     }
+    // Agent API methods
+    async syncAgents(agents) {
+        const result = await this.request('/agents/sync', {
+            method: 'POST',
+            body: JSON.stringify({ agents }),
+        });
+        return result.count;
+    }
+    async listAgents() {
+        return this.request('/agents');
+    }
+    async getPredefinedAgents() {
+        return this.request('/agents/predefined');
+    }
 }
 exports.LunaArcApiClient = LunaArcApiClient;
 // Create client instance from environment variables

package/dist/server.js

@@ -8,8 +8,9 @@ const client_js_1 = require("./api/client.js");
 const wiki_js_1 = require("./tools/wiki.js");
 const kanban_js_1 = require("./tools/kanban.js");
 const todos_js_1 = require("./tools/todos.js");
+const agents_js_1 = require("./tools/agents.js");
 // All available tools
-const allTools = [...wiki_js_1.wikiTools, ...kanban_js_1.kanbanTools, ...todos_js_1.todosTools];
+const allTools = [...wiki_js_1.wikiTools, ...kanban_js_1.kanbanTools, ...todos_js_1.todosTools, ...agents_js_1.agentTools];
 // Create API client
 let apiClient;
 try {
@@ -26,7 +27,7 @@ catch (error) {
 // Create MCP server
 const server = new index_js_1.Server({
     name: 'lunaarc-mcp',
-    version: '1.2.4',
+    version: '1.2.7',
 }, {
     capabilities: {
         tools: {},
@@ -52,6 +53,9 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
         else if (name.startsWith('todos_')) {
             return await (0, todos_js_1.handleTodosTool)(apiClient, name, args || {});
         }
+        else if (name.startsWith('agents_')) {
+            return await (0, agents_js_1.handleAgentTool)(apiClient, name, args || {});
+        }
         else {
             throw new Error(`Unknown tool: ${name}`);
         }
@@ -77,6 +81,14 @@ async function main() {
     console.error('LunaArc MCP Server started');
     console.error(`API URL: ${process.env.LUNAARC_API_URL}`);
     console.error(`Available tools: ${allTools.map((t) => t.name).join(', ')}`);
+    // Handle graceful shutdown
+    const shutdown = async () => {
+        console.error('LunaArc MCP Server shutting down...');
+        await server.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
 }
 main().catch((error) => {
     console.error('Fatal error:', error);

package/dist/tools/agents.d.ts

@@ -0,0 +1,50 @@
+import { LunaArcApiClient } from '../api/client.js';
+export declare const agentTools: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            agents_dir: {
+                type: string;
+                description: string;
+            };
+            overwrite?: undefined;
+        };
+        required: never[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            agents_dir?: undefined;
+            overwrite?: undefined;
+        };
+        required: never[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            agents_dir: {
+                type: string;
+                description: string;
+            };
+            overwrite: {
+                type: string;
+                description: string;
+            };
+        };
+        required: never[];
+    };
+})[];
+export declare function handleAgentTool(client: LunaArcApiClient, toolName: string, args: Record<string, unknown>): Promise<{
+    content: {
+        type: 'text';
+        text: string;
+    }[];
+}>;

package/dist/tools/agents.js

@@ -0,0 +1,354 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentTools = void 0;
+exports.handleAgentTool = handleAgentTool;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Tool definitions for agent operations
+exports.agentTools = [
+    {
+        name: 'agents_sync',
+        description: `Sync local Claude Code agents to LunaArc project.
+
+Reads all agent files from .claude/agents/ directory and syncs them to the project.
+Agent files must be Markdown with YAML frontmatter containing: name, description, tools, model.
+
+Example agent file:
+\`\`\`markdown
+---
+name: layout-designer
+description: Layout design specialist...
+tools: Read, Grep, Glob, Edit
+model: haiku
+---
+System prompt here...
+\`\`\`
+
+This allows the project to know which agents are available for card assignment.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agents_dir: {
+                    type: 'string',
+                    description: 'Path to agents directory (default: .claude/agents/)',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'agents_list',
+        description: 'List all AI agents synced to this project. Shows agent names, descriptions, tools, and usage count.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: 'agents_download',
+        description: `Download predefined LunaArc agents to your local project.
+
+Downloads optimized, ready-to-use agent files from LunaArc to your .claude/agents/ directory.
+These agents are maintained by LunaArc and include best practices for common development tasks.
+
+Perfect for users who want to get started quickly without creating custom agents.
+After download, you can customize the agents or use them as-is.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agents_dir: {
+                    type: 'string',
+                    description: 'Target directory for agent files (default: .claude/agents/)',
+                },
+                overwrite: {
+                    type: 'boolean',
+                    description: 'Overwrite existing agent files (default: false)',
+                },
+            },
+            required: [],
+        },
+    },
+];
+// Parse agent frontmatter from markdown file
+function parseAgentFile(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        // Extract YAML frontmatter between --- markers
+        const match = content.match(/^---\n([\s\S]*?)\n---/);
+        if (!match) {
+            console.error(`No frontmatter found in ${filePath}`);
+            return null;
+        }
+        const frontmatter = match[1];
+        // Parse YAML manually (simple key: value pairs)
+        const lines = frontmatter.split('\n');
+        const data = {};
+        for (const line of lines) {
+            const colonIndex = line.indexOf(':');
+            if (colonIndex > 0) {
+                const key = line.slice(0, colonIndex).trim();
+                const value = line.slice(colonIndex + 1).trim();
+                data[key] = value;
+            }
+        }
+        if (!data.name) {
+            console.error(`Missing 'name' in ${filePath}`);
+            return null;
+        }
+        // Parse tools (comma-separated)
+        const tools = data.tools
+            ? data.tools.split(',').map((t) => t.trim()).filter(Boolean)
+            : [];
+        return {
+            name: data.name,
+            description: data.description || '',
+            tools,
+            model: data.model || 'sonnet',
+        };
+    }
+    catch (error) {
+        console.error(`Error parsing ${filePath}:`, error);
+        return null;
+    }
+}
+// Tool handlers
+async function handleAgentTool(client, toolName, args) {
+    switch (toolName) {
+        case 'agents_sync': {
+            const agentsDir = args.agents_dir || '.claude/agents';
+            // Resolve path
+            const resolvedPath = path.isAbsolute(agentsDir)
+                ? agentsDir
+                : path.join(process.cwd(), agentsDir);
+            // Check if directory exists
+            if (!fs.existsSync(resolvedPath)) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ Agents directory not found: ${resolvedPath}
+
+Create the directory and add agent files:
+\`\`\`
+mkdir -p .claude/agents
+\`\`\`
+
+Then create agent files like \`.claude/agents/layout-designer.md\``,
+                        },
+                    ],
+                };
+            }
+            // Read all .md files
+            const files = fs.readdirSync(resolvedPath).filter((f) => f.endsWith('.md'));
+            if (files.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `⚠️ No agent files found in ${resolvedPath}
+
+Agent files must be Markdown files (.md) with YAML frontmatter.`,
+                        },
+                    ],
+                };
+            }
+            // Parse all agent files
+            const agents = [];
+            const errors = [];
+            for (const file of files) {
+                const filePath = path.join(resolvedPath, file);
+                const agent = parseAgentFile(filePath);
+                if (agent) {
+                    agents.push(agent);
+                }
+                else {
+                    errors.push(file);
+                }
+            }
+            if (agents.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ No valid agents found.
+
+Parsing errors in: ${errors.join(', ')}
+
+Ensure each file has valid YAML frontmatter with at least a 'name' field.`,
+                        },
+                    ],
+                };
+            }
+            // Sync to LunaArc
+            const count = await client.syncAgents(agents);
+            let output = `✅ ${count} agent(s) synced successfully!
+
+**Synced Agents:**
+`;
+            for (const agent of agents) {
+                output += `- **${agent.name}** [${agent.model}]\n`;
+                if (agent.description) {
+                    output += `  ${agent.description.slice(0, 60)}${agent.description.length > 60 ? '...' : ''}\n`;
+                }
+                if (agent.tools.length > 0) {
+                    output += `  Tools: ${agent.tools.join(', ')}\n`;
+                }
+            }
+            if (errors.length > 0) {
+                output += `\n⚠️ Failed to parse: ${errors.join(', ')}`;
+            }
+            return {
+                content: [{ type: 'text', text: output }],
+            };
+        }
+        case 'agents_list': {
+            const agents = await client.listAgents();
+            if (agents.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `# Project AI Agents
+
+_No agents synced yet._
+
+To sync agents, create files in \`.claude/agents/\` and run:
+\`agents_sync\`
+
+Or download predefined agents with:
+\`agents_download\``,
+                        },
+                    ],
+                };
+            }
+            let output = `# Project AI Agents (${agents.length})
+
+`;
+            for (const agent of agents) {
+                output += `## ${agent.name} [${agent.model}]\n`;
+                if (agent.description) {
+                    output += `${agent.description}\n`;
+                }
+                output += `**Tools:** ${agent.tools.join(', ') || 'all'}\n`;
+                output += `**Usage:** ${agent.usage_count} card(s)\n`;
+                output += `**Last Sync:** ${new Date(agent.synced_at).toLocaleString()}\n\n`;
+            }
+            return {
+                content: [{ type: 'text', text: output }],
+            };
+        }
+        case 'agents_download': {
+            const agentsDir = args.agents_dir || '.claude/agents';
+            const overwrite = args.overwrite || false;
+            // Resolve path
+            const resolvedPath = path.isAbsolute(agentsDir)
+                ? agentsDir
+                : path.join(process.cwd(), agentsDir);
+            // Fetch predefined agents from LunaArc
+            const predefinedAgents = await client.getPredefinedAgents();
+            if (predefinedAgents.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `⚠️ No predefined agents available.
+
+There are no predefined agents configured in LunaArc yet.
+You can create your own agents manually in \`.claude/agents/\`.`,
+                        },
+                    ],
+                };
+            }
+            // Create directory if it doesn't exist
+            if (!fs.existsSync(resolvedPath)) {
+                fs.mkdirSync(resolvedPath, { recursive: true });
+            }
+            const downloaded = [];
+            const skipped = [];
+            const errors = [];
+            for (const agent of predefinedAgents) {
+                const fileName = `${agent.slug}.md`;
+                const filePath = path.join(resolvedPath, fileName);
+                // Check if file already exists
+                if (fs.existsSync(filePath) && !overwrite) {
+                    skipped.push(agent.name);
+                    continue;
+                }
+                try {
+                    // Write agent file
+                    fs.writeFileSync(filePath, agent.content, 'utf-8');
+                    downloaded.push(agent.name);
+                }
+                catch (err) {
+                    errors.push(`${agent.name}: ${err instanceof Error ? err.message : 'Unknown error'}`);
+                }
+            }
+            let output = '';
+            if (downloaded.length > 0) {
+                output += `✅ Downloaded ${downloaded.length} agent(s) to ${resolvedPath}\n\n`;
+                output += `**Downloaded:**\n`;
+                for (const name of downloaded) {
+                    output += `- ${name}\n`;
+                }
+            }
+            if (skipped.length > 0) {
+                output += `\n⏭️ Skipped ${skipped.length} existing agent(s):\n`;
+                for (const name of skipped) {
+                    output += `- ${name}\n`;
+                }
+                output += `\n_Use \`overwrite: true\` to update existing files._`;
+            }
+            if (errors.length > 0) {
+                output += `\n\n❌ Errors:\n`;
+                for (const err of errors) {
+                    output += `- ${err}\n`;
+                }
+            }
+            if (downloaded.length === 0 && skipped.length === 0) {
+                output = `❌ No agents were downloaded. Check the errors above.`;
+            }
+            if (downloaded.length > 0) {
+                output += `\n\n📌 **Next step:** Run \`agents_sync\` to sync these agents to your LunaArc project.`;
+            }
+            return {
+                content: [{ type: 'text', text: output }],
+            };
+        }
+        default:
+            throw new Error(`Unknown agent tool: ${toolName}`);
+    }
+}

package/dist/tools/kanban.js

@@ -445,22 +445,11 @@ ${totalCards > 1 ? `_(${totalCards - 1} weitere Karte${totalCards > 2 ? 'n' : ''
 
 `;
             }
-            // IMPORTANT: Show role FIRST if present - before any card details
-            if (cardToShow.agent_content) {
-                output += `## 🛑 STOP - ADOPT ROLE FIRST
-
-**You MUST confirm this role BEFORE reading or working on the task!**
-
-### Role: ${cardToShow.agent_name || 'AI Agent'}
-
-${cardToShow.agent_content}
-
----
-
-**✋ MANDATORY CONFIRMATION:**
-Write FIRST: "I adopt the role ${cardToShow.agent_name || 'AI Agent'}" before starting the task.
+            // Show agent assignment if present - AI uses local agent definition
+            if (cardToShow.agent_name) {
+                output += `## 🤖 AI Agent: ${cardToShow.agent_name}
 
-**Do NOT proceed without this confirmation!**
+Use your local agent definition from \`.claude/agents/${cardToShow.agent_name}.md\`
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lunaarc-mcp",
-  "version": "1.2.5",
+  "version": "1.2.7",
   "description": "MCP Server for LunaArc - Access Wiki and Kanban from AI assistants",
   "main": "dist/server.js",
   "bin": {