@todu/pi-extensions 0.1.0

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

@@ -0,0 +1,59 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ProjectSummary } from "../domain/task";
+import type { ProjectService } from "../services/project-service";
+interface ProjectListToolDetails {
+    kind: "project_list";
+    projects: ProjectSummary[];
+    total: number;
+    empty: boolean;
+}
+interface ProjectShowToolDetails {
+    kind: "project_show";
+    projectRef: string;
+    found: boolean;
+    project?: ProjectSummary;
+}
+interface ProjectShowToolParams {
+    projectRef: string;
+}
+interface ProjectReadToolDependencies {
+    getProjectService: () => Promise<ProjectService>;
+}
+declare const createProjectListToolDefinition: ({ getProjectService }: ProjectReadToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{}>;
+    execute(_toolCallId: string, _params: Record<string, never>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: ProjectListToolDetails;
+    }>;
+};
+declare const createProjectShowToolDefinition: ({ getProjectService }: ProjectReadToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        projectRef: import("@sinclair/typebox").TString;
+    }>;
+    execute(_toolCallId: string, params: ProjectShowToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: ProjectShowToolDetails;
+    }>;
+};
+declare const registerProjectReadTools: (pi: Pick<ExtensionAPI, "registerTool">, dependencies: ProjectReadToolDependencies) => void;
+declare const resolveProjectByRef: (projectService: ProjectService, projectRef: string) => Promise<ProjectSummary | null>;
+declare const formatProjectListContent: (details: ProjectListToolDetails) => string;
+declare const formatProjectShowContent: (project: ProjectSummary) => string;
+export type { ProjectListToolDetails, ProjectReadToolDependencies, ProjectShowToolDetails };
+export { createProjectListToolDefinition, createProjectShowToolDefinition, formatProjectListContent, formatProjectShowContent, registerProjectReadTools, resolveProjectByRef, };

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

@@ -0,0 +1,131 @@
+import { Type } from "@sinclair/typebox";
+const ProjectListParams = Type.Object({});
+const ProjectShowParams = Type.Object({
+    projectRef: Type.String({ description: "Project ID or unique project name" }),
+});
+const createProjectListToolDefinition = ({ getProjectService }) => ({
+    name: "project_list",
+    label: "Project List",
+    description: "List projects.",
+    promptSnippet: "List projects using the native backend tool.",
+    promptGuidelines: [
+        "Use this tool when the user asks to list projects in normal chat.",
+        "Keep project_list unfiltered in V1.",
+    ],
+    parameters: ProjectListParams,
+    async execute(_toolCallId, _params) {
+        try {
+            const projectService = await getProjectService();
+            const projects = await projectService.listProjects();
+            const details = {
+                kind: "project_list",
+                projects,
+                total: projects.length,
+                empty: projects.length === 0,
+            };
+            return {
+                content: [{ type: "text", text: formatProjectListContent(details) }],
+                details,
+            };
+        }
+        catch (error) {
+            throw new Error(formatToolError(error, "project_list failed"), { cause: error });
+        }
+    },
+});
+const createProjectShowToolDefinition = ({ getProjectService }) => ({
+    name: "project_show",
+    label: "Project Show",
+    description: "Show project details by ID or unique name.",
+    promptSnippet: "Show details for a project by explicit ID or unique name.",
+    promptGuidelines: [
+        "Use this tool when the user asks for details about a known project.",
+        "Resolve by project ID first, then by unique name when needed.",
+        "If the project is missing or ambiguous, report that explicitly instead of guessing.",
+    ],
+    parameters: ProjectShowParams,
+    async execute(_toolCallId, params) {
+        const projectRef = normalizeRequiredText(params.projectRef, "projectRef");
+        try {
+            const projectService = await getProjectService();
+            const project = await resolveProjectByRef(projectService, projectRef);
+            if (!project) {
+                const details = {
+                    kind: "project_show",
+                    projectRef,
+                    found: false,
+                };
+                return {
+                    content: [{ type: "text", text: `Project not found: ${projectRef}` }],
+                    details,
+                };
+            }
+            const details = {
+                kind: "project_show",
+                projectRef,
+                found: true,
+                project,
+            };
+            return {
+                content: [{ type: "text", text: formatProjectShowContent(project) }],
+                details,
+            };
+        }
+        catch (error) {
+            throw new Error(formatToolError(error, "project_show failed"), { cause: error });
+        }
+    },
+});
+const registerProjectReadTools = (pi, dependencies) => {
+    pi.registerTool(createProjectListToolDefinition(dependencies));
+    pi.registerTool(createProjectShowToolDefinition(dependencies));
+};
+const resolveProjectByRef = async (projectService, projectRef) => {
+    const project = await projectService.getProject(projectRef);
+    if (project) {
+        return project;
+    }
+    const projects = await projectService.listProjects();
+    const nameMatches = projects.filter((candidate) => candidate.name === projectRef);
+    if (nameMatches.length === 0) {
+        return null;
+    }
+    if (nameMatches.length > 1) {
+        throw new Error(`project_show found multiple projects named: ${projectRef}`);
+    }
+    return nameMatches[0] ?? null;
+};
+const formatProjectListContent = (details) => {
+    if (details.empty) {
+        return "No projects found.";
+    }
+    const lines = [`Projects (${details.total}):`];
+    for (const project of details.projects) {
+        lines.push(`- ${formatProjectSummaryLine(project)}`);
+    }
+    return lines.join("\n");
+};
+const formatProjectShowContent = (project) => [
+    `Project ${project.id}: ${project.name}`,
+    "",
+    `Status: ${project.status}`,
+    `Priority: ${project.priority}`,
+    "",
+    "Description:",
+    project.description?.trim().length ? project.description : "(none)",
+].join("\n");
+const formatProjectSummaryLine = (project) => `${project.id} • ${project.name} • ${project.status} • ${project.priority}`;
+const normalizeRequiredText = (value, fieldName) => {
+    const trimmedValue = value.trim();
+    if (trimmedValue.length === 0) {
+        throw new Error(`${fieldName} is required`);
+    }
+    return trimmedValue;
+};
+const formatToolError = (error, prefix) => {
+    if (error instanceof Error && error.message.trim().length > 0) {
+        return `${prefix}: ${error.message}`;
+    }
+    return prefix;
+};
+export { createProjectListToolDefinition, createProjectShowToolDefinition, formatProjectListContent, formatProjectShowContent, registerProjectReadTools, resolveProjectByRef, };

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

@@ -0,0 +1,130 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { RecurringMissPolicy, RecurringTemplateDetail } from "../domain/recurring";
+import type { ProjectSummary, TaskPriority } from "../domain/task";
+import type { ProjectService } from "../services/project-service";
+import type { CreateRecurringInput, DeleteRecurringResult, RecurringService, UpdateRecurringInput } from "../services/recurring-service";
+interface RecurringCreateToolParams {
+    title: string;
+    projectId: string;
+    schedule: string;
+    timezone: string;
+    startDate: string;
+    description?: string;
+    priority?: TaskPriority;
+    endDate?: string;
+    missPolicy?: RecurringMissPolicy;
+}
+interface RecurringUpdateToolParams {
+    recurringId: string;
+    title?: string;
+    projectId?: string;
+    schedule?: string;
+    timezone?: string;
+    startDate?: string;
+    description?: string;
+    priority?: TaskPriority;
+    endDate?: string;
+    missPolicy?: RecurringMissPolicy;
+    paused?: boolean;
+}
+interface RecurringDeleteToolParams {
+    recurringId: string;
+}
+interface RecurringCreateToolDetails {
+    kind: "recurring_create";
+    input: CreateRecurringInput;
+    template: RecurringTemplateDetail;
+}
+interface RecurringUpdateToolDetails {
+    kind: "recurring_update";
+    input: UpdateRecurringInput;
+    template: RecurringTemplateDetail;
+}
+interface RecurringDeleteToolDetails {
+    kind: "recurring_delete";
+    recurringId: string;
+    found: boolean;
+    deleted: boolean;
+    template?: DeleteRecurringResult;
+}
+interface RecurringMutationToolDependencies {
+    getRecurringService: () => Promise<RecurringService>;
+    getProjectService: () => Promise<ProjectService>;
+}
+declare const createRecurringCreateToolDefinition: ({ getRecurringService, getProjectService, }: RecurringMutationToolDependencies) => {
+    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;
+        schedule: import("@sinclair/typebox").TString;
+        timezone: import("@sinclair/typebox").TString;
+        startDate: import("@sinclair/typebox").TString;
+        description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        priority: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnsafe<"low" | "medium" | "high">>;
+        endDate: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        missPolicy: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnsafe<"accumulate" | "rollForward">>;
+    }>;
+    execute(_toolCallId: string, params: RecurringCreateToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: RecurringCreateToolDetails;
+    }>;
+};
+declare const createRecurringUpdateToolDefinition: ({ getRecurringService, getProjectService, }: RecurringMutationToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        recurringId: import("@sinclair/typebox").TString;
+        title: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        projectId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        schedule: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        timezone: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        startDate: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        priority: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnsafe<"low" | "medium" | "high">>;
+        endDate: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        missPolicy: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnsafe<"accumulate" | "rollForward">>;
+        paused: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    }>;
+    execute(_toolCallId: string, params: RecurringUpdateToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: RecurringUpdateToolDetails;
+    }>;
+};
+declare const createRecurringDeleteToolDefinition: ({ getRecurringService, }: RecurringMutationToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        recurringId: import("@sinclair/typebox").TString;
+    }>;
+    execute(_toolCallId: string, params: RecurringDeleteToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: RecurringDeleteToolDetails;
+    }>;
+};
+declare const registerRecurringMutationTools: (pi: Pick<ExtensionAPI, "registerTool">, dependencies: RecurringMutationToolDependencies) => void;
+declare const normalizeCreateRecurringInput: (params: RecurringCreateToolParams) => CreateRecurringInput;
+declare const resolveCreateRecurringInput: (projectService: ProjectService, params: RecurringCreateToolParams) => Promise<CreateRecurringInput>;
+declare const resolveUpdateRecurringInput: (projectService: ProjectService, params: RecurringUpdateToolParams) => Promise<UpdateRecurringInput>;
+declare const normalizeUpdateRecurringInput: (params: RecurringUpdateToolParams) => UpdateRecurringInput;
+declare const resolveProjectForRecurringMutation: (projectService: ProjectService, projectRef: string) => Promise<ProjectSummary>;
+export type { RecurringCreateToolDetails, RecurringDeleteToolDetails, RecurringMutationToolDependencies, RecurringUpdateToolDetails, };
+export { createRecurringCreateToolDefinition, createRecurringDeleteToolDefinition, createRecurringUpdateToolDefinition, normalizeCreateRecurringInput, normalizeUpdateRecurringInput, registerRecurringMutationTools, resolveCreateRecurringInput, resolveProjectForRecurringMutation, resolveUpdateRecurringInput, };

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

@@ -0,0 +1,317 @@
+import { StringEnum } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+import { ToduRecurringServiceError } from "../services/todu/todu-recurring-service.js";
+import { validateAndNormalizeScheduleRule } from "../utils/schedule.js";
+const TASK_PRIORITY_VALUES = ["low", "medium", "high"];
+const RECURRING_MISS_POLICY_VALUES = ["accumulate", "rollForward"];
+const RecurringCreateParams = Type.Object({
+    title: Type.String({ description: "Recurring template title" }),
+    projectId: Type.String({ description: "Project ID or unique project name" }),
+    schedule: Type.String({ description: "Normalized RRULE schedule string" }),
+    timezone: Type.String({ description: "IANA timezone" }),
+    startDate: Type.String({ description: "Start date in YYYY-MM-DD format" }),
+    description: Type.Optional(Type.String({ description: "Optional recurring template description" })),
+    priority: Type.Optional(StringEnum(TASK_PRIORITY_VALUES, { description: "Optional recurring template priority" })),
+    endDate: Type.Optional(Type.String({
+        description: "Optional end date in YYYY-MM-DD format. Use an empty string to clear it.",
+    })),
+    missPolicy: Type.Optional(StringEnum(RECURRING_MISS_POLICY_VALUES, { description: "Optional recurring miss policy" })),
+});
+const RecurringUpdateParams = Type.Object({
+    recurringId: Type.String({ description: "Recurring template ID" }),
+    title: Type.Optional(Type.String({ description: "Optional replacement recurring template title" })),
+    projectId: Type.Optional(Type.String({ description: "Optional replacement project ID or unique project name" })),
+    schedule: Type.Optional(Type.String({ description: "Optional replacement normalized RRULE schedule string" })),
+    timezone: Type.Optional(Type.String({ description: "Optional replacement IANA timezone" })),
+    startDate: Type.Optional(Type.String({ description: "Optional replacement start date in YYYY-MM-DD format" })),
+    description: Type.Optional(Type.String({
+        description: "Optional replacement description. Use an empty string to clear it.",
+    })),
+    priority: Type.Optional(StringEnum(TASK_PRIORITY_VALUES, {
+        description: "Optional replacement recurring template priority",
+    })),
+    endDate: Type.Optional(Type.String({ description: "Optional replacement end date. Use an empty string to clear it." })),
+    missPolicy: Type.Optional(StringEnum(RECURRING_MISS_POLICY_VALUES, {
+        description: "Optional replacement recurring miss policy",
+    })),
+    paused: Type.Optional(Type.Boolean({ description: "Optional paused state" })),
+});
+const RecurringDeleteParams = Type.Object({
+    recurringId: Type.String({ description: "Recurring template ID" }),
+});
+const createRecurringCreateToolDefinition = ({ getRecurringService, getProjectService, }) => ({
+    name: "recurring_create",
+    label: "Recurring Create",
+    description: "Create a recurring task template.",
+    promptSnippet: "Create a recurring task template through the native recurring service.",
+    promptGuidelines: [
+        "Use this tool for backend recurring template creation in normal chat.",
+        "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.",
+        "Provide normalized RRULE schedule strings instead of natural-language schedules.",
+    ],
+    parameters: RecurringCreateParams,
+    async execute(_toolCallId, params) {
+        try {
+            const projectService = await getProjectService();
+            const input = await resolveCreateRecurringInput(projectService, params);
+            const recurringService = await getRecurringService();
+            const template = await recurringService.createRecurring(input);
+            const details = {
+                kind: "recurring_create",
+                input,
+                template,
+            };
+            return {
+                content: [{ type: "text", text: formatRecurringCreateContent(template) }],
+                details,
+            };
+        }
+        catch (error) {
+            throw new Error(formatToolError(error, "recurring_create failed"), { cause: error });
+        }
+    },
+});
+const createRecurringUpdateToolDefinition = ({ getRecurringService, getProjectService, }) => ({
+    name: "recurring_update",
+    label: "Recurring Update",
+    description: "Update a recurring template's supported fields.",
+    promptSnippet: "Update a recurring template through the native recurring service.",
+    promptGuidelines: [
+        "Use this tool for backend recurring template updates in normal chat.",
+        "Do not use it for occurrence previews or forecast helpers.",
+        "Provide normalized RRULE schedule strings instead of natural-language schedules.",
+    ],
+    parameters: RecurringUpdateParams,
+    async execute(_toolCallId, params) {
+        try {
+            const projectService = await getProjectService();
+            const input = await resolveUpdateRecurringInput(projectService, params);
+            const recurringService = await getRecurringService();
+            const template = await recurringService.updateRecurring(input);
+            const details = {
+                kind: "recurring_update",
+                input,
+                template,
+            };
+            return {
+                content: [{ type: "text", text: formatRecurringUpdateContent(template, input) }],
+                details,
+            };
+        }
+        catch (error) {
+            throw new Error(formatToolError(error, "recurring_update failed"), { cause: error });
+        }
+    },
+});
+const createRecurringDeleteToolDefinition = ({ getRecurringService, }) => ({
+    name: "recurring_delete",
+    label: "Recurring Delete",
+    description: "Delete a recurring template by explicit ID.",
+    promptSnippet: "Delete a recurring template by explicit ID.",
+    promptGuidelines: [
+        "Use this tool for backend recurring template deletion in normal chat.",
+        "Do not use it for occurrence cleanup or generated-task deletion.",
+    ],
+    parameters: RecurringDeleteParams,
+    async execute(_toolCallId, params) {
+        const recurringId = normalizeRequiredText(params.recurringId, "recurringId");
+        try {
+            const recurringService = await getRecurringService();
+            const template = await recurringService.deleteRecurring(recurringId);
+            const details = {
+                kind: "recurring_delete",
+                recurringId,
+                found: true,
+                deleted: true,
+                template,
+            };
+            return {
+                content: [{ type: "text", text: formatRecurringDeleteContent(details) }],
+                details,
+            };
+        }
+        catch (error) {
+            if (isRecurringNotFoundError(error)) {
+                const details = {
+                    kind: "recurring_delete",
+                    recurringId,
+                    found: false,
+                    deleted: false,
+                };
+                return {
+                    content: [{ type: "text", text: formatRecurringDeleteContent(details) }],
+                    details,
+                };
+            }
+            throw new Error(formatToolError(error, "recurring_delete failed"), { cause: error });
+        }
+    },
+});
+const registerRecurringMutationTools = (pi, dependencies) => {
+    pi.registerTool(createRecurringCreateToolDefinition(dependencies));
+    pi.registerTool(createRecurringUpdateToolDefinition(dependencies));
+    pi.registerTool(createRecurringDeleteToolDefinition(dependencies));
+};
+const normalizeCreateRecurringInput = (params) => ({
+    title: normalizeRequiredText(params.title, "title"),
+    projectId: normalizeRequiredText(params.projectId, "projectId"),
+    schedule: normalizeScheduleInput(params.schedule),
+    timezone: normalizeRequiredText(params.timezone, "timezone"),
+    startDate: normalizeRequiredText(params.startDate, "startDate"),
+    description: normalizeOptionalDescription(params, "description"),
+    priority: params.priority,
+    endDate: normalizeOptionalDate(params, "endDate"),
+    missPolicy: params.missPolicy,
+});
+const resolveCreateRecurringInput = async (projectService, params) => {
+    const input = normalizeCreateRecurringInput(params);
+    const project = await resolveProjectForRecurringMutation(projectService, input.projectId);
+    return {
+        ...input,
+        projectId: project.id,
+    };
+};
+const resolveUpdateRecurringInput = async (projectService, params) => {
+    const input = normalizeUpdateRecurringInput(params);
+    if (input.projectId === undefined) {
+        return input;
+    }
+    const project = await resolveProjectForRecurringMutation(projectService, input.projectId);
+    return {
+        ...input,
+        projectId: project.id,
+    };
+};
+const normalizeUpdateRecurringInput = (params) => {
+    const input = {
+        recurringId: normalizeRequiredText(params.recurringId, "recurringId"),
+        priority: params.priority,
+        missPolicy: params.missPolicy,
+        paused: params.paused,
+    };
+    if (hasOwn(params, "title")) {
+        input.title = normalizeRequiredText(params.title ?? "", "title");
+    }
+    if (hasOwn(params, "projectId")) {
+        input.projectId = normalizeRequiredText(params.projectId ?? "", "projectId");
+    }
+    if (hasOwn(params, "schedule")) {
+        input.schedule = normalizeScheduleInput(params.schedule ?? "");
+    }
+    if (hasOwn(params, "timezone")) {
+        input.timezone = normalizeRequiredText(params.timezone ?? "", "timezone");
+    }
+    if (hasOwn(params, "startDate")) {
+        input.startDate = normalizeRequiredText(params.startDate ?? "", "startDate");
+    }
+    if (hasOwn(params, "description")) {
+        input.description = normalizeNullableText(params.description);
+    }
+    if (hasOwn(params, "endDate")) {
+        input.endDate = normalizeNullableText(params.endDate);
+    }
+    if (input.title === undefined &&
+        input.projectId === undefined &&
+        input.schedule === undefined &&
+        input.timezone === undefined &&
+        input.startDate === undefined &&
+        input.priority === undefined &&
+        input.missPolicy === undefined &&
+        input.paused === undefined &&
+        !hasOwn(input, "description") &&
+        !hasOwn(input, "endDate")) {
+        throw new Error("recurring_update requires at least one supported field: title, projectId, schedule, timezone, startDate, description, priority, endDate, missPolicy, or paused");
+    }
+    return input;
+};
+const resolveProjectForRecurringMutation = async (projectService, projectRef) => {
+    const project = await projectService.getProject(projectRef);
+    if (project) {
+        return project;
+    }
+    const projects = await projectService.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 normalizeScheduleInput = (value) => {
+    const normalizedValue = normalizeRequiredText(value, "schedule");
+    const result = validateAndNormalizeScheduleRule(normalizedValue);
+    if (!result.ok) {
+        throw new Error(result.error.message);
+    }
+    return result.value.rule;
+};
+const normalizeOptionalDescription = (params, fieldName) => {
+    if (!hasOwn(params, fieldName)) {
+        return undefined;
+    }
+    return normalizeNullableText(params[fieldName]);
+};
+const normalizeOptionalDate = (params, fieldName) => {
+    if (!hasOwn(params, fieldName)) {
+        return undefined;
+    }
+    return normalizeNullableText(params[fieldName]);
+};
+const normalizeRequiredText = (value, fieldName) => {
+    const trimmedValue = value.trim();
+    if (trimmedValue.length === 0) {
+        throw new Error(`${fieldName} is required`);
+    }
+    return trimmedValue;
+};
+const normalizeNullableText = (value) => {
+    const trimmedValue = value?.trim() ?? "";
+    return trimmedValue.length > 0 ? trimmedValue : null;
+};
+const hasOwn = (value, property) => Object.prototype.hasOwnProperty.call(value, property);
+const isRecurringNotFoundError = (error) => error instanceof ToduRecurringServiceError && error.causeCode === "not-found";
+const formatRecurringCreateContent = (template) => [
+    `Created recurring template ${template.id}: ${template.title}`,
+    `Status: ${template.paused ? "paused" : "active"}`,
+    `Priority: ${template.priority}`,
+    `Project: ${template.projectName ?? template.projectId}`,
+].join("\n");
+const formatRecurringUpdateContent = (template, input) => {
+    const changedFields = [
+        input.title !== undefined ? `title=${JSON.stringify(input.title)}` : null,
+        input.projectId !== undefined ? `projectId=${input.projectId}` : null,
+        input.schedule !== undefined ? `schedule=${input.schedule}` : null,
+        input.timezone !== undefined ? `timezone=${input.timezone}` : null,
+        input.startDate !== undefined ? `startDate=${input.startDate}` : null,
+        input.priority !== undefined ? `priority=${input.priority}` : null,
+        input.missPolicy !== undefined ? `missPolicy=${input.missPolicy}` : null,
+        input.paused !== undefined ? `paused=${input.paused}` : null,
+        hasOwn(input, "description")
+            ? `description=${input.description === null ? "cleared" : "updated"}`
+            : null,
+        hasOwn(input, "endDate")
+            ? `endDate=${input.endDate === null ? "cleared" : input.endDate}`
+            : null,
+    ].filter((value) => value !== null);
+    return [
+        `Updated recurring template ${template.id}: ${template.title}`,
+        `Changes: ${changedFields.join(", ")}`,
+    ].join("\n");
+};
+const formatRecurringDeleteContent = (details) => details.found
+    ? `Deleted recurring template ${details.recurringId}.`
+    : `Recurring template not found: ${details.recurringId}`;
+const formatToolError = (error, prefix) => {
+    if (error instanceof Error && error.message.trim().length > 0) {
+        return `${prefix}: ${error.message}`;
+    }
+    return prefix;
+};
+export { createRecurringCreateToolDefinition, createRecurringDeleteToolDefinition, createRecurringUpdateToolDefinition, normalizeCreateRecurringInput, normalizeUpdateRecurringInput, registerRecurringMutationTools, resolveCreateRecurringInput, resolveProjectForRecurringMutation, resolveUpdateRecurringInput, };

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

@@ -0,0 +1,31 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { RecurringTemplateSummary } from "../domain/recurring";
+import type { RecurringService } from "../services/recurring-service";
+interface RecurringListToolDetails {
+    kind: "recurring_list";
+    templates: RecurringTemplateSummary[];
+    total: number;
+    empty: boolean;
+}
+interface RecurringReadToolDependencies {
+    getRecurringService: () => Promise<RecurringService>;
+}
+declare const createRecurringListToolDefinition: ({ getRecurringService, }: RecurringReadToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{}>;
+    execute(_toolCallId: string, _params: Record<string, never>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: RecurringListToolDetails;
+    }>;
+};
+declare const registerRecurringReadTools: (pi: Pick<ExtensionAPI, "registerTool">, dependencies: RecurringReadToolDependencies) => void;
+declare const formatRecurringListContent: (details: RecurringListToolDetails) => string;
+export type { RecurringListToolDetails, RecurringReadToolDependencies };
+export { createRecurringListToolDefinition, formatRecurringListContent, registerRecurringReadTools, };