@projora/mcp-server 1.0.0

package/README.md

@@ -0,0 +1,131 @@
+# @projora/mcp-server
+
+A Model Context Protocol (MCP) server for [Projora](https://projora.app) task management. Integrates with Claude Code and OpenCode to manage tasks directly from your AI coding assistant.
+
+## Features
+
+- **start_task** - Start working on a task (sets status to "In Progress", adds comment, returns full context)
+- **complete_task** - Mark a task as done with an optional summary
+- **get_task** - Get a specific task by its key (e.g., "PRJ-123")
+- **list_projects** - List all projects
+- **list_tasks** - List tasks with optional filters (project, status, priority, assignee)
+- **my_tasks** - Get tasks assigned to you
+- **overdue_tasks** - Get all overdue tasks
+- **search_tasks** - Search for tasks and projects by keyword
+- **update_task** - Update task fields (title, description, priority, assignee, due date)
+- **update_task_status** - Update task status
+- **add_comment** - Add a comment to a task
+- **log_time** - Log time worked on a task
+- **get_project** - Get project details including linked GitHub repository
+- **get_config** - Get available statuses, priorities, and task types
+- **dashboard_stats** - Get dashboard statistics
+
+## Installation
+
+```bash
+npx @projora/mcp-server
+```
+
+Or install globally:
+
+```bash
+npm install -g @projora/mcp-server
+```
+
+## Configuration
+
+The server requires two environment variables:
+
+- `PROJORA_GRAPHQL_URL` - Your Projora GraphQL endpoint (defaults to `https://api.projora.app/graphql`)
+- `PROJORA_AUTH_TOKEN` - Your API token from Projora
+
+Get your API token from **Settings > Integrations** in the Projora web app.
+
+## Usage with Claude Code
+
+Add to your Claude Code configuration (`~/.claude.json`):
+
+```json
+{
+  "projora": {
+    "command": "npx",
+    "args": ["-y", "@projora/mcp-server"],
+    "env": {
+      "PROJORA_AUTH_TOKEN": "your-api-token"
+    }
+  }
+}
+```
+
+## Usage with OpenCode
+
+Add to your OpenCode configuration (`opencode.json`):
+
+```json
+{
+  "mcp": {
+    "projora": {
+      "type": "local",
+      "command": ["npx", "-y", "@projora/mcp-server"],
+      "enabled": true,
+      "environment": {
+        "PROJORA_AUTH_TOKEN": "your-api-token"
+      }
+    }
+  }
+}
+```
+
+> Note: `PROJORA_GRAPHQL_URL` defaults to `https://api.projora.app/graphql`. Only set it if you're using a self-hosted instance.
+
+## Example Prompts
+
+Once configured, use prompts like:
+
+- "Start working on task PRJ-123"
+- "Show me my tasks"
+- "What are the overdue tasks?"
+- "Search for tasks related to authentication"
+- "Mark task PRJ-123 as done with summary: Fixed the login bug"
+- "Add a comment to PRJ-123: Need to review the test coverage"
+- "Log 2 hours on task PRJ-123"
+
+## Workflow Example
+
+1. **Start a task**: "Use projora to start working on task PRJ-123"
+   - Status automatically changes to "In Progress"
+   - A comment is added noting work has started
+   - You get the full task context including description, GitHub repo, and suggested branch name
+
+2. **Work on the task**: Make your changes, commit code, etc.
+
+3. **Complete the task**: "Use projora to complete task PRJ-123 with summary: Implemented the new feature with tests"
+   - Status changes to "Done"
+   - A completion comment is added with your summary
+
+## Development
+
+```bash
+# Clone the repo
+git clone https://github.com/projora/projora.git
+cd projora/mcp-server
+
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Run locally
+PROJORA_GRAPHQL_URL=http://localhost:8000/graphql PROJORA_AUTH_TOKEN=your-token npm start
+```
+
+## License
+
+MIT
+
+## Links
+
+- [Projora](https://projora.app)
+- [Documentation](https://projora.app/docs)
+- [GitHub](https://github.com/projora/projora)

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/index.js

@@ -0,0 +1,956 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+// Configuration - set via environment variables
+const GRAPHQL_URL = process.env.PROJORA_GRAPHQL_URL || "https://api.projora.app/graphql";
+const AUTH_TOKEN = process.env.PROJORA_AUTH_TOKEN || "";
+// Create server instance
+const server = new McpServer({
+    name: "projora",
+    version: "1.0.0",
+});
+// GraphQL query helper
+async function graphqlQuery(query, variables = {}) {
+    const headers = {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+    };
+    if (AUTH_TOKEN) {
+        headers["Authorization"] = `Bearer ${AUTH_TOKEN}`;
+    }
+    try {
+        const response = await fetch(GRAPHQL_URL, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({ query, variables }),
+        });
+        if (!response.ok) {
+            console.error(`HTTP error! status: ${response.status}`);
+            return null;
+        }
+        const result = (await response.json());
+        if (result.errors) {
+            console.error("GraphQL errors:", JSON.stringify(result.errors));
+            return null;
+        }
+        return result.data ?? null;
+    }
+    catch (error) {
+        console.error("Error making GraphQL request:", error);
+        return null;
+    }
+}
+// Format task for display
+function formatTask(task) {
+    const lines = [
+        `[${task.taskKey}] ${task.title}`,
+        `  Status: ${task.status?.name || "No status"}`,
+        `  Priority: ${task.priority?.name || "No priority"}`,
+        `  Project: ${task.project.name}`,
+        `  List: ${task.taskList.name}`,
+    ];
+    if (task.assignee) {
+        lines.push(`  Assignee: ${task.assignee.name}`);
+    }
+    if (task.dueDate) {
+        lines.push(`  Due: ${task.dueDate}${task.isOverdue ? " (OVERDUE)" : ""}`);
+    }
+    if (task.description) {
+        lines.push(`  Description: ${task.description.substring(0, 200)}${task.description.length > 200 ? "..." : ""}`);
+    }
+    lines.push(`  Comments: ${task.commentsCount}`);
+    return lines.join("\n");
+}
+// Register tools
+// 1. List all projects
+server.registerTool("list_projects", {
+    description: "List all projects in Projora",
+    inputSchema: {},
+}, async () => {
+    const query = `
+      query ListProjects {
+        projects {
+          id
+          name
+          key
+          description
+          taskCount
+          openTaskCount
+        }
+      }
+    `;
+    const data = await graphqlQuery(query);
+    if (!data) {
+        return {
+            content: [{ type: "text", text: "Failed to fetch projects. Check your authentication token." }],
+        };
+    }
+    if (data.projects.length === 0) {
+        return {
+            content: [{ type: "text", text: "No projects found." }],
+        };
+    }
+    const projectList = data.projects
+        .map((p) => `[${p.key}] ${p.name} - ${p.openTaskCount}/${p.taskCount} open tasks\n  ${p.description || "No description"}`)
+        .join("\n\n");
+    return {
+        content: [{ type: "text", text: `Projects:\n\n${projectList}` }],
+    };
+});
+// 2. List tasks with optional filters
+server.registerTool("list_tasks", {
+    description: "List tasks in Projora with optional filters",
+    inputSchema: {
+        projectId: z.string().optional().describe("Filter by project ID"),
+        statusId: z.string().optional().describe("Filter by status ID"),
+        priorityId: z.string().optional().describe("Filter by priority ID"),
+        assigneeId: z.string().optional().describe("Filter by assignee ID"),
+    },
+}, async ({ projectId, statusId, priorityId, assigneeId }) => {
+    const query = `
+      query ListTasks($projectId: ID, $statusId: ID, $priorityId: ID, $assigneeId: ID) {
+        tasks(projectId: $projectId, statusId: $statusId, priorityId: $priorityId, assigneeId: $assigneeId) {
+          id
+          taskKey
+          title
+          description
+          dueDate
+          isOverdue
+          commentsCount
+          createdAt
+          updatedAt
+          status { id name color }
+          priority { id name color }
+          taskType { id name }
+          assignee { id name email }
+          project { id name key }
+          taskList { id name }
+        }
+      }
+    `;
+    const data = await graphqlQuery(query, {
+        projectId,
+        statusId,
+        priorityId,
+        assigneeId,
+    });
+    if (!data) {
+        return {
+            content: [{ type: "text", text: "Failed to fetch tasks. Check your authentication token." }],
+        };
+    }
+    if (data.tasks.length === 0) {
+        return {
+            content: [{ type: "text", text: "No tasks found matching the criteria." }],
+        };
+    }
+    const taskList = data.tasks.map(formatTask).join("\n\n---\n\n");
+    return {
+        content: [{ type: "text", text: `Found ${data.tasks.length} tasks:\n\n${taskList}` }],
+    };
+});
+// 3. Get a specific task by key (e.g., "PRJ-123")
+server.registerTool("get_task", {
+    description: "Get a specific task by its key (e.g., 'PRJ-123')",
+    inputSchema: {
+        taskKey: z.string().describe("The task key (e.g., 'PRJ-123')"),
+    },
+}, async ({ taskKey }) => {
+    const query = `
+      query GetTask($taskKey: String!) {
+        taskByKey(taskKey: $taskKey) {
+          id
+          taskKey
+          title
+          description
+          dueDate
+          isOverdue
+          commentsCount
+          createdAt
+          updatedAt
+          status { id name color }
+          priority { id name color }
+          taskType { id name }
+          assignee { id name email }
+          project { id name key }
+          taskList { id name }
+          comments {
+            id
+            body
+            user { name }
+            createdAt
+          }
+        }
+      }
+    `;
+    const data = await graphqlQuery(query, { taskKey });
+    if (!data || !data.taskByKey) {
+        return {
+            content: [{ type: "text", text: `Task '${taskKey}' not found.` }],
+        };
+    }
+    const task = data.taskByKey;
+    let output = formatTask(task);
+    if (task.comments && task.comments.length > 0) {
+        output += "\n\nComments:\n";
+        task.comments.forEach((comment) => {
+            output += `\n  - ${comment.user.name} (${comment.createdAt}):\n    ${comment.body}\n`;
+        });
+    }
+    return {
+        content: [{ type: "text", text: output }],
+    };
+});
+// 4. Get my tasks (assigned to current user)
+server.registerTool("my_tasks", {
+    description: "Get tasks assigned to the current user",
+    inputSchema: {
+        limit: z.number().optional().describe("Maximum number of tasks to return"),
+    },
+}, async ({ limit }) => {
+    const query = `
+      query MyTasks($limit: Int) {
+        myTasks(limit: $limit) {
+          id
+          taskKey
+          title
+          description
+          dueDate
+          isOverdue
+          commentsCount
+          createdAt
+          updatedAt
+          status { id name color }
+          priority { id name color }
+          taskType { id name }
+          assignee { id name email }
+          project { id name key }
+          taskList { id name }
+        }
+      }
+    `;
+    const data = await graphqlQuery(query, { limit });
+    if (!data) {
+        return {
+            content: [{ type: "text", text: "Failed to fetch your tasks. Check your authentication token." }],
+        };
+    }
+    if (data.myTasks.length === 0) {
+        return {
+            content: [{ type: "text", text: "You have no tasks assigned to you." }],
+        };
+    }
+    const taskList = data.myTasks.map(formatTask).join("\n\n---\n\n");
+    return {
+        content: [{ type: "text", text: `Your ${data.myTasks.length} tasks:\n\n${taskList}` }],
+    };
+});
+// 5. Get overdue tasks
+server.registerTool("overdue_tasks", {
+    description: "Get all overdue tasks",
+    inputSchema: {
+        limit: z.number().optional().describe("Maximum number of tasks to return"),
+    },
+}, async ({ limit }) => {
+    const query = `
+      query OverdueTasks($limit: Int) {
+        overdueTasks(limit: $limit) {
+          id
+          taskKey
+          title
+          description
+          dueDate
+          isOverdue
+          commentsCount
+          createdAt
+          updatedAt
+          status { id name color }
+          priority { id name color }
+          taskType { id name }
+          assignee { id name email }
+          project { id name key }
+          taskList { id name }
+        }
+      }
+    `;
+    const data = await graphqlQuery(query, { limit });
+    if (!data) {
+        return {
+            content: [{ type: "text", text: "Failed to fetch overdue tasks. Check your authentication token." }],
+        };
+    }
+    if (data.overdueTasks.length === 0) {
+        return {
+            content: [{ type: "text", text: "No overdue tasks found." }],
+        };
+    }
+    const taskList = data.overdueTasks.map(formatTask).join("\n\n---\n\n");
+    return {
+        content: [{ type: "text", text: `${data.overdueTasks.length} overdue tasks:\n\n${taskList}` }],
+    };
+});
+// 6. Search tasks
+server.registerTool("search_tasks", {
+    description: "Search for tasks and projects by keyword",
+    inputSchema: {
+        query: z.string().describe("Search query string"),
+    },
+}, async ({ query: searchQuery }) => {
+    const query = `
+      query Search($query: String!) {
+        search(query: $query) {
+          tasks {
+            id
+            taskKey
+            title
+            description
+            dueDate
+            isOverdue
+            commentsCount
+            createdAt
+            updatedAt
+            status { id name color }
+            priority { id name color }
+            taskType { id name }
+            assignee { id name email }
+            project { id name key }
+            taskList { id name }
+          }
+          projects {
+            id
+            name
+            key
+            description
+          }
+        }
+      }
+    `;
+    const data = await graphqlQuery(query, { query: searchQuery });
+    if (!data) {
+        return {
+            content: [{ type: "text", text: "Failed to search. Check your authentication token." }],
+        };
+    }
+    let output = `Search results for "${searchQuery}":\n\n`;
+    if (data.search.projects.length > 0) {
+        output += `Projects (${data.search.projects.length}):\n`;
+        data.search.projects.forEach((p) => {
+            output += `  [${p.key}] ${p.name}\n`;
+        });
+        output += "\n";
+    }
+    if (data.search.tasks.length > 0) {
+        output += `Tasks (${data.search.tasks.length}):\n\n`;
+        output += data.search.tasks.map(formatTask).join("\n\n---\n\n");
+    }
+    if (data.search.projects.length === 0 && data.search.tasks.length === 0) {
+        output += "No results found.";
+    }
+    return {
+        content: [{ type: "text", text: output }],
+    };
+});
+// 7. Get dashboard stats
+server.registerTool("dashboard_stats", {
+    description: "Get dashboard statistics overview",
+    inputSchema: {},
+}, async () => {
+    const query = `
+      query DashboardStats {
+        dashboardStats {
+          totalTasks
+          openTasks
+          inProgressTasks
+          completedTasks
+          overdueTasks
+          totalProjects
+          activeProjects
+          myTasksCount
+        }
+      }
+    `;
+    const data = await graphqlQuery(query);
+    if (!data) {
+        return {
+            content: [{ type: "text", text: "Failed to fetch dashboard stats. Check your authentication token." }],
+        };
+    }
+    const stats = data.dashboardStats;
+    const output = `Dashboard Statistics:
+
+Tasks:
+  - Total: ${stats.totalTasks}
+  - Open: ${stats.openTasks}
+  - In Progress: ${stats.inProgressTasks}
+  - Completed: ${stats.completedTasks}
+  - Overdue: ${stats.overdueTasks}
+  - My Tasks: ${stats.myTasksCount}
+
+Projects:
+  - Total: ${stats.totalProjects}
+  - Active: ${stats.activeProjects}`;
+    return {
+        content: [{ type: "text", text: output }],
+    };
+});
+// 8. Get statuses, priorities, and task types for reference
+server.registerTool("get_config", {
+    description: "Get available statuses, priorities, and task types",
+    inputSchema: {},
+}, async () => {
+    const query = `
+      query GetConfig {
+        statuses { id name color isClosed }
+        priorities { id name color level }
+        taskTypes { id name color icon }
+      }
+    `;
+    const data = await graphqlQuery(query);
+    if (!data) {
+        return {
+            content: [{ type: "text", text: "Failed to fetch configuration. Check your authentication token." }],
+        };
+    }
+    let output = "Available Configuration:\n\n";
+    output += "Statuses:\n";
+    data.statuses.forEach((s) => {
+        output += `  - ${s.name} (ID: ${s.id})${s.isClosed ? " [Closed]" : ""}\n`;
+    });
+    output += "\nPriorities:\n";
+    data.priorities.forEach((p) => {
+        output += `  - ${p.name} (ID: ${p.id}, Level: ${p.level})\n`;
+    });
+    output += "\nTask Types:\n";
+    data.taskTypes.forEach((t) => {
+        output += `  - ${t.name} (ID: ${t.id})\n`;
+    });
+    return {
+        content: [{ type: "text", text: output }],
+    };
+});
+// Helper function to find a status by name (case-insensitive partial match)
+async function findStatusByName(statusName) {
+    const query = `
+    query GetStatuses {
+      statuses { id name }
+    }
+  `;
+    const data = await graphqlQuery(query);
+    if (!data)
+        return null;
+    const lowerName = statusName.toLowerCase();
+    return data.statuses.find(s => s.name.toLowerCase().includes(lowerName)) || null;
+}
+// Helper function to update task status
+async function updateTaskStatusById(taskId, statusId) {
+    const mutation = `
+    mutation UpdateTaskStatus($id: ID!, $statusId: ID!) {
+      updateTask(id: $id, input: { statusId: $statusId }) {
+        id
+        taskKey
+        status { id name }
+      }
+    }
+  `;
+    const result = await graphqlQuery(mutation, {
+        id: taskId,
+        statusId,
+    });
+    return result?.updateTask || null;
+}
+// Helper function to add a comment to a task
+async function addCommentToTask(taskId, body) {
+    const mutation = `
+    mutation CreateComment($taskId: ID!, $body: String!) {
+      createComment(taskId: $taskId, body: $body) {
+        id
+      }
+    }
+  `;
+    const result = await graphqlQuery(mutation, { taskId, body });
+    return !!result?.createComment;
+}
+// 9. Start working on a task - get full context and set status to In Progress
+server.registerTool("start_task", {
+    description: "Start working on a task. This will: 1) Set the task status to 'In Progress', 2) Add a comment noting work has started, 3) Return comprehensive task details including description, comments, GitHub repo info, and suggested branch name.",
+    inputSchema: {
+        taskKey: z.string().describe("The task key (e.g., 'PRJ-123')"),
+    },
+}, async ({ taskKey }) => {
+    const query = `
+      query StartTask($taskKey: String!) {
+        taskByKey(taskKey: $taskKey) {
+          id
+          taskKey
+          title
+          description
+          dueDate
+          isOverdue
+          estimatedHours
+          status { id name color }
+          priority { id name color }
+          taskType { id name }
+          assignee { id name email }
+          reporter { id name email }
+          project {
+            id
+            name
+            key
+            description
+            githubRepoOwner
+            githubRepoName
+            githubDefaultBranch
+            githubRepoFullName
+            githubRepoUrl
+          }
+          taskList { id name }
+          comments {
+            id
+            body
+            user { name }
+            createdAt
+          }
+          subTasks {
+            id
+            taskKey
+            title
+            status { name }
+          }
+          dependencies {
+            dependsOn { taskKey title status { name } }
+            type
+          }
+        }
+      }
+    `;
+    const data = await graphqlQuery(query, { taskKey });
+    if (!data || !data.taskByKey) {
+        return {
+            content: [{ type: "text", text: `Task '${taskKey}' not found.` }],
+        };
+    }
+    const task = data.taskByKey;
+    const project = task.project;
+    const previousStatus = task.status?.name || 'No status';
+    // Update status to "In Progress" if not already in progress or done
+    let statusUpdateMessage = "";
+    if (!task.status?.name?.toLowerCase().includes('progress') && !task.status?.name?.toLowerCase().includes('done')) {
+        const inProgressStatus = await findStatusByName('in progress');
+        if (inProgressStatus) {
+            const updated = await updateTaskStatusById(task.id, inProgressStatus.id);
+            if (updated) {
+                statusUpdateMessage = `\n**Status updated: ${previousStatus} → ${updated.status.name}**\n`;
+            }
+        }
+    }
+    // Add a comment noting that work has started
+    const timestamp = new Date().toISOString().split('T')[0];
+    await addCommentToTask(task.id, `Started working on this task via Claude Code on ${timestamp}`);
+    // Generate suggested branch name
+    const slugifiedTitle = task.title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '')
+        .substring(0, 50);
+    const suggestedBranch = `feature/${task.taskKey.toLowerCase()}-${slugifiedTitle}`;
+    let output = `# Task: ${task.taskKey} - ${task.title}\n`;
+    if (statusUpdateMessage) {
+        output += statusUpdateMessage;
+    }
+    output += `\n`;
+    output += `## Overview\n`;
+    output += `- **Project**: ${project.name} (${project.key})\n`;
+    output += `- **Status**: ${task.status?.name || 'No status'}${statusUpdateMessage ? ' (just updated)' : ''}\n`;
+    output += `- **Priority**: ${task.priority?.name || 'No priority'}\n`;
+    output += `- **Type**: ${task.taskType?.name || 'No type'}\n`;
+    output += `- **Assignee**: ${task.assignee?.name || 'Unassigned'}\n`;
+    output += `- **Reporter**: ${task.reporter?.name || 'Unknown'}\n`;
+    if (task.dueDate) {
+        output += `- **Due Date**: ${task.dueDate}${task.isOverdue ? ' (OVERDUE)' : ''}\n`;
+    }
+    if (task.estimatedHours) {
+        output += `- **Estimate**: ${task.estimatedHours} hours\n`;
+    }
+    output += `- **List**: ${task.taskList.name}\n`;
+    if (task.description) {
+        output += `\n## Description\n${task.description}\n`;
+    }
+    // GitHub info
+    if (project.githubRepoFullName) {
+        output += `\n## GitHub Repository\n`;
+        output += `- **Repository**: ${project.githubRepoFullName}\n`;
+        output += `- **URL**: ${project.githubRepoUrl}\n`;
+        output += `- **Default Branch**: ${project.githubDefaultBranch}\n`;
+        output += `- **Suggested Branch**: \`${suggestedBranch}\`\n`;
+        output += `\nTo create a branch:\n\`\`\`bash\ngit checkout -b ${suggestedBranch}\n\`\`\`\n`;
+    }
+    // Sub-tasks
+    if (task.subTasks && task.subTasks.length > 0) {
+        output += `\n## Sub-tasks (${task.subTasks.length})\n`;
+        task.subTasks.forEach((sub) => {
+            const statusIcon = sub.status?.name === 'Done' ? '✓' : '○';
+            output += `- ${statusIcon} [${sub.taskKey}] ${sub.title}\n`;
+        });
+    }
+    // Dependencies
+    if (task.dependencies && task.dependencies.length > 0) {
+        output += `\n## Dependencies\n`;
+        task.dependencies.forEach((dep) => {
+            const status = dep.dependsOn.status?.name || 'No status';
+            output += `- ${dep.type === 'blocked_by' ? 'Blocked by' : 'Blocks'}: [${dep.dependsOn.taskKey}] ${dep.dependsOn.title} (${status})\n`;
+        });
+    }
+    // Recent comments
+    if (task.comments && task.comments.length > 0) {
+        output += `\n## Recent Comments (${task.comments.length})\n`;
+        const recentComments = task.comments.slice(0, 5);
+        recentComments.forEach((comment) => {
+            output += `\n**${comment.user.name}** (${comment.createdAt}):\n${comment.body}\n`;
+        });
+        if (task.comments.length > 5) {
+            output += `\n... and ${task.comments.length - 5} more comments\n`;
+        }
+    }
+    output += `\n---\n`;
+    output += `**Tip:** When you're done, use \`complete_task\` to mark this task as Done.\n`;
+    return {
+        content: [{ type: "text", text: output }],
+    };
+});
+// 9b. Complete a task - mark as Done and add completion comment
+server.registerTool("complete_task", {
+    description: "Mark a task as complete/done. This will: 1) Set the task status to 'Done', 2) Add a comment with an optional summary of what was accomplished.",
+    inputSchema: {
+        taskKey: z.string().describe("The task key (e.g., 'PRJ-123')"),
+        summary: z.string().optional().describe("Optional summary of what was accomplished"),
+    },
+}, async ({ taskKey, summary }) => {
+    // Get the task
+    const getTaskQuery = `
+      query GetTaskId($taskKey: String!) {
+        taskByKey(taskKey: $taskKey) {
+          id
+          taskKey
+          title
+          status { id name }
+        }
+      }
+    `;
+    const taskData = await graphqlQuery(getTaskQuery, { taskKey });
+    if (!taskData || !taskData.taskByKey) {
+        return {
+            content: [{ type: "text", text: `Task '${taskKey}' not found.` }],
+        };
+    }
+    const task = taskData.taskByKey;
+    const previousStatus = task.status?.name || 'No status';
+    // Find the "Done" status
+    const doneStatus = await findStatusByName('done');
+    if (!doneStatus) {
+        return {
+            content: [{ type: "text", text: `Could not find a 'Done' status. Available statuses may have different names.` }],
+        };
+    }
+    // Update status to Done
+    const updated = await updateTaskStatusById(task.id, doneStatus.id);
+    if (!updated) {
+        return {
+            content: [{ type: "text", text: `Failed to update task status. Check your permissions.` }],
+        };
+    }
+    // Add completion comment
+    const timestamp = new Date().toISOString().split('T')[0];
+    let commentBody = `Task completed via Claude Code on ${timestamp}`;
+    if (summary) {
+        commentBody += `\n\n**Summary:**\n${summary}`;
+    }
+    await addCommentToTask(task.id, commentBody);
+    let output = `# Task Completed: ${task.taskKey}\n\n`;
+    output += `**${task.title}**\n\n`;
+    output += `Status updated: ${previousStatus} → ${updated.status.name}\n`;
+    if (summary) {
+        output += `\nSummary added to task comments.\n`;
+    }
+    return {
+        content: [{ type: "text", text: output }],
+    };
+});
+// 10. Update task status
+server.registerTool("update_task_status", {
+    description: "Update the status of a task",
+    inputSchema: {
+        taskKey: z.string().describe("The task key (e.g., 'PRJ-123')"),
+        statusId: z.string().describe("The ID of the new status (use get_config to see available statuses)"),
+    },
+}, async ({ taskKey, statusId }) => {
+    // First get the task ID
+    const getTaskQuery = `
+      query GetTaskId($taskKey: String!) {
+        taskByKey(taskKey: $taskKey) {
+          id
+          status { name }
+        }
+      }
+    `;
+    const taskData = await graphqlQuery(getTaskQuery, { taskKey });
+    if (!taskData || !taskData.taskByKey) {
+        return {
+            content: [{ type: "text", text: `Task '${taskKey}' not found.` }],
+        };
+    }
+    const mutation = `
+      mutation UpdateTaskStatus($id: ID!, $statusId: ID!) {
+        updateTask(id: $id, input: { statusId: $statusId }) {
+          id
+          taskKey
+          status { id name }
+        }
+      }
+    `;
+    const result = await graphqlQuery(mutation, {
+        id: taskData.taskByKey.id,
+        statusId,
+    });
+    if (!result) {
+        return {
+            content: [{ type: "text", text: `Failed to update task status. Check your permissions.` }],
+        };
+    }
+    const previousStatus = taskData.taskByKey.status?.name || 'None';
+    return {
+        content: [{ type: "text", text: `Updated ${result.updateTask.taskKey}: ${previousStatus} → ${result.updateTask.status.name}` }],
+    };
+});
+// 11. Add a comment to a task
+server.registerTool("add_comment", {
+    description: "Add a comment to a task",
+    inputSchema: {
+        taskKey: z.string().describe("The task key (e.g., 'PRJ-123')"),
+        body: z.string().describe("The comment text"),
+    },
+}, async ({ taskKey, body }) => {
+    // First get the task ID
+    const getTaskQuery = `
+      query GetTaskId($taskKey: String!) {
+        taskByKey(taskKey: $taskKey) {
+          id
+        }
+      }
+    `;
+    const taskData = await graphqlQuery(getTaskQuery, { taskKey });
+    if (!taskData || !taskData.taskByKey) {
+        return {
+            content: [{ type: "text", text: `Task '${taskKey}' not found.` }],
+        };
+    }
+    const mutation = `
+      mutation CreateComment($taskId: ID!, $body: String!) {
+        createComment(taskId: $taskId, body: $body) {
+          id
+          body
+          createdAt
+        }
+      }
+    `;
+    const result = await graphqlQuery(mutation, {
+        taskId: taskData.taskByKey.id,
+        body,
+    });
+    if (!result) {
+        return {
+            content: [{ type: "text", text: `Failed to add comment. Check your permissions.` }],
+        };
+    }
+    return {
+        content: [{ type: "text", text: `Comment added to ${taskKey} at ${result.createComment.createdAt}` }],
+    };
+});
+// 12. Log time on a task
+server.registerTool("log_time", {
+    description: "Log time worked on a task",
+    inputSchema: {
+        taskKey: z.string().describe("The task key (e.g., 'PRJ-123')"),
+        minutes: z.number().describe("Duration in minutes"),
+        description: z.string().optional().describe("Optional description of work done"),
+    },
+}, async ({ taskKey, minutes, description }) => {
+    // First get the task ID
+    const getTaskQuery = `
+      query GetTaskId($taskKey: String!) {
+        taskByKey(taskKey: $taskKey) {
+          id
+        }
+      }
+    `;
+    const taskData = await graphqlQuery(getTaskQuery, { taskKey });
+    if (!taskData || !taskData.taskByKey) {
+        return {
+            content: [{ type: "text", text: `Task '${taskKey}' not found.` }],
+        };
+    }
+    const now = new Date();
+    const startedAt = new Date(now.getTime() - minutes * 60 * 1000);
+    const mutation = `
+      mutation LogTime($taskId: ID!, $input: LogTimeInput!) {
+        logTime(taskId: $taskId, input: $input) {
+          id
+          durationMinutes
+          formattedDuration
+        }
+      }
+    `;
+    const result = await graphqlQuery(mutation, {
+        taskId: taskData.taskByKey.id,
+        input: {
+            description: description || null,
+            startedAt: startedAt.toISOString().replace('T', ' ').substring(0, 19),
+            endedAt: now.toISOString().replace('T', ' ').substring(0, 19),
+        },
+    });
+    if (!result) {
+        return {
+            content: [{ type: "text", text: `Failed to log time. Check your permissions.` }],
+        };
+    }
+    return {
+        content: [{ type: "text", text: `Logged ${result.logTime.formattedDuration} on ${taskKey}${description ? `: ${description}` : ''}` }],
+    };
+});
+// 13. Update task (general)
+server.registerTool("update_task", {
+    description: "Update task fields (title, description, priority, assignee, due date, estimate)",
+    inputSchema: {
+        taskKey: z.string().describe("The task key (e.g., 'PRJ-123')"),
+        title: z.string().optional().describe("New title"),
+        description: z.string().optional().describe("New description"),
+        priorityId: z.string().optional().describe("New priority ID"),
+        assigneeId: z.string().optional().describe("New assignee user ID"),
+        dueDate: z.string().optional().describe("New due date (YYYY-MM-DD)"),
+        estimatedHours: z.number().optional().describe("Estimated hours"),
+    },
+}, async ({ taskKey, title, description, priorityId, assigneeId, dueDate, estimatedHours }) => {
+    // First get the task ID
+    const getTaskQuery = `
+      query GetTaskId($taskKey: String!) {
+        taskByKey(taskKey: $taskKey) {
+          id
+          title
+        }
+      }
+    `;
+    const taskData = await graphqlQuery(getTaskQuery, { taskKey });
+    if (!taskData || !taskData.taskByKey) {
+        return {
+            content: [{ type: "text", text: `Task '${taskKey}' not found.` }],
+        };
+    }
+    const input = {};
+    if (title !== undefined)
+        input.title = title;
+    if (description !== undefined)
+        input.description = description;
+    if (priorityId !== undefined)
+        input.priorityId = priorityId;
+    if (assigneeId !== undefined)
+        input.assigneeId = assigneeId;
+    if (dueDate !== undefined)
+        input.dueDate = dueDate;
+    if (estimatedHours !== undefined)
+        input.estimatedHours = estimatedHours;
+    if (Object.keys(input).length === 0) {
+        return {
+            content: [{ type: "text", text: `No fields to update provided.` }],
+        };
+    }
+    const mutation = `
+      mutation UpdateTask($id: ID!, $input: UpdateTaskInput!) {
+        updateTask(id: $id, input: $input) {
+          id
+          taskKey
+          title
+          status { name }
+          priority { name }
+          assignee { name }
+          dueDate
+          estimatedHours
+        }
+      }
+    `;
+    const result = await graphqlQuery(mutation, {
+        id: taskData.taskByKey.id,
+        input,
+    });
+    if (!result) {
+        return {
+            content: [{ type: "text", text: `Failed to update task. Check your permissions.` }],
+        };
+    }
+    const updatedFields = Object.keys(input).join(', ');
+    return {
+        content: [{ type: "text", text: `Updated ${result.updateTask.taskKey}: ${updatedFields}` }],
+    };
+});
+// 14. Get project with GitHub info
+server.registerTool("get_project", {
+    description: "Get project details including linked GitHub repository",
+    inputSchema: {
+        projectKey: z.string().describe("The project key (e.g., 'PRJ')"),
+    },
+}, async ({ projectKey }) => {
+    const query = `
+      query GetProjects {
+        projects {
+          id
+          name
+          key
+          description
+          taskCount
+          openTaskCount
+          githubRepoOwner
+          githubRepoName
+          githubDefaultBranch
+          githubRepoFullName
+          githubRepoUrl
+        }
+      }
+    `;
+    const data = await graphqlQuery(query);
+    if (!data) {
+        return {
+            content: [{ type: "text", text: "Failed to fetch projects. Check your authentication token." }],
+        };
+    }
+    const project = data.projects.find(p => p.key.toLowerCase() === projectKey.toLowerCase());
+    if (!project) {
+        return {
+            content: [{ type: "text", text: `Project with key '${projectKey}' not found.` }],
+        };
+    }
+    let output = `# Project: ${project.name} (${project.key})\n\n`;
+    output += `**Tasks**: ${project.openTaskCount} open / ${project.taskCount} total\n`;
+    if (project.description) {
+        output += `\n## Description\n${project.description}\n`;
+    }
+    if (project.githubRepoFullName) {
+        output += `\n## GitHub Repository\n`;
+        output += `- **Repository**: [${project.githubRepoFullName}](${project.githubRepoUrl})\n`;
+        output += `- **Default Branch**: ${project.githubDefaultBranch}\n`;
+    }
+    else {
+        output += `\n*No GitHub repository linked*\n`;
+    }
+    return {
+        content: [{ type: "text", text: output }],
+    };
+});
+// Main function to run the server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Projora MCP Server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@projora/mcp-server",
+  "version": "1.0.0",
+  "description": "MCP server for Projora task management - integrate with Claude Code and OpenCode to manage tasks, update statuses, and track work",
+  "type": "module",
+  "bin": {
+    "projora-mcp": "./build/index.js"
+  },
+  "main": "./build/index.js",
+  "scripts": {
+    "build": "tsc && chmod 755 build/index.js",
+    "dev": "tsc --watch",
+    "start": "node build/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "build"
+  ],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "projora",
+    "task-management",
+    "claude",
+    "opencode",
+    "ai-coding",
+    "project-management"
+  ],
+  "author": {
+    "name": "Projora",
+    "email": "support@projora.app",
+    "url": "https://projora.app"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/projora/projora.git",
+    "directory": "mcp-server"
+  },
+  "bugs": {
+    "url": "https://github.com/projora/projora/issues"
+  },
+  "homepage": "https://projora.app",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  }
+}