init claude-code

tools/TaskGetTool/TaskGetTool.ts

@@ -0,0 +1,128 @@
+import { z } from 'zod/v4'
+import { buildTool, type ToolDef } from '../../Tool.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import {
+  getTask,
+  getTaskListId,
+  isTodoV2Enabled,
+  TaskStatusSchema,
+} from '../../utils/tasks.js'
+import { TASK_GET_TOOL_NAME } from './constants.js'
+import { DESCRIPTION, PROMPT } from './prompt.js'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    taskId: z.string().describe('The ID of the task to retrieve'),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+
+const outputSchema = lazySchema(() =>
+  z.object({
+    task: z
+      .object({
+        id: z.string(),
+        subject: z.string(),
+        description: z.string(),
+        status: TaskStatusSchema(),
+        blocks: z.array(z.string()),
+        blockedBy: z.array(z.string()),
+      })
+      .nullable(),
+  }),
+)
+type OutputSchema = ReturnType<typeof outputSchema>
+
+export type Output = z.infer<OutputSchema>
+
+export const TaskGetTool = buildTool({
+  name: TASK_GET_TOOL_NAME,
+  searchHint: 'retrieve a task by ID',
+  maxResultSizeChars: 100_000,
+  async description() {
+    return DESCRIPTION
+  },
+  async prompt() {
+    return PROMPT
+  },
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+  get outputSchema(): OutputSchema {
+    return outputSchema()
+  },
+  userFacingName() {
+    return 'TaskGet'
+  },
+  shouldDefer: true,
+  isEnabled() {
+    return isTodoV2Enabled()
+  },
+  isConcurrencySafe() {
+    return true
+  },
+  isReadOnly() {
+    return true
+  },
+  toAutoClassifierInput(input) {
+    return input.taskId
+  },
+  renderToolUseMessage() {
+    return null
+  },
+  async call({ taskId }) {
+    const taskListId = getTaskListId()
+
+    const task = await getTask(taskListId, taskId)
+
+    if (!task) {
+      return {
+        data: {
+          task: null,
+        },
+      }
+    }
+
+    return {
+      data: {
+        task: {
+          id: task.id,
+          subject: task.subject,
+          description: task.description,
+          status: task.status,
+          blocks: task.blocks,
+          blockedBy: task.blockedBy,
+        },
+      },
+    }
+  },
+  mapToolResultToToolResultBlockParam(content, toolUseID) {
+    const { task } = content as Output
+    if (!task) {
+      return {
+        tool_use_id: toolUseID,
+        type: 'tool_result',
+        content: 'Task not found',
+      }
+    }
+
+    const lines = [
+      `Task #${task.id}: ${task.subject}`,
+      `Status: ${task.status}`,
+      `Description: ${task.description}`,
+    ]
+
+    if (task.blockedBy.length > 0) {
+      lines.push(`Blocked by: ${task.blockedBy.map(id => `#${id}`).join(', ')}`)
+    }
+    if (task.blocks.length > 0) {
+      lines.push(`Blocks: ${task.blocks.map(id => `#${id}`).join(', ')}`)
+    }
+
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: lines.join('\n'),
+    }
+  },
+} satisfies ToolDef<InputSchema, Output>)

tools/TaskGetTool/constants.ts

@@ -0,0 +1 @@
+export const TASK_GET_TOOL_NAME = 'TaskGet'

tools/TaskGetTool/prompt.ts

@@ -0,0 +1,24 @@
+export const DESCRIPTION = 'Get a task by ID from the task list'
+
+export const PROMPT = `Use this tool to retrieve a task by its ID from the task list.
+
+## When to Use This Tool
+
+- When you need the full description and context before starting work on a task
+- To understand task dependencies (what it blocks, what blocks it)
+- After being assigned a task, to get complete requirements
+
+## Output
+
+Returns full task details:
+- **subject**: Task title
+- **description**: Detailed requirements and context
+- **status**: 'pending', 'in_progress', or 'completed'
+- **blocks**: Tasks waiting on this one to complete
+- **blockedBy**: Tasks that must complete before this one can start
+
+## Tips
+
+- After fetching a task, verify its blockedBy list is empty before beginning work.
+- Use TaskList to see all tasks in summary form.
+`