wave-agent-sdk 0.5.0 → 0.6.2

package/dist/tools/todoWriteTool.js

@@ -1,220 +0,0 @@
-import { TODO_WRITE_TOOL_NAME } from "../constants/tools.js";
-/**
- * TodoWrite tool for creating and managing structured task lists
- */
-export const todoWriteTool = {
-    name: TODO_WRITE_TOOL_NAME,
-    config: {
-        type: "function",
-        function: {
-            name: TODO_WRITE_TOOL_NAME,
-            description: `Use this tool to create and manage a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
-It also helps the user understand the progress of the task and overall progress of their requests.
-
-## When to Use This Tool
-Use this tool proactively in these scenarios:
-
-1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
-2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
-3. User explicitly requests todo list - When the user directly asks you to use the todo list
-4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
-5. After receiving new instructions - Immediately capture user requirements as todos
-6. When you start working on a task - Mark it as in_progress BEFORE beginning work. Ideally you should only have one todo as in_progress at a time
-7. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
-
-## When NOT to Use This Tool
-
-Skip using this tool when:
-1. There is only a single, straightforward task
-2. The task is trivial and tracking it provides no organizational benefit
-3. The task can be completed in less than 3 trivial steps
-4. The task is purely conversational or informational
-
-NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.
-
-## Task States and Management
-
-1. **Task States**: Use these states to track progress:
-   - pending: Task not yet started
-   - in_progress: Currently working on (limit to ONE task at a time)
-   - completed: Task finished successfully
-
-2. **Task Management**:
-   - Update task status in real-time as you work
-   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
-   - Only have ONE task in_progress at any time
-   - Complete current tasks before starting new ones
-   - Remove tasks that are no longer relevant from the list entirely
-
-3. **Task Completion Requirements**:
-   - ONLY mark a task as completed when you have FULLY accomplished it
-   - If you encounter errors, blockers, or cannot finish, keep the task as in_progress
-   - When blocked, create a new task describing what needs to be resolved
-   - Never mark a task as completed if:
-     - Tests are failing
-     - Implementation is partial
-     - You encountered unresolved errors
-     - You couldn't find necessary files or dependencies
-
-4. **Task Breakdown**:
-   - Create specific, actionable items
-   - Break complex tasks into smaller, manageable steps
-   - Use clear, descriptive task names
-
-When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully.`,
-            parameters: {
-                type: "object",
-                properties: {
-                    todos: {
-                        type: "array",
-                        items: {
-                            type: "object",
-                            properties: {
-                                content: {
-                                    type: "string",
-                                    minLength: 1,
-                                },
-                                status: {
-                                    type: "string",
-                                    enum: ["pending", "in_progress", "completed"],
-                                },
-                                id: {
-                                    type: "string",
-                                },
-                            },
-                            required: ["content", "status", "id"],
-                            additionalProperties: false,
-                        },
-                        description: "The updated todo list",
-                    },
-                },
-                required: ["todos"],
-                additionalProperties: false,
-            },
-        },
-    },
-    formatCompactParams: (params, context) => {
-        void context; // Context not needed for this tool
-        try {
-            const { todos } = params;
-            // Handle invalid or missing tasks array
-            if (!todos || !Array.isArray(todos)) {
-                return "invalid todos";
-            }
-            // Handle empty task list
-            if (todos.length === 0) {
-                return "0 tasks";
-            }
-            // Count completed tasks
-            const completedCount = todos.filter((todo) => todo && todo.status === "completed").length;
-            const totalCount = todos.length;
-            // Format with proper singular/plural
-            const taskWord = totalCount === 1 ? "task" : "tasks";
-            return `${completedCount}/${totalCount} ${taskWord}`;
-        }
-        catch {
-            return "invalid todos";
-        }
-    },
-    execute: async (args) => {
-        try {
-            // Validate arguments
-            const { todos } = args;
-            if (!todos || !Array.isArray(todos)) {
-                return {
-                    success: false,
-                    content: "",
-                    error: "todos parameter must be an array",
-                    shortResult: "Invalid todos format",
-                };
-            }
-            // Validate each task item
-            for (const [index, todo] of todos.entries()) {
-                if (!todo || typeof todo !== "object") {
-                    return {
-                        success: false,
-                        content: "",
-                        error: `Todo item at index ${index} must be an object`,
-                        shortResult: "Invalid todo item",
-                    };
-                }
-                if (!todo.content ||
-                    typeof todo.content !== "string" ||
-                    todo.content.trim().length === 0) {
-                    return {
-                        success: false,
-                        content: "",
-                        error: `Todo item at index ${index} must have non-empty content`,
-                        shortResult: "Invalid todo content",
-                    };
-                }
-                if (!["pending", "in_progress", "completed"].includes(todo.status)) {
-                    return {
-                        success: false,
-                        content: "",
-                        error: `Todo item at index ${index} has invalid status: ${todo.status}`,
-                        shortResult: "Invalid todo status",
-                    };
-                }
-                if (!todo.id ||
-                    typeof todo.id !== "string" ||
-                    todo.id.trim().length === 0) {
-                    return {
-                        success: false,
-                        content: "",
-                        error: `Todo item at index ${index} must have a non-empty id`,
-                        shortResult: "Invalid todo id",
-                    };
-                }
-            }
-            // Check for duplicate IDs
-            const ids = todos.map((todo) => todo.id);
-            const duplicateIds = ids.filter((id, index) => ids.indexOf(id) !== index);
-            if (duplicateIds.length > 0) {
-                return {
-                    success: false,
-                    content: "",
-                    error: `Duplicate todo IDs found: ${duplicateIds.join(", ")}`,
-                    shortResult: "Duplicate todo IDs",
-                };
-            }
-            // Check that only one task is in_progress
-            const inProgressTodos = todos.filter((todo) => todo.status === "in_progress");
-            if (inProgressTodos.length > 1) {
-                return {
-                    success: false,
-                    content: "",
-                    error: `Only one todo can be in_progress at a time. Found ${inProgressTodos.length} in_progress todos`,
-                    shortResult: "Multiple in_progress todos",
-                };
-            }
-            const completedCount = todos.filter((t) => t.status === "completed").length;
-            const totalCount = todos.length;
-            let shortResult = `${completedCount}/${totalCount} done`;
-            if (totalCount > 0) {
-                const symbols = {
-                    pending: "[ ]",
-                    in_progress: "[>]",
-                    completed: "[x]",
-                };
-                // Show all todos in the shortResult
-                for (const todo of todos) {
-                    shortResult += `\n${symbols[todo.status]} ${todo.content}`;
-                }
-            }
-            return {
-                success: true,
-                content: `Todo list updated: ${completedCount}/${totalCount} completed`,
-                shortResult: shortResult,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                content: "",
-                error: error instanceof Error ? error.message : String(error),
-                shortResult: "Todo list update failed",
-            };
-        }
-    },
-};

package/src/constants/prompts.ts

@@ -1,155 +0,0 @@
-import {
-  ASK_USER_QUESTION_TOOL_NAME,
-  BASH_TOOL_NAME,
-  EDIT_TOOL_NAME,
-  GLOB_TOOL_NAME,
-  GREP_TOOL_NAME,
-  LS_TOOL_NAME,
-  MULTI_EDIT_TOOL_NAME,
-  READ_TOOL_NAME,
-  TASK_TOOL_NAME,
-  TODO_WRITE_TOOL_NAME,
-  WRITE_TOOL_NAME,
-} from "./tools.js";
-
-export const BASE_SYSTEM_PROMPT = `You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
-
-# Doing tasks
-The user will primarily request you perform software engineering tasks. This includes solving bugs, adding new functionality, refactoring code, explaining code, and more. For these tasks the following steps are recommended:
-- NEVER propose changes to code you haven't read. If a user asks about or wants you to modify a file, read it first. Understand existing code before suggesting modifications.
-- Be careful not to introduce security vulnerabilities such as command injection, XSS, SQL injection, and other OWASP top 10 vulnerabilities. If you notice that you wrote insecure code, immediately fix it.
-- Avoid over-engineering. Only make changes that are directly requested or clearly necessary. Keep solutions simple and focused.
-  - Don't add features, refactor code, or make "improvements" beyond what was asked. A bug fix doesn't need surrounding code cleaned up. A simple feature doesn't need extra configurability. Don't add docstrings, comments, or type annotations to code you didn't change. Only add comments where the logic isn't self-evident.
-  - Don't add error handling, fallbacks, or validation for scenarios that can't happen. Trust internal code and framework guarantees. Only validate at system boundaries (user input, external APIs). Don't use feature flags or backwards-compatibility shims when you can just change the code.
-  - Don't create helpers, utilities, or abstractions for one-time operations. Don't design for hypothetical future requirements. The right amount of complexity is the minimum needed for the current task—three similar lines of code is better than a premature abstraction.
-- Avoid backwards-compatibility hacks like renaming unused \`_vars\`, re-exporting types, adding \`// removed\` comments for removed code, etc. If something is unused, delete it completely.
-
-# Tool usage policy
-- You can call multiple tools in a single response. If you intend to call multiple tools and there are no dependencies between them, make all independent tool calls in parallel. Maximize use of parallel tool calls where possible to increase efficiency.
-- However, if some tool calls depend on previous calls to inform dependent values, do NOT call these tools in parallel and instead call them sequentially. For instance, if one operation must complete before another starts, run these operations sequentially instead. Never use placeholders or guess missing parameters in tool calls.
-- If the user specifies that they want you to run tools "in parallel", you MUST send a single message with multiple tool use content blocks.`;
-
-export const TASK_MANAGEMENT_POLICY = `
-# Task Management
-You have access to the ${TODO_WRITE_TOOL_NAME} tools to help you manage and plan tasks. Use these tools VERY frequently to ensure that you are tracking your tasks and giving the user visibility into your progress.
-These tools are also EXTREMELY helpful for planning tasks, and for breaking down larger complex tasks into smaller steps. If you do not use this tool when planning, you may forget to do important tasks - and that is unacceptable.
-It is critical that you mark todos as completed as soon as you are done with a task. Do not batch up multiple tasks before marking them as completed.`;
-
-export const ASK_USER_POLICY = `
-# Asking questions as you work
-You have access to the ${ASK_USER_QUESTION_TOOL_NAME} tool to ask the user questions when you need clarification, want to validate assumptions, or need to make a decision you're unsure about. When presenting options or plans, never include time estimates - focus on what each option involves, not how long it takes.`;
-
-export const SUBAGENT_POLICY = `
-- When doing file search, prefer to use the ${TASK_TOOL_NAME} tool in order to reduce context usage.
-- You should proactively use the ${TASK_TOOL_NAME} tool with specialized agents when the task at hand matches the agent's description.
-- VERY IMPORTANT: When exploring the codebase to gather context or to answer a question that is not a needle query for a specific file/class/function, it is CRITICAL that you use the ${TASK_TOOL_NAME} tool with subagent_type=Explore instead of running search commands directly.`;
-
-export const FILE_TOOL_POLICY_PREFIX = `\n- Use specialized tools instead of bash commands when possible, as this provides a better user experience. For file operations, use dedicated tools:`;
-export const READ_FILE_POLICY = ` ${READ_TOOL_NAME} for reading files instead of cat/head/tail`;
-export const EDIT_FILE_POLICY = ` ${EDIT_TOOL_NAME}/${MULTI_EDIT_TOOL_NAME} for editing instead of sed/awk`;
-export const WRITE_FILE_POLICY = ` ${WRITE_TOOL_NAME} for creating files instead of cat with heredoc or echo redirection`;
-export const SEARCH_FILE_POLICY = ` ${LS_TOOL_NAME}/${GLOB_TOOL_NAME}/${GREP_TOOL_NAME} for searching and listing files instead of find/ls/grep`;
-
-export const BASH_POLICY = `
-- Reserve bash tools exclusively for actual system commands and terminal operations that require shell execution. NEVER use bash echo or other command-line tools to communicate thoughts, explanations, or instructions to the user. Output all communication directly in your response text instead.
-- When making multiple bash tool calls, you MUST send a single message with multiple tools calls to run the calls in parallel. For example, if you need to run "git status" and "git diff", send a single message with two tool calls to run the calls in parallel.`;
-
-export const DEFAULT_SYSTEM_PROMPT = BASE_SYSTEM_PROMPT;
-
-export const GENERAL_PURPOSE_SYSTEM_PROMPT = `You are an agent. Given the user's message, you should use the tools available to complete the task. Do what has been asked; nothing more, nothing less. When you complete the task simply respond with a detailed writeup.
-
-Your strengths:
-- Searching for code, configurations, and patterns across large codebases
-- Analyzing multiple files to understand system architecture
-- Investigating complex questions that require exploring many files
-- Performing multi-step research tasks
-
-Guidelines:
-- For file searches: Use Grep or Glob when you need to search broadly. Use Read when you know the specific file path.
-- For analysis: Start broad and narrow down. Use multiple search strategies if the first doesn't yield results.
-- Be thorough: Check multiple locations, consider different naming conventions, look for related files.
-- NEVER create files unless they're absolutely necessary for achieving your goal. ALWAYS prefer editing an existing file to creating a new one.
-- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested.
-- In your final response always share relevant file names and code snippets. Any file paths you return in your response MUST be absolute. Do NOT use relative paths.
-- For clear communication, avoid using emojis.`;
-
-export const INIT_PROMPT = `Please analyze this codebase and create a AGENTS.md file, which will be given to future instances of Agent to operate in this repository.
-
-What to add:
-1. Commands that will be commonly used, such as how to build, lint, and run tests. Include the necessary commands to develop in this codebase, such as how to run a single test.
-2. High-level code architecture and structure so that future instances can be productive more quickly. Focus on the "big picture" architecture that requires reading multiple files to understand.
-
-Usage notes:
-- If there's already a AGENTS.md, suggest improvements to it.
-- When you make the initial AGENTS.md, do not repeat yourself and do not include obvious instructions like "Provide helpful error messages to users", "Write unit tests for all new utilities", "Never include sensitive information (API keys, tokens) in code or commits".
-- Avoid listing every component or file structure that can be easily discovered.
-- Don't include generic development practices.
-- If there are Cursor rules (in .cursor/rules/ or .cursorrules) or Copilot rules (in .github/copilot-instructions.md), make sure to include the important parts.
-- If there is a README.md, make sure to include the important parts.
-- Do not make up information such as "Common Development Tasks", "Tips for Development", "Support and Documentation" unless this is expressly included in other files that you read.
-- Be sure to prefix the file with the following text:
-
-\`\`\`
-# AGENTS.md
-
-This file provides guidance to Agent when working with code in this repository.
-\`\`\``;
-
-export function buildSystemPrompt(
-  basePrompt: string,
-  tools: { name?: string; function?: { name: string } }[],
-): string {
-  let prompt = basePrompt;
-  const toolNames = new Set(
-    tools.map((t) => t.function?.name || t.name).filter(Boolean),
-  );
-
-  if (toolNames.has(TODO_WRITE_TOOL_NAME)) {
-    prompt += TASK_MANAGEMENT_POLICY;
-  }
-  if (toolNames.has(ASK_USER_QUESTION_TOOL_NAME)) {
-    prompt += ASK_USER_POLICY;
-  }
-
-  if (toolNames.has(TASK_TOOL_NAME)) {
-    prompt += SUBAGENT_POLICY;
-  }
-
-  if (
-    toolNames.has(READ_TOOL_NAME) ||
-    toolNames.has(EDIT_TOOL_NAME) ||
-    toolNames.has(MULTI_EDIT_TOOL_NAME) ||
-    toolNames.has(WRITE_TOOL_NAME) ||
-    toolNames.has(LS_TOOL_NAME) ||
-    toolNames.has(GLOB_TOOL_NAME) ||
-    toolNames.has(GREP_TOOL_NAME)
-  ) {
-    const parts: string[] = [];
-    if (toolNames.has(READ_TOOL_NAME)) {
-      parts.push(READ_FILE_POLICY);
-    }
-    if (toolNames.has(EDIT_TOOL_NAME) || toolNames.has(MULTI_EDIT_TOOL_NAME)) {
-      parts.push(EDIT_FILE_POLICY);
-    }
-    if (toolNames.has(WRITE_TOOL_NAME)) {
-      parts.push(WRITE_FILE_POLICY);
-    }
-    if (
-      toolNames.has(LS_TOOL_NAME) ||
-      toolNames.has(GLOB_TOOL_NAME) ||
-      toolNames.has(GREP_TOOL_NAME)
-    ) {
-      parts.push(SEARCH_FILE_POLICY);
-    }
-
-    if (parts.length > 0) {
-      prompt += FILE_TOOL_POLICY_PREFIX + parts.join(",") + ".";
-    }
-  }
-
-  if (toolNames.has(BASH_TOOL_NAME)) {
-    prompt += BASH_POLICY;
-  }
-
-  return prompt;
-}

package/src/tools/todoWriteTool.ts

@@ -1,257 +0,0 @@
-import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
-import { TODO_WRITE_TOOL_NAME } from "../constants/tools.js";
-
-interface TodoItem {
-  content: string;
-  status: "pending" | "in_progress" | "completed";
-  id: string;
-}
-
-/**
- * TodoWrite tool for creating and managing structured task lists
- */
-export const todoWriteTool: ToolPlugin = {
-  name: TODO_WRITE_TOOL_NAME,
-  config: {
-    type: "function",
-    function: {
-      name: TODO_WRITE_TOOL_NAME,
-      description: `Use this tool to create and manage a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
-It also helps the user understand the progress of the task and overall progress of their requests.
-
-## When to Use This Tool
-Use this tool proactively in these scenarios:
-
-1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
-2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
-3. User explicitly requests todo list - When the user directly asks you to use the todo list
-4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
-5. After receiving new instructions - Immediately capture user requirements as todos
-6. When you start working on a task - Mark it as in_progress BEFORE beginning work. Ideally you should only have one todo as in_progress at a time
-7. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
-
-## When NOT to Use This Tool
-
-Skip using this tool when:
-1. There is only a single, straightforward task
-2. The task is trivial and tracking it provides no organizational benefit
-3. The task can be completed in less than 3 trivial steps
-4. The task is purely conversational or informational
-
-NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.
-
-## Task States and Management
-
-1. **Task States**: Use these states to track progress:
-   - pending: Task not yet started
-   - in_progress: Currently working on (limit to ONE task at a time)
-   - completed: Task finished successfully
-
-2. **Task Management**:
-   - Update task status in real-time as you work
-   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
-   - Only have ONE task in_progress at any time
-   - Complete current tasks before starting new ones
-   - Remove tasks that are no longer relevant from the list entirely
-
-3. **Task Completion Requirements**:
-   - ONLY mark a task as completed when you have FULLY accomplished it
-   - If you encounter errors, blockers, or cannot finish, keep the task as in_progress
-   - When blocked, create a new task describing what needs to be resolved
-   - Never mark a task as completed if:
-     - Tests are failing
-     - Implementation is partial
-     - You encountered unresolved errors
-     - You couldn't find necessary files or dependencies
-
-4. **Task Breakdown**:
-   - Create specific, actionable items
-   - Break complex tasks into smaller, manageable steps
-   - Use clear, descriptive task names
-
-When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully.`,
-      parameters: {
-        type: "object",
-        properties: {
-          todos: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                content: {
-                  type: "string",
-                  minLength: 1,
-                },
-                status: {
-                  type: "string",
-                  enum: ["pending", "in_progress", "completed"],
-                },
-                id: {
-                  type: "string",
-                },
-              },
-              required: ["content", "status", "id"],
-              additionalProperties: false,
-            },
-            description: "The updated todo list",
-          },
-        },
-        required: ["todos"],
-        additionalProperties: false,
-      },
-    },
-  },
-
-  formatCompactParams: (
-    params: Record<string, unknown>,
-    context: ToolContext,
-  ) => {
-    void context; // Context not needed for this tool
-    try {
-      const { todos } = params as { todos?: TodoItem[] };
-
-      // Handle invalid or missing tasks array
-      if (!todos || !Array.isArray(todos)) {
-        return "invalid todos";
-      }
-
-      // Handle empty task list
-      if (todos.length === 0) {
-        return "0 tasks";
-      }
-
-      // Count completed tasks
-      const completedCount = todos.filter(
-        (todo) => todo && todo.status === "completed",
-      ).length;
-      const totalCount = todos.length;
-
-      // Format with proper singular/plural
-      const taskWord = totalCount === 1 ? "task" : "tasks";
-      return `${completedCount}/${totalCount} ${taskWord}`;
-    } catch {
-      return "invalid todos";
-    }
-  },
-
-  execute: async (args: Record<string, unknown>): Promise<ToolResult> => {
-    try {
-      // Validate arguments
-      const { todos } = args as { todos?: TodoItem[] };
-
-      if (!todos || !Array.isArray(todos)) {
-        return {
-          success: false,
-          content: "",
-          error: "todos parameter must be an array",
-          shortResult: "Invalid todos format",
-        };
-      }
-
-      // Validate each task item
-      for (const [index, todo] of todos.entries()) {
-        if (!todo || typeof todo !== "object") {
-          return {
-            success: false,
-            content: "",
-            error: `Todo item at index ${index} must be an object`,
-            shortResult: "Invalid todo item",
-          };
-        }
-
-        if (
-          !todo.content ||
-          typeof todo.content !== "string" ||
-          todo.content.trim().length === 0
-        ) {
-          return {
-            success: false,
-            content: "",
-            error: `Todo item at index ${index} must have non-empty content`,
-            shortResult: "Invalid todo content",
-          };
-        }
-
-        if (!["pending", "in_progress", "completed"].includes(todo.status)) {
-          return {
-            success: false,
-            content: "",
-            error: `Todo item at index ${index} has invalid status: ${todo.status}`,
-            shortResult: "Invalid todo status",
-          };
-        }
-
-        if (
-          !todo.id ||
-          typeof todo.id !== "string" ||
-          todo.id.trim().length === 0
-        ) {
-          return {
-            success: false,
-            content: "",
-            error: `Todo item at index ${index} must have a non-empty id`,
-            shortResult: "Invalid todo id",
-          };
-        }
-      }
-
-      // Check for duplicate IDs
-      const ids = todos.map((todo) => todo.id);
-      const duplicateIds = ids.filter((id, index) => ids.indexOf(id) !== index);
-      if (duplicateIds.length > 0) {
-        return {
-          success: false,
-          content: "",
-          error: `Duplicate todo IDs found: ${duplicateIds.join(", ")}`,
-          shortResult: "Duplicate todo IDs",
-        };
-      }
-
-      // Check that only one task is in_progress
-      const inProgressTodos = todos.filter(
-        (todo) => todo.status === "in_progress",
-      );
-      if (inProgressTodos.length > 1) {
-        return {
-          success: false,
-          content: "",
-          error: `Only one todo can be in_progress at a time. Found ${inProgressTodos.length} in_progress todos`,
-          shortResult: "Multiple in_progress todos",
-        };
-      }
-
-      const completedCount = todos.filter(
-        (t) => t.status === "completed",
-      ).length;
-      const totalCount = todos.length;
-
-      let shortResult = `${completedCount}/${totalCount} done`;
-
-      if (totalCount > 0) {
-        const symbols = {
-          pending: "[ ]",
-          in_progress: "[>]",
-          completed: "[x]",
-        };
-
-        // Show all todos in the shortResult
-        for (const todo of todos) {
-          shortResult += `\n${symbols[todo.status]} ${todo.content}`;
-        }
-      }
-
-      return {
-        success: true,
-        content: `Todo list updated: ${completedCount}/${totalCount} completed`,
-        shortResult: shortResult,
-      };
-    } catch (error) {
-      return {
-        success: false,
-        content: "",
-        error: error instanceof Error ? error.message : String(error),
-        shortResult: "Todo list update failed",
-      };
-    }
-  },
-};