@doist/todoist-mcp 12.2.3 → 12.3.0

package/dist/{require-valid-todoist-token-b21ze0l_.js → require-valid-todoist-token-CLh0YpWi.js}

@@ -1,4 +1,4 @@
-import { P as A, Q as v, R as T } from "./mcp-server-S9IIW20j.js";
+import { P as A, Q as v, R as T } from "./mcp-server-BOvuwJio.js";
 const y = /* @__PURE__ */ new Set([401, 403]);
 function C(e) {
   const t = T(e);

package/dist/tools/update-tasks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/update-tasks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAQ,UAAU,EAAkB,MAAM,oBAAoB,CAAA;AAC1E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAoIvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAsBqB,MAAM;uBAAS,MAAM;uBAAS,MAAM;;;;;;;;;CAsDX,CAAA;AA8M/D,OAAO,EAAE,WAAW,EAAE,CAAA"}
+{"version":3,"file":"update-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/update-tasks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAQ,UAAU,EAAkB,MAAM,oBAAoB,CAAA;AAC1E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAqIvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAsBqB,MAAM;uBAAS,MAAM;uBAAS,MAAM;;;;;;;;;CAsDX,CAAA;AAsN/D,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/usage-tracking.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usage-tracking.d.ts","sourceRoot":"","sources":["../src/usage-tracking.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,WAAW,EAA4B,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAI3F,QAAA,MAAM,mBAAmB,QAAsB,CAAA;AAI/C,KAAK,mBAAmB,GAAG;IACvB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,KAAK,gBAAgB,GAAG;IACpB,oBAAoB,EAAE,MAAM,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAAA;CAC3D,CAAA;AAcD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAE5E;AAED,wBAAgB,yBAAyB,CAAC,EACtC,KAAK,EACL,QAAgB,EAChB,SAAwB,GAC3B,GAAE;IACC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;CAChB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAW9B;AAkGD,wBAAsB,8BAA8B,IAAI,OAAO,CAAC,IAAI,CAAC,CAYpE;AAED,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,gBAAgB,CAAC,GAAG,IAAI,CAE/F;AAED,wBAAgB,mCAAmC,IAAI,IAAI,CAE1D;AAsBD,wBAAgB,kBAAkB,CAC9B,SAAS,GAAE,OAAO,KAAwB,EAC1C,QAAQ,GAAE,mBAAwB,GACnC,WAAW,CA+Bb;AAED,wBAAgB,mBAAmB,CAC/B,MAAM,EAAE,MAAM,EACd,EACI,OAAO,EACP,QAAQ,GACX,GAAE;IACC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,mBAAmB,CAAA;CAC5B,GACP,UAAU,CAKZ;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAA"}
+{"version":3,"file":"usage-tracking.d.ts","sourceRoot":"","sources":["../src/usage-tracking.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,WAAW,EAA4B,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAK3F,QAAA,MAAM,mBAAmB,QAAsB,CAAA;AAI/C,KAAK,mBAAmB,GAAG;IACvB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,KAAK,gBAAgB,GAAG;IACpB,oBAAoB,EAAE,MAAM,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAAA;CAC3D,CAAA;AAcD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAE5E;AAED,wBAAgB,yBAAyB,CAAC,EACtC,KAAK,EACL,QAAgB,EAChB,SAAwB,GAC3B,GAAE;IACC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;CAChB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAW9B;AAkGD,wBAAsB,8BAA8B,IAAI,OAAO,CAAC,IAAI,CAAC,CAYpE;AAED,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,gBAAgB,CAAC,GAAG,IAAI,CAE/F;AAED,wBAAgB,mCAAmC,IAAI,IAAI,CAE1D;AAsBD,wBAAgB,kBAAkB,CAC9B,SAAS,GAAE,OAAO,KAAwB,EAC1C,QAAQ,GAAE,mBAAwB,GACnC,WAAW,CA+Bb;AAED,wBAAgB,mBAAmB,CAC/B,MAAM,EAAE,MAAM,EACd,EACI,OAAO,EACP,QAAQ,GACX,GAAE;IACC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,mBAAmB,CAAA;CAC5B,GACP,UAAU,CAUZ;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAA"}

package/dist/utils/concurrency.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Wraps a task so it only runs once a slot is free.
+ */
+type Limiter = <T>(fn: () => Promise<T>) => Promise<T>;
+/**
+ * A FIFO semaphore. Tasks beyond `maxConcurrent` queue and start as slots free up.
+ *
+ * Deliberately applied at the tool layer rather than inside the SDK's
+ * `customFetch`: the SDK installs its request-timeout `AbortSignal` *before*
+ * calling `customFetch`, so gating there would charge queue time against the
+ * request timeout and fail long-queued requests that never actually ran.
+ *
+ * That same property is why queued tasks need their own deadline. A task's request
+ * timeout only starts once it reaches the front of the queue, so without one a task
+ * can wait indefinitely — long past the point its caller gave up — and then still
+ * issue its request. `queueTimeoutMs` bounds the wait instead, failing the task with
+ * a reason that says the request was never sent.
+ */
+declare function createLimiter(maxConcurrent: number, { queueTimeoutMs }?: {
+    queueTimeoutMs?: number;
+}): Limiter;
+/**
+ * Associates a client with its account's limiters, sharing one pair across every
+ * client built for the same account.
+ */
+declare function registerClientLimiters(client: object, apiKey: string): void;
+declare function getMoveLimiter(client: object): Limiter;
+declare function getWriteLimiter(client: object): Limiter;
+/** Test-only: drops all registered limiters so cases start from a clean slate. */
+declare function resetLimitersForTesting(): void;
+export { createLimiter, getMoveLimiter, getWriteLimiter, type Limiter, registerClientLimiters, resetLimitersForTesting, };
+//# sourceMappingURL=concurrency.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"concurrency.d.ts","sourceRoot":"","sources":["../../src/utils/concurrency.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,KAAK,OAAO,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAA;AAetD;;;;;;;;;;;;;GAaG;AACH,iBAAS,aAAa,CAClB,aAAa,EAAE,MAAM,EACrB,EAAE,cAAgD,EAAE,GAAE;IAAE,cAAc,CAAC,EAAE,MAAM,CAAA;CAAO,GACvF,OAAO,CA8DT;AAsCD;;;GAGG;AACH,iBAAS,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAQpE;AAMD,iBAAS,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE/C;AAED,iBAAS,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED,kFAAkF;AAClF,iBAAS,uBAAuB,IAAI,IAAI,CAGvC;AAED,OAAO,EACH,aAAa,EACb,cAAc,EACd,eAAe,EACf,KAAK,OAAO,EACZ,sBAAsB,EACtB,uBAAuB,GAC1B,CAAA"}

package/dist/utils/constants.d.ts

@@ -50,6 +50,29 @@ 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.
+     *
+     * 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.
+     */
+    readonly TASK_MOVES: 1;
+    /** In-flight non-move write requests per account. */
+    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;

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

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/utils/constants.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,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,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,WAAW;IACpB,oEAAoE;;CAE9D,CAAA;AAGV,eAAO,MAAM,cAAc;IACvB,oDAAoD;;IAEpD,mCAAmC;;CAE7B,CAAA"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/utils/constants.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,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,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,WAAW;IACpB,oEAAoE;;CAE9D,CAAA;AAGV,eAAO,MAAM,iBAAiB;IAC1B;;;;;;;;OAQG;;IAEH,qDAAqD;;IAErD;;;;;;;OAOG;;CAEG,CAAA;AAGV,eAAO,MAAM,cAAc;IACvB,oDAAoD;;IAEpD,mCAAmC;;CAE7B,CAAA"}

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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@doist/todoist-mcp",
-    "version": "12.2.3",
+    "version": "12.3.0",
     "type": "module",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",