@doist/todoist-ai 8.12.2 → 9.0.0

package/scripts/run-tool.ts

@@ -1,240 +0,0 @@
-#!/usr/bin/env npx tsx
-/**
- * Run any Todoist tool directly without going through MCP.
- *
- * Usage:
- *   npx tsx scripts/run-tool.ts <tool-name> '<json-args>'
- *   npx tsx scripts/run-tool.ts <tool-name> --file <args.json>
- *   npx tsx scripts/run-tool.ts --list
- *
- * Examples:
- *   npx tsx scripts/run-tool.ts add-tasks '{"tasks":[{"content":"Test task","order":1}]}'
- *   npx tsx scripts/run-tool.ts find-tasks '{"searchText":"meeting"}'
- *   npx tsx scripts/run-tool.ts get-overview '{}'
- *
- * Requires TODOIST_API_KEY in .env file (and optionally TODOIST_BASE_URL).
- */
-import { readFileSync } from 'node:fs'
-import { TodoistApi } from '@doist/todoist-sdk'
-import { config } from 'dotenv'
-import { addComments } from '../src/tools/add-comments.js'
-import { addFilters } from '../src/tools/add-filters.js'
-import { addLabels } from '../src/tools/add-labels.js'
-import { addProjects } from '../src/tools/add-projects.js'
-import { addSections } from '../src/tools/add-sections.js'
-import { addTasks } from '../src/tools/add-tasks.js'
-import { analyzeProjectHealth } from '../src/tools/analyze-project-health.js'
-import { completeTasks } from '../src/tools/complete-tasks.js'
-import { deleteObject } from '../src/tools/delete-object.js'
-import { fetchObject } from '../src/tools/fetch-object.js'
-import { fetch } from '../src/tools/fetch.js'
-import { findActivity } from '../src/tools/find-activity.js'
-import { findComments } from '../src/tools/find-comments.js'
-import { findCompletedTasks } from '../src/tools/find-completed-tasks.js'
-import { findFilters } from '../src/tools/find-filters.js'
-import { findLabels } from '../src/tools/find-labels.js'
-import { findProjectCollaborators } from '../src/tools/find-project-collaborators.js'
-import { findProjects } from '../src/tools/find-projects.js'
-import { findSections } from '../src/tools/find-sections.js'
-import { findTasksByDate } from '../src/tools/find-tasks-by-date.js'
-import { findTasks } from '../src/tools/find-tasks.js'
-import { getOverview } from '../src/tools/get-overview.js'
-import { getProjectActivityStats } from '../src/tools/get-project-activity-stats.js'
-import { getProjectHealth } from '../src/tools/get-project-health.js'
-import { getWorkspaceInsights } from '../src/tools/get-workspace-insights.js'
-import { listWorkspaces } from '../src/tools/list-workspaces.js'
-import { manageAssignments } from '../src/tools/manage-assignments.js'
-import { projectManagement } from '../src/tools/project-management.js'
-import { projectMove } from '../src/tools/project-move.js'
-import { reorderObjects } from '../src/tools/reorder-objects.js'
-import { rescheduleTasks } from '../src/tools/reschedule-tasks.js'
-import { search } from '../src/tools/search.js'
-import { uncompleteTasks } from '../src/tools/uncomplete-tasks.js'
-import { updateComments } from '../src/tools/update-comments.js'
-import { updateFilters } from '../src/tools/update-filters.js'
-import { updateLabels } from '../src/tools/update-labels.js'
-import { updateProjects } from '../src/tools/update-projects.js'
-import { updateSections } from '../src/tools/update-sections.js'
-import { updateTasks } from '../src/tools/update-tasks.js'
-import { userInfo } from '../src/tools/user-info.js'
-import { viewAttachment } from '../src/tools/view-attachment.js'
-import { createTodoistClient, runWithUsageTrackingContext } from '../src/usage-tracking.js'
-
-config()
-
-// Define a minimal type for tool execution that works with any tool
-type ExecutableTool = {
-    name: string
-    description: string
-    execute: (
-        // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- tools have varying parameter schemas
-        args: any,
-        client: TodoistApi,
-    ) => Promise<{ textContent?: string; structuredContent?: unknown; contentItems?: unknown[] }>
-}
-
-const tools: Record<string, ExecutableTool> = {
-    'add-tasks': addTasks,
-    'add-projects': addProjects,
-    'add-filters': addFilters,
-    'add-sections': addSections,
-    'add-comments': addComments,
-    'add-labels': addLabels,
-    'complete-tasks': completeTasks,
-    'uncomplete-tasks': uncompleteTasks,
-    'delete-object': deleteObject,
-    fetch: fetch,
-    'fetch-object': fetchObject,
-    'find-activity': findActivity,
-    'find-comments': findComments,
-    'find-filters': findFilters,
-    'find-completed-tasks': findCompletedTasks,
-    'find-labels': findLabels,
-    'find-project-collaborators': findProjectCollaborators,
-    'find-projects': findProjects,
-    'find-sections': findSections,
-    'find-tasks': findTasks,
-    'find-tasks-by-date': findTasksByDate,
-    'get-overview': getOverview,
-    'get-project-health': getProjectHealth,
-    'get-project-activity-stats': getProjectActivityStats,
-    'analyze-project-health': analyzeProjectHealth,
-    'get-workspace-insights': getWorkspaceInsights,
-    'list-workspaces': listWorkspaces,
-    'manage-assignments': manageAssignments,
-    'project-management': projectManagement,
-    'project-move': projectMove,
-    'reorder-objects': reorderObjects,
-    'reschedule-tasks': rescheduleTasks,
-    search: search,
-    'update-comments': updateComments,
-    'update-filters': updateFilters,
-    'update-labels': updateLabels,
-    'update-projects': updateProjects,
-    'update-sections': updateSections,
-    'update-tasks': updateTasks,
-    'user-info': userInfo,
-    'view-attachment': viewAttachment,
-}
-
-function printUsage() {
-    console.log(`
-Usage:
-  npx tsx scripts/run-tool.ts <tool-name> '<json-args>'
-  npx tsx scripts/run-tool.ts <tool-name> --file <args.json>
-  npx tsx scripts/run-tool.ts --list
-
-Available tools:
-${Object.keys(tools)
-    .sort()
-    .map((name) => `  - ${name}`)
-    .join('\n')}
-`)
-}
-
-async function main() {
-    const args = process.argv.slice(2)
-
-    if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
-        printUsage()
-        process.exit(0)
-    }
-
-    if (args[0] === '--list') {
-        console.log('Available tools:')
-        for (const name of Object.keys(tools).sort()) {
-            const tool = tools[name]
-            console.log(`\n${name}:`)
-            console.log(`  ${tool.description}`)
-        }
-        process.exit(0)
-    }
-
-    const toolName = args[0]
-    const tool = tools[toolName]
-
-    if (!tool) {
-        console.error(`Unknown tool: ${toolName}`)
-        console.error(`Available tools: ${Object.keys(tools).sort().join(', ')}`)
-        process.exit(1)
-    }
-
-    let jsonArgs: string
-    if (args[1] === '--file') {
-        if (!args[2]) {
-            console.error('--file requires a path argument')
-            process.exit(1)
-        }
-        jsonArgs = readFileSync(args[2], 'utf-8')
-    } else {
-        jsonArgs = args[1] || '{}'
-    }
-
-    let parsedArgs: unknown
-    try {
-        parsedArgs = JSON.parse(jsonArgs)
-    } catch (e) {
-        console.error('Invalid JSON args:', e)
-        process.exit(1)
-    }
-
-    const apiKey = process.env.TODOIST_API_KEY
-    if (!apiKey) {
-        console.error('TODOIST_API_KEY not found in environment or .env file')
-        process.exit(1)
-    }
-
-    const baseUrl = process.env.TODOIST_BASE_URL
-    const client = createTodoistClient(apiKey, {
-        baseUrl,
-        // Local direct runs are a dev helper, not real MCP traffic.
-        tracking: { enabled: false },
-    })
-
-    console.log(`Running ${toolName} with args:`)
-    console.log(JSON.stringify(parsedArgs, null, 2))
-    console.log('---')
-
-    try {
-        const result = await runWithUsageTrackingContext(tool.name, () =>
-            tool.execute(parsedArgs, client),
-        )
-
-        if (result.textContent) {
-            console.log('\nText output:')
-            console.log(result.textContent)
-        }
-
-        if (result.structuredContent) {
-            console.log('\nStructured output:')
-            console.log(JSON.stringify(result.structuredContent, null, 2))
-        }
-
-        if (result.contentItems?.length) {
-            console.log(`\nContent items: ${result.contentItems.length}`)
-            for (const item of result.contentItems) {
-                const entry = item as Record<string, unknown>
-                if (entry.type === 'image') {
-                    const data = entry.data as string
-                    console.log(
-                        `  [image] ${entry.mimeType} (${Math.round((data.length * 0.75) / 1024)}KB base64)`,
-                    )
-                } else if (entry.type === 'text') {
-                    const text = entry.text as string
-                    console.log(`  [text] ${text.length > 200 ? `${text.slice(0, 200)}...` : text}`)
-                } else if (entry.type === 'resource') {
-                    const resource = entry.resource as Record<string, unknown>
-                    const blob = resource.blob as string
-                    console.log(
-                        `  [resource] ${resource.mimeType} (${Math.round((blob.length * 0.75) / 1024)}KB base64)`,
-                    )
-                }
-            }
-        }
-    } catch (error) {
-        console.error('Tool execution failed:', error)
-        process.exit(1)
-    }
-}
-
-main()

package/scripts/test-executable.cjs

@@ -1,69 +0,0 @@
-#!/usr/bin/env node
-
-const { spawn } = require('node:child_process')
-const path = require('node:path')
-
-console.log('Testing MCP server executable...')
-
-const mainJs = path.join(__dirname, '..', 'dist', 'main.js')
-const child = spawn('node', [mainJs], {
-    stdio: ['pipe', 'pipe', 'pipe'],
-})
-
-let _stdoutOutput = ''
-let stderrOutput = ''
-let hasError = false
-
-child.stdout.on('data', (data) => {
-    _stdoutOutput += data.toString()
-})
-
-child.stderr.on('data', (data) => {
-    const output = data.toString()
-    stderrOutput += output
-
-    // Only consider it an error if it's not related to graceful shutdown
-    if (output.includes('Error:') && !output.includes('SIGTERM') && !output.includes('SIGKILL')) {
-        console.error('Server startup error detected:', output)
-        hasError = true
-    }
-})
-
-child.on('error', (error) => {
-    console.error('Failed to start MCP server:', error.message)
-    hasError = true
-    process.exit(1)
-})
-
-child.on('exit', (code, signal) => {
-    // Expected signals when we kill the process
-    if (signal === 'SIGTERM' || signal === 'SIGKILL') {
-        return // This is expected
-    }
-
-    // Unexpected exit codes during startup
-    if (code !== null && code !== 0) {
-        console.error(`Server exited unexpectedly with code ${code}`)
-        hasError = true
-    }
-})
-
-// Kill the process after 2 seconds (MCP server should start successfully)
-setTimeout(() => {
-    if (hasError) {
-        console.error('❌ MCP server failed to start properly')
-        if (stderrOutput.trim()) {
-            console.error('Error output:', stderrOutput.trim())
-        }
-        process.exit(1)
-    }
-
-    // Gracefully terminate
-    child.kill('SIGTERM')
-
-    setTimeout(() => {
-        console.log('✅ MCP server executable test passed')
-        console.log('Server started successfully and is ready to accept connections')
-        process.exit(0)
-    }, 200) // Give it a moment to clean up
-}, 2000)

package/scripts/validate-schemas.ts

@@ -1,284 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Schema Validation Script for Todoist AI MCP Server
- *
- * This script validates that all tool parameter schemas follow Gemini API compatibility rules.
- * Specifically, it checks that no Zod string schemas use both .nullable() and .optional().
- *
- * This version imports the actual tools from the compiled index.js and validates their
- * runtime Zod schemas for maximum accuracy.
- *
- * Usage:
- *   npm run build && node scripts/validate-schemas.js
- *   npm run build && node scripts/validate-schemas.js --verbose
- *   npm run build && node scripts/validate-schemas.js --json
- */
-
-import { z } from 'zod'
-
-type ValidationIssue = {
-    toolName: string
-    parameterPath: string
-    issue: string
-    suggestion: string
-}
-
-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: AnyZodSchema,
-    path: string,
-    issues: ValidationIssue[],
-    toolName: string,
-): void {
-    // Check for ZodOptional containing a ZodNullable 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,
-                    issue: 'GEMINI_API_INCOMPATIBLE: z.string().nullable().optional() pattern detected',
-                    suggestion:
-                        'REQUIRED FIX: Change "z.string().nullable().optional()" to "z.string().optional()" and use special strings like "remove" or "unassign" in description to handle clearing. This pattern causes HTTP 400 errors in Google Gemini API due to OpenAPI 3.1 nullable type incompatibility.',
-                })
-            }
-        }
-    }
-
-    // Check for ZodNullable containing a ZodOptional 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,
-                    issue: 'GEMINI_API_INCOMPATIBLE: z.string().optional().nullable() pattern detected',
-                    suggestion:
-                        'REQUIRED FIX: Change "z.string().optional().nullable()" to "z.string().optional()" and use special strings like "remove" or "unassign" in description to handle clearing. This pattern causes HTTP 400 errors in Google Gemini API due to OpenAPI 3.1 nullable type incompatibility.',
-                })
-            }
-        }
-    }
-
-    // Recursively check nested schemas
-    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)
-        }
-    } 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
- */
-function validateToolSchema(tool: {
-    name?: string
-    parameters?: Record<string, z.ZodTypeAny>
-}): ValidationIssue[] {
-    const issues: ValidationIssue[] = []
-    const toolName = tool.name || 'unknown'
-
-    if (!tool.parameters) {
-        return issues
-    }
-
-    try {
-        const schema = z.object(tool.parameters)
-        walkZodSchema(schema, '', issues, toolName)
-    } catch (error) {
-        issues.push({
-            toolName,
-            parameterPath: 'root',
-            issue: `Failed to analyze schema: ${error}`,
-            suggestion: 'Check that the tool parameters are valid Zod schemas',
-        })
-    }
-
-    return issues
-}
-
-/**
- * Main validation function using runtime schema analysis
- */
-async function validateAllSchemas(verbose: boolean = false): Promise<ValidationResult> {
-    try {
-        const { tools } = await import(`${process.cwd()}/dist/index.js`)
-
-        const allIssues: ValidationIssue[] = []
-        let totalParameters = 0
-        const toolNames = Object.keys(tools)
-
-        for (const toolName of toolNames) {
-            const tool = tools[toolName]
-            const toolIssues = validateToolSchema(tool)
-            allIssues.push(...toolIssues)
-
-            // Count parameters for stats
-            if (tool.parameters) {
-                try {
-                    const schema = z.object(tool.parameters)
-                    const shape = schema.shape
-                    if (shape) {
-                        totalParameters += Object.keys(shape).length
-                    }
-                } catch {
-                    // Skip counting if schema is invalid
-                }
-            }
-
-            if (verbose) {
-                const issueCount = toolIssues.length
-                const status = issueCount === 0 ? '✅' : `❌ (${issueCount} issues)`
-                const paramCount = tool.parameters ? Object.keys(tool.parameters).length : 0
-                console.log(`${status} ${toolName} (${paramCount} parameters)`)
-
-                if (issueCount > 0) {
-                    toolIssues.forEach((issue) => {
-                        console.log(`    ${issue.parameterPath}: ${issue.issue}`)
-                    })
-                }
-            }
-        }
-
-        return {
-            success: allIssues.length === 0,
-            issues: allIssues,
-            toolsChecked: toolNames.length,
-            parametersChecked: totalParameters,
-        }
-    } catch (error) {
-        return {
-            success: false,
-            issues: [
-                {
-                    toolName: 'system',
-                    parameterPath: 'import',
-                    issue: `Failed to import tools: ${error}`,
-                    suggestion: 'Ensure the project is built and dist/index.js exists',
-                },
-            ],
-            toolsChecked: 0,
-            parametersChecked: 0,
-        }
-    }
-}
-
-/**
- * CLI interface
- */
-async function main() {
-    const args = process.argv.slice(2)
-    const verbose = args.includes('--verbose')
-    const jsonOutput = args.includes('--json')
-
-    try {
-        const result = await validateAllSchemas(verbose)
-
-        if (jsonOutput) {
-            console.log(JSON.stringify(result, null, 2))
-        } else {
-            if (result.success) {
-                console.log('✅ Schema validation passed!')
-                console.log(
-                    `   Checked ${result.toolsChecked} tools with ${result.parametersChecked} parameters`,
-                )
-                console.log(
-                    '   All schemas are Gemini API compatible (no .nullable() on optional strings)',
-                )
-            } else {
-                console.log('❌ Schema validation failed!')
-                console.log(
-                    `   Found ${result.issues.length} issue(s) in ${result.toolsChecked} tools:\n`,
-                )
-
-                result.issues.forEach((issue, index) => {
-                    console.log(`\n${index + 1}. 🚫 VALIDATION FAILURE`)
-                    console.log(`   Tool: ${issue.toolName}`)
-                    console.log(`   Parameter: ${issue.parameterPath}`)
-                    console.log(`   Issue: ${issue.issue}`)
-                    console.log(`   Action Required: ${issue.suggestion}`)
-                    console.log(`   File Location: src/tools/${issue.toolName}.ts`)
-                    console.log(`   Fix Pattern: Remove .nullable() from the parameter schema`)
-                    console.log(
-                        `   Example Fix: Change z.string().nullable().optional() → z.string().optional()`,
-                    )
-                    console.log(
-                        `   ⚠️  This validation failure will cause Gemini API HTTP 400 errors\n`,
-                    )
-                })
-            }
-        }
-
-        process.exit(result.success ? 0 : 1)
-    } catch (error) {
-        console.error('Fatal error during schema validation:', error)
-        process.exit(1)
-    }
-}
-
-// Run if this script is executed directly
-if (
-    process.argv[1]?.endsWith('validate-schemas.ts') ||
-    process.argv[1]?.endsWith('validate-schemas.js')
-) {
-    main()
-}
-
-export type { ValidationIssue, ValidationResult }
-export { validateAllSchemas }