@todu/pi-extensions 0.1.0

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

@@ -0,0 +1,152 @@
+import { Type } from "@sinclair/typebox";
+const HabitListParams = Type.Object({});
+const HabitShowParams = Type.Object({
+    habitId: Type.String({ description: "Habit ID" }),
+});
+const createHabitListToolDefinition = ({ getHabitService }) => ({
+    name: "habit_list",
+    label: "Habit List",
+    description: "List habits.",
+    promptSnippet: "List habits through the native habit service.",
+    promptGuidelines: [
+        "Use this tool for backend habit lookups in normal chat.",
+        "Keep habit_list unfiltered in the first wave unless the task explicitly widens scope.",
+    ],
+    parameters: HabitListParams,
+    async execute(_toolCallId, _params) {
+        try {
+            const habitService = await getHabitService();
+            const habits = await habitService.listHabitsWithStreaks();
+            const details = {
+                kind: "habit_list",
+                habits,
+                total: habits.length,
+                empty: habits.length === 0,
+            };
+            return {
+                content: [{ type: "text", text: formatHabitListContent(details) }],
+                details,
+            };
+        }
+        catch (error) {
+            throw new Error(formatToolError(error, "habit_list failed"), { cause: error });
+        }
+    },
+});
+const createHabitShowToolDefinition = ({ getHabitService }) => ({
+    name: "habit_show",
+    label: "Habit Show",
+    description: "Show habit details, including description, schedule, and streak.",
+    promptSnippet: "Show details for a specific habit by habit ID.",
+    promptGuidelines: [
+        "Use this tool when the user asks for details about a known habit ID.",
+        "If the habit is missing, report the explicit not-found result instead of guessing.",
+    ],
+    parameters: HabitShowParams,
+    async execute(_toolCallId, params) {
+        try {
+            const habitService = await getHabitService();
+            const habit = await habitService.getHabit(params.habitId);
+            if (!habit) {
+                const details = {
+                    kind: "habit_show",
+                    habitId: params.habitId,
+                    found: false,
+                };
+                return {
+                    content: [{ type: "text", text: `Habit not found: ${params.habitId}` }],
+                    details,
+                };
+            }
+            const streak = await safeGetStreak(habitService, params.habitId);
+            const details = {
+                kind: "habit_show",
+                habitId: params.habitId,
+                found: true,
+                habit,
+                streak: streak ?? undefined,
+            };
+            return {
+                content: [{ type: "text", text: formatHabitShowContent(habit, streak) }],
+                details,
+            };
+        }
+        catch (error) {
+            throw new Error(formatToolError(error, "habit_show failed"), { cause: error });
+        }
+    },
+});
+const registerHabitReadTools = (pi, dependencies) => {
+    pi.registerTool(createHabitListToolDefinition(dependencies));
+    pi.registerTool(createHabitShowToolDefinition(dependencies));
+};
+const safeGetStreak = async (habitService, habitId) => {
+    try {
+        return await habitService.getHabitStreak(habitId);
+    }
+    catch {
+        return null;
+    }
+};
+const formatHabitListContent = (details) => {
+    if (details.empty) {
+        return "No habits found.";
+    }
+    const lines = [`Habits (${details.total}):`];
+    for (const habit of details.habits) {
+        lines.push(`- ${formatHabitSummaryLine(habit)}`);
+    }
+    return lines.join("\n");
+};
+const formatHabitSummaryLine = (habit) => {
+    const projectLabel = habit.projectName ?? habit.projectId;
+    const status = habit.paused ? "paused" : "active";
+    const streakLabel = formatStreakLabel(habit.streak);
+    const todayLabel = formatTodayLabel(habit.streak);
+    return `${habit.id} • ${habit.title} • ${status} • ${projectLabel} • streak: ${streakLabel} • today: ${todayLabel}`;
+};
+const formatStreakLabel = (streak) => {
+    if (!streak) {
+        return "?";
+    }
+    return streak.current > 0 ? `🔥 ${streak.current}` : "0";
+};
+const formatTodayLabel = (streak) => {
+    if (!streak) {
+        return "?";
+    }
+    return streak.completedToday ? "✅" : "—";
+};
+const formatHabitShowContent = (habit, streak) => {
+    const status = habit.paused ? "paused" : "active";
+    const projectLabel = habit.projectName ?? habit.projectId;
+    const streakLabel = streak
+        ? `${streak.current} current, ${streak.longest} longest, ${streak.totalCheckins} total`
+        : "unknown";
+    const todayLabel = streak ? (streak.completedToday ? "✅" : "—") : "?";
+    const lines = [
+        `Habit ${habit.id}: ${habit.title}`,
+        "",
+        `Status: ${status}`,
+        `Project: ${projectLabel}`,
+        `Schedule: ${habit.schedule}`,
+        `Timezone: ${habit.timezone}`,
+        `Start: ${habit.startDate}`,
+        `End: ${habit.endDate ?? "none"}`,
+        `Next due: ${habit.nextDue}`,
+        "",
+        "Description:",
+        habit.description?.trim().length ? habit.description : "(none)",
+        "",
+        `Streak: ${streakLabel}`,
+        `Today: ${todayLabel}`,
+    ];
+    return lines.join("\n");
+};
+const formatToolError = (error, prefix) => {
+    if (error instanceof Error && error.message.trim().length > 0) {
+        return `${prefix}: ${error.message}`;
+    }
+    return prefix;
+};
+export { createHabitListToolDefinition, createHabitShowToolDefinition, formatHabitListContent, formatHabitShowContent, formatStreakLabel, formatTodayLabel, registerHabitReadTools, };

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

@@ -0,0 +1,79 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { NoteEntityType, NoteFilter, NoteSummary } from "../domain/note";
+import type { NoteService } from "../services/note-service";
+interface NoteListToolParams {
+    entityType?: NoteEntityType;
+    entityId?: string;
+    tag?: string;
+    author?: string;
+    from?: string;
+    to?: string;
+    journal?: boolean;
+    timezone?: string;
+}
+interface NoteListToolDetails {
+    kind: "note_list";
+    filter: NoteFilter;
+    notes: NoteSummary[];
+    total: number;
+    empty: boolean;
+}
+interface NoteShowToolParams {
+    noteId: string;
+}
+interface NoteShowToolDetails {
+    kind: "note_show";
+    noteId: string;
+    found: boolean;
+    note?: NoteSummary;
+}
+interface NoteReadToolDependencies {
+    getNoteService: () => Promise<NoteService>;
+}
+declare const createNoteListToolDefinition: ({ getNoteService }: NoteReadToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        entityType: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnsafe<"task" | "project" | "habit">>;
+        entityId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        tag: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        author: 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>;
+        journal: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        timezone: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>;
+    execute(_toolCallId: string, params: NoteListToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: NoteListToolDetails;
+    }>;
+};
+declare const createNoteShowToolDefinition: ({ getNoteService }: NoteReadToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        noteId: import("@sinclair/typebox").TString;
+    }>;
+    execute(_toolCallId: string, params: NoteShowToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: NoteShowToolDetails;
+    }>;
+};
+declare const registerNoteReadTools: (pi: Pick<ExtensionAPI, "registerTool">, dependencies: NoteReadToolDependencies) => void;
+declare const normalizeNoteListFilter: (params: NoteListToolParams) => NoteFilter;
+declare const formatNoteListContent: (details: NoteListToolDetails) => string;
+declare const formatNoteShowContent: (note: NoteSummary) => string;
+export type { NoteListToolDetails, NoteShowToolDetails, NoteReadToolDependencies };
+export { createNoteListToolDefinition, createNoteShowToolDefinition, formatNoteListContent, formatNoteShowContent, normalizeNoteListFilter, registerNoteReadTools, };

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

@@ -0,0 +1,148 @@
+import { StringEnum } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+import { getSystemTimezone } from "../utils/timezone.js";
+const NOTE_ENTITY_TYPE_VALUES = ["task", "project", "habit"];
+const NoteShowParams = Type.Object({
+    noteId: Type.String({ description: "Note ID" }),
+});
+const NoteListParams = Type.Object({
+    entityType: Type.Optional(StringEnum(NOTE_ENTITY_TYPE_VALUES, {
+        description: "Optional entity type filter (task, project, habit)",
+    })),
+    entityId: Type.Optional(Type.String({ description: "Optional entity ID filter (task ID, project ID, or habit ID)" })),
+    tag: Type.Optional(Type.String({ description: "Optional tag filter" })),
+    author: Type.Optional(Type.String({ description: "Optional author filter" })),
+    from: Type.Optional(Type.String({ description: "Optional created-at start date (YYYY-MM-DD)" })),
+    to: Type.Optional(Type.String({ description: "Optional created-at end date (YYYY-MM-DD)" })),
+    journal: Type.Optional(Type.Boolean({ description: "Filter to standalone journal entries only" })),
+    timezone: Type.Optional(Type.String({ description: "IANA timezone (auto-detected if omitted)" })),
+});
+const createNoteListToolDefinition = ({ getNoteService }) => ({
+    name: "note_list",
+    label: "Note List",
+    description: "List notes with optional entity type, entity ID, tag, author, date range, and journal filters.",
+    promptSnippet: "List notes using structured filters for entity type, entity ID, tag, author, date range, or journal mode.",
+    promptGuidelines: [
+        "Use this tool for backend note lookups in normal chat.",
+        "Use entityType and entityId together to scope notes to a specific task, project, or habit.",
+        "Use journal=true to find standalone journal entries without an attached entity.",
+    ],
+    parameters: NoteListParams,
+    async execute(_toolCallId, params) {
+        const filter = normalizeNoteListFilter(params);
+        try {
+            const noteService = await getNoteService();
+            const notes = await noteService.listNotes(filter);
+            const details = {
+                kind: "note_list",
+                filter,
+                notes,
+                total: notes.length,
+                empty: notes.length === 0,
+            };
+            return {
+                content: [{ type: "text", text: formatNoteListContent(details) }],
+                details,
+            };
+        }
+        catch (error) {
+            throw new Error(formatToolError(error, "note_list failed"), { cause: error });
+        }
+    },
+});
+const createNoteShowToolDefinition = ({ getNoteService }) => ({
+    name: "note_show",
+    label: "Note Show",
+    description: "Show full note details by note ID.",
+    promptSnippet: "Show details for a specific note by note ID.",
+    promptGuidelines: [
+        "Use this tool when the user asks for details about a known note ID.",
+        "If the note is missing, report the explicit not-found result instead of guessing.",
+    ],
+    parameters: NoteShowParams,
+    async execute(_toolCallId, params) {
+        try {
+            const noteService = await getNoteService();
+            const note = await noteService.getNote(params.noteId);
+            if (!note) {
+                const details = {
+                    kind: "note_show",
+                    noteId: params.noteId,
+                    found: false,
+                };
+                return {
+                    content: [{ type: "text", text: `Note not found: ${params.noteId}` }],
+                    details,
+                };
+            }
+            const details = {
+                kind: "note_show",
+                noteId: params.noteId,
+                found: true,
+                note,
+            };
+            return {
+                content: [{ type: "text", text: formatNoteShowContent(note) }],
+                details,
+            };
+        }
+        catch (error) {
+            throw new Error(formatToolError(error, "note_show failed"), { cause: error });
+        }
+    },
+});
+const registerNoteReadTools = (pi, dependencies) => {
+    pi.registerTool(createNoteListToolDefinition(dependencies));
+    pi.registerTool(createNoteShowToolDefinition(dependencies));
+};
+const normalizeNoteListFilter = (params) => ({
+    entityType: params.entityType ?? undefined,
+    entityId: normalizeOptionalText(params.entityId),
+    tag: normalizeOptionalText(params.tag),
+    author: normalizeOptionalText(params.author),
+    from: normalizeOptionalText(params.from),
+    to: normalizeOptionalText(params.to),
+    journal: params.journal ?? undefined,
+    timezone: normalizeOptionalText(params.timezone) ?? getSystemTimezone(),
+});
+const normalizeOptionalText = (value) => {
+    const trimmedValue = value?.trim();
+    return trimmedValue && trimmedValue.length > 0 ? trimmedValue : undefined;
+};
+const formatNoteListContent = (details) => {
+    if (details.empty) {
+        return "No notes found.";
+    }
+    const lines = [`Notes (${details.total}):`];
+    for (const note of details.notes) {
+        lines.push(`- ${formatNoteSummaryLine(note)}`);
+    }
+    return lines.join("\n");
+};
+const formatNoteSummaryLine = (note) => {
+    const entityLabel = note.entityType ? `${note.entityType}:${note.entityId ?? "?"}` : "journal";
+    const tagLabel = note.tags.length > 0 ? note.tags.join(", ") : "no tags";
+    return `${note.id} • ${entityLabel} • ${note.author} • ${tagLabel} • ${note.createdAt}\n    ${note.content}`;
+};
+const formatNoteShowContent = (note) => {
+    const entityLabel = note.entityType ? `${note.entityType}:${note.entityId ?? "?"}` : "journal";
+    const tagLabel = note.tags.length > 0 ? note.tags.join(", ") : "no tags";
+    return [
+        `Note ${note.id}`,
+        "",
+        `Author: ${note.author}`,
+        `Entity: ${entityLabel}`,
+        `Tags: ${tagLabel}`,
+        `Created: ${note.createdAt}`,
+        "",
+        "Content:",
+        note.content.trim().length > 0 ? note.content : "(empty)",
+    ].join("\n");
+};
+const formatToolError = (error, prefix) => {
+    if (error instanceof Error && error.message.trim().length > 0) {
+        return `${prefix}: ${error.message}`;
+    }
+    return prefix;
+};
+export { createNoteListToolDefinition, createNoteShowToolDefinition, formatNoteListContent, formatNoteShowContent, normalizeNoteListFilter, registerNoteReadTools, };

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

@@ -0,0 +1,92 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ProjectSummary, TaskPriority } from "../domain/task";
+import type { IntegrationBinding, ProjectIntegrationService, RegisterRepositoryProjectInput } from "../services/project-integration-service";
+import type { ProjectService } from "../services/project-service";
+import type { ResolvedRepositoryContext } from "../services/repo-context";
+interface ProjectCheckToolParams {
+    repositoryPath?: string;
+    provider?: string;
+    targetRef?: string;
+}
+interface ProjectRegisterToolParams extends ProjectCheckToolParams {
+    projectName?: string;
+    description?: string;
+    priority?: TaskPriority;
+}
+interface ProjectCheckToolDetails {
+    kind: "project_check";
+    state: "registered" | "not-registered" | "ambiguous" | "missing-context" | "unsupported";
+    repositoryPath?: string;
+    repository?: ResolvedRepositoryContext;
+    reason?: string;
+    project?: ProjectSummary | null;
+    binding?: IntegrationBinding;
+    bindings?: IntegrationBinding[];
+    remotes?: string[];
+}
+interface ProjectRegisterToolDetails {
+    kind: "project_register";
+    state: "registered" | "already-registered" | "name-conflict" | "ambiguous" | "missing-context" | "unsupported";
+    repositoryPath?: string;
+    repository?: ResolvedRepositoryContext;
+    project?: ProjectSummary | null;
+    binding?: IntegrationBinding;
+    createdProject?: boolean;
+    createdBinding?: boolean;
+    conflictingProjects?: ProjectSummary[];
+    reason?: string;
+    remotes?: string[];
+    bindings?: IntegrationBinding[];
+}
+interface ProjectIntegrationToolDependencies {
+    getProjectIntegrationService: () => Promise<ProjectIntegrationService>;
+    getProjectService: () => Promise<ProjectService>;
+}
+declare const createProjectCheckToolDefinition: ({ getProjectIntegrationService, }: Pick<ProjectIntegrationToolDependencies, "getProjectIntegrationService">) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        repositoryPath: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        provider: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        targetRef: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>;
+    execute(_toolCallId: string, params: ProjectCheckToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: ProjectCheckToolDetails;
+    }>;
+};
+declare const createProjectRegisterToolDefinition: ({ getProjectIntegrationService, getProjectService, }: ProjectIntegrationToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        projectName: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        repositoryPath: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        provider: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        targetRef: 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">>;
+    }>;
+    execute(_toolCallId: string, params: ProjectRegisterToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: ProjectRegisterToolDetails;
+    }>;
+};
+declare const registerProjectIntegrationTools: (pi: Pick<ExtensionAPI, "registerTool">, dependencies: ProjectIntegrationToolDependencies) => void;
+declare const normalizeProjectCheckInput: (params: ProjectCheckToolParams) => ProjectCheckToolParams;
+declare const normalizeProjectRegisterInput: (params: ProjectRegisterToolParams) => RegisterRepositoryProjectInput;
+declare const formatProjectCheckContent: (details: ProjectCheckToolDetails) => string;
+declare const formatProjectRegisterContent: (details: ProjectRegisterToolDetails) => string;
+export type { ProjectCheckToolDetails, ProjectIntegrationToolDependencies, ProjectRegisterToolDetails, };
+export { createProjectCheckToolDefinition, createProjectRegisterToolDefinition, formatProjectCheckContent, formatProjectRegisterContent, normalizeProjectCheckInput, normalizeProjectRegisterInput, registerProjectIntegrationTools, };