mcp-task-server 0.1.0

package/dist/tools.js

@@ -0,0 +1,732 @@
+import { z } from "zod";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+import { existsSync, statSync, readdirSync } from "fs";
+import { join } from "path";
+import { loadTasks, saveTasks, generateId, findTask, updateTask as updateTaskInStore, addSubtaskToTask, } from "./storage.js";
+import { hasPermission, canActOnTask, getOrCreateAgent } from "./agents.js";
+import { expandTaskPrompt, parsePrdPrompt, researchTaskPrompt, analyzeComplexityPrompt, checkCompliancePrompt, } from "./prompts.js";
+import { resolvePath } from "./config.js";
+import { getTemplateFiles, getInitialTasksJson } from "./templates.js";
+// ============================================================================
+// Schema Definitions
+// ============================================================================
+const AgentContextSchema = z.object({
+    agent_id: z.string().optional(),
+    role: z.enum(["planner", "worker", "judge"]).optional(),
+});
+export const ListTasksSchema = AgentContextSchema.extend({
+    status: z
+        .enum([
+        "pending",
+        "claimed",
+        "in_progress",
+        "review",
+        "approved",
+        "rejected",
+        "completed",
+        "cancelled",
+        "done",
+        "deprecated",
+    ])
+        .optional(),
+    assigned_to: z.string().optional(),
+});
+export const GetTaskSchema = AgentContextSchema.extend({
+    task_id: z.string(),
+});
+export const AddTaskSchema = AgentContextSchema.extend({
+    title: z.string().optional(),
+    content: z.string().optional(), // Legacy alias for title
+    description: z.string().optional(),
+    details: z.string().optional(),
+    testStrategy: z.string().optional(),
+    priority: z.enum(["low", "medium", "high", "critical"]).default("medium"),
+    dependencies: z.array(z.string()).optional(),
+});
+export const UpdateTaskSchema = AgentContextSchema.extend({
+    task_id: z.string(),
+    title: z.string().optional(),
+    content: z.string().optional(), // Legacy alias for title
+    description: z.string().optional(),
+    details: z.string().optional(),
+    testStrategy: z.string().optional(),
+    status: z
+        .enum([
+        "pending",
+        "claimed",
+        "in_progress",
+        "review",
+        "approved",
+        "rejected",
+        "completed",
+        "cancelled",
+        "done",
+        "deprecated",
+    ])
+        .optional(),
+    priority: z.enum(["low", "medium", "high", "critical"]).optional(),
+    metadata: z.record(z.unknown()).optional(),
+});
+export const CompleteTaskSchema = AgentContextSchema.extend({
+    task_id: z.string(),
+});
+export const NextTaskSchema = AgentContextSchema.extend({});
+export const ClaimTaskSchema = AgentContextSchema.extend({
+    task_id: z.string(),
+});
+export const ReleaseTaskSchema = AgentContextSchema.extend({
+    task_id: z.string(),
+});
+export const HandoffTaskSchema = AgentContextSchema.extend({
+    task_id: z.string(),
+    to_role: z.enum(["planner", "worker", "judge"]),
+    notes: z.string().optional(),
+});
+export const ReviewTaskSchema = AgentContextSchema.extend({
+    task_id: z.string(),
+});
+export const ApproveTaskSchema = AgentContextSchema.extend({
+    task_id: z.string(),
+    notes: z.string().optional(),
+});
+export const RejectTaskSchema = AgentContextSchema.extend({
+    task_id: z.string(),
+    feedback: z.string(),
+});
+export const ExpandTaskSchema = AgentContextSchema.extend({
+    task_id: z.string(),
+});
+export const AddSubtaskSchema = AgentContextSchema.extend({
+    parent_id: z.string(),
+    title: z.string().optional(),
+    content: z.string().optional(), // Legacy alias for title
+    description: z.string().optional(),
+    details: z.string().optional(),
+    dependencies: z.array(z.number()).optional(),
+});
+export const SetDependenciesSchema = AgentContextSchema.extend({
+    task_id: z.string(),
+    dependencies: z.array(z.string()),
+});
+export const RemoveTaskSchema = AgentContextSchema.extend({
+    task_id: z.string(),
+});
+export const ParsePrdSchema = AgentContextSchema.extend({
+    prd_content: z.string(),
+});
+export const ResearchTaskSchema = AgentContextSchema.extend({
+    task_id: z.string(),
+    topic: z.string().optional(),
+});
+export const AnalyzeComplexitySchema = AgentContextSchema.extend({
+    task_id: z.string(),
+});
+export const CheckComplianceSchema = AgentContextSchema.extend({
+    path: z.string(),
+    fix: z.boolean().default(false),
+});
+export const InitProjectSchema = z.object({
+    project_name: z.string().optional(),
+    force: z.boolean().default(false),
+});
+function result(data) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    };
+}
+function error(message) {
+    return {
+        content: [{ type: "text", text: JSON.stringify({ error: message }) }],
+    };
+}
+function checkPermission(role, tool) {
+    if (!hasPermission(role, tool)) {
+        return error(`Role '${role}' does not have permission to use '${tool}'`);
+    }
+    return null;
+}
+// ============================================================================
+// Core Tools
+// ============================================================================
+export async function listTasks(config, params) {
+    const permError = checkPermission(params.role, "list_tasks");
+    if (permError)
+        return permError;
+    const store = await loadTasks(config);
+    let tasks = store.tasks;
+    if (params.status) {
+        tasks = tasks.filter((t) => t.status === params.status);
+    }
+    if (params.assigned_to) {
+        tasks = tasks.filter((t) => t.assigned_to === params.assigned_to);
+    }
+    return result({ tasks, total: tasks.length });
+}
+export async function getTask(config, params) {
+    const permError = checkPermission(params.role, "get_task");
+    if (permError)
+        return permError;
+    const store = await loadTasks(config);
+    const task = findTask(store, params.task_id);
+    if (!task) {
+        return error(`Task '${params.task_id}' not found`);
+    }
+    return result({ task });
+}
+export async function addTask(config, params) {
+    const permError = checkPermission(params.role, "add_task");
+    if (permError)
+        return permError;
+    // Use title or content (legacy)
+    const title = params.title || params.content;
+    if (!title) {
+        return error("Either 'title' or 'content' is required");
+    }
+    const store = await loadTasks(config);
+    const id = generateId(store);
+    const task = {
+        id,
+        title,
+        description: params.description,
+        details: params.details,
+        testStrategy: params.testStrategy,
+        status: "pending",
+        priority: params.priority,
+        dependencies: params.dependencies,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+    };
+    store.tasks.push(task);
+    await saveTasks(config, store);
+    return result({ task, message: `Task ${id} created` });
+}
+export async function updateTask(config, params) {
+    const permError = checkPermission(params.role, "update_task");
+    if (permError)
+        return permError;
+    const store = await loadTasks(config);
+    const canAct = canActOnTask(store, params.task_id, params.agent_id, "update");
+    if (!canAct.allowed) {
+        return error(canAct.reason);
+    }
+    const updates = {};
+    // Use title or content (legacy)
+    if (params.title)
+        updates.title = params.title;
+    else if (params.content)
+        updates.title = params.content;
+    if (params.description)
+        updates.description = params.description;
+    if (params.details)
+        updates.details = params.details;
+    if (params.testStrategy)
+        updates.testStrategy = params.testStrategy;
+    if (params.status)
+        updates.status = params.status;
+    if (params.priority)
+        updates.priority = params.priority;
+    if (params.metadata)
+        updates.metadata = params.metadata;
+    const task = updateTaskInStore(store, params.task_id, updates);
+    if (!task) {
+        return error(`Task '${params.task_id}' not found`);
+    }
+    await saveTasks(config, store);
+    return result({ task, message: `Task ${params.task_id} updated` });
+}
+export async function completeTask(config, params) {
+    const permError = checkPermission(params.role, "complete_task");
+    if (permError)
+        return permError;
+    const store = await loadTasks(config);
+    const canAct = canActOnTask(store, params.task_id, params.agent_id, "complete");
+    if (!canAct.allowed) {
+        return error(canAct.reason);
+    }
+    const task = updateTaskInStore(store, params.task_id, {
+        status: "completed",
+        completed_at: new Date().toISOString(),
+    });
+    if (!task) {
+        return error(`Task '${params.task_id}' not found`);
+    }
+    await saveTasks(config, store);
+    return result({ task, message: `Task ${params.task_id} completed` });
+}
+export async function nextTask(config, params) {
+    const permError = checkPermission(params.role, "next_task");
+    if (permError)
+        return permError;
+    const store = await loadTasks(config);
+    // Find top-level tasks that are pending and have all dependencies met
+    const pendingTasks = store.tasks.filter((t) => {
+        if (t.parent_id)
+            return false; // Skip subtasks
+        if (t.status !== "pending")
+            return false;
+        // Check dependencies
+        if (t.dependencies && t.dependencies.length > 0) {
+            const unmetDeps = t.dependencies.filter((depId) => {
+                const dep = findTask(store, depId);
+                return !dep || (dep.status !== "completed" && dep.status !== "done");
+            });
+            if (unmetDeps.length > 0)
+                return false;
+        }
+        return true;
+    });
+    if (pendingTasks.length === 0) {
+        return result({
+            task: null,
+            message: "No tasks available (all completed or blocked by dependencies)",
+        });
+    }
+    // Sort by priority (critical > high > medium > low)
+    const priorityOrder = {
+        critical: 0,
+        high: 1,
+        medium: 2,
+        low: 3,
+    };
+    pendingTasks.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+    const nextTask = pendingTasks[0];
+    return result({
+        task: nextTask,
+        message: `Recommended next task: ${nextTask.id}`,
+        available_count: pendingTasks.length,
+    });
+}
+// ============================================================================
+// Multi-Agent Coordination Tools
+// ============================================================================
+export async function claimTask(config, params) {
+    const permError = checkPermission(params.role, "claim_task");
+    if (permError)
+        return permError;
+    const store = await loadTasks(config);
+    const task = findTask(store, params.task_id);
+    if (!task) {
+        return error(`Task '${params.task_id}' not found`);
+    }
+    if (task.assigned_to) {
+        return error(`Task '${params.task_id}' is already assigned to ${task.assigned_to}`);
+    }
+    if (task.status !== "pending") {
+        return error(`Task '${params.task_id}' is not pending (status: ${task.status})`);
+    }
+    // Check dependencies
+    if (task.dependencies && task.dependencies.length > 0) {
+        const unmetDeps = task.dependencies.filter((depId) => {
+            const dep = findTask(store, depId);
+            return !dep || (dep.status !== "completed" && dep.status !== "done");
+        });
+        if (unmetDeps.length > 0) {
+            return error(`Task has unmet dependencies: ${unmetDeps.join(", ")}`);
+        }
+    }
+    const agentId = params.agent_id || "default-worker";
+    if (params.agent_id && params.role) {
+        getOrCreateAgent(store, params.agent_id, params.role);
+    }
+    updateTaskInStore(store, params.task_id, {
+        status: "claimed",
+        assigned_to: agentId,
+        claimed_at: new Date().toISOString(),
+    });
+    await saveTasks(config, store);
+    return result({ task, message: `Task ${params.task_id} claimed by ${agentId}` });
+}
+export async function releaseTask(config, params) {
+    const permError = checkPermission(params.role, "release_task");
+    if (permError)
+        return permError;
+    const store = await loadTasks(config);
+    const canAct = canActOnTask(store, params.task_id, params.agent_id, "release");
+    if (!canAct.allowed) {
+        return error(canAct.reason);
+    }
+    const task = updateTaskInStore(store, params.task_id, {
+        status: "pending",
+        assigned_to: undefined,
+        claimed_at: undefined,
+    });
+    if (!task) {
+        return error(`Task '${params.task_id}' not found`);
+    }
+    await saveTasks(config, store);
+    return result({ task, message: `Task ${params.task_id} released` });
+}
+export async function handoffTask(config, params) {
+    const permError = checkPermission(params.role, "handoff_task");
+    if (permError)
+        return permError;
+    const store = await loadTasks(config);
+    const canAct = canActOnTask(store, params.task_id, params.agent_id, "release");
+    if (!canAct.allowed) {
+        return error(canAct.reason);
+    }
+    const newStatus = params.to_role === "judge" ? "review" : "pending";
+    const task = updateTaskInStore(store, params.task_id, {
+        status: newStatus,
+        assigned_to: undefined,
+        claimed_at: undefined,
+        metadata: params.notes
+            ? { ...findTask(store, params.task_id)?.metadata, handoff_notes: params.notes }
+            : undefined,
+    });
+    if (!task) {
+        return error(`Task '${params.task_id}' not found`);
+    }
+    await saveTasks(config, store);
+    return result({
+        task,
+        message: `Task ${params.task_id} handed off to ${params.to_role}`,
+    });
+}
+export async function reviewTask(config, params) {
+    const permError = checkPermission(params.role, "review_task");
+    if (permError)
+        return permError;
+    const store = await loadTasks(config);
+    const task = findTask(store, params.task_id);
+    if (!task) {
+        return error(`Task '${params.task_id}' not found`);
+    }
+    return result({
+        task,
+        message: `Review task ${params.task_id}. Use approve_task or reject_task when done.`,
+    });
+}
+export async function approveTask(config, params) {
+    const permError = checkPermission(params.role, "approve_task");
+    if (permError)
+        return permError;
+    const store = await loadTasks(config);
+    const task = findTask(store, params.task_id);
+    if (!task) {
+        return error(`Task '${params.task_id}' not found`);
+    }
+    if (task.status !== "review") {
+        return error(`Task '${params.task_id}' is not in review status`);
+    }
+    updateTaskInStore(store, params.task_id, {
+        status: "completed",
+        completed_at: new Date().toISOString(),
+        metadata: params.notes
+            ? { ...task.metadata, approval_notes: params.notes }
+            : task.metadata,
+    });
+    await saveTasks(config, store);
+    return result({ task, message: `Task ${params.task_id} approved and completed` });
+}
+export async function rejectTask(config, params) {
+    const permError = checkPermission(params.role, "reject_task");
+    if (permError)
+        return permError;
+    const store = await loadTasks(config);
+    const task = findTask(store, params.task_id);
+    if (!task) {
+        return error(`Task '${params.task_id}' not found`);
+    }
+    if (task.status !== "review") {
+        return error(`Task '${params.task_id}' is not in review status`);
+    }
+    updateTaskInStore(store, params.task_id, {
+        status: "rejected",
+        metadata: { ...task.metadata, rejection_feedback: params.feedback },
+    });
+    await saveTasks(config, store);
+    return result({
+        task,
+        message: `Task ${params.task_id} rejected. Feedback: ${params.feedback}`,
+    });
+}
+// ============================================================================
+// Task Breakdown Tools
+// ============================================================================
+export async function expandTask(config, params) {
+    const permError = checkPermission(params.role, "expand_task");
+    if (permError)
+        return permError;
+    const store = await loadTasks(config);
+    const task = findTask(store, params.task_id);
+    if (!task) {
+        return error(`Task '${params.task_id}' not found`);
+    }
+    const promptResult = expandTaskPrompt(task);
+    return result(promptResult);
+}
+export async function addSubtask(config, params) {
+    const permError = checkPermission(params.role, "add_subtask");
+    if (permError)
+        return permError;
+    const store = await loadTasks(config);
+    const parent = findTask(store, params.parent_id);
+    if (!parent) {
+        return error(`Parent task '${params.parent_id}' not found`);
+    }
+    // Use title or content (legacy)
+    const title = params.title || params.content;
+    if (!title) {
+        return error("Either 'title' or 'content' is required");
+    }
+    const subtask = addSubtaskToTask(parent, {
+        title,
+        description: params.description,
+        details: params.details,
+        status: "pending",
+        dependencies: params.dependencies,
+    });
+    await saveTasks(config, store);
+    return result({ subtask, message: `Subtask ${subtask.id} added to task ${params.parent_id}` });
+}
+export async function setDependencies(config, params) {
+    const permError = checkPermission(params.role, "set_dependencies");
+    if (permError)
+        return permError;
+    const store = await loadTasks(config);
+    const task = findTask(store, params.task_id);
+    if (!task) {
+        return error(`Task '${params.task_id}' not found`);
+    }
+    // Validate all dependencies exist
+    for (const depId of params.dependencies) {
+        if (!findTask(store, depId)) {
+            return error(`Dependency task '${depId}' not found`);
+        }
+    }
+    // Check for circular dependencies (simple check)
+    if (params.dependencies.includes(params.task_id)) {
+        return error("Task cannot depend on itself");
+    }
+    updateTaskInStore(store, params.task_id, {
+        dependencies: params.dependencies,
+    });
+    await saveTasks(config, store);
+    return result({
+        task,
+        message: `Dependencies set for task ${params.task_id}: ${params.dependencies.join(", ")}`,
+    });
+}
+export async function removeTask(config, params) {
+    const permError = checkPermission(params.role, "remove_task");
+    if (permError)
+        return permError;
+    const store = await loadTasks(config);
+    const taskIndex = store.tasks.findIndex((t) => t.id === params.task_id);
+    if (taskIndex === -1) {
+        return error(`Task '${params.task_id}' not found`);
+    }
+    const task = store.tasks[taskIndex];
+    // Remove task
+    store.tasks.splice(taskIndex, 1);
+    // Remove this task from any dependencies
+    for (const t of store.tasks) {
+        if (t.dependencies) {
+            t.dependencies = t.dependencies.filter((id) => id !== params.task_id);
+        }
+    }
+    await saveTasks(config, store);
+    return result({ message: `Task ${params.task_id} removed` });
+}
+// ============================================================================
+// Prompt-Based Tools
+// ============================================================================
+export async function parsePrd(config, params) {
+    const permError = checkPermission(params.role, "parse_prd");
+    if (permError)
+        return permError;
+    const promptResult = parsePrdPrompt(params.prd_content);
+    return result(promptResult);
+}
+export async function researchTask(config, params) {
+    const permError = checkPermission(params.role, "research_task");
+    if (permError)
+        return permError;
+    const store = await loadTasks(config);
+    const task = findTask(store, params.task_id);
+    if (!task) {
+        return error(`Task '${params.task_id}' not found`);
+    }
+    const promptResult = researchTaskPrompt(task, params.topic);
+    return result(promptResult);
+}
+export async function analyzeComplexity(config, params) {
+    const permError = checkPermission(params.role, "analyze_complexity");
+    if (permError)
+        return permError;
+    const store = await loadTasks(config);
+    const task = findTask(store, params.task_id);
+    if (!task) {
+        return error(`Task '${params.task_id}' not found`);
+    }
+    const promptResult = analyzeComplexityPrompt(task);
+    return result(promptResult);
+}
+/**
+ * Read file contents, handling text files only
+ */
+async function readFileContent(filePath) {
+    const content = await readFile(filePath, "utf-8");
+    return content;
+}
+/**
+ * Get all text files in a directory (non-recursive for safety)
+ */
+function getTextFilesInDir(dirPath) {
+    const textExtensions = new Set([
+        ".md", ".txt", ".json", ".yaml", ".yml", ".ts", ".tsx", ".js", ".jsx",
+        ".html", ".css", ".scss", ".py", ".rb", ".go", ".rs", ".toml", ".ini",
+        ".sh", ".bash", ".zsh", ".fish", ".mdx", ".astro", ".vue", ".svelte",
+    ]);
+    const files = [];
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isFile()) {
+            const ext = entry.name.substring(entry.name.lastIndexOf("."));
+            if (textExtensions.has(ext)) {
+                files.push(join(dirPath, entry.name));
+            }
+        }
+    }
+    return files;
+}
+export async function checkCompliance(config, params) {
+    // No permission check - anyone can check compliance
+    const fullPath = resolvePath(config, params.path);
+    if (!existsSync(fullPath)) {
+        return error(`Path not found: ${params.path}`);
+    }
+    const stat = statSync(fullPath);
+    let content;
+    let pathDescription;
+    if (stat.isDirectory()) {
+        // Read all text files in directory
+        const files = getTextFilesInDir(fullPath);
+        if (files.length === 0) {
+            return error(`No text files found in directory: ${params.path}`);
+        }
+        const fileContents = [];
+        for (const file of files.slice(0, 10)) {
+            // Limit to 10 files
+            try {
+                const fileContent = await readFileContent(file);
+                const relativePath = file.replace(config.workspaceRoot + "/", "");
+                fileContents.push(`### ${relativePath}\n\`\`\`\n${fileContent.slice(0, 2000)}\n\`\`\``);
+            }
+            catch {
+                // Skip files that can't be read
+            }
+        }
+        content = fileContents.join("\n\n");
+        pathDescription = `${params.path} (${files.length} files${files.length > 10 ? ", showing first 10" : ""})`;
+    }
+    else {
+        // Single file
+        try {
+            content = await readFileContent(fullPath);
+            pathDescription = params.path;
+        }
+        catch {
+            return error(`Could not read file: ${params.path}`);
+        }
+    }
+    // Truncate very large content
+    if (content.length > 20000) {
+        content = content.slice(0, 20000) + "\n\n... (truncated)";
+    }
+    const promptResult = checkCompliancePrompt(pathDescription, content, params.fix);
+    return result(promptResult);
+}
+// ============================================================================
+// Project Initialization
+// ============================================================================
+/**
+ * Ensure directory exists
+ */
+async function ensureDir(filePath) {
+    const dir = dirname(filePath);
+    if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+    }
+}
+/**
+ * Initialize a project with agent-kit, memory_bank, and cursor rules
+ */
+export async function initProject(config, params) {
+    // Derive project name from workspace root if not provided
+    const projectName = params.project_name || config.workspaceRoot.split("/").pop() || "project";
+    const templateFiles = getTemplateFiles(projectName);
+    const created = [];
+    const skipped = [];
+    const errors = [];
+    // Process template files
+    for (const template of templateFiles) {
+        const fullPath = resolvePath(config, template.path);
+        // Check if file exists and has content
+        if (existsSync(fullPath) && !params.force) {
+            try {
+                const content = await readFile(fullPath, "utf-8");
+                if (content.trim().length > 0) {
+                    skipped.push(template.path);
+                    continue;
+                }
+            }
+            catch {
+                // File exists but can't be read, skip it
+                skipped.push(template.path);
+                continue;
+            }
+        }
+        // Create the file
+        try {
+            await ensureDir(fullPath);
+            await writeFile(fullPath, template.content, "utf-8");
+            created.push(template.path);
+        }
+        catch (e) {
+            errors.push(`${template.path}: ${e}`);
+        }
+    }
+    // Create tasks directory with empty tasks.json
+    const tasksJsonPath = resolvePath(config, "memory_bank/tasks/tasks.json");
+    if (!existsSync(tasksJsonPath) || params.force) {
+        try {
+            await ensureDir(tasksJsonPath);
+            await writeFile(tasksJsonPath, getInitialTasksJson(), "utf-8");
+            created.push("memory_bank/tasks/tasks.json");
+        }
+        catch (e) {
+            errors.push(`memory_bank/tasks/tasks.json: ${e}`);
+        }
+    }
+    else {
+        skipped.push("memory_bank/tasks/tasks.json");
+    }
+    // Build result message
+    const messages = [];
+    if (created.length > 0) {
+        messages.push(`Created ${created.length} files:`);
+        created.forEach((f) => messages.push(`  ✓ ${f}`));
+    }
+    if (skipped.length > 0) {
+        messages.push(`\nSkipped ${skipped.length} existing files:`);
+        skipped.forEach((f) => messages.push(`  - ${f}`));
+    }
+    if (errors.length > 0) {
+        messages.push(`\nErrors (${errors.length}):`);
+        errors.forEach((e) => messages.push(`  ✗ ${e}`));
+    }
+    if (created.length === 0 && skipped.length > 0) {
+        messages.push("\nProject already initialised. Use force: true to overwrite.");
+    }
+    return result({
+        project_name: projectName,
+        created,
+        skipped,
+        errors,
+        message: messages.join("\n"),
+    });
+}
+//# sourceMappingURL=tools.js.map