@doist/todoist-ai 6.0.0 → 6.2.0

package/dist/mcp-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../src/mcp-server.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AA+FnE;;;;;GAKG;AACH,iBAAS,YAAY,CAAC,EAAE,aAAa,EAAE,OAAO,EAAE,EAAE;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,aAqD5F;AAED,OAAO,EAAE,YAAY,EAAE,CAAA"}
+{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../src/mcp-server.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAwGnE;;;;;GAKG;AACH,iBAAS,YAAY,CAAC,EAAE,aAAa,EAAE,OAAO,EAAE,EAAE;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,aA0E5F;AAED,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/todoist-tool.d.ts

@@ -44,6 +44,12 @@ type TodoistTool<Params extends z.ZodRawShape, Output extends z.ZodRawShape> = {
      * This is used to generate appropriate MCP annotation hints (readOnlyHint, destructiveHint).
      */
     mutability: ToolMutability;
+    /**
+     * The meta data of the tool.
+     *
+     * This is used to store additional information about the tool.
+     */
+    _meta?: Record<string, unknown>;
     /**
      * The function that executes the tool.
      *

package/dist/todoist-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"todoist-tool.d.ts","sourceRoot":"","sources":["../src/todoist-tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAA;AAC/D,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,KAAK,aAAa,CAAC,MAAM,SAAS,CAAC,CAAC,WAAW,IAAI,OAAO,CAAC;IACvD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,iBAAiB,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAA;CACnD,CAAC,CAAA;AAEF;;;;;;GAMG;AACH,KAAK,cAAc,GAAG,UAAU,GAAG,UAAU,GAAG,UAAU,CAAA;AAE1D;;GAEG;AACH,KAAK,WAAW,CAAC,MAAM,SAAS,CAAC,CAAC,WAAW,EAAE,MAAM,SAAS,CAAC,CAAC,WAAW,IAAI;IAC3E;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;IAEZ;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAA;IAEnB;;;;;OAKG;IACH,UAAU,EAAE,MAAM,CAAA;IAElB;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAA;IAEpB;;;;OAIG;IACH,UAAU,EAAE,cAAc,CAAA;IAE1B;;;;;;;;OAQG;IACH,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,KAAK,aAAa,CAAC,MAAM,CAAC,CAAA;CAC7F,CAAA;AAED,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,CAAA"}
+{"version":3,"file":"todoist-tool.d.ts","sourceRoot":"","sources":["../src/todoist-tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAA;AAC/D,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,KAAK,aAAa,CAAC,MAAM,SAAS,CAAC,CAAC,WAAW,IAAI,OAAO,CAAC;IACvD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,iBAAiB,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAA;CACnD,CAAC,CAAA;AAEF;;;;;;GAMG;AACH,KAAK,cAAc,GAAG,UAAU,GAAG,UAAU,GAAG,UAAU,CAAA;AAE1D;;GAEG;AACH,KAAK,WAAW,CAAC,MAAM,SAAS,CAAC,CAAC,WAAW,EAAE,MAAM,SAAS,CAAC,CAAC,WAAW,IAAI;IAC3E;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;IAEZ;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAA;IAEnB;;;;;OAKG;IACH,UAAU,EAAE,MAAM,CAAA;IAElB;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAA;IAEpB;;;;OAIG;IACH,UAAU,EAAE,cAAc,CAAA;IAE1B;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAE/B;;;;;;;;OAQG;IACH,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,KAAK,aAAa,CAAC,MAAM,CAAC,CAAA;CAC7F,CAAA;AAED,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,CAAA"}

package/dist/tools/fetch-object.d.ts

@@ -0,0 +1,168 @@
+import { z } from 'zod';
+declare const fetchObject: {
+    name: "fetch-object";
+    description: string;
+    parameters: {
+        type: z.ZodEnum<{
+            task: "task";
+            comment: "comment";
+            project: "project";
+            section: "section";
+        }>;
+        id: z.ZodString;
+    };
+    outputSchema: {
+        type: z.ZodEnum<{
+            task: "task";
+            comment: "comment";
+            project: "project";
+            section: "section";
+        }>;
+        id: z.ZodString;
+        object: z.ZodUnion<readonly [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>;
+            checked: z.ZodBoolean;
+            completedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            color: z.ZodString;
+            isFavorite: z.ZodBoolean;
+            isShared: z.ZodBoolean;
+            parentId: z.ZodOptional<z.ZodString>;
+            inboxProject: z.ZodBoolean;
+            viewStyle: z.ZodString;
+        }, z.core.$strip>, 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>;
+            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>, z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>]>;
+    };
+    mutability: "readonly";
+    execute(args: {
+        type: "task" | "comment" | "project" | "section";
+        id: string;
+    }, client: import('@doist/todoist-api-typescript').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            type: "task";
+            id: string;
+            object: {
+                id: string;
+                content: string;
+                description: string;
+                dueDate: string | undefined;
+                recurring: string | boolean;
+                deadlineDate: string | undefined;
+                priority: "p1" | "p2" | "p3" | "p4";
+                projectId: string;
+                sectionId: string | undefined;
+                parentId: string | undefined;
+                labels: string[];
+                duration: string | undefined;
+                responsibleUid: string | undefined;
+                assignedByUid: string | undefined;
+                checked: boolean;
+                completedAt: string | undefined;
+            };
+        };
+    } | {
+        textContent: string;
+        structuredContent: {
+            type: "project";
+            id: string;
+            object: {
+                id: string;
+                name: string;
+                color: string;
+                isFavorite: boolean;
+                isShared: boolean;
+                parentId: string | undefined;
+                inboxProject: boolean;
+                viewStyle: string;
+            };
+        };
+    } | {
+        textContent: string;
+        structuredContent: {
+            type: "comment";
+            id: string;
+            object: {
+                id: string;
+                taskId: string | undefined;
+                projectId: string | undefined;
+                content: string;
+                postedAt: string;
+                postedUid: string;
+                fileAttachment: {
+                    resourceType: string;
+                    fileName: string | undefined;
+                    fileSize: number | undefined;
+                    fileType: string | undefined;
+                    fileUrl: string | undefined;
+                    fileDuration: number | undefined;
+                    uploadState: "pending" | "completed" | undefined;
+                    url: string | undefined;
+                    title: string | undefined;
+                    image: string | undefined;
+                    imageWidth: number | undefined;
+                    imageHeight: number | undefined;
+                } | undefined;
+            };
+        };
+    } | {
+        textContent: string;
+        structuredContent: {
+            type: "section";
+            id: string;
+            object: {
+                id: string;
+                name: string;
+            };
+        };
+    }>;
+};
+export { fetchObject };
+//# sourceMappingURL=fetch-object.d.ts.map

package/dist/tools/fetch-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-object.d.ts","sourceRoot":"","sources":["../../src/tools/fetch-object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAqBvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+E8C,CAAA;AAE/D,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/tools/fetch.d.ts

@@ -1,4 +1,11 @@
 import { z } from 'zod';
+type FetchResult = {
+    id: string;
+    title: string;
+    text: string;
+    url: string;
+    metadata?: Record<string, unknown>;
+};
 /**
  * OpenAI MCP fetch tool - retrieves the full contents of a task or project by ID.
  *
@@ -23,6 +30,7 @@ declare const fetch: {
         id: string;
     }, client: import('@doist/todoist-api-typescript').TodoistApi): Promise<{
         textContent: string;
+        structuredContent: FetchResult;
     }>;
 };
 export { fetch };

package/dist/tools/fetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/tools/fetch.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAiCvB;;;;;GAKG;AACH,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;CAwFoD,CAAA;AAE/D,OAAO,EAAE,KAAK,EAAE,CAAA"}
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/tools/fetch.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAcvB,KAAK,WAAW,GAAG;IACf,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACrC,CAAA;AAaD;;;;;GAKG;AACH,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;CA2FoD,CAAA;AAE/D,OAAO,EAAE,KAAK,EAAE,CAAA"}

package/dist/tools/find-comments.d.ts

@@ -35,6 +35,9 @@ declare const findComments: {
                 imageHeight: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
+        searchType: z.ZodString;
+        searchId: z.ZodString;
+        hasMore: z.ZodBoolean;
         nextCursor: z.ZodOptional<z.ZodString>;
         totalCount: z.ZodNumber;
     };

package/dist/tools/find-comments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"find-comments.d.ts","sourceRoot":"","sources":["../../src/tools/find-comments.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAiCvB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8E6C,CAAA;AAmD/D,OAAO,EAAE,YAAY,EAAE,CAAA"}
+{"version":3,"file":"find-comments.d.ts","sourceRoot":"","sources":["../../src/tools/find-comments.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAwCvB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8E6C,CAAA;AAmD/D,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/tools/find-tasks-by-date.resource.d.ts

@@ -0,0 +1,28 @@
+declare function createFindTasksByDateResource(uri: string, rawHtml: string): {
+    name: string;
+    uri: string;
+    mimeType: string;
+    text: string;
+    _meta: {
+        /**
+         * Renders the widget within a rounded border and shadow.
+         * Otherwise, the HTML is rendered full-bleed in the conversation
+         */
+        'openai/widgetDescription': string;
+        'openai/widgetPrefersBorder': boolean;
+        'openai/widgetAccessible': boolean;
+        'openai/toolInvocation/invoking': string;
+        'openai/toolInvocation/invoked': string;
+        'openai/widgetDomain': string;
+        /**
+         * Required to make external network requests from the HTML code.
+         * Also used to validate `openai.openExternal()` requests.
+         */
+        'openai/widgetCSP': {
+            connect_domains: string[];
+            resource_domains: string[];
+        };
+    };
+};
+export { createFindTasksByDateResource };
+//# sourceMappingURL=find-tasks-by-date.resource.d.ts.map

package/dist/tools/find-tasks-by-date.resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-tasks-by-date.resource.d.ts","sourceRoot":"","sources":["../../src/tools/find-tasks-by-date.resource.ts"],"names":[],"mappings":"AAAA,iBAAS,6BAA6B,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;;;;;;QAOvD;;;WAGG;;;;;;;QAOH;;;WAGG;;;;;;EASd;AAED,OAAO,EAAE,6BAA6B,EAAE,CAAA"}

package/dist/utils/tool-names.d.ts

@@ -26,6 +26,7 @@ export declare const ToolNames: {
     readonly FIND_ACTIVITY: "find-activity";
     readonly GET_OVERVIEW: "get-overview";
     readonly DELETE_OBJECT: "delete-object";
+    readonly FETCH_OBJECT: "fetch-object";
     readonly USER_INFO: "user-info";
     readonly SEARCH: "search";
     readonly FETCH: "fetch";

package/dist/utils/tool-names.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-names.d.ts","sourceRoot":"","sources":["../../src/utils/tool-names.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;CAuCZ,CAAA;AAGV,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAA"}
+{"version":3,"file":"tool-names.d.ts","sourceRoot":"","sources":["../../src/utils/tool-names.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;CAwCZ,CAAA;AAGV,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAA"}

package/dist/utils/widget-loader.d.ts

@@ -0,0 +1,7 @@
+type TaskListWidget = {
+    fileName: string;
+    content: string;
+};
+declare function loadTaskListWidget(loadedWidget?: TaskListWidget): TaskListWidget;
+export { loadTaskListWidget };
+//# sourceMappingURL=widget-loader.d.ts.map

package/dist/utils/widget-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widget-loader.d.ts","sourceRoot":"","sources":["../../src/utils/widget-loader.ts"],"names":[],"mappings":"AAEA,KAAK,cAAc,GAAG;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAClB,CAAA;AAYD,iBAAS,kBAAkB,CAAC,YAAY,GAAE,cAA+B,GAAG,cAAc,CAMzF;AAED,OAAO,EAAE,kBAAkB,EAAE,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@doist/todoist-ai",
-    "version": "6.0.0",
+    "version": "6.2.0",
     "type": "module",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
@@ -10,6 +10,7 @@
     },
     "files": [
         "dist",
+        "!dist/dev",
         "scripts",
         "package.json",
         "LICENSE.txt",
@@ -34,6 +35,7 @@
         "postbuild": "chmod +x dist/main.js",
         "start": "npm run build && npx @modelcontextprotocol/inspector node dist/main.js",
         "dev": "concurrently \"vite build --watch\" \"npx @modelcontextprotocol/inspector npx nodemon --quiet --watch dist --ext js --exec node dist/main.js\"",
+        "dev:widget": "vite build --watch --minify false",
         "setup": "cp .env.example .env && npm install && npm run build",
         "test:executable": "npm run build && node scripts/test-executable.cjs",
         "type-check": "npx tsc --noEmit",
@@ -51,14 +53,18 @@
         "@doist/todoist-api-typescript": "6.2.1",
         "@modelcontextprotocol/sdk": "1.24.3",
         "date-fns": "4.1.0",
+        "dompurify": "3.3.1",
         "dotenv": "17.2.3",
         "zod": "4.1.13"
     },
     "devDependencies": {
         "@biomejs/biome": "2.3.8",
+        "@types/dompurify": "3.0.5",
         "@types/express": "5.0.6",
         "@types/morgan": "1.9.10",
         "@types/node": "22.19.2",
+        "@types/react": "19.2.2",
+        "@types/react-dom": "19.2.2",
         "concurrently": "9.2.1",
         "express": "5.2.1",
         "husky": "9.1.7",
@@ -66,6 +72,10 @@
         "morgan": "1.10.1",
         "nodemon": "3.1.11",
         "rimraf": "6.1.2",
+        "react": "19.2.0",
+        "react-dom": "19.2.0",
+        "snarkdown": "2.0.0",
+        "tsx": "4.20.6",
         "typescript": "5.9.3",
         "vite": "7.2.7",
         "vite-plugin-dts": "4.5.4",

package/scripts/inline-widget-builder.ts

@@ -0,0 +1,87 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import type { BuildResult } from 'esbuild'
+import { build } from 'esbuild'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+const PLACEHOLDER = '<!-- INLINE_WIDGET_SCRIPT -->'
+
+type InlineWidget = {
+    entryFile: string
+    htmlTemplate: string
+    outputName: string
+}
+
+export type InlineWidgetBuildResult = {
+    fileName: string
+    content: string
+}
+
+export async function buildInlineWidget(
+    widget: InlineWidget,
+    { buildTimestamp }: { buildTimestamp: string },
+): Promise<InlineWidgetBuildResult> {
+    const projectRoot = resolve(__dirname, '..')
+    const entryPath = join(projectRoot, widget.entryFile)
+    const templatePath = join(projectRoot, widget.htmlTemplate)
+    const outputFileName = `${widget.outputName}-${buildTimestamp}.html`
+
+    if (!existsSync(templatePath)) {
+        throw new Error(`HTML template not found: ${templatePath}`)
+    }
+    const htmlTemplateContent = readFileSync(templatePath, 'utf-8')
+    if (!htmlTemplateContent.includes(PLACEHOLDER)) {
+        throw new Error(`Placeholder ${PLACEHOLDER} not found in ${templatePath}`)
+    }
+
+    const result: BuildResult = await build({
+        entryPoints: [entryPath],
+        bundle: true,
+        write: false,
+        format: 'iife',
+        platform: 'browser',
+        target: 'es2020',
+        minify: true,
+        jsx: 'automatic',
+        globalName: 'Widget',
+        outdir: 'out',
+        loader: {
+            '.svg': 'dataurl',
+        },
+    })
+
+    if (!result.outputFiles || result.outputFiles.length === 0) {
+        throw new Error(`Failed to build ${widget.entryFile}`)
+    }
+
+    const jsFile = result.outputFiles.find((file) => file.path.endsWith('.js'))
+    const cssFile = result.outputFiles.find((file) => file.path.endsWith('.css'))
+
+    if (!jsFile) {
+        throw new Error(`No JavaScript output found for ${widget.entryFile}`)
+    }
+
+    const bundledCode = jsFile.text
+    const sanitizedBundledCode = bundledCode
+        .replace(/<\/script/gi, '<\\/script')
+        .replace(/<!--/g, '<\\!--')
+
+    // Build the inline style tag if CSS exists
+    const inlinedStyle = cssFile ? `<style>${cssFile.text}</style>` : ''
+
+    const inlinedScript = `
+        ${inlinedStyle}
+        <script>
+            ${sanitizedBundledCode}
+            if (typeof Widget !== 'undefined' && typeof Widget.renderWidget === 'function') {
+                Widget.renderWidget();
+            }
+        </script>
+    `
+    const finalHtml = htmlTemplateContent.replace(PLACEHOLDER, () => inlinedScript)
+
+    return { fileName: outputFileName, content: finalHtml }
+}

package/scripts/inline-widgets-vite-plugin.ts

@@ -0,0 +1,134 @@
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import type { Plugin, PluginContext } from 'vite'
+
+import { buildInlineWidget, type InlineWidgetBuildResult } from './inline-widget-builder.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+type InlineWidgetConfig = {
+    entryFile: string
+    htmlTemplate: string
+    outputName: string
+}
+
+const TASK_LIST_WIDGET: InlineWidgetConfig = {
+    entryFile: 'src/widgets/task-list/widget.tsx',
+    htmlTemplate: 'src/widgets/task-list/template.html',
+    outputName: 'task-list-widget',
+}
+
+const WIDGET_SOURCE_PATTERN = /src[\\/]widgets[\\/].+\.(tsx?|css|html|svg)$/
+const WIDGET_FILE_EXTENSIONS = /\.(tsx?|css|html|svg)$/
+const WIDGET_SOURCE_DIR = 'src/widgets'
+
+function getWidgetSourceFiles(rootDir: string): string[] {
+    const widgetsDir = join(rootDir, WIDGET_SOURCE_DIR)
+    if (!existsSync(widgetsDir)) {
+        return []
+    }
+
+    const files: string[] = []
+    const entries = readdirSync(widgetsDir, { withFileTypes: true, recursive: true })
+
+    for (const entry of entries) {
+        if (entry.isFile() && WIDGET_FILE_EXTENSIONS.test(entry.name)) {
+            const parentPath = entry.parentPath ?? entry.path
+            files.push(join(parentPath, entry.name))
+        }
+    }
+
+    return files
+}
+
+export function inlineWidgetsVitePlugin(): Plugin {
+    let cachedResult: InlineWidgetBuildResult | undefined
+    let isWatchMode = false
+    let projectRoot: string
+    const virtualModuleId = 'virtual:todoist-ai-widgets'
+    const resolvedVirtualModuleId = `\0${virtualModuleId}`
+
+    async function rebuildWidget(): Promise<void> {
+        const buildTimestamp = process.env.BUILD_TIMESTAMP ?? Date.now().toString()
+        cachedResult = await buildInlineWidget(TASK_LIST_WIDGET, { buildTimestamp })
+    }
+
+    function writePreviewHtml(): void {
+        if (!cachedResult) {
+            return
+        }
+
+        const previewDir = resolve(projectRoot, 'dist', 'dev')
+        if (!existsSync(previewDir)) {
+            mkdirSync(previewDir, { recursive: true })
+        }
+
+        const previewPath = resolve(previewDir, `${TASK_LIST_WIDGET.outputName}.html`)
+        writeFileSync(previewPath, cachedResult.content, 'utf-8')
+        console.log(`[widgets] Preview written to ${previewPath}`)
+    }
+
+    function addWidgetFilesToWatch(ctx: PluginContext): void {
+        const widgetFiles = getWidgetSourceFiles(projectRoot)
+        for (const file of widgetFiles) {
+            ctx.addWatchFile(file)
+        }
+        if (widgetFiles.length > 0) {
+            console.log(`[widgets] Watching ${widgetFiles.length} widget source files`)
+        }
+    }
+
+    return {
+        name: 'todoist-ai-inline-widgets',
+        enforce: 'pre' as const,
+
+        configResolved(config) {
+            projectRoot = config.root
+            isWatchMode = config.command === 'build' && Boolean(config.build.watch)
+        },
+
+        async buildStart() {
+            await rebuildWidget()
+            addWidgetFilesToWatch(this)
+        },
+
+        async watchChange(id) {
+            if (WIDGET_SOURCE_PATTERN.test(id)) {
+                console.log(`[widgets] Detected change in ${id}, rebuilding...`)
+                await rebuildWidget()
+
+                // Write preview HTML in watch mode
+                if (isWatchMode) {
+                    writePreviewHtml()
+                }
+            }
+        },
+
+        writeBundle() {
+            writePreviewHtml()
+        },
+
+        resolveId(id: string) {
+            if (id === virtualModuleId) {
+                return resolvedVirtualModuleId
+            }
+
+            return null
+        },
+
+        load(id: string) {
+            if (id !== resolvedVirtualModuleId || !cachedResult) {
+                return null
+            }
+
+            const moduleSource = `
+                const taskListWidget = ${JSON.stringify(cachedResult)};
+                export { taskListWidget };
+                export default { taskListWidget };
+            `
+            return moduleSource
+        },
+    }
+}