@todoist/mcp 0.0.1 → 15.0.0

package/dist/utils/constants.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Application-wide constants
+ *
+ * This module centralizes magic numbers and configuration values
+ * to improve maintainability and provide a single source of truth.
+ */
+/** One hour in milliseconds. */
+export declare const ONE_HOUR_MS: number;
+/** One year (365 days) in milliseconds. */
+export declare const ONE_YEAR_MS: number;
+export declare const ApiLimits: {
+    /** Default limit for task listings */
+    readonly TASKS_DEFAULT: 10;
+    /** Maximum limit for task search and list operations */
+    readonly TASKS_MAX: 100;
+    /** Default limit for completed tasks */
+    readonly COMPLETED_TASKS_DEFAULT: 50;
+    /** Maximum limit for completed tasks */
+    readonly COMPLETED_TASKS_MAX: 200;
+    /** Default limit for project listings */
+    readonly PROJECTS_DEFAULT: 50;
+    /** Maximum limit for project listings */
+    readonly PROJECTS_MAX: 200;
+    /** Maximum limit for section listings */
+    readonly SECTIONS_MAX: 200;
+    /** Batch size for fetching all tasks in a project */
+    readonly TASKS_BATCH_SIZE: 50;
+    /** Maximum number of direct children returned when children are requested alongside an object */
+    readonly CHILDREN_MAX: 25;
+    /** Default limit for comment listings */
+    readonly COMMENTS_DEFAULT: 10;
+    /** Maximum limit for comment search and list operations */
+    readonly COMMENTS_MAX: 10;
+    /** Maximum number of users a single comment can notify */
+    readonly NOTIFY_USERS_MAX: 25;
+    /** Default limit for activity log listings */
+    readonly ACTIVITY_DEFAULT: 20;
+    /** Maximum limit for activity log search and list operations */
+    readonly ACTIVITY_MAX: 100;
+    /** Default limit for label listings */
+    readonly LABELS_DEFAULT: 50;
+    /** Maximum limit for label listings */
+    readonly LABELS_MAX: 200;
+    /** Default limit for reminder listings */
+    readonly REMINDERS_DEFAULT: 50;
+    /** Maximum limit for reminder search operations */
+    readonly REMINDERS_MAX: 200;
+};
+export declare const DisplayLimits: {
+    /** Maximum number of failures to show in detailed error messages */
+    readonly MAX_FAILURES_SHOWN: 3;
+    /** Threshold for suggesting batch operations */
+    readonly BATCH_OPERATION_THRESHOLD: 10;
+};
+export declare const LogLimits: {
+    /** Maximum number of failed items named in one log line */
+    readonly MAX_FAILURES_LOGGED: 5;
+};
+export declare const BatchLimits: {
+    /** Maximum tasks accepted by one task create or update operation */
+    readonly TASKS_PER_OPERATION: 25;
+};
+export declare const ConcurrencyLimits: {
+    /**
+     * In-flight task-move requests per account, per process.
+     *
+     * Kept at 1 because the API locks the whole task tree for a move, and a tree
+     * spans a task's source as well as its destination — two moves of sibling
+     * subtasks contend even when they target different projects, and the loser
+     * fails. Batching same-destination moves into a single request means
+     * serialising costs little in practice. One per process is the smallest
+     * contribution a process can make; see the note above for the global picture.
+     */
+    readonly TASK_MOVES: 1;
+    /** In-flight non-move write requests per account, per process. */
+    readonly WRITES: 4;
+    /**
+     * How long a request may wait for a slot before it is abandoned unsent.
+     *
+     * Matches the SDK's own 30s request timeout, which only starts once a request
+     * actually goes out: a task that has already waited that long would be
+     * answering a caller who has given up. Comfortably above the worst realistic
+     * queue (serialised moves to 100 distinct destinations is roughly 15s).
+     */
+    readonly QUEUE_WAIT_MS: 30000;
+};
+export declare const ResponseConfig: {
+    /** Maximum characters per line in text responses */
+    readonly MAX_LINE_LENGTH: 100;
+    /** Indentation for nested items */
+    readonly INDENT_SIZE: 2;
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/utils/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/utils/constants.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,gCAAgC;AAChC,eAAO,MAAM,WAAW,QAAiB,CAAA;AACzC,2CAA2C;AAC3C,eAAO,MAAM,WAAW,QAAyB,CAAA;AAGjD,eAAO,MAAM,SAAS;IAClB,sCAAsC;;IAEtC,wDAAwD;;IAExD,wCAAwC;;IAExC,wCAAwC;;IAExC,yCAAyC;;IAEzC,yCAAyC;;IAEzC,yCAAyC;;IAEzC,qDAAqD;;IAErD,iGAAiG;;IAEjG,yCAAyC;;IAEzC,2DAA2D;;IAE3D,0DAA0D;;IAE1D,8CAA8C;;IAE9C,gEAAgE;;IAEhE,uCAAuC;;IAEvC,uCAAuC;;IAEvC,0CAA0C;;IAE1C,mDAAmD;;CAE7C,CAAA;AAGV,eAAO,MAAM,aAAa;IACtB,oEAAoE;;IAEpE,gDAAgD;;CAE1C,CAAA;AAGV,eAAO,MAAM,SAAS;IAClB,2DAA2D;;CAErD,CAAA;AAGV,eAAO,MAAM,WAAW;IACpB,oEAAoE;;CAE9D,CAAA;AAYV,eAAO,MAAM,iBAAiB;IAC1B;;;;;;;;;OASG;;IAEH,kEAAkE;;IAElE;;;;;;;OAOG;;CAEG,CAAA;AAGV,eAAO,MAAM,cAAc;IACvB,oDAAoD;;IAEpD,mCAAmC;;CAE7B,CAAA"}

package/dist/utils/date.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Format a Date using UTC calendar components (YYYY-MM-DD).
+ */
+export declare function formatUtcDate(date: Date): string;
+/**
+ * Parse a GMT offset string (+HH:MM or -HH:MM) to total minutes.
+ * Falls back to 0 for malformed offsets.
+ */
+export declare function parseGmtOffsetToMinutes(gmtOffset: string): number;
+/**
+ * Return the date string (YYYY-MM-DD) in a provided GMT offset.
+ */
+export declare function getDateInOffset(date: Date, offsetMinutes: number): string;
+/**
+ * Shift a YYYY-MM-DD date string by the specified number of days in UTC.
+ */
+export declare function shiftDateStringByDays(dateString: string, days: number): string;
+//# sourceMappingURL=date.d.ts.map

package/dist/utils/date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../src/utils/date.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAKhD;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CASjE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAGzE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAa9E"}

package/dist/utils/duration-parser.d.ts

@@ -0,0 +1,39 @@
+import { DurationUnit } from '@doist/todoist-sdk';
+type ParsedDuration = {
+    amount: number;
+    unit: DurationUnit;
+};
+export declare const DURATION_INPUT_DESCRIPTION = "The duration of the task. Use format: \"2h\" (hours), \"90m\" (minutes), \"2h30m\" (combined), \"1.5h\" (decimal hours), or \"3d\" (whole days; days cannot be combined with hours or minutes). Todoist apps only display durations under 24 hours: a longer or day-based duration is stored and reported by this server, but the apps show the task as having no duration.";
+export declare class DurationParseError extends Error {
+    constructor(input: string, reason: string);
+}
+/**
+ * Parses a duration string in the restricted syntax into the amount and unit
+ * the API stores: whole days for "3d", otherwise minutes.
+ *
+ * @param durationStr - Duration string like "2h30m", "45m", "1.5h", "3d"
+ * @returns Parsed duration amount and unit
+ * @throws DurationParseError for invalid formats
+ */
+export declare function parseDuration(durationStr: string): ParsedDuration;
+/**
+ * Formats a stored duration back to a human-readable string.
+ * Used when returning task data to LLMs.
+ *
+ * The output mirrors the stored unit so it round-trips through `parseDuration`:
+ * day durations become "3d", and minute durations always use hours/minutes
+ * ("48h", never "2d") so a day-based and a minute-based duration stay
+ * distinguishable.
+ *
+ * @param amount - Duration amount in the given unit
+ * @param unit - The unit the amount is stored in
+ * @returns Formatted duration string like "2h30m", "45m" or "3d"
+ */
+/**
+ * Parses one batch item's duration, prefixing a format error with `label` (e.g.
+ * `Task 123`) so the caller can report it against that item.
+ */
+export declare function parseItemDuration(label: string, durationStr: string): ParsedDuration;
+export declare function formatDuration(amount: number, unit?: DurationUnit): string;
+export {};
+//# sourceMappingURL=duration-parser.d.ts.map

package/dist/utils/duration-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration-parser.d.ts","sourceRoot":"","sources":["../../src/utils/duration-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEtD,KAAK,cAAc,GAAG;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,YAAY,CAAA;CACrB,CAAA;AAED,eAAO,MAAM,0BAA0B,gXACgU,CAAA;AAIvW,qBAAa,kBAAmB,SAAQ,KAAK;gBAC7B,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAI5C;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,cAAc,CA0BjE;AAqFD;;;;;;;;;;;;GAYG;AACH;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,cAAc,CASpF;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,GAAE,YAAuB,GAAG,MAAM,CAmBpF"}

package/dist/utils/filter-description.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Normalizes a filter's description for structured output.
+ *
+ * A filter with no description can arrive as either `null` or `""`: the column is
+ * nullable, and the sync view normalizes NULL to an empty string on the way out.
+ * Both mean the same thing, so both collapse to `undefined` here.
+ *
+ * Returning `undefined` rather than `null` matters. Structured content is sanitised
+ * with `removeNullFields` on the way out, so a null would be stripped from the payload
+ * and then fail validation against the declared output schema, which is optional
+ * rather than nullable.
+ */
+export declare function readFilterDescription(filter: {
+    description?: string | null;
+}): string | undefined;
+//# sourceMappingURL=filter-description.d.ts.map

package/dist/utils/filter-description.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-description.d.ts","sourceRoot":"","sources":["../../src/utils/filter-description.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAAG,MAAM,GAAG,SAAS,CAGjG"}

package/dist/utils/filter-resolver.d.ts

@@ -0,0 +1,27 @@
+import { TodoistApi } from '@doist/todoist-sdk';
+export type ResolvedFilter = {
+    filterId: string;
+    filterName: string;
+    filterQuery: string;
+};
+export declare class FilterResolver {
+    private cacheByClient;
+    private getFilters;
+    /**
+     * Resolve a filter name or ID to a filter ID, name, and query.
+     *
+     * Resolution order:
+     * 1. Exact ID match
+     * 2. Exact case-insensitive name match
+     * 3. Unique partial case-insensitive name match
+     * 4. Multiple partial matches → throw ambiguous error
+     * 5. No match → throw not-found error
+     */
+    resolveFilter(client: TodoistApi, nameOrId: string): Promise<ResolvedFilter>;
+    /**
+     * Clear all client caches and detach pending syncs — useful for testing.
+     */
+    clearCache(): void;
+}
+export declare const filterResolver: FilterResolver;
+//# sourceMappingURL=filter-resolver.d.ts.map

package/dist/utils/filter-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-resolver.d.ts","sourceRoot":"","sources":["../../src/utils/filter-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAU,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAE5D,MAAM,MAAM,cAAc,GAAG;IACzB,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;CACtB,CAAA;AAMD,qBAAa,cAAc;IAMvB,OAAO,CAAC,aAAa,CAA8C;YAErD,UAAU;IAiBxB;;;;;;;;;OASG;IACG,aAAa,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAuDlF;;OAEG;IACH,UAAU,IAAI,IAAI;CAGrB;AAGD,eAAO,MAAM,cAAc,gBAAuB,CAAA"}

package/dist/utils/host.d.ts

@@ -0,0 +1,6 @@
+/** Strip the surrounding brackets from a bracketed IPv6 literal, if present. */
+declare function normalizeListenHost(host: string): string;
+/** Whether `host` refers to a loopback interface (localhost / 127.0.0.0/8 / ::1). */
+declare function isLoopbackHost(host: string): boolean;
+export { isLoopbackHost, normalizeListenHost };
+//# sourceMappingURL=host.d.ts.map

package/dist/utils/host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../../src/utils/host.ts"],"names":[],"mappings":"AAEA,gFAAgF;AAChF,iBAAS,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAKjD;AAED,qFAAqF;AACrF,iBAAS,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAY7C;AAED,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,CAAA"}

package/dist/utils/labels.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+declare const LABELS_OPERATORS: readonly ["and", "or"];
+type LabelsOperator = (typeof LABELS_OPERATORS)[number];
+export declare const LabelsSchema: {
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    labelsOperator: z.ZodOptional<z.ZodEnum<{
+        and: "and";
+        or: "or";
+    }>>;
+};
+export declare function generateLabelsFilter(labels?: string[], labelsOperator?: LabelsOperator): string;
+export {};
+//# sourceMappingURL=labels.d.ts.map

package/dist/utils/labels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"labels.d.ts","sourceRoot":"","sources":["../../src/utils/labels.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,QAAA,MAAM,gBAAgB,wBAAyB,CAAA;AAC/C,KAAK,cAAc,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEvD,eAAO,MAAM,YAAY;;;;;;CAQxB,CAAA;AAED,wBAAgB,oBAAoB,CAAC,MAAM,GAAE,MAAM,EAAO,EAAE,cAAc,GAAE,cAAqB,UAOhG"}

package/dist/utils/move-planner.d.ts

@@ -0,0 +1,63 @@
+import { MoveTaskArgs, Task } from '@doist/todoist-sdk';
+/** The container fields a caller can send to relocate a task. */
+type MoveRequest = {
+    projectId?: string | undefined;
+    sectionId?: string | undefined;
+    parentId?: string | undefined;
+};
+type MovePlan = {
+    /** The move to perform, or undefined when the task is already where it was asked to go. */
+    move?: MoveTaskArgs;
+    /** True when a requested destination was dropped as already-satisfied. */
+    redundantMoveSkipped: boolean;
+};
+/**
+ * Whether moving `current` to `destination` would leave the task exactly where it
+ * already is, making the request a pointless write.
+ *
+ * Matching the destination field alone is not enough. Moving a task to a project
+ * also lifts it out of its section and out from under its parent, and moving it
+ * to a section lifts it out from under its parent — so a task that matches on
+ * `projectId` but sits in a section is *not* already in the requested end state.
+ *
+ * The extra conditions therefore make this predicate conservative on purpose: it
+ * only reports "redundant" when the task already looks the way the move would
+ * leave it under those detaching semantics. If the API turned out not to detach,
+ * the cost is a move we could have skipped, never a move we wrongly skipped.
+ */
+declare function isMoveRedundant(current: Task, destination: MoveTaskArgs): boolean;
+/**
+ * Identifies a move destination, so tasks heading to the same place can be
+ * collapsed into one request.
+ */
+declare function destinationKey(move: MoveTaskArgs): string;
+/**
+ * Works out what move, if any, a requested update actually needs.
+ *
+ * Callers commonly echo a task's whole current shape back when they only meant to
+ * edit a field, which would otherwise be read as a relocation. Dropping the
+ * containers the task already satisfies means those calls perform no move at all —
+ * and a request that names several containers, all but one of them unchanged,
+ * resolves to the single real move instead of being rejected as ambiguous.
+ *
+ * A single container is judged on the whole position it describes, so asking for a
+ * task's current project still moves it when that would lift it out of a section.
+ * Several containers are judged field by field, so a task described as already
+ * being in its project *and* its section is left alone rather than pulled out of
+ * that section.
+ *
+ * @param taskId - Used only to describe the task in error messages.
+ * @param request - The container fields as supplied by the caller.
+ * @param current - The task's current state, or undefined when it could not be
+ *   read. Unknown state means every requested move is performed, matching the
+ *   behaviour of not checking at all.
+ * @throws If more than one genuine destination remains, since the API accepts
+ *   exactly one.
+ */
+declare function planMove({ taskId, request, current, }: {
+    taskId: string;
+    request: MoveRequest;
+    current: Task | undefined;
+}): MovePlan;
+export { destinationKey, isMoveRedundant, type MovePlan, type MoveRequest, planMove };
+//# sourceMappingURL=move-planner.d.ts.map

package/dist/utils/move-planner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-planner.d.ts","sourceRoot":"","sources":["../../src/utils/move-planner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAA;AAE5D,iEAAiE;AACjE,KAAK,WAAW,GAAG;IACf,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC9B,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC9B,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAChC,CAAA;AAED,KAAK,QAAQ,GAAG;IACZ,2FAA2F;IAC3F,IAAI,CAAC,EAAE,YAAY,CAAA;IACnB,0EAA0E;IAC1E,oBAAoB,EAAE,OAAO,CAAA;CAChC,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,iBAAS,eAAe,CAAC,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,YAAY,GAAG,OAAO,CAY1E;AAsBD;;;GAGG;AACH,iBAAS,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAQlD;AAgBD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,iBAAS,QAAQ,CAAC,EACd,MAAM,EACN,OAAO,EACP,OAAO,GACV,EAAE;IACC,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,WAAW,CAAA;IACpB,OAAO,EAAE,IAAI,GAAG,SAAS,CAAA;CAC5B,GAAG,QAAQ,CA4BX;AAED,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,KAAK,QAAQ,EAAE,KAAK,WAAW,EAAE,QAAQ,EAAE,CAAA"}

package/dist/utils/order-keys.d.ts

@@ -0,0 +1,36 @@
+/** One entity in a list of siblings that Todoist orders by fractional-indexing key. */
+type OrderedSibling = {
+    id: string;
+    /** The entity's order key, or null where Todoist has not assigned one yet. */
+    key: string | null;
+    /** The legacy integer order, used to sort the siblings when any of them has no key. */
+    legacyOrder: number;
+};
+/** Where one sibling should end up: a 0-based position in the reordered list. */
+type Placement = {
+    id: string;
+    position: number;
+};
+/**
+ * Works out the order keys that put each placed sibling at its requested position.
+ *
+ * Positions are 0-based indexes into the list as it reads after the reorder, and
+ * one past the end (or beyond) appends. Placements are applied lowest position
+ * first, so several can be given at once and each lands where it asked. Placements
+ * that ask for the same position are kept together, in the order they were given.
+ *
+ * Only placed siblings get new keys: each run of them is keyed between the
+ * unplaced neighbours around it, so every other sibling keeps its key. A placed
+ * sibling whose key already sits in the right place keeps it too, so repeating a
+ * reorder writes nothing. When the existing keys cannot anchor a placement (a
+ * sibling has no key yet, or two share one), the whole list is re-keyed in its
+ * new order instead.
+ *
+ * Keys compare by UTF-16 code unit, as Todoist sorts them, never by locale.
+ *
+ * @returns The new key for each sibling whose key must change.
+ */
+declare function computeOrderKeys(siblings: readonly OrderedSibling[], placements: readonly Placement[]): Map<string, string>;
+export { computeOrderKeys };
+export type { OrderedSibling, Placement };
+//# sourceMappingURL=order-keys.d.ts.map

package/dist/utils/order-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-keys.d.ts","sourceRoot":"","sources":["../../src/utils/order-keys.ts"],"names":[],"mappings":"AAEA,uFAAuF;AACvF,KAAK,cAAc,GAAG;IAClB,EAAE,EAAE,MAAM,CAAA;IACV,8EAA8E;IAC9E,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IAClB,uFAAuF;IACvF,WAAW,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,iFAAiF;AACjF,KAAK,SAAS,GAAG;IACb,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,iBAAS,gBAAgB,CACrB,QAAQ,EAAE,SAAS,cAAc,EAAE,EACnC,UAAU,EAAE,SAAS,SAAS,EAAE,GACjC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CA0CrB;AAyED,OAAO,EAAE,gBAAgB,EAAE,CAAA;AAC3B,YAAY,EAAE,cAAc,EAAE,SAAS,EAAE,CAAA"}

package/dist/utils/output-schemas.d.ts

@@ -0,0 +1,209 @@
+import { Section } from '@doist/todoist-sdk';
+import { z } from 'zod';
+/**
+ * Schema for a mapped task object returned by tools
+ */
+declare const TaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodString;
+    description: z.ZodString;
+    dueDate: z.ZodOptional<z.ZodString>;
+    recurring: z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>;
+    deadlineDate: z.ZodOptional<z.ZodString>;
+    priority: z.ZodEnum<{
+        p1: "p1";
+        p2: "p2";
+        p3: "p3";
+        p4: "p4";
+    }>;
+    projectId: z.ZodString;
+    sectionId: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodOptional<z.ZodString>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    duration: z.ZodOptional<z.ZodString>;
+    responsibleUid: z.ZodOptional<z.ZodString>;
+    isUncompletable: z.ZodOptional<z.ZodBoolean>;
+    assignedByUid: z.ZodOptional<z.ZodString>;
+    isDeleted: z.ZodOptional<z.ZodBoolean>;
+    checked: z.ZodBoolean;
+    completedAt: z.ZodOptional<z.ZodString>;
+    addedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Schema for a mapped project object returned by tools
+ */
+declare const ProjectSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    color: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
+        berry_red: "berry_red";
+        red: "red";
+        orange: "orange";
+        yellow: "yellow";
+        olive_green: "olive_green";
+        lime_green: "lime_green";
+        green: "green";
+        mint_green: "mint_green";
+        teal: "teal";
+        sky_blue: "sky_blue";
+        light_blue: "light_blue";
+        blue: "blue";
+        grape: "grape";
+        violet: "violet";
+        lavender: "lavender";
+        magenta: "magenta";
+        salmon: "salmon";
+        charcoal: "charcoal";
+        grey: "grey";
+        taupe: "taupe";
+    }>>>;
+    isFavorite: z.ZodBoolean;
+    isShared: z.ZodBoolean;
+    parentId: z.ZodOptional<z.ZodString>;
+    inboxProject: z.ZodBoolean;
+    viewStyle: z.ZodString;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    folderId: z.ZodOptional<z.ZodString>;
+    childOrder: z.ZodNumber;
+    isArchived: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Schema for a section object returned by tools
+ */
+declare const SectionSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    sectionOrder: z.ZodNumber;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SectionSummary = z.infer<typeof SectionSchema>;
+/**
+ * Strip an SDK Section down to the fields declared in SectionSchema. Keeps tool
+ * responses aligned with the schema. The output schema uses an optional string
+ * (Gemini-compatible), so the read's `string | null` description maps `null` to
+ * `undefined`.
+ */
+declare function toSectionSummary({ id, name, sectionOrder, description }: Section): SectionSummary;
+/**
+ * Schema for a comment object returned by tools
+ */
+declare const CommentSchema: z.ZodObject<{
+    id: z.ZodString;
+    taskId: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    content: z.ZodString;
+    postedAt: z.ZodString;
+    postedUid: z.ZodOptional<z.ZodString>;
+    notifiedUserIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    fileAttachment: z.ZodOptional<z.ZodObject<{
+        resourceType: z.ZodString;
+        fileName: z.ZodOptional<z.ZodString>;
+        fileSize: z.ZodOptional<z.ZodNumber>;
+        fileType: z.ZodOptional<z.ZodString>;
+        fileUrl: z.ZodOptional<z.ZodString>;
+        fileDuration: z.ZodOptional<z.ZodNumber>;
+        uploadState: z.ZodOptional<z.ZodEnum<{
+            pending: "pending";
+            completed: "completed";
+        }>>;
+        url: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+        image: z.ZodOptional<z.ZodString>;
+        imageWidth: z.ZodOptional<z.ZodNumber>;
+        imageHeight: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Schema for an activity event object returned by tools
+ */
+declare const ActivityEventSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    objectType: z.ZodString;
+    objectId: z.ZodString;
+    eventType: z.ZodString;
+    eventDate: z.ZodString;
+    parentProjectId: z.ZodOptional<z.ZodString>;
+    parentItemId: z.ZodOptional<z.ZodString>;
+    initiatorId: z.ZodOptional<z.ZodString>;
+    extraData: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * Schema for a user/collaborator object returned by tools
+ */
+declare const CollaboratorSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    email: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Schema for a label object returned by tools
+ */
+declare const LabelSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    color: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
+        berry_red: "berry_red";
+        red: "red";
+        orange: "orange";
+        yellow: "yellow";
+        olive_green: "olive_green";
+        lime_green: "lime_green";
+        green: "green";
+        mint_green: "mint_green";
+        teal: "teal";
+        sky_blue: "sky_blue";
+        light_blue: "light_blue";
+        blue: "blue";
+        grape: "grape";
+        violet: "violet";
+        lavender: "lavender";
+        magenta: "magenta";
+        salmon: "salmon";
+        charcoal: "charcoal";
+        grey: "grey";
+        taupe: "taupe";
+    }>>>;
+    order: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    isFavorite: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Schema for a mapped reminder object returned by tools
+ */
+declare const ReminderSchema: z.ZodObject<{
+    id: z.ZodString;
+    taskId: z.ZodString;
+    type: z.ZodEnum<{
+        location: "location";
+        absolute: "absolute";
+        relative: "relative";
+    }>;
+    notifyUid: z.ZodOptional<z.ZodString>;
+    minuteOffset: z.ZodOptional<z.ZodNumber>;
+    due: z.ZodOptional<z.ZodObject<{
+        isRecurring: z.ZodBoolean;
+        string: z.ZodString;
+        date: z.ZodString;
+        datetime: z.ZodOptional<z.ZodString>;
+        timezone: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    name: z.ZodOptional<z.ZodString>;
+    locLat: z.ZodOptional<z.ZodString>;
+    locLong: z.ZodOptional<z.ZodString>;
+    locTrigger: z.ZodOptional<z.ZodEnum<{
+        on_enter: "on_enter";
+        on_leave: "on_leave";
+    }>>;
+    radius: z.ZodOptional<z.ZodNumber>;
+    isUrgent: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Schema for batch operation failure
+ */
+declare const FailureSchema: z.ZodObject<{
+    item: z.ZodString;
+    error: z.ZodString;
+    code: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export { ActivityEventSchema, CollaboratorSchema, CommentSchema, FailureSchema, LabelSchema, ProjectSchema, ReminderSchema, SectionSchema, type SectionSummary, TaskSchema, toSectionSummary, };
+//# sourceMappingURL=output-schemas.d.ts.map

package/dist/utils/output-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-schemas.d.ts","sourceRoot":"","sources":["../../src/utils/output-schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqC,KAAK,OAAO,EAAE,MAAM,oBAAoB,CAAA;AACpF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB;;GAEG;AACH,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;iBAsBd,CAAA;AAEF;;GAEG;AACH,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAcjB,CAAA;AAEF;;GAEG;AACH,QAAA,MAAM,aAAa;;;;;iBAKjB,CAAA;AAEF,KAAK,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAEnD;;;;;GAKG;AACH,iBAAS,gBAAgB,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE,OAAO,GAAG,cAAc,CAE1F;AAoBD;;GAEG;AACH,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;iBAYjB,CAAA;AAEF;;GAEG;AACH,QAAA,MAAM,mBAAmB;;;;;;;;;;iBAUvB,CAAA;AAEF;;GAEG;AACH,QAAA,MAAM,kBAAkB;;;;iBAItB,CAAA;AAEF;;GAEG;AACH,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMf,CAAA;AAaF;;GAEG;AACH,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;iBAalB,CAAA;AAEF;;GAEG;AACH,QAAA,MAAM,aAAa;;;;iBAIjB,CAAA;AAEF,OAAO,EACH,mBAAmB,EACnB,kBAAkB,EAClB,aAAa,EACb,aAAa,EACb,WAAW,EACX,aAAa,EACb,cAAc,EACd,aAAa,EACb,KAAK,cAAc,EACnB,UAAU,EACV,gBAAgB,GACnB,CAAA"}

package/dist/utils/personal-project-limit.d.ts

@@ -0,0 +1,31 @@
+import { TodoistApi } from '@doist/todoist-sdk';
+import { ToolName } from './tool-names.js';
+type PersonalProjectCapacity = {
+    /** The account's current plan limit on active personal projects. */
+    maxProjects: number;
+    /** Active personal projects that count towards the limit. */
+    activeCount: number;
+};
+/**
+ * Reads the account's personal project limit and how many projects count towards it.
+ *
+ * The API accepts a couple of projects beyond the plan limit, so offline clients
+ * can sync at the boundary. It therefore does not reject a create, unarchive or
+ * move-to-personal that the Todoist apps refuse; a tool that adds an active
+ * personal project checks this capacity first, as the apps do. The SDK applies the
+ * apps' counting rule: every active personal project except the Inbox.
+ *
+ * @returns The capacity, or `undefined` when the read fails or the plan has no
+ * project limit. The underlying error is logged under `toolName`, since the message
+ * the caller reports is deliberately generic.
+ */
+declare function loadPersonalProjectCapacity(client: TodoistApi, toolName: ToolName): Promise<PersonalProjectCapacity | undefined>;
+/**
+ * Throws unless the account has room for one more active personal project.
+ *
+ * @param outcome - What the caller did not do, e.g. "This project was not created."
+ */
+declare function assertPersonalProjectCapacity(capacity: PersonalProjectCapacity | undefined, outcome: string): asserts capacity is PersonalProjectCapacity;
+export { assertPersonalProjectCapacity, loadPersonalProjectCapacity };
+export type { PersonalProjectCapacity };
+//# sourceMappingURL=personal-project-limit.d.ts.map

package/dist/utils/personal-project-limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"personal-project-limit.d.ts","sourceRoot":"","sources":["../../src/utils/personal-project-limit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAEpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAE/C,KAAK,uBAAuB,GAAG;IAC3B,oEAAoE;IACpE,WAAW,EAAE,MAAM,CAAA;IACnB,6DAA6D;IAC7D,WAAW,EAAE,MAAM,CAAA;CACtB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,iBAAe,2BAA2B,CACtC,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,QAAQ,GACnB,OAAO,CAAC,uBAAuB,GAAG,SAAS,CAAC,CAU9C;AAED;;;;GAIG;AACH,iBAAS,6BAA6B,CAClC,QAAQ,EAAE,uBAAuB,GAAG,SAAS,EAC7C,OAAO,EAAE,MAAM,GAChB,OAAO,CAAC,QAAQ,IAAI,uBAAuB,CAW7C;AAED,OAAO,EAAE,6BAA6B,EAAE,2BAA2B,EAAE,CAAA;AACrE,YAAY,EAAE,uBAAuB,EAAE,CAAA"}

package/dist/utils/priorities.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+declare const PRIORITY_VALUES: readonly ["p1", "p2", "p3", "p4"];
+export type Priority = (typeof PRIORITY_VALUES)[number];
+export declare const PRIORITY_INPUT_DESCRIPTION = "Task priority as a string: \"p1\" (highest), \"p2\" (high), \"p3\" (medium), or \"p4\" (lowest/default). Integers like 1, 2, 3, or 4 are not accepted.";
+export declare const PrioritySchema: z.ZodEnum<{
+    p1: "p1";
+    p2: "p2";
+    p3: "p3";
+    p4: "p4";
+}>;
+export declare function convertPriorityToNumber(priority: Priority): number;
+export declare function convertNumberToPriority(priority: number): Priority | undefined;
+export {};
+//# sourceMappingURL=priorities.d.ts.map

package/dist/utils/priorities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"priorities.d.ts","sourceRoot":"","sources":["../../src/utils/priorities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,QAAA,MAAM,eAAe,mCAAoC,CAAA;AACzD,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAA;AAEvD,eAAO,MAAM,0BAA0B,2JAC6G,CAAA;AAEpJ,eAAO,MAAM,cAAc;;;;;EAA+D,CAAA;AAE1F,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAIlE;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAI9E"}

package/dist/utils/reminder-recipients.d.ts

@@ -0,0 +1,21 @@
+import { TodoistApi } from '@doist/todoist-sdk';
+/**
+ * Resolve each reminder's `notifyUser` reference to a user ID.
+ *
+ * The result lines up with the input. Each entry is settled on its own, so a
+ * reference that cannot be resolved fails only the reminders that use it. A
+ * reminder with no reference resolves to `undefined`, which keeps Todoist's
+ * default of notifying its creator.
+ */
+export declare function resolveReminderRecipients(client: TodoistApi, notifyUsers: (string | undefined)[]): Promise<PromiseSettledResult<string | undefined>[]>;
+/**
+ * Warn about every reminder that notifies someone other than the user it was
+ * meant for, which happens when Todoist does not apply the requested recipient.
+ * Without this, the tool would report success while the reminder silently
+ * reaches the wrong person.
+ */
+export declare function describeRecipientMismatches(reminders: {
+    id: string;
+    notifyUid?: string;
+}[], requestedUserIds: (string | undefined)[]): string[];
+//# sourceMappingURL=reminder-recipients.d.ts.map

package/dist/utils/reminder-recipients.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reminder-recipients.d.ts","sourceRoot":"","sources":["../../src/utils/reminder-recipients.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAIpD;;;;;;;GAOG;AACH,wBAAsB,yBAAyB,CAC3C,MAAM,EAAE,UAAU,EAClB,WAAW,EAAE,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,GACpC,OAAO,CAAC,oBAAoB,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,CAAC,CA0BrD;AAMD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACvC,SAAS,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,EAC/C,gBAAgB,EAAE,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,GACzC,MAAM,EAAE,CAQV"}