@todu/pi-extensions 0.1.0

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

@@ -0,0 +1,170 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { HabitCheckResult, HabitDetail } from "../domain/habit";
+import type { NoteSummary } from "../domain/note";
+import type { ProjectSummary } from "../domain/task";
+import type { AddHabitNoteInput, CreateHabitInput, DeleteHabitResult, HabitService, UpdateHabitInput } from "../services/habit-service";
+import type { ProjectService } from "../services/project-service";
+interface HabitCreateToolParams {
+    title: string;
+    projectId: string;
+    schedule: string;
+    timezone: string;
+    startDate: string;
+    description?: string;
+    endDate?: string;
+}
+interface HabitUpdateToolParams {
+    habitId: string;
+    title?: string;
+    schedule?: string;
+    timezone?: string;
+    description?: string;
+    endDate?: string;
+}
+interface HabitCheckToolParams {
+    habitId: string;
+}
+interface HabitDeleteToolParams {
+    habitId: string;
+}
+interface HabitNoteAddToolParams {
+    habitId: string;
+    content: string;
+}
+interface HabitCreateToolDetails {
+    kind: "habit_create";
+    input: CreateHabitInput;
+    habit: HabitDetail;
+}
+interface HabitUpdateToolDetails {
+    kind: "habit_update";
+    input: UpdateHabitInput;
+    habit: HabitDetail;
+}
+interface HabitCheckToolDetails {
+    kind: "habit_check";
+    habitId: string;
+    found: boolean;
+    result?: HabitCheckResult;
+}
+interface HabitDeleteToolDetails {
+    kind: "habit_delete";
+    habitId: string;
+    found: boolean;
+    deleted: boolean;
+    result?: DeleteHabitResult;
+}
+interface HabitNoteAddToolDetails {
+    kind: "habit_note_add";
+    habitId: string;
+    note: NoteSummary;
+}
+interface HabitMutationToolDependencies {
+    getHabitService: () => Promise<HabitService>;
+    getProjectService: () => Promise<ProjectService>;
+}
+declare const createHabitCreateToolDefinition: ({ getHabitService, getProjectService, }: HabitMutationToolDependencies) => {
+    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>;
+        endDate: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>;
+    execute(_toolCallId: string, params: HabitCreateToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: HabitCreateToolDetails;
+    }>;
+};
+declare const createHabitUpdateToolDefinition: ({ getHabitService }: HabitMutationToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        habitId: import("@sinclair/typebox").TString;
+        title: 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>;
+        description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        endDate: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>;
+    execute(_toolCallId: string, params: HabitUpdateToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: HabitUpdateToolDetails;
+    }>;
+};
+declare const createHabitCheckToolDefinition: ({ getHabitService }: HabitMutationToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        habitId: import("@sinclair/typebox").TString;
+    }>;
+    execute(_toolCallId: string, params: HabitCheckToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: HabitCheckToolDetails;
+    }>;
+};
+declare const createHabitDeleteToolDefinition: ({ getHabitService }: HabitMutationToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        habitId: import("@sinclair/typebox").TString;
+    }>;
+    execute(_toolCallId: string, params: HabitDeleteToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: HabitDeleteToolDetails;
+    }>;
+};
+declare const createHabitNoteAddToolDefinition: ({ getHabitService }: HabitMutationToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        habitId: import("@sinclair/typebox").TString;
+        content: import("@sinclair/typebox").TString;
+    }>;
+    execute(_toolCallId: string, params: HabitNoteAddToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: HabitNoteAddToolDetails;
+    }>;
+};
+declare const registerHabitMutationTools: (pi: Pick<ExtensionAPI, "registerTool">, dependencies: HabitMutationToolDependencies) => void;
+declare const normalizeCreateHabitInput: (params: HabitCreateToolParams) => CreateHabitInput;
+declare const resolveCreateHabitInput: (projectService: ProjectService, params: HabitCreateToolParams) => Promise<CreateHabitInput>;
+declare const normalizeUpdateHabitInput: (params: HabitUpdateToolParams) => UpdateHabitInput;
+declare const resolveProjectForHabitMutation: (projectService: ProjectService, projectRef: string) => Promise<ProjectSummary>;
+declare const normalizeHabitNoteAddInput: (params: HabitNoteAddToolParams) => AddHabitNoteInput;
+export type { HabitCheckToolDetails, HabitCreateToolDetails, HabitDeleteToolDetails, HabitMutationToolDependencies, HabitNoteAddToolDetails, HabitUpdateToolDetails, };
+export { createHabitCheckToolDefinition, createHabitCreateToolDefinition, createHabitDeleteToolDefinition, createHabitNoteAddToolDefinition, createHabitUpdateToolDefinition, normalizeCreateHabitInput, normalizeHabitNoteAddInput, normalizeUpdateHabitInput, registerHabitMutationTools, resolveCreateHabitInput, resolveProjectForHabitMutation, };

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

@@ -0,0 +1,363 @@
+import { Type } from "@sinclair/typebox";
+import { ToduHabitServiceError } from "../services/todu/todu-habit-service.js";
+import { validateAndNormalizeScheduleRule } from "../utils/schedule.js";
+const HabitCreateParams = Type.Object({
+    title: Type.String({ description: "Habit 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 habit description" })),
+    endDate: Type.Optional(Type.String({
+        description: "Optional end date in YYYY-MM-DD format. Use an empty string to clear it.",
+    })),
+});
+const HabitUpdateParams = Type.Object({
+    habitId: Type.String({ description: "Habit ID" }),
+    title: Type.Optional(Type.String({ description: "Optional replacement habit title" })),
+    schedule: Type.Optional(Type.String({ description: "Optional replacement normalized RRULE schedule string" })),
+    timezone: Type.Optional(Type.String({ description: "Optional replacement IANA timezone" })),
+    description: Type.Optional(Type.String({
+        description: "Optional replacement description. Use an empty string to clear it.",
+    })),
+    endDate: Type.Optional(Type.String({ description: "Optional replacement end date. Use an empty string to clear it." })),
+});
+const HabitCheckParams = Type.Object({
+    habitId: Type.String({ description: "Habit ID" }),
+});
+const HabitDeleteParams = Type.Object({
+    habitId: Type.String({ description: "Habit ID" }),
+});
+const HabitNoteAddParams = Type.Object({
+    habitId: Type.String({ description: "Habit ID" }),
+    content: Type.String({ description: "Note content" }),
+});
+const createHabitCreateToolDefinition = ({ getHabitService, getProjectService, }) => ({
+    name: "habit_create",
+    label: "Habit Create",
+    description: "Create a habit.",
+    promptSnippet: "Create a habit through the native habit service.",
+    promptGuidelines: [
+        "Use this tool for backend habit 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: HabitCreateParams,
+    async execute(_toolCallId, params) {
+        try {
+            const projectService = await getProjectService();
+            const input = await resolveCreateHabitInput(projectService, params);
+            const habitService = await getHabitService();
+            const habit = await habitService.createHabit(input);
+            const details = {
+                kind: "habit_create",
+                input,
+                habit,
+            };
+            return {
+                content: [{ type: "text", text: formatHabitCreateContent(habit) }],
+                details,
+            };
+        }
+        catch (error) {
+            throw new Error(formatToolError(error, "habit_create failed"), { cause: error });
+        }
+    },
+});
+const createHabitUpdateToolDefinition = ({ getHabitService }) => ({
+    name: "habit_update",
+    label: "Habit Update",
+    description: "Update a habit's supported fields.",
+    promptSnippet: "Update a habit through the native habit service.",
+    promptGuidelines: [
+        "Use this tool for backend habit updates in normal chat.",
+        "Provide normalized RRULE schedule strings instead of natural-language schedules.",
+    ],
+    parameters: HabitUpdateParams,
+    async execute(_toolCallId, params) {
+        try {
+            const habitService = await getHabitService();
+            const input = normalizeUpdateHabitInput(params);
+            const habit = await habitService.updateHabit(input);
+            const details = {
+                kind: "habit_update",
+                input,
+                habit,
+            };
+            return {
+                content: [{ type: "text", text: formatHabitUpdateContent(habit, input) }],
+                details,
+            };
+        }
+        catch (error) {
+            throw new Error(formatToolError(error, "habit_update failed"), { cause: error });
+        }
+    },
+});
+const createHabitCheckToolDefinition = ({ getHabitService }) => ({
+    name: "habit_check",
+    label: "Habit Check",
+    description: "Check in a habit for today or toggle today's check-in.",
+    promptSnippet: "Check in a habit through the native habit service.",
+    promptGuidelines: [
+        "Use this tool to check in or toggle a habit for today.",
+        "Provide the habit ID explicitly.",
+    ],
+    parameters: HabitCheckParams,
+    async execute(_toolCallId, params) {
+        const habitId = normalizeRequiredText(params.habitId, "habitId");
+        try {
+            const habitService = await getHabitService();
+            const result = await habitService.checkHabit(habitId);
+            const details = {
+                kind: "habit_check",
+                habitId,
+                found: true,
+                result,
+            };
+            return {
+                content: [{ type: "text", text: formatHabitCheckContent(result) }],
+                details,
+            };
+        }
+        catch (error) {
+            if (isHabitNotFoundError(error)) {
+                const details = {
+                    kind: "habit_check",
+                    habitId,
+                    found: false,
+                };
+                return {
+                    content: [{ type: "text", text: `Habit not found: ${habitId}` }],
+                    details,
+                };
+            }
+            throw new Error(formatToolError(error, "habit_check failed"), { cause: error });
+        }
+    },
+});
+const createHabitDeleteToolDefinition = ({ getHabitService }) => ({
+    name: "habit_delete",
+    label: "Habit Delete",
+    description: "Delete a habit by explicit ID.",
+    promptSnippet: "Delete a habit by explicit ID.",
+    promptGuidelines: [
+        "Use this tool for backend habit deletion in normal chat.",
+        "Provide the habit ID explicitly.",
+    ],
+    parameters: HabitDeleteParams,
+    async execute(_toolCallId, params) {
+        const habitId = normalizeRequiredText(params.habitId, "habitId");
+        try {
+            const habitService = await getHabitService();
+            const result = await habitService.deleteHabit(habitId);
+            const details = {
+                kind: "habit_delete",
+                habitId,
+                found: true,
+                deleted: true,
+                result,
+            };
+            return {
+                content: [{ type: "text", text: formatHabitDeleteContent(details) }],
+                details,
+            };
+        }
+        catch (error) {
+            if (isHabitNotFoundError(error)) {
+                const details = {
+                    kind: "habit_delete",
+                    habitId,
+                    found: false,
+                    deleted: false,
+                };
+                return {
+                    content: [{ type: "text", text: formatHabitDeleteContent(details) }],
+                    details,
+                };
+            }
+            throw new Error(formatToolError(error, "habit_delete failed"), { cause: error });
+        }
+    },
+});
+const createHabitNoteAddToolDefinition = ({ getHabitService }) => ({
+    name: "habit_note_add",
+    label: "Habit Note Add",
+    description: "Add a note to a habit.",
+    promptSnippet: "Attach a note to a habit by habit ID.",
+    promptGuidelines: [
+        "Use this tool to attach notes to habits in normal chat.",
+        "Provide the habit ID and note content explicitly.",
+    ],
+    parameters: HabitNoteAddParams,
+    async execute(_toolCallId, params) {
+        const input = normalizeHabitNoteAddInput(params);
+        try {
+            const habitService = await getHabitService();
+            const note = await habitService.addHabitNote(input);
+            const details = {
+                kind: "habit_note_add",
+                habitId: input.habitId,
+                note,
+            };
+            return {
+                content: [{ type: "text", text: formatHabitNoteAddContent(note, input.habitId) }],
+                details,
+            };
+        }
+        catch (error) {
+            throw new Error(formatToolError(error, "habit_note_add failed"), { cause: error });
+        }
+    },
+});
+const registerHabitMutationTools = (pi, dependencies) => {
+    pi.registerTool(createHabitCreateToolDefinition(dependencies));
+    pi.registerTool(createHabitUpdateToolDefinition(dependencies));
+    pi.registerTool(createHabitCheckToolDefinition(dependencies));
+    pi.registerTool(createHabitDeleteToolDefinition(dependencies));
+    pi.registerTool(createHabitNoteAddToolDefinition(dependencies));
+};
+const normalizeCreateHabitInput = (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"),
+    endDate: normalizeOptionalDate(params, "endDate"),
+});
+const resolveCreateHabitInput = async (projectService, params) => {
+    const input = normalizeCreateHabitInput(params);
+    const project = await resolveProjectForHabitMutation(projectService, input.projectId);
+    return {
+        ...input,
+        projectId: project.id,
+    };
+};
+const normalizeUpdateHabitInput = (params) => {
+    const input = {
+        habitId: normalizeRequiredText(params.habitId, "habitId"),
+    };
+    if (hasOwn(params, "title")) {
+        input.title = normalizeRequiredText(params.title ?? "", "title");
+    }
+    if (hasOwn(params, "schedule")) {
+        input.schedule = normalizeScheduleInput(params.schedule ?? "");
+    }
+    if (hasOwn(params, "timezone")) {
+        input.timezone = normalizeRequiredText(params.timezone ?? "", "timezone");
+    }
+    if (hasOwn(params, "description")) {
+        input.description = normalizeNullableText(params.description);
+    }
+    if (hasOwn(params, "endDate")) {
+        input.endDate = normalizeNullableText(params.endDate);
+    }
+    if (input.title === undefined &&
+        input.schedule === undefined &&
+        input.timezone === undefined &&
+        !hasOwn(input, "description") &&
+        !hasOwn(input, "endDate")) {
+        throw new Error("habit_update requires at least one supported field: title, schedule, timezone, description, or endDate");
+    }
+    return input;
+};
+const resolveProjectForHabitMutation = 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 isHabitNotFoundError = (error) => error instanceof ToduHabitServiceError && error.causeCode === "not-found";
+const formatHabitCreateContent = (habit) => [
+    `Created habit ${habit.id}: ${habit.title}`,
+    `Status: ${habit.paused ? "paused" : "active"}`,
+    `Project: ${habit.projectName ?? habit.projectId}`,
+].join("\n");
+const formatHabitUpdateContent = (habit, input) => {
+    const changedFields = [
+        input.title !== undefined ? `title=${JSON.stringify(input.title)}` : null,
+        input.schedule !== undefined ? `schedule=${input.schedule}` : null,
+        input.timezone !== undefined ? `timezone=${input.timezone}` : 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 habit ${habit.id}: ${habit.title}`, `Changes: ${changedFields.join(", ")}`].join("\n");
+};
+const formatHabitCheckContent = (result) => {
+    const status = result.completed ? "checked in" : "unchecked";
+    const streakLine = formatHabitCheckStreakLine(result.streak);
+    return [`Habit ${result.habitId}: ${status} for ${result.date}`, streakLine].join("\n");
+};
+const formatHabitCheckStreakLine = (streak) => {
+    if (!streak) {
+        return "Streak: unavailable";
+    }
+    const current = typeof streak.current === "number" ? streak.current : "?";
+    const longest = typeof streak.longest === "number" ? streak.longest : "?";
+    const totalCheckins = typeof streak.totalCheckins === "number" ? streak.totalCheckins : "?";
+    return `Streak: ${current} current, ${longest} longest, ${totalCheckins} total`;
+};
+const formatHabitDeleteContent = (details) => details.found ? `Deleted habit ${details.habitId}.` : `Habit not found: ${details.habitId}`;
+const normalizeHabitNoteAddInput = (params) => ({
+    habitId: normalizeRequiredText(params.habitId, "habitId"),
+    content: normalizeRequiredText(params.content, "content"),
+});
+const formatHabitNoteAddContent = (note, habitId) => `Added note ${note.id} to habit ${habitId}.`;
+const formatToolError = (error, prefix) => {
+    if (error instanceof Error && error.message.trim().length > 0) {
+        return `${prefix}: ${error.message}`;
+    }
+    return prefix;
+};
+export { createHabitCheckToolDefinition, createHabitCreateToolDefinition, createHabitDeleteToolDefinition, createHabitNoteAddToolDefinition, createHabitUpdateToolDefinition, normalizeCreateHabitInput, normalizeHabitNoteAddInput, normalizeUpdateHabitInput, registerHabitMutationTools, resolveCreateHabitInput, resolveProjectForHabitMutation, };

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

@@ -0,0 +1,61 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { HabitDetail, HabitId, HabitStreak, HabitSummaryWithStreak } from "../domain/habit";
+import type { HabitService } from "../services/habit-service";
+interface HabitListToolDetails {
+    kind: "habit_list";
+    habits: HabitSummaryWithStreak[];
+    total: number;
+    empty: boolean;
+}
+interface HabitShowToolParams {
+    habitId: HabitId;
+}
+interface HabitShowToolDetails {
+    kind: "habit_show";
+    habitId: HabitId;
+    found: boolean;
+    habit?: HabitDetail;
+    streak?: HabitStreak;
+}
+interface HabitReadToolDependencies {
+    getHabitService: () => Promise<HabitService>;
+}
+declare const createHabitListToolDefinition: ({ getHabitService }: HabitReadToolDependencies) => {
+    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: HabitListToolDetails;
+    }>;
+};
+declare const createHabitShowToolDefinition: ({ getHabitService }: HabitReadToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        habitId: import("@sinclair/typebox").TString;
+    }>;
+    execute(_toolCallId: string, params: HabitShowToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: HabitShowToolDetails;
+    }>;
+};
+declare const registerHabitReadTools: (pi: Pick<ExtensionAPI, "registerTool">, dependencies: HabitReadToolDependencies) => void;
+declare const formatHabitListContent: (details: HabitListToolDetails) => string;
+declare const formatStreakLabel: (streak: HabitStreak | null) => string;
+declare const formatTodayLabel: (streak: HabitStreak | null) => string;
+declare const formatHabitShowContent: (habit: HabitDetail, streak: HabitStreak | null) => string;
+export type { HabitListToolDetails, HabitReadToolDependencies, HabitShowToolDetails };
+export { createHabitListToolDefinition, createHabitShowToolDefinition, formatHabitListContent, formatHabitShowContent, formatStreakLabel, formatTodayLabel, registerHabitReadTools, };