@finityno/claude-code-acp 0.14.0 → 0.16.0

package/dist/task-mcp-tools.js

@@ -0,0 +1,256 @@
+import { z } from "zod";
+import { TaskManager } from "./task-manager.js";
+/**
+ * Register MCP tools for task management
+ */
+export function registerTaskMcpTools(server, options) {
+    const { tracker, taskManager, sessionId } = options;
+    // List all tasks
+    server.registerTool("ListTasks", {
+        title: "List Tasks",
+        description: `List all tracked tasks/subagents across sessions.
+Use this to see running, completed, failed, or cancelled tasks.
+Can filter by status, session, or background execution.`,
+        inputSchema: {
+            status: z
+                .array(z.enum(["pending", "running", "completed", "failed", "cancelled", "stopped"]))
+                .optional()
+                .describe("Filter by task status"),
+            sessionId: z.string().optional().describe("Filter by session ID"),
+            backgroundOnly: z.boolean().optional().describe("Only show background tasks"),
+            subagentType: z.string().optional().describe("Filter by subagent type"),
+            limit: z.number().optional().default(20).describe("Maximum number of tasks to return"),
+        },
+        annotations: {
+            title: "List tasks",
+            readOnlyHint: true,
+        },
+    }, async (input) => {
+        const manager = taskManager ?? createTempManager(tracker);
+        const tasks = manager.getAllTasks({
+            status: input.status,
+            sessionId: input.sessionId,
+            runInBackground: input.backgroundOnly,
+            subagentType: input.subagentType,
+        });
+        const limited = tasks.slice(0, input.limit);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        total: tasks.length,
+                        returned: limited.length,
+                        tasks: limited.map((t) => ({
+                            id: t.id,
+                            type: t.subagentType,
+                            description: t.description,
+                            status: t.status,
+                            runInBackground: t.runInBackground,
+                            createdAt: new Date(t.createdAt).toISOString(),
+                            durationMs: t.completedAt && t.startedAt ? t.completedAt - t.startedAt : undefined,
+                            agentId: t.agentId,
+                            canResume: !!(t.agentId && ["completed", "failed", "stopped"].includes(t.status)),
+                            summary: t.summary,
+                        })),
+                    }, null, 2),
+                }],
+        };
+    });
+    // Get task status
+    server.registerTool("GetTaskStatus", {
+        title: "Get Task Status",
+        description: "Get detailed status and metadata for a specific task.",
+        inputSchema: {
+            taskId: z.string().describe("The task ID to get status for"),
+        },
+        annotations: {
+            title: "Get task status",
+            readOnlyHint: true,
+        },
+    }, async (input) => {
+        const task = tracker.getSubagent(input.taskId);
+        if (!task) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Task not found: ${input.taskId}` }],
+            };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        id: task.id,
+                        type: task.subagentType,
+                        description: task.description,
+                        prompt: task.prompt,
+                        status: task.status,
+                        model: task.model,
+                        runInBackground: task.runInBackground,
+                        parentSessionId: task.parentSessionId,
+                        parentToolUseId: task.parentToolUseId,
+                        createdAt: new Date(task.createdAt).toISOString(),
+                        startedAt: task.startedAt ? new Date(task.startedAt).toISOString() : undefined,
+                        completedAt: task.completedAt ? new Date(task.completedAt).toISOString() : undefined,
+                        durationMs: task.completedAt && task.startedAt ? task.completedAt - task.startedAt : undefined,
+                        agentId: task.agentId,
+                        agentName: task.agentName,
+                        teamName: task.teamName,
+                        permissionMode: task.permissionMode,
+                        outputFile: task.outputFile,
+                        summary: task.summary,
+                        result: task.result,
+                        error: task.error,
+                        isResumed: task.isResumed,
+                        originalTaskId: task.originalTaskId,
+                        canResume: !!(task.agentId && ["completed", "failed", "stopped"].includes(task.status)),
+                    }, null, 2),
+                }],
+        };
+    });
+    // Get task output
+    server.registerTool("GetTaskOutput", {
+        title: "Get Task Output",
+        description: "Read output file content for a background task.",
+        inputSchema: {
+            taskId: z.string().describe("The task ID to get output for"),
+            tail: z.number().optional().describe("Only return last N lines"),
+        },
+        annotations: {
+            title: "Get task output",
+            readOnlyHint: true,
+        },
+    }, async (input) => {
+        const task = tracker.getSubagent(input.taskId);
+        if (!task) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Task not found: ${input.taskId}` }],
+            };
+        }
+        if (!task.outputFile) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Task ${input.taskId} has no output file` }],
+            };
+        }
+        const manager = taskManager ?? createTempManager(tracker);
+        const output = input.tail
+            ? await manager.getTaskOutputTail(input.taskId, input.tail)
+            : await manager.getTaskOutput(input.taskId);
+        if (output === null) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Output file not found: ${task.outputFile}` }],
+            };
+        }
+        return { content: [{ type: "text", text: output }] };
+    });
+    // Cancel task
+    server.registerTool("CancelTask", {
+        title: "Cancel Task",
+        description: "Cancel a running task/subagent.",
+        inputSchema: {
+            taskId: z.string().describe("The task ID to cancel"),
+        },
+        annotations: {
+            title: "Cancel task",
+            destructiveHint: true,
+        },
+    }, async (input) => {
+        const task = tracker.getSubagent(input.taskId);
+        if (!task) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Task not found: ${input.taskId}` }],
+            };
+        }
+        if (task.status !== "running") {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Task not running: ${task.status}` }],
+            };
+        }
+        await tracker.cancelSubagent(input.taskId);
+        return { content: [{ type: "text", text: `Task ${input.taskId} cancelled` }] };
+    });
+    // List resumable tasks
+    server.registerTool("ListResumableTasks", {
+        title: "List Resumable Tasks",
+        description: "List tasks that can be resumed via Task tool's resume parameter.",
+        inputSchema: {
+            limit: z.number().optional().default(10).describe("Maximum number of tasks to return"),
+        },
+        annotations: {
+            title: "List resumable tasks",
+            readOnlyHint: true,
+        },
+    }, async (input) => {
+        const tasks = tracker.getResumableTasks().slice(0, input.limit);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        count: tasks.length,
+                        tasks: tasks.map((t) => ({
+                            id: t.id,
+                            agentId: t.agentId,
+                            type: t.subagentType,
+                            description: t.description,
+                            status: t.status,
+                            completedAt: t.completedAt ? new Date(t.completedAt).toISOString() : undefined,
+                            summary: t.summary,
+                            error: t.error,
+                        })),
+                    }, null, 2),
+                }],
+        };
+    });
+    // Get task stats
+    server.registerTool("GetTaskStats", {
+        title: "Get Task Statistics",
+        description: "Get statistics about all tracked tasks.",
+        inputSchema: {},
+        annotations: {
+            title: "Get task statistics",
+            readOnlyHint: true,
+        },
+    }, async () => {
+        const stats = tracker.getStats();
+        return { content: [{ type: "text", text: JSON.stringify(stats, null, 2) }] };
+    });
+    // Get running tasks
+    server.registerTool("GetRunningTasks", {
+        title: "Get Running Tasks",
+        description: "Get all currently running tasks.",
+        inputSchema: {
+            allSessions: z.boolean().optional().default(false).describe("Include all sessions"),
+        },
+        annotations: {
+            title: "Get running tasks",
+            readOnlyHint: true,
+        },
+    }, async (input) => {
+        const tasks = input.allSessions
+            ? tracker.getRunningSubagents()
+            : tracker.getRunningSubagentsForSession(sessionId);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        count: tasks.length,
+                        tasks: tasks.map((t) => ({
+                            id: t.id,
+                            type: t.subagentType,
+                            description: t.description,
+                            runInBackground: t.runInBackground,
+                            startedAt: t.startedAt ? new Date(t.startedAt).toISOString() : undefined,
+                            elapsedMs: t.startedAt ? Date.now() - t.startedAt : undefined,
+                        })),
+                    }, null, 2),
+                }],
+        };
+    });
+}
+function createTempManager(tracker) {
+    return new TaskManager(tracker, { autoSave: false });
+}

package/dist/task-store.d.ts

@@ -0,0 +1,123 @@
+import { Logger } from "./acp-agent.js";
+/**
+ * Task status matching Claude Code's internal system
+ */
+export type TaskStatus = "pending" | "in_progress" | "completed";
+/**
+ * Task structure matching Claude Code's ~/.claude/tasks/ format
+ */
+export interface Task {
+    id: string;
+    subject: string;
+    description: string;
+    activeForm: string;
+    status: TaskStatus;
+    owner?: string;
+    blocks: string[];
+    blockedBy: string[];
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Input for creating a new task
+ */
+export interface TaskCreateInput {
+    subject: string;
+    description: string;
+    activeForm?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Input for updating a task
+ */
+export interface TaskUpdateInput {
+    status?: TaskStatus;
+    subject?: string;
+    description?: string;
+    activeForm?: string;
+    owner?: string;
+    addBlocks?: string[];
+    addBlockedBy?: string[];
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Options for TaskStore
+ */
+export interface TaskStoreOptions {
+    /** Task list ID (UUID or custom ID) */
+    taskListId: string;
+    /** Base path for task storage (default: ~/.claude/tasks) */
+    basePath?: string;
+    /** Logger instance */
+    logger?: Logger;
+    /** Callback when tasks change (from file watcher) */
+    onChange?: (tasks: Task[]) => void;
+}
+/**
+ * TaskStore manages reading/writing tasks to ~/.claude/tasks/
+ * Compatible with Claude Code's internal task system
+ */
+export declare class TaskStore {
+    private taskListId;
+    private basePath;
+    private logger;
+    private onChange?;
+    private watcher;
+    private nextId;
+    private initialized;
+    constructor(options: TaskStoreOptions);
+    /**
+     * Get the directory path for this task list
+     */
+    get taskListPath(): string;
+    /**
+     * Initialize the task store (create directory, determine next ID)
+     */
+    init(): Promise<void>;
+    /**
+     * Create a new task
+     */
+    create(input: TaskCreateInput): Promise<Task>;
+    /**
+     * Get a task by ID
+     */
+    get(taskId: string): Promise<Task | null>;
+    /**
+     * Update a task
+     */
+    update(taskId: string, input: TaskUpdateInput): Promise<Task>;
+    /**
+     * List all tasks
+     */
+    list(): Promise<Task[]>;
+    /**
+     * Delete a task
+     */
+    delete(taskId: string): Promise<boolean>;
+    /**
+     * Start watching for changes from other sessions
+     */
+    watch(): Promise<void>;
+    /**
+     * Stop watching for changes
+     */
+    close(): void;
+    /**
+     * Get task statistics
+     */
+    getStats(): Promise<{
+        total: number;
+        pending: number;
+        inProgress: number;
+        completed: number;
+        blocked: number;
+    }>;
+    private getTaskFilePath;
+    private saveTask;
+    /**
+     * Generate activeForm from subject (convert to present participle)
+     * "Fix bug" -> "Fixing bug"
+     * "Add feature" -> "Adding feature"
+     */
+    private generateActiveForm;
+}
+//# sourceMappingURL=task-store.d.ts.map

package/dist/task-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-store.d.ts","sourceRoot":"","sources":["../src/task-store.ts"],"names":[],"mappings":"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"}

package/dist/task-store.js

@@ -0,0 +1,292 @@
+import { mkdir, readFile, writeFile, readdir, rm } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+/**
+ * TaskStore manages reading/writing tasks to ~/.claude/tasks/
+ * Compatible with Claude Code's internal task system
+ */
+export class TaskStore {
+    constructor(options) {
+        this.watcher = null;
+        this.nextId = 1;
+        this.initialized = false;
+        this.taskListId = options.taskListId;
+        this.basePath = options.basePath ?? join(homedir(), ".claude", "tasks");
+        this.logger = options.logger ?? console;
+        this.onChange = options.onChange;
+    }
+    /**
+     * Get the directory path for this task list
+     */
+    get taskListPath() {
+        return join(this.basePath, this.taskListId);
+    }
+    /**
+     * Initialize the task store (create directory, determine next ID)
+     */
+    async init() {
+        if (this.initialized)
+            return;
+        try {
+            await mkdir(this.taskListPath, { recursive: true });
+            // Determine next ID from existing tasks
+            const tasks = await this.list();
+            if (tasks.length > 0) {
+                const maxId = Math.max(...tasks.map((t) => parseInt(t.id, 10) || 0));
+                this.nextId = maxId + 1;
+            }
+            this.initialized = true;
+            this.logger.log(`[TaskStore] Initialized at ${this.taskListPath}, next ID: ${this.nextId}`);
+        }
+        catch (err) {
+            this.logger.error(`[TaskStore] Failed to initialize:`, err);
+            throw err;
+        }
+    }
+    /**
+     * Create a new task
+     */
+    async create(input) {
+        await this.init();
+        const task = {
+            id: String(this.nextId++),
+            subject: input.subject,
+            description: input.description,
+            activeForm: input.activeForm ?? this.generateActiveForm(input.subject),
+            status: "pending",
+            blocks: [],
+            blockedBy: [],
+            metadata: input.metadata,
+        };
+        await this.saveTask(task);
+        this.logger.log(`[TaskStore] Created task ${task.id}: ${task.subject}`);
+        return task;
+    }
+    /**
+     * Get a task by ID
+     */
+    async get(taskId) {
+        await this.init();
+        const filePath = this.getTaskFilePath(taskId);
+        try {
+            const content = await readFile(filePath, "utf8");
+            return JSON.parse(content);
+        }
+        catch (err) {
+            if (err.code === "ENOENT") {
+                return null;
+            }
+            throw err;
+        }
+    }
+    /**
+     * Update a task
+     */
+    async update(taskId, input) {
+        await this.init();
+        const task = await this.get(taskId);
+        if (!task) {
+            throw new Error(`Task not found: ${taskId}`);
+        }
+        // Apply updates
+        if (input.status !== undefined)
+            task.status = input.status;
+        if (input.subject !== undefined)
+            task.subject = input.subject;
+        if (input.description !== undefined)
+            task.description = input.description;
+        if (input.activeForm !== undefined)
+            task.activeForm = input.activeForm;
+        if (input.owner !== undefined)
+            task.owner = input.owner;
+        // Handle blocks/blockedBy additions
+        if (input.addBlocks) {
+            for (const blockId of input.addBlocks) {
+                if (!task.blocks.includes(blockId)) {
+                    task.blocks.push(blockId);
+                }
+                // Also update the blocked task's blockedBy
+                const blockedTask = await this.get(blockId);
+                if (blockedTask && !blockedTask.blockedBy.includes(taskId)) {
+                    blockedTask.blockedBy.push(taskId);
+                    await this.saveTask(blockedTask);
+                }
+            }
+        }
+        if (input.addBlockedBy) {
+            for (const blockerId of input.addBlockedBy) {
+                if (!task.blockedBy.includes(blockerId)) {
+                    task.blockedBy.push(blockerId);
+                }
+                // Also update the blocking task's blocks
+                const blockerTask = await this.get(blockerId);
+                if (blockerTask && !blockerTask.blocks.includes(taskId)) {
+                    blockerTask.blocks.push(taskId);
+                    await this.saveTask(blockerTask);
+                }
+            }
+        }
+        // Merge metadata
+        if (input.metadata) {
+            task.metadata = { ...task.metadata, ...input.metadata };
+            // Remove null values (deletion)
+            for (const [key, value] of Object.entries(input.metadata)) {
+                if (value === null && task.metadata) {
+                    delete task.metadata[key];
+                }
+            }
+        }
+        // When completing a task, update blockedBy for tasks it blocks
+        if (input.status === "completed") {
+            for (const blockedId of task.blocks) {
+                const blockedTask = await this.get(blockedId);
+                if (blockedTask) {
+                    blockedTask.blockedBy = blockedTask.blockedBy.filter((id) => id !== taskId);
+                    await this.saveTask(blockedTask);
+                }
+            }
+        }
+        await this.saveTask(task);
+        this.logger.log(`[TaskStore] Updated task ${taskId}: ${task.subject} -> ${task.status}`);
+        return task;
+    }
+    /**
+     * List all tasks
+     */
+    async list() {
+        await this.init();
+        try {
+            const files = await readdir(this.taskListPath);
+            const tasks = [];
+            for (const file of files) {
+                if (!file.endsWith(".json"))
+                    continue;
+                const taskId = file.replace(".json", "");
+                const task = await this.get(taskId);
+                if (task)
+                    tasks.push(task);
+            }
+            // Sort by ID (numeric)
+            return tasks.sort((a, b) => parseInt(a.id, 10) - parseInt(b.id, 10));
+        }
+        catch (err) {
+            if (err.code === "ENOENT") {
+                return [];
+            }
+            throw err;
+        }
+    }
+    /**
+     * Delete a task
+     */
+    async delete(taskId) {
+        await this.init();
+        const task = await this.get(taskId);
+        if (!task)
+            return false;
+        // Remove from blocks/blockedBy of other tasks
+        for (const blockedId of task.blocks) {
+            const blockedTask = await this.get(blockedId);
+            if (blockedTask) {
+                blockedTask.blockedBy = blockedTask.blockedBy.filter((id) => id !== taskId);
+                await this.saveTask(blockedTask);
+            }
+        }
+        for (const blockerId of task.blockedBy) {
+            const blockerTask = await this.get(blockerId);
+            if (blockerTask) {
+                blockerTask.blocks = blockerTask.blocks.filter((id) => id !== taskId);
+                await this.saveTask(blockerTask);
+            }
+        }
+        try {
+            await rm(this.getTaskFilePath(taskId));
+            this.logger.log(`[TaskStore] Deleted task ${taskId}`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Start watching for changes from other sessions
+     */
+    async watch() {
+        if (this.watcher)
+            return;
+        await this.init();
+        try {
+            const fsWatch = await import("fs");
+            this.watcher = fsWatch.watch(this.taskListPath, async (eventType, filename) => {
+                if (!filename?.endsWith(".json"))
+                    return;
+                this.logger.log(`[TaskStore] File change detected: ${eventType} ${filename}`);
+                if (this.onChange) {
+                    const tasks = await this.list();
+                    this.onChange(tasks);
+                }
+            });
+            this.logger.log(`[TaskStore] Watching for changes at ${this.taskListPath}`);
+        }
+        catch (err) {
+            this.logger.error(`[TaskStore] Failed to start watcher:`, err);
+        }
+    }
+    /**
+     * Stop watching for changes
+     */
+    close() {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+            this.logger.log(`[TaskStore] Stopped watching`);
+        }
+    }
+    /**
+     * Get task statistics
+     */
+    async getStats() {
+        const tasks = await this.list();
+        return {
+            total: tasks.length,
+            pending: tasks.filter((t) => t.status === "pending").length,
+            inProgress: tasks.filter((t) => t.status === "in_progress").length,
+            completed: tasks.filter((t) => t.status === "completed").length,
+            blocked: tasks.filter((t) => t.blockedBy.length > 0 && t.status !== "completed").length,
+        };
+    }
+    // Private helpers
+    getTaskFilePath(taskId) {
+        return join(this.taskListPath, `${taskId}.json`);
+    }
+    async saveTask(task) {
+        const filePath = this.getTaskFilePath(task.id);
+        await writeFile(filePath, JSON.stringify(task, null, 2), "utf8");
+    }
+    /**
+     * Generate activeForm from subject (convert to present participle)
+     * "Fix bug" -> "Fixing bug"
+     * "Add feature" -> "Adding feature"
+     */
+    generateActiveForm(subject) {
+        const words = subject.split(" ");
+        if (words.length === 0)
+            return subject;
+        const verb = words[0].toLowerCase();
+        let participle;
+        // Handle common verb endings
+        if (verb.endsWith("e")) {
+            participle = verb.slice(0, -1) + "ing";
+        }
+        else if (verb.match(/[aeiou][^aeiou]$/)) {
+            // Double consonant for short vowel + consonant
+            participle = verb + verb.slice(-1) + "ing";
+        }
+        else {
+            participle = verb + "ing";
+        }
+        // Capitalize first letter
+        participle = participle.charAt(0).toUpperCase() + participle.slice(1);
+        return [participle, ...words.slice(1)].join(" ");
+    }
+}

package/dist/work-item-mcp-tools.d.ts

@@ -0,0 +1,12 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TaskStore } from "./task-store.js";
+export interface WorkItemMcpToolsOptions {
+    /** The TaskStore instance for managing work item tasks */
+    taskStore: TaskStore;
+}
+/**
+ * Register MCP tools for work item task management (TaskCreate, TaskGet, TaskUpdate, TaskList)
+ * These match Claude Code's internal task system stored in ~/.claude/tasks/
+ */
+export declare function registerWorkItemMcpTools(server: McpServer, options: WorkItemMcpToolsOptions): void;
+//# sourceMappingURL=work-item-mcp-tools.d.ts.map

package/dist/work-item-mcp-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"work-item-mcp-tools.d.ts","sourceRoot":"","sources":["../src/work-item-mcp-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE,OAAO,EAAE,SAAS,EAAoB,MAAM,iBAAiB,CAAC;AAE9D,MAAM,WAAW,uBAAuB;IACtC,0DAA0D;IAC1D,SAAS,EAAE,SAAS,CAAC;CACtB;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,uBAAuB,GAC/B,IAAI,CAgUN"}