lunaarc-mcp 1.1.0

package/dist/tools/todos.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.todosTools = void 0;
+exports.handleTodosTool = handleTodosTool;
+// Tool definitions for todo operations
+exports.todosTools = [
+    {
+        name: 'todos_lists',
+        description: 'Get all todo lists with their todos. Shows list names, descriptions, and all todos with their completion status.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: 'todos_read',
+        description: 'Read detailed information about a specific todo. Returns title, description, completion status, and due date.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                todo_id: {
+                    type: 'string',
+                    description: 'The todo ID (UUID)',
+                },
+            },
+            required: ['todo_id'],
+        },
+    },
+    {
+        name: 'todos_create',
+        description: 'Create a new todo in a specific todo list. Requires the todo list ID and a title.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                todo_list_id: {
+                    type: 'string',
+                    description: 'The ID of the todo list to add the todo to (UUID)',
+                },
+                title: {
+                    type: 'string',
+                    description: 'The todo title (required)',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Detailed description of the todo (optional)',
+                },
+                due_date: {
+                    type: 'string',
+                    description: 'Due date in ISO format (optional, e.g., 2025-01-15)',
+                },
+            },
+            required: ['todo_list_id', 'title'],
+        },
+    },
+    {
+        name: 'todos_update',
+        description: 'Update an existing todo. Can change title, description, completion status, or due date.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                todo_id: {
+                    type: 'string',
+                    description: 'The todo ID to update (UUID)',
+                },
+                title: {
+                    type: 'string',
+                    description: 'New title (optional)',
+                },
+                description: {
+                    type: 'string',
+                    description: 'New description (optional)',
+                },
+                completed: {
+                    type: 'boolean',
+                    description: 'Mark as completed (true) or incomplete (false) (optional)',
+                },
+                due_date: {
+                    type: 'string',
+                    description: 'New due date in ISO format, or null to remove (optional)',
+                },
+            },
+            required: ['todo_id'],
+        },
+    },
+];
+// Tool handlers
+async function handleTodosTool(client, toolName, args) {
+    switch (toolName) {
+        case 'todos_lists': {
+            const lists = await client.getTodoLists();
+            if (lists.length === 0) {
+                return {
+                    content: [{ type: 'text', text: '_No todo lists found_' }],
+                };
+            }
+            let output = '# Todo Lists\n\n';
+            for (const list of lists) {
+                const completedCount = list.completed_count;
+                const totalCount = list.todo_count;
+                const progressIndicator = totalCount > 0 ? ` (${completedCount}/${totalCount})` : '';
+                output += `## ${list.name}${progressIndicator}\n`;
+                output += `**ID:** \`${list.id}\`\n`;
+                if (list.description) {
+                    output += `${list.description}\n`;
+                }
+                output += '\n';
+                if (list.todos.length === 0) {
+                    output += '_No todos_\n\n';
+                }
+                else {
+                    for (const todo of list.todos) {
+                        const checkbox = todo.completed ? '[x]' : '[ ]';
+                        const dueInfo = todo.due_date
+                            ? ` (Due: ${new Date(todo.due_date).toLocaleDateString()})`
+                            : '';
+                        output += `- ${checkbox} **${todo.title}**${dueInfo}\n`;
+                        output += `  ID: \`${todo.id}\`\n`;
+                    }
+                    output += '\n';
+                }
+            }
+            return {
+                content: [{ type: 'text', text: output }],
+            };
+        }
+        case 'todos_read': {
+            const todoId = args.todo_id;
+            if (!todoId) {
+                throw new Error('todo_id parameter is required');
+            }
+            const todo = await client.getTodo(todoId);
+            const status = todo.completed ? 'Completed' : 'Pending';
+            const statusIcon = todo.completed ? '✅' : '⬜';
+            let output = `# ${statusIcon} ${todo.title}
+
+**ID:** \`${todo.id}\`
+**Status:** ${status}
+**Created:** ${new Date(todo.created_at).toLocaleString()}
+**Updated:** ${new Date(todo.updated_at).toLocaleString()}`;
+            if (todo.due_date) {
+                output += `\n**Due Date:** ${new Date(todo.due_date).toLocaleDateString()}`;
+            }
+            if (todo.completed_at) {
+                output += `\n**Completed:** ${new Date(todo.completed_at).toLocaleString()}`;
+            }
+            output += '\n\n---\n\n';
+            output += todo.description || '_No description_';
+            return {
+                content: [{ type: 'text', text: output }],
+            };
+        }
+        case 'todos_create': {
+            const todoListId = args.todo_list_id;
+            const title = args.title;
+            const description = args.description;
+            const dueDate = args.due_date;
+            if (!todoListId) {
+                throw new Error('todo_list_id parameter is required');
+            }
+            if (!title) {
+                throw new Error('title parameter is required');
+            }
+            const result = await client.createTodo({
+                todo_list_id: todoListId,
+                title,
+                description,
+                due_date: dueDate,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `✅ Todo created successfully!
+
+**Todo ID:** \`${result.id}\`
+**Title:** ${title}
+${dueDate ? `**Due Date:** ${new Date(dueDate).toLocaleDateString()}` : ''}`,
+                    },
+                ],
+            };
+        }
+        case 'todos_update': {
+            const todoId = args.todo_id;
+            const title = args.title;
+            const description = args.description;
+            const completed = args.completed;
+            const dueDate = args.due_date;
+            if (!todoId) {
+                throw new Error('todo_id parameter is required');
+            }
+            if (title === undefined &&
+                description === undefined &&
+                completed === undefined &&
+                dueDate === undefined) {
+                throw new Error('At least one field (title, description, completed, due_date) must be provided');
+            }
+            await client.updateTodo(todoId, {
+                title,
+                description,
+                completed,
+                due_date: dueDate,
+            });
+            const updates = [];
+            if (title)
+                updates.push(`Title → ${title}`);
+            if (description !== undefined)
+                updates.push('Description updated');
+            if (completed !== undefined)
+                updates.push(`Status → ${completed ? 'Completed' : 'Pending'}`);
+            if (dueDate !== undefined) {
+                updates.push(dueDate ? `Due Date → ${new Date(dueDate).toLocaleDateString()}` : 'Due Date removed');
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `✅ Todo updated successfully!
+
+**Todo ID:** \`${todoId}\`
+
+**Changes:**
+${updates.map((u) => `- ${u}`).join('\n')}`,
+                    },
+                ],
+            };
+        }
+        default:
+            throw new Error(`Unknown todos tool: ${toolName}`);
+    }
+}

package/dist/tools/wiki.d.ts

@@ -0,0 +1,118 @@
+import { LunaArcApiClient } from '../api/client.js';
+export declare const wikiTools: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            id_or_slug?: undefined;
+            query?: undefined;
+            title?: undefined;
+            content?: undefined;
+            parent_id?: undefined;
+            icon?: undefined;
+            page_id?: undefined;
+        };
+        required: never[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            id_or_slug: {
+                type: string;
+                description: string;
+            };
+            query?: undefined;
+            title?: undefined;
+            content?: undefined;
+            parent_id?: undefined;
+            icon?: undefined;
+            page_id?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            id_or_slug?: undefined;
+            title?: undefined;
+            content?: undefined;
+            parent_id?: undefined;
+            icon?: undefined;
+            page_id?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            title: {
+                type: string;
+                description: string;
+            };
+            content: {
+                type: string;
+                description: string;
+            };
+            parent_id: {
+                type: string;
+                description: string;
+            };
+            icon: {
+                type: string;
+                description: string;
+            };
+            id_or_slug?: undefined;
+            query?: undefined;
+            page_id?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            page_id: {
+                type: string;
+                description: string;
+            };
+            title: {
+                type: string;
+                description: string;
+            };
+            content: {
+                type: string;
+                description: string;
+            };
+            icon: {
+                type: string;
+                description: string;
+            };
+            id_or_slug?: undefined;
+            query?: undefined;
+            parent_id?: undefined;
+        };
+        required: string[];
+    };
+})[];
+export declare function handleWikiTool(client: LunaArcApiClient, toolName: string, args: Record<string, unknown>): Promise<{
+    content: {
+        type: 'text';
+        text: string;
+    }[];
+}>;

package/dist/tools/wiki.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wikiTools = void 0;
+exports.handleWikiTool = handleWikiTool;
+// Tool definitions for wiki operations
+exports.wikiTools = [
+    {
+        name: 'wiki_list',
+        description: 'List all wiki pages in the project. Returns page titles, slugs, and hierarchy (parent_id). Use this to get an overview of the wiki structure.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: 'wiki_read',
+        description: 'Read a specific wiki page by its ID or slug. Returns the full page content including markdown formatting.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id_or_slug: {
+                    type: 'string',
+                    description: 'The page ID (UUID) or slug (URL-friendly name)',
+                },
+            },
+            required: ['id_or_slug'],
+        },
+    },
+    {
+        name: 'wiki_search',
+        description: 'Search wiki pages by title and content. Returns matching pages with a content snippet. Use this to find relevant information in the wiki.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'The search query (minimum 2 characters)',
+                },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'wiki_page_create',
+        description: 'Create a new wiki page. The page will be created with the given title and optional content. A URL-friendly slug will be automatically generated from the title.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                title: {
+                    type: 'string',
+                    description: 'The page title (required)',
+                },
+                content: {
+                    type: 'string',
+                    description: 'The page content in Markdown format (optional)',
+                },
+                parent_id: {
+                    type: 'string',
+                    description: 'Parent page ID to create this page as a child (optional, UUID)',
+                },
+                icon: {
+                    type: 'string',
+                    description: 'An emoji icon for the page (optional, e.g., "📚")',
+                },
+            },
+            required: ['title'],
+        },
+    },
+    {
+        name: 'wiki_page_update',
+        description: 'Update an existing wiki page. You can update the title, content, or icon. At least one field must be provided.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                page_id: {
+                    type: 'string',
+                    description: 'The page ID (UUID) to update',
+                },
+                title: {
+                    type: 'string',
+                    description: 'New page title (optional)',
+                },
+                content: {
+                    type: 'string',
+                    description: 'New page content in Markdown format (optional)',
+                },
+                icon: {
+                    type: 'string',
+                    description: 'New emoji icon for the page (optional)',
+                },
+            },
+            required: ['page_id'],
+        },
+    },
+];
+// Tool handlers
+async function handleWikiTool(client, toolName, args) {
+    switch (toolName) {
+        case 'wiki_list': {
+            const pages = await client.listWikiPages();
+            if (pages.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'No wiki pages found in this project.',
+                        },
+                    ],
+                };
+            }
+            // Build tree structure for better readability
+            const rootPages = pages.filter((p) => !p.parent_id);
+            const childPages = pages.filter((p) => p.parent_id);
+            let output = `Found ${pages.length} wiki page(s):\n\n`;
+            function formatPage(page, indent) {
+                const prefix = '  '.repeat(indent);
+                const icon = page.icon || '📄';
+                let line = `${prefix}${icon} ${page.title} (slug: ${page.slug})\n`;
+                // Find children
+                const children = childPages.filter((c) => c.parent_id === page.id);
+                for (const child of children) {
+                    line += formatPage(child, indent + 1);
+                }
+                return line;
+            }
+            for (const page of rootPages) {
+                output += formatPage(page, 0);
+            }
+            return {
+                content: [{ type: 'text', text: output }],
+            };
+        }
+        case 'wiki_read': {
+            const idOrSlug = args.id_or_slug;
+            if (!idOrSlug) {
+                throw new Error('id_or_slug parameter is required');
+            }
+            const page = await client.getWikiPage(idOrSlug);
+            const output = `# ${page.icon || '📄'} ${page.title}
+
+**Slug:** ${page.slug}
+**Last updated:** ${new Date(page.updated_at).toLocaleString()}
+
+---
+
+${page.content || '_This page has no content yet._'}`;
+            return {
+                content: [{ type: 'text', text: output }],
+            };
+        }
+        case 'wiki_search': {
+            const query = args.query;
+            if (!query || query.length < 2) {
+                throw new Error('Search query must be at least 2 characters');
+            }
+            const results = await client.searchWiki(query);
+            if (results.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `No wiki pages found matching "${query}".`,
+                        },
+                    ],
+                };
+            }
+            let output = `Found ${results.length} result(s) for "${query}":\n\n`;
+            for (const result of results) {
+                output += `## ${result.icon || '📄'} ${result.title}\n`;
+                output += `**Slug:** ${result.slug}\n`;
+                output += `**Updated:** ${new Date(result.updated_at).toLocaleString()}\n`;
+                if (result.snippet) {
+                    output += `> ${result.snippet}\n`;
+                }
+                output += '\n';
+            }
+            return {
+                content: [{ type: 'text', text: output }],
+            };
+        }
+        case 'wiki_page_create': {
+            const title = args.title;
+            const content = args.content;
+            const parentId = args.parent_id;
+            const icon = args.icon;
+            if (!title) {
+                throw new Error('title parameter is required');
+            }
+            const result = await client.createWikiPage({
+                title,
+                content,
+                parent_id: parentId,
+                icon,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `✅ Wiki page created successfully!
+
+**Page ID:** \`${result.id}\`
+**Title:** ${icon || '📄'} ${title}
+${parentId ? `**Parent:** ${parentId}` : ''}
+${content ? `\n**Content preview:**\n> ${content.substring(0, 200)}${content.length > 200 ? '...' : ''}` : ''}
+
+The page is now available in the wiki.`,
+                    },
+                ],
+            };
+        }
+        case 'wiki_page_update': {
+            const pageId = args.page_id;
+            const title = args.title;
+            const content = args.content;
+            const icon = args.icon;
+            if (!pageId) {
+                throw new Error('page_id parameter is required');
+            }
+            if (!title && content === undefined && !icon) {
+                throw new Error('At least one field (title, content, icon) must be provided');
+            }
+            await client.updateWikiPage(pageId, {
+                title,
+                content,
+                icon,
+            });
+            const updates = [];
+            if (title)
+                updates.push(`Title → ${title}`);
+            if (content !== undefined)
+                updates.push('Content updated');
+            if (icon)
+                updates.push(`Icon → ${icon}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `✅ Wiki page updated successfully!
+
+**Page ID:** \`${pageId}\`
+
+**Changes:**
+${updates.map((u) => `- ${u}`).join('\n')}`,
+                    },
+                ],
+            };
+        }
+        default:
+            throw new Error(`Unknown wiki tool: ${toolName}`);
+    }
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "lunaarc-mcp",
+  "version": "1.1.0",
+  "description": "MCP Server for LunaArc - Access Wiki and Kanban from AI assistants",
+  "main": "dist/server.js",
+  "bin": {
+    "lunaarc-mcp": "./bin/lunaarc-mcp"
+  },
+  "scripts": {
+    "dev": "tsx src/server.ts",
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "lunaarc",
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "claude",
+    "wiki",
+    "kanban"
+  ],
+  "author": "LunaArc",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lunaarc/lunaarc-mcp"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ]
+}