@todu/pi-extensions 0.1.0

package/dist/tools/recurring-read-tools.js

@@ -0,0 +1,57 @@
+import { Type } from "@sinclair/typebox";
+const RecurringListParams = Type.Object({});
+const createRecurringListToolDefinition = ({ getRecurringService, }) => ({
+    name: "recurring_list",
+    label: "Recurring List",
+    description: "List recurring task templates.",
+    promptSnippet: "List recurring task templates through the native recurring service.",
+    promptGuidelines: [
+        "Use this tool for backend recurring template lookups in normal chat.",
+        "Keep recurring_list unfiltered in the first wave unless the task explicitly widens scope.",
+    ],
+    parameters: RecurringListParams,
+    async execute(_toolCallId, _params) {
+        try {
+            const recurringService = await getRecurringService();
+            const templates = await recurringService.listRecurring();
+            const details = {
+                kind: "recurring_list",
+                templates,
+                total: templates.length,
+                empty: templates.length === 0,
+            };
+            return {
+                content: [{ type: "text", text: formatRecurringListContent(details) }],
+                details,
+            };
+        }
+        catch (error) {
+            throw new Error(formatToolError(error, "recurring_list failed"), { cause: error });
+        }
+    },
+});
+const registerRecurringReadTools = (pi, dependencies) => {
+    pi.registerTool(createRecurringListToolDefinition(dependencies));
+};
+const formatRecurringListContent = (details) => {
+    if (details.empty) {
+        return "No recurring templates found.";
+    }
+    const lines = [`Recurring templates (${details.total}):`];
+    for (const template of details.templates) {
+        lines.push(`- ${formatRecurringSummaryLine(template)}`);
+    }
+    return lines.join("\n");
+};
+const formatRecurringSummaryLine = (template) => {
+    const projectLabel = template.projectName ?? template.projectId;
+    const status = template.paused ? "paused" : "active";
+    return `${template.id} • ${template.title} • ${status} • ${template.priority} • ${projectLabel}`;
+};
+const formatToolError = (error, prefix) => {
+    if (error instanceof Error && error.message.trim().length > 0) {
+        return `${prefix}: ${error.message}`;
+    }
+    return prefix;
+};
+export { createRecurringListToolDefinition, formatRecurringListContent, registerRecurringReadTools, };

package/dist/tools/task-mutation-tools.d.ts

@@ -0,0 +1,159 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ProjectSummary, TaskComment, TaskDetail, TaskId, TaskPriority, TaskStatus } from "../domain/task";
+import type { AddTaskCommentInput, CreateTaskInput, DeleteTaskResult, MoveTaskResult, TaskService, UpdateTaskInput } from "../services/task-service";
+interface TaskCreateToolParams {
+    title: string;
+    projectId: string;
+    description?: string;
+}
+interface TaskUpdateToolParams {
+    taskId: TaskId;
+    title?: string;
+    status?: TaskStatus;
+    priority?: TaskPriority;
+    description?: string;
+}
+interface TaskCommentCreateToolParams {
+    taskId: TaskId;
+    content: string;
+}
+interface TaskCreateToolDetails {
+    kind: "task_create";
+    input: CreateTaskInput;
+    task: TaskDetail;
+}
+interface TaskUpdateToolDetails {
+    kind: "task_update";
+    input: UpdateTaskInput;
+    task: TaskDetail;
+}
+interface TaskCommentCreateToolDetails {
+    kind: "task_comment_create";
+    taskId: TaskId;
+    comment: TaskComment;
+}
+interface TaskDeleteToolParams {
+    taskId: string;
+}
+interface TaskDeleteToolDetails {
+    kind: "task_delete";
+    taskId: TaskId;
+    found: boolean;
+    deleted: boolean;
+    result?: DeleteTaskResult;
+}
+interface TaskMoveToolParams {
+    taskId: string;
+    projectId: string;
+}
+interface TaskMoveToolDetails {
+    kind: "task_move";
+    sourceTaskId: TaskId;
+    found: boolean;
+    moved: boolean;
+    result?: MoveTaskResult;
+}
+interface TaskMutationToolDependencies {
+    getTaskService: () => Promise<TaskService>;
+}
+declare const createTaskCreateToolDefinition: ({ getTaskService }: TaskMutationToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        title: import("@sinclair/typebox").TString;
+        projectId: import("@sinclair/typebox").TString;
+        description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>;
+    execute(_toolCallId: string, params: TaskCreateToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: TaskCreateToolDetails;
+    }>;
+};
+declare const createTaskUpdateToolDefinition: ({ getTaskService }: TaskMutationToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        taskId: import("@sinclair/typebox").TString;
+        title: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        status: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnsafe<"active" | "inprogress" | "waiting" | "done" | "cancelled">>;
+        priority: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnsafe<"low" | "medium" | "high">>;
+        description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>;
+    execute(_toolCallId: string, params: TaskUpdateToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: TaskUpdateToolDetails;
+    }>;
+};
+declare const createTaskCommentCreateToolDefinition: ({ getTaskService, }: TaskMutationToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        taskId: import("@sinclair/typebox").TString;
+        content: import("@sinclair/typebox").TString;
+    }>;
+    execute(_toolCallId: string, params: TaskCommentCreateToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: TaskCommentCreateToolDetails;
+    }>;
+};
+declare const createTaskDeleteToolDefinition: ({ getTaskService }: TaskMutationToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        taskId: import("@sinclair/typebox").TString;
+    }>;
+    execute(_toolCallId: string, params: TaskDeleteToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: TaskDeleteToolDetails;
+    }>;
+};
+declare const createTaskMoveToolDefinition: ({ getTaskService }: TaskMutationToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        taskId: import("@sinclair/typebox").TString;
+        projectId: import("@sinclair/typebox").TString;
+    }>;
+    execute(_toolCallId: string, params: TaskMoveToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: TaskMoveToolDetails;
+    }>;
+};
+declare const registerTaskMutationTools: (pi: Pick<ExtensionAPI, "registerTool">, dependencies: TaskMutationToolDependencies) => void;
+declare const normalizeCreateTaskInput: (params: TaskCreateToolParams) => CreateTaskInput;
+declare const resolveCreateTaskInput: (taskService: TaskService, params: TaskCreateToolParams) => Promise<CreateTaskInput>;
+declare const resolveProjectForTaskCreate: (taskService: TaskService, projectRef: string) => Promise<ProjectSummary>;
+declare const normalizeUpdateTaskInput: (params: TaskUpdateToolParams) => UpdateTaskInput;
+declare const normalizeTaskCommentInput: (params: TaskCommentCreateToolParams) => AddTaskCommentInput;
+export type { TaskCommentCreateToolDetails, TaskCreateToolDetails, TaskDeleteToolDetails, TaskMoveToolDetails, TaskMutationToolDependencies, TaskUpdateToolDetails, };
+export { createTaskCommentCreateToolDefinition, createTaskCreateToolDefinition, createTaskDeleteToolDefinition, createTaskMoveToolDefinition, createTaskUpdateToolDefinition, normalizeCreateTaskInput, normalizeTaskCommentInput, normalizeUpdateTaskInput, registerTaskMutationTools, resolveCreateTaskInput, resolveProjectForTaskCreate, };

package/dist/tools/task-mutation-tools.js

@@ -0,0 +1,340 @@
+import { StringEnum } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+import { commentOnTask } from "../flows/comment-on-task.js";
+import { createTask } from "../flows/create-task.js";
+import { updateTask } from "../flows/update-task.js";
+import { ToduTaskServiceError } from "../services/todu/todu-task-service.js";
+const TASK_STATUS_VALUES = ["active", "inprogress", "waiting", "done", "cancelled"];
+const TASK_PRIORITY_VALUES = ["low", "medium", "high"];
+const TaskCreateParams = Type.Object({
+    title: Type.String({ description: "Task title" }),
+    projectId: Type.String({ description: "Project ID or unique project name for the new task" }),
+    description: Type.Optional(Type.String({ description: "Optional task description" })),
+});
+const TaskUpdateParams = Type.Object({
+    taskId: Type.String({ description: "Task ID" }),
+    title: Type.Optional(Type.String({ description: "Optional replacement task title" })),
+    status: Type.Optional(StringEnum(TASK_STATUS_VALUES, { description: "Optional next task status" })),
+    priority: Type.Optional(StringEnum(TASK_PRIORITY_VALUES, { description: "Optional next task priority" })),
+    description: Type.Optional(Type.String({
+        description: "Optional replacement description. Use an empty string to clear it.",
+    })),
+});
+const TaskCommentCreateParams = Type.Object({
+    taskId: Type.String({ description: "Task ID" }),
+    content: Type.String({ description: "Comment content" }),
+});
+const TaskDeleteParams = Type.Object({
+    taskId: Type.String({ description: "Task ID" }),
+});
+const TaskMoveParams = Type.Object({
+    taskId: Type.String({ description: "Task ID" }),
+    projectId: Type.String({ description: "Target project ID or unique project name" }),
+});
+const createTaskCreateToolDefinition = ({ getTaskService }) => ({
+    name: "task_create",
+    label: "Task Create",
+    description: "Create a task with a title, project reference, and optional description.",
+    promptSnippet: "Create a task when the title and project reference are known.",
+    promptGuidelines: [
+        "Use this tool for backend task creation in normal chat instead of interactive slash-command flows.",
+        "Provide an explicit project ID when known.",
+        "If only a project name is available, pass the exact unique project name so the tool can resolve it.",
+        "Do not guess project identity.",
+    ],
+    parameters: TaskCreateParams,
+    async execute(_toolCallId, params) {
+        try {
+            const taskService = await getTaskService();
+            const input = await resolveCreateTaskInput(taskService, params);
+            const task = await createTask({ taskService }, input);
+            const details = {
+                kind: "task_create",
+                input,
+                task,
+            };
+            return {
+                content: [{ type: "text", text: formatTaskCreateContent(task) }],
+                details,
+            };
+        }
+        catch (error) {
+            throw new Error(formatToolError(error, "task_create failed"), { cause: error });
+        }
+    },
+});
+const createTaskUpdateToolDefinition = ({ getTaskService }) => ({
+    name: "task_update",
+    label: "Task Update",
+    description: "Update a task's title, status, priority, or description.",
+    promptSnippet: "Update a task's supported metadata fields by task ID.",
+    promptGuidelines: [
+        "Use this tool for backend task updates in normal chat.",
+        "Supported fields are title, status, priority, and description.",
+    ],
+    parameters: TaskUpdateParams,
+    async execute(_toolCallId, params) {
+        try {
+            const input = normalizeUpdateTaskInput(params);
+            const taskService = await getTaskService();
+            const task = await updateTask({ taskService }, input);
+            const details = {
+                kind: "task_update",
+                input,
+                task,
+            };
+            return {
+                content: [{ type: "text", text: formatTaskUpdateContent(task, input) }],
+                details,
+            };
+        }
+        catch (error) {
+            throw new Error(formatToolError(error, "task_update failed"), { cause: error });
+        }
+    },
+});
+const createTaskCommentCreateToolDefinition = ({ getTaskService, }) => ({
+    name: "task_comment_create",
+    label: "Task Comment Create",
+    description: "Add a comment to a task.",
+    promptSnippet: "Add a comment to a task when the task ID and comment content are known.",
+    promptGuidelines: [
+        "Use this tool to attach task comments in normal chat.",
+        "Provide explicit task IDs instead of guessing which task to comment on.",
+    ],
+    parameters: TaskCommentCreateParams,
+    async execute(_toolCallId, params) {
+        try {
+            const input = normalizeTaskCommentInput(params);
+            const taskService = await getTaskService();
+            const comment = await commentOnTask({ taskService }, input);
+            const details = {
+                kind: "task_comment_create",
+                taskId: input.taskId,
+                comment,
+            };
+            return {
+                content: [{ type: "text", text: formatTaskCommentCreateContent(comment) }],
+                details,
+            };
+        }
+        catch (error) {
+            throw new Error(formatToolError(error, "task_comment_create failed"), { cause: error });
+        }
+    },
+});
+const createTaskDeleteToolDefinition = ({ getTaskService }) => ({
+    name: "task_delete",
+    label: "Task Delete",
+    description: "Delete a task by explicit ID.",
+    promptSnippet: "Delete a task by explicit task ID.",
+    promptGuidelines: [
+        "Use this tool for backend task deletion in normal chat.",
+        "Provide the task ID explicitly.",
+        "Do not guess which task to delete.",
+    ],
+    parameters: TaskDeleteParams,
+    async execute(_toolCallId, params) {
+        const taskId = normalizeRequiredText(params.taskId, "taskId");
+        try {
+            const taskService = await getTaskService();
+            const result = await taskService.deleteTask(taskId);
+            const details = {
+                kind: "task_delete",
+                taskId,
+                found: true,
+                deleted: true,
+                result,
+            };
+            return {
+                content: [{ type: "text", text: formatTaskDeleteContent(details) }],
+                details,
+            };
+        }
+        catch (error) {
+            if (isTaskNotFoundError(error)) {
+                const details = {
+                    kind: "task_delete",
+                    taskId,
+                    found: false,
+                    deleted: false,
+                };
+                return {
+                    content: [{ type: "text", text: formatTaskDeleteContent(details) }],
+                    details,
+                };
+            }
+            throw new Error(formatToolError(error, "task_delete failed"), { cause: error });
+        }
+    },
+});
+const createTaskMoveToolDefinition = ({ getTaskService }) => ({
+    name: "task_move",
+    label: "Task Move",
+    description: "Move a task to a different project.",
+    promptSnippet: "Move a task to a different project by task ID and target project reference.",
+    promptGuidelines: [
+        "Use this tool to move a task between projects in normal chat.",
+        "Provide the task ID and target project ID or unique project name explicitly.",
+        "The original task is cancelled and a new task is created in the target project.",
+    ],
+    parameters: TaskMoveParams,
+    async execute(_toolCallId, params) {
+        const taskId = normalizeRequiredText(params.taskId, "taskId");
+        const projectRef = normalizeRequiredText(params.projectId, "projectId");
+        try {
+            const taskService = await getTaskService();
+            const project = await resolveProjectForTaskCreate(taskService, projectRef);
+            const result = await taskService.moveTask({
+                taskId,
+                targetProjectId: project.id,
+            });
+            const details = {
+                kind: "task_move",
+                sourceTaskId: taskId,
+                found: true,
+                moved: true,
+                result,
+            };
+            return {
+                content: [{ type: "text", text: formatTaskMoveContent(details) }],
+                details,
+            };
+        }
+        catch (error) {
+            if (isTaskNotFoundError(error)) {
+                const details = {
+                    kind: "task_move",
+                    sourceTaskId: taskId,
+                    found: false,
+                    moved: false,
+                };
+                return {
+                    content: [{ type: "text", text: formatTaskMoveContent(details) }],
+                    details,
+                };
+            }
+            throw new Error(formatToolError(error, "task_move failed"), { cause: error });
+        }
+    },
+});
+const registerTaskMutationTools = (pi, dependencies) => {
+    pi.registerTool(createTaskCreateToolDefinition(dependencies));
+    pi.registerTool(createTaskUpdateToolDefinition(dependencies));
+    pi.registerTool(createTaskCommentCreateToolDefinition(dependencies));
+    pi.registerTool(createTaskDeleteToolDefinition(dependencies));
+    pi.registerTool(createTaskMoveToolDefinition(dependencies));
+};
+const normalizeCreateTaskInput = (params) => ({
+    title: normalizeRequiredText(params.title, "title"),
+    projectId: normalizeRequiredText(params.projectId, "projectId"),
+    description: normalizeOptionalDescription(params, "description"),
+});
+const resolveCreateTaskInput = async (taskService, params) => {
+    const input = normalizeCreateTaskInput(params);
+    const project = await resolveProjectForTaskCreate(taskService, normalizeRequiredText(input.projectId ?? "", "projectId"));
+    return {
+        ...input,
+        projectId: project.id,
+    };
+};
+const resolveProjectForTaskCreate = async (taskService, projectRef) => {
+    const project = await taskService.getProject(projectRef);
+    if (project) {
+        return project;
+    }
+    const projects = await taskService.listProjects();
+    const nameMatches = projects.filter((candidate) => candidate.name === projectRef);
+    if (nameMatches.length === 0) {
+        throw new Error(`project not found: ${projectRef}`);
+    }
+    if (nameMatches.length > 1) {
+        throw new Error(`multiple projects matched: ${projectRef}`);
+    }
+    const matchedProject = nameMatches[0];
+    if (!matchedProject) {
+        throw new Error(`project not found: ${projectRef}`);
+    }
+    return matchedProject;
+};
+const normalizeUpdateTaskInput = (params) => {
+    const input = {
+        taskId: normalizeRequiredText(params.taskId, "taskId"),
+        status: params.status,
+        priority: params.priority,
+    };
+    if (hasOwn(params, "title")) {
+        input.title = normalizeRequiredText(params.title ?? "", "title");
+    }
+    if (hasOwn(params, "description")) {
+        input.description = normalizeNullableText(params.description);
+    }
+    if (input.title === undefined &&
+        input.status === undefined &&
+        input.priority === undefined &&
+        !hasOwn(input, "description")) {
+        throw new Error("task_update requires at least one supported field: title, status, priority, or description");
+    }
+    return input;
+};
+const normalizeTaskCommentInput = (params) => ({
+    taskId: normalizeRequiredText(params.taskId, "taskId"),
+    content: normalizeRequiredText(params.content, "content"),
+});
+const normalizeRequiredText = (value, fieldName) => {
+    const trimmedValue = value.trim();
+    if (trimmedValue.length === 0) {
+        throw new Error(`${fieldName} is required`);
+    }
+    return trimmedValue;
+};
+const normalizeOptionalDescription = (params, fieldName) => {
+    if (!hasOwn(params, fieldName)) {
+        return undefined;
+    }
+    return normalizeNullableText(params[fieldName]);
+};
+const normalizeNullableText = (value) => {
+    const trimmedValue = value?.trim() ?? "";
+    return trimmedValue.length > 0 ? trimmedValue : null;
+};
+const hasOwn = (value, property) => Object.prototype.hasOwnProperty.call(value, property);
+const formatTaskCreateContent = (task) => [
+    `Created task ${task.id}: ${task.title}`,
+    `Status: ${task.status}`,
+    `Priority: ${task.priority}`,
+    `Project: ${task.projectName ?? task.projectId ?? "No project"}`,
+].join("\n");
+const formatTaskUpdateContent = (task, input) => {
+    const changedFields = [
+        input.title !== undefined ? `title=${JSON.stringify(input.title)}` : null,
+        input.status !== undefined ? `status=${input.status}` : null,
+        input.priority !== undefined ? `priority=${input.priority}` : null,
+        hasOwn(input, "description")
+            ? `description=${input.description === null ? "cleared" : "updated"}`
+            : null,
+    ].filter((value) => value !== null);
+    return [`Updated task ${task.id}: ${task.title}`, `Changes: ${changedFields.join(", ")}`].join("\n");
+};
+const formatTaskCommentCreateContent = (comment) => `Added comment ${comment.id} to task ${comment.taskId}.`;
+const formatTaskDeleteContent = (details) => details.found ? `Deleted task ${details.taskId}.` : `Task not found: ${details.taskId}`;
+const isTaskNotFoundError = (error) => error instanceof ToduTaskServiceError && error.causeCode === "not-found";
+const formatTaskMoveContent = (details) => {
+    if (!details.found) {
+        return `Task not found: ${details.sourceTaskId}`;
+    }
+    const target = details.result?.targetTask;
+    const projectLabel = target?.projectName ?? target?.projectId ?? "unknown";
+    return [
+        `Moved task ${details.sourceTaskId} → ${target?.id ?? "unknown"}`,
+        `Target project: ${projectLabel}`,
+        `New task: ${target?.id}: ${target?.title}`,
+    ].join("\n");
+};
+const formatToolError = (error, prefix) => {
+    if (error instanceof Error && error.message.trim().length > 0) {
+        return `${prefix}: ${error.message}`;
+    }
+    return prefix;
+};
+export { createTaskCommentCreateToolDefinition, createTaskCreateToolDefinition, createTaskDeleteToolDefinition, createTaskMoveToolDefinition, createTaskUpdateToolDefinition, normalizeCreateTaskInput, normalizeTaskCommentInput, normalizeUpdateTaskInput, registerTaskMutationTools, resolveCreateTaskInput, resolveProjectForTaskCreate, };

package/dist/tools/task-read-tools.d.ts

@@ -0,0 +1,91 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { TaskDetail, TaskFilter, TaskId, TaskPriority, TaskSortDirection, TaskSortField, TaskStatus, TaskSummary } from "../domain/task";
+import type { TaskService } from "../services/task-service";
+interface TaskListToolParams {
+    statuses?: TaskStatus[];
+    priorities?: TaskPriority[];
+    projectId?: string;
+    query?: string;
+    from?: string;
+    to?: string;
+    updatedFrom?: string;
+    updatedTo?: string;
+    label?: string;
+    overdue?: boolean;
+    today?: boolean;
+    sort?: TaskSortField;
+    sortDirection?: TaskSortDirection;
+    timezone?: string;
+}
+interface TaskShowToolParams {
+    taskId: TaskId;
+}
+interface TaskListToolDetails {
+    kind: "task_list";
+    filter: TaskFilter;
+    tasks: TaskSummary[];
+    total: number;
+    empty: boolean;
+}
+interface TaskShowToolDetails {
+    kind: "task_show";
+    taskId: TaskId;
+    found: boolean;
+    task?: TaskDetail;
+}
+interface TaskReadToolDependencies {
+    getTaskService: () => Promise<TaskService>;
+}
+declare const createTaskListToolDefinition: ({ getTaskService }: TaskReadToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        statuses: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnsafe<"active" | "inprogress" | "waiting" | "done" | "cancelled">>>;
+        priorities: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnsafe<"low" | "medium" | "high">>>;
+        projectId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        query: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        from: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        to: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        updatedFrom: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        updatedTo: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        label: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        overdue: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        today: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        sort: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnsafe<"priority" | "dueDate" | "createdAt" | "updatedAt" | "title">>;
+        sortDirection: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnsafe<"asc" | "desc">>;
+        timezone: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>;
+    execute(_toolCallId: string, params: TaskListToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: TaskListToolDetails;
+    }>;
+};
+declare const createTaskShowToolDefinition: ({ getTaskService }: TaskReadToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        taskId: import("@sinclair/typebox").TString;
+    }>;
+    execute(_toolCallId: string, params: TaskShowToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: TaskShowToolDetails;
+    }>;
+};
+declare const registerTaskReadTools: (pi: Pick<ExtensionAPI, "registerTool">, dependencies: TaskReadToolDependencies) => void;
+declare const normalizeTaskListFilter: (params: TaskListToolParams) => TaskFilter;
+declare const formatTaskListContent: (details: TaskListToolDetails) => string;
+declare const formatTaskShowContent: (task: TaskDetail) => string;
+export type { TaskListToolDetails, TaskShowToolDetails, TaskReadToolDependencies };
+export { createTaskListToolDefinition, createTaskShowToolDefinition, formatTaskListContent, formatTaskShowContent, normalizeTaskListFilter, registerTaskReadTools, };