@doist/todoist-ai 5.2.0 → 6.1.0

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
+        },
+    }
+}

package/scripts/validate-schemas.ts

@@ -17,37 +17,37 @@
 
 import { z } from 'zod'
 
-interface ValidationIssue {
+type ValidationIssue = {
     toolName: string
     parameterPath: string
     issue: string
     suggestion: string
 }
 
-interface ValidationResult {
+type ValidationResult = {
     success: boolean
     issues: ValidationIssue[]
     toolsChecked: number
     parametersChecked: number
 }
 
+type AnyZodSchema = z.ZodTypeAny | { _zod: { def: unknown } }
+
 /**
  * Recursively walk a Zod schema and detect problematic patterns
  */
 function walkZodSchema(
-    schema: z.ZodTypeAny,
+    schema: AnyZodSchema,
     path: string,
     issues: ValidationIssue[],
     toolName: string,
 ): void {
-    const typeName = schema._def.typeName
-
     // Check for ZodOptional containing a ZodNullable ZodString
-    if (typeName === 'ZodOptional') {
-        const innerSchema = schema._def.innerType
-        if (innerSchema._def.typeName === 'ZodNullable') {
-            const nullableInner = innerSchema._def.innerType
-            if (nullableInner._def.typeName === 'ZodString') {
+    if (schema instanceof z.ZodOptional) {
+        const innerSchema = schema.unwrap()
+        if (innerSchema instanceof z.ZodNullable) {
+            const nullableInner = innerSchema.unwrap()
+            if (nullableInner instanceof z.ZodString) {
                 issues.push({
                     toolName,
                     parameterPath: path,
@@ -60,11 +60,11 @@ function walkZodSchema(
     }
 
     // Check for ZodNullable containing a ZodOptional ZodString
-    if (typeName === 'ZodNullable') {
-        const innerSchema = schema._def.innerType
-        if (innerSchema._def.typeName === 'ZodOptional') {
-            const optionalInner = innerSchema._def.innerType
-            if (optionalInner._def.typeName === 'ZodString') {
+    if (schema instanceof z.ZodNullable) {
+        const innerSchema = schema.unwrap()
+        if (innerSchema instanceof z.ZodOptional) {
+            const optionalInner = innerSchema.unwrap()
+            if (optionalInner instanceof z.ZodString) {
                 issues.push({
                     toolName,
                     parameterPath: path,
@@ -77,61 +77,60 @@ function walkZodSchema(
     }
 
     // Recursively check nested schemas
-    switch (typeName) {
-        case 'ZodObject': {
-            const shape = schema._def.shape()
-            for (const [key, value] of Object.entries(shape)) {
-                const newPath = path ? `${path}.${key}` : key
-                walkZodSchema(value as z.ZodTypeAny, newPath, issues, toolName)
-            }
-            break
-        }
-        case 'ZodArray':
-            walkZodSchema(schema._def.type, `${path}[]`, issues, toolName)
-            break
-
-        case 'ZodOptional':
-        case 'ZodNullable':
-        case 'ZodDefault':
-            walkZodSchema(schema._def.innerType, path, issues, toolName)
-            break
-
-        case 'ZodUnion':
-        case 'ZodDiscriminatedUnion': {
-            const options = schema._def.options || schema._def.discriminatedUnion
-            if (Array.isArray(options)) {
-                options.forEach((option: z.ZodTypeAny, index: number) => {
-                    walkZodSchema(option, `${path}[union:${index}]`, issues, toolName)
-                })
-            }
-            break
+    if (schema instanceof z.ZodObject) {
+        const shape = schema.shape
+        for (const [key, value] of Object.entries(shape)) {
+            const newPath = path ? `${path}.${key}` : key
+            walkZodSchema(value as AnyZodSchema, newPath, issues, toolName)
         }
-        case 'ZodIntersection':
-            walkZodSchema(schema._def.left, `${path}[left]`, issues, toolName)
-            walkZodSchema(schema._def.right, `${path}[right]`, issues, toolName)
-            break
-
-        case 'ZodRecord':
-            if (schema._def.valueType) {
-                walkZodSchema(schema._def.valueType, `${path}[value]`, issues, toolName)
-            }
-            break
-
-        case 'ZodTuple':
-            if (schema._def.items) {
-                schema._def.items.forEach((item: z.ZodTypeAny, index: number) => {
-                    walkZodSchema(item, `${path}[${index}]`, issues, toolName)
-                })
-            }
-            break
+    } else if (schema instanceof z.ZodArray) {
+        const element = (schema as unknown as { _zod: { def: { element: AnyZodSchema } } })._zod.def
+            .element
+        walkZodSchema(element, `${path}[]`, issues, toolName)
+    } else if (
+        schema instanceof z.ZodOptional ||
+        schema instanceof z.ZodNullable ||
+        schema instanceof z.ZodDefault
+    ) {
+        walkZodSchema(schema.unwrap() as AnyZodSchema, path, issues, toolName)
+    } else if (schema instanceof z.ZodUnion) {
+        const options = (schema as unknown as { _zod: { def: { options: AnyZodSchema[] } } })._zod
+            .def.options
+        options.forEach((option: AnyZodSchema, index: number) => {
+            walkZodSchema(option, `${path}[union:${index}]`, issues, toolName)
+        })
+    } else if (schema instanceof z.ZodDiscriminatedUnion) {
+        const options = (schema as unknown as { _zod: { def: { options: AnyZodSchema[] } } })._zod
+            .def.options
+        options.forEach((option: AnyZodSchema, index: number) => {
+            walkZodSchema(option, `${path}[union:${index}]`, issues, toolName)
+        })
+    } else if (schema instanceof z.ZodIntersection) {
+        const left = (schema as unknown as { _zod: { def: { left: AnyZodSchema } } })._zod.def.left
+        const right = (schema as unknown as { _zod: { def: { right: AnyZodSchema } } })._zod.def
+            .right
+        walkZodSchema(left, `${path}[left]`, issues, toolName)
+        walkZodSchema(right, `${path}[right]`, issues, toolName)
+    } else if (schema instanceof z.ZodRecord) {
+        const valueType = (schema as unknown as { _zod: { def: { valueType: AnyZodSchema } } })._zod
+            .def.valueType
+        walkZodSchema(valueType, `${path}[value]`, issues, toolName)
+    } else if (schema instanceof z.ZodTuple) {
+        const items = (schema as unknown as { _zod: { def: { items: AnyZodSchema[] } } })._zod.def
+            .items
+        items.forEach((item: AnyZodSchema, index: number) => {
+            walkZodSchema(item, `${path}[${index}]`, issues, toolName)
+        })
     }
 }
 
 /**
  * Validate a single tool's parameter schema
  */
-// biome-ignore lint/suspicious/noExplicitAny: this is a tooling script
-function validateToolSchema(tool: any): ValidationIssue[] {
+function validateToolSchema(tool: {
+    name?: string
+    parameters?: Record<string, z.ZodTypeAny>
+}): ValidationIssue[] {
     const issues: ValidationIssue[] = []
     const toolName = tool.name || 'unknown'
 
@@ -174,8 +173,10 @@ async function validateAllSchemas(verbose: boolean = false): Promise<ValidationR
             if (tool.parameters) {
                 try {
                     const schema = z.object(tool.parameters)
-                    const shape = schema._def.shape()
-                    totalParameters += Object.keys(shape).length
+                    const shape = schema.shape
+                    if (shape) {
+                        totalParameters += Object.keys(shape).length
+                    }
                 } catch {
                     // Skip counting if schema is invalid
                 }