mcp-taskflow 0.1.0

package/dist/prompts/templates/v1/templates_en/initProjectRules/index.md

@@ -0,0 +1,81 @@
+Please use the "process_thought" tool to consider the following issues
+
+# Project Standards Initialization Guide
+
+## Purpose
+
+**This document is specifically designed for AI Agents, not for general developer documentation.**
+**Must generate a project standards document (taskflow-rules.md) exclusively for AI Agent operational use.**
+
+**Must focus on the following key objectives:**
+
+- Clearly define project-specific rules and limitations, prohibit inclusion of general development knowledge
+- Provide project-specific information needed for AI to execute tasks
+- Provide clear guidance for AI decision-making processes
+
+**Mandatory requirements:**
+
+- Completed standards must enable AI Agents to immediately understand which files must be referenced or modified
+- Clearly indicate multi-file coordination requirements (e.g., when modifying README.md, /docs/zh/README.md must be updated simultaneously)
+- Use imperative language to define rules, avoid explanatory content
+- Do not explain project functionality, but rather how to modify or add functionality
+- Please provide examples of what can be done and what cannot be done
+- Must **recursively** check all folders and files
+
+**Strictly prohibited:**
+
+- Including general development knowledge
+- Including general development knowledge already known to LLMs
+- Explaining project functionality
+
+## Suggested Structure
+
+Please use the following structure to create the standards document:
+
+```markdown
+# Development Guidelines
+
+## Title
+
+### Subtitle
+
+- Rule one
+- Rule two
+```
+
+## Content Guidelines
+
+The standards document should include but not be limited to the following:
+
+1. **Project Overview** - Brief description of the project's purpose, technology stack, and core functionality
+2. **Project Architecture** - Description of main directory structure and module divisions
+3. **Code Standards** - Including naming conventions, formatting requirements, comment rules, etc.
+4. **Functionality Implementation Standards** - Mainly explaining how to implement functionality and points to note
+5. **Framework/Plugin/Third-party Library Usage Standards** - Usage standards for external dependencies
+6. **Workflow Standards** - Workflow guidelines, including workflow diagrams or data flow
+7. **Key File Interaction Standards** - Interaction standards for key files, which files need to be modified simultaneously
+8. **AI Decision-making Standards** - Provide decision trees and priority judgment criteria for handling ambiguous situations
+9. **Prohibited Actions** - Clearly list practices that are prohibited
+
+## Notes
+
+1. **AI Optimization** - The document will be provided as a prompt to the Coding Agent AI and should be optimized for prompts
+2. **Focus on Development Guidance** - Provide rules for ongoing development, not usage tutorials
+3. **Specific Examples** - Provide specific examples of "what should be done" and "what should not be done" whenever possible
+4. **Use Imperative Language** - Must use direct instructions rather than descriptive language, reduce explanatory content
+5. **Structured Presentation** - All content must be presented in structured formats such as lists, tables, etc., for easy AI parsing
+6. **Highlight Key Markings** - Use bold, warning markers, etc. to highlight key rules and taboos
+7. **Remove General Knowledge** - Prohibit including general development knowledge already known to LLMs, only include project-specific rules
+
+## Update Mode Guidelines
+
+1. **Minimal Changes** - When users request updates to project rules, you should maintain existing rules unless necessary, with the principle of minimal changes
+2. **Timeliness** - You should check if existing rules are still beneficial or outdated, as users may have modified or removed relevant code, you must correct or remove corresponding rules
+3. **Completeness** - You should check all folders and file contents in the existing project, as users may have added or modified relevant code, you must supplement corresponding rules
+4. **Autonomous Handling of Ambiguous Requests**: When receiving ambiguous instructions such as "update rules" without specifying concrete content, the AI **must** first attempt to independently analyze the current codebase, recent changes (if available), and existing `taskflow-rules.md` content to infer possible update points. List these inferred points and their rationale during the `process_thought` phase, then propose specific modification suggestions. **Strictly prohibited** from seeking clarification from users on ambiguous update requests before performing this autonomous analysis.
+
+Based on the above guidelines, create a file named taskflow-rules.md and save it in the project root directory
+
+**[AI Agent Action]** Now start calling the "process_thought" tool to think about how to write standards document that guides the Coding Agent
+**[AI Agent Action]** After completing the thought process, immediately edit the taskflow-rules.md file, prohibited from calling the "analyze_task" tool
+**[AI Agent Action]** Strictly forbidden not to call tools. The AI must independently complete the entire process from receiving instructions to implementing modifications, and should not interrupt the process to seek user input unless encountering technical errors or unresolvable dependency conflicts.

package/dist/prompts/templates/v1/templates_en/listTasks/index.md

@@ -0,0 +1,7 @@
+# Task Management Dashboard
+
+## Task Status Overview
+
+{statusCount}
+
+{taskDetailsTemplate}

package/dist/prompts/templates/v1/templates_en/listTasks/notFound.md

@@ -0,0 +1,3 @@
+# System Notification
+
+There are currently no {statusText} tasks in the system. Please query other status tasks or first use the "split_tasks" tool to create task structures before proceeding with subsequent operations.

package/dist/prompts/templates/v1/templates_en/listTasks/taskDetails.md

@@ -0,0 +1,13 @@
+### {name}
+
+**ID:** `{id}`
+
+**Description:** {description}
+
+{complatedSummary}
+
+**Dependencies:** {dependencies}
+
+**Creation Time:** {createAt}
+
+{complatedAt}

package/dist/prompts/templates/v1/templates_en/planTask/hasThought.md

@@ -0,0 +1,4 @@
+**Step Two: Must forcibly use "process_thought" to think about the answer (prohibited from directly using analyze_task)**
+
+1. **Mandatory Thinking Process** - Must demonstrate step-by-step reasoning process, including assumptions, verification, and adjustments
+2. Warning: Must first use the "process_thought" tool to think, strictly prohibited from directly using analyze_task or answering directly

package/dist/prompts/templates/v1/templates_en/planTask/index.md

@@ -0,0 +1,96 @@
+## Task Analysis
+
+You must complete the following sub-steps in sequence, and at the end call the `analyze_task` tool to pass the preliminary design solution to the next stage.
+
+1. **Analysis Purpose**
+
+   - Read and understand:
+     ```
+     Task Description: {description}
+     Task Requirements and Constraints: {requirements}
+     {tasksTemplate}
+     ```
+   - Confirm:
+     - Task objectives and expected outcomes
+     - Technical challenges and key decision points
+     - Integration requirements with existing systems/architecture
+
+2. **Identify Project Architecture**
+
+   - View key configuration files and structures:
+     - Examine root directory structure and important configuration files (package.json, tsconfig.json, etc.)
+     - If taskflow-rules.md exists at `{rulesPath}`, please read and refer to it in detail
+     - Check project memory directory at `{memoryDir}` for existing context
+     - Analyze main directory organization and module divisions
+   - Identify architectural patterns:
+     - Identify core design patterns and architectural styles (MVC, MVVM, microservices, etc.)
+     - Determine the project's layered structure and module boundaries
+   - Analyze core components:
+     - Research main class/interface designs and dependencies
+     - Mark key services/utility classes and their responsibilities and uses
+   - Document existing patterns:
+     - Document discovered code organization methods and architectural regularities
+     - Establish deep understanding of the project's technology stack and architectural characteristics
+
+3. **Collect Information**  
+   If there is any uncertainty or lack of confidence, **must do one of the following**:
+
+   - Ask the user for clarification
+   - Use `query_task`, `read_file`, `codebase_search` or other similar tools to query existing programs/architecture
+   - Use `web_search` or other web search tools to query unfamiliar concepts or technologies  
+     Speculation is prohibited; all information must have traceable sources.
+
+4. **Check Existing Programs and Structures**
+
+   - Use precise search strategies:
+     - Use `read_file`, `codebase_search` or other similar tools to query existing implementation methods related to the task
+     - Look for existing code with functionality similar to the current task
+     - Analyze directory structure to find similar functional modules
+   - Analyze code style and conventions:
+     - Check naming conventions of existing components (camelCase, snake_case, etc.)
+     - Confirm comment styles and format conventions
+     - Analyze error handling patterns and logging methods
+   - Record and follow discovered patterns:
+     - Document code patterns and organizational structures in detail
+     - Plan how to extend these patterns in the design
+   - Determine if there is overlap with existing functionality, and decide whether to "reuse" or "abstract and refactor"
+   - **Do not** generate designs before checking existing code; must "check first, then design"
+
+5. **Task Type-Specific Guidelines**
+
+   Based on task characteristics, additionally consider the following specific guidelines:
+
+   - **Frontend/UI Tasks**:
+
+     - Prioritize examining existing UI component libraries and design systems
+     - Analyze page layout structures and component composition patterns
+     - Confirm style management methods (CSS modules, Styled Components, etc.)
+     - Understand state management and data flow patterns
+
+   - **Backend API Tasks**:
+
+     - Check API route structures and naming conventions
+     - Analyze request handling and middleware patterns
+     - Confirm error handling and response format standards
+     - Understand authorization/authentication implementation methods
+
+   - **Database Operations**:
+     - Analyze existing data access patterns and abstraction layers
+     - Confirm query building and transaction processing methods
+     - Understand relationship handling and data validation methods
+     - Check caching strategies and performance optimization techniques
+
+6. **Preliminary Solution Output**
+   - Based on the above, write a "Preliminary Design Solution":
+     - Clearly mark **facts** (sources) vs **inferences** (selection basis)
+     - Prohibit vague statements; must be final deliverable content
+     - Ensure the solution is consistent with the project's existing architectural patterns
+     - Explain how to reuse existing components or follow existing patterns
+   - The process must be thought through step by step and organize thoughts; if the problem is too complex, utilize `process_thought` to think
+   - **Critical Warning**: All forms of `assumptions`, `guesses`, and `imagination` are strictly prohibited. You must use every `available tool` at your disposal to `gather real information`.
+   - Call tool:
+     ```
+     analyze_task({ summary: <Task Summary>, initialConcept: <Initial Concept> })
+     ```
+
+**Now start calling `analyze_task`, strictly forbidden not to call the tool**

package/dist/prompts/templates/v1/templates_en/planTask/noThought.md

@@ -0,0 +1,4 @@
+**Step Two: Use analyze_task to submit analysis results**
+
+1. **Task Summary** - Objectives, scope, challenges, and constraints
+2. **Initial Solution Concept** - Viable technical solutions and implementation plans

package/dist/prompts/templates/v1/templates_en/planTask/tasks.md

@@ -0,0 +1,17 @@
+### Existing Task References
+
+#### Completed Tasks
+
+{completedTasks}
+
+#### Incomplete Tasks
+
+{unfinishedTasks}
+
+#### Task Adjustment Principles
+
+1. **Completed Task Protection** - Completed tasks cannot be modified or deleted
+2. **Incomplete Task Adjustability** - Incomplete tasks can be modified based on new requirements
+3. **Task ID Consistency** - Must use original IDs when referencing existing tasks
+4. **Dependency Relationship Integrity** - Avoid circular dependencies, do not depend on tasks marked for removal
+5. **Task Continuity** - New tasks should form a coherent whole with existing tasks

package/dist/prompts/templates/v1/templates_en/processThought/complatedThought.md

@@ -0,0 +1,6 @@
+## Thinking Complete
+
+Next, use "analyze_task" to submit analysis results
+
+1. **Task Summary** - Objectives, scope, challenges, and constraints
+2. **Initial Solution Concept** - Viable technical solutions and implementation plans

package/dist/prompts/templates/v1/templates_en/processThought/index.md

@@ -0,0 +1,13 @@
+## Thought {thoughtNumber}/{totalThoughts} - {stage}
+
+{thought}
+
+**Tags:** {tags}
+
+**Principles Used:** {axioms_used}
+
+**Assumptions Challenged:** {assumptions_challenged}
+
+**Prohibitions:** You should prohibit all speculation, for any concerns please thoroughly review related code or use web search tools to query
+
+{nextThoughtNeeded}

package/dist/prompts/templates/v1/templates_en/processThought/moreThought.md

@@ -0,0 +1 @@
+More thinking is needed, continue using the "process_thought" tool to think and find answers

package/dist/prompts/templates/v1/templates_en/queryTask/index.md

@@ -0,0 +1,24 @@
+# Task Query Results
+
+## Query Information
+
+- Query term: {query}
+
+## Task List
+
+Below are tasks matching the query:
+
+{tasksContent}
+
+## Pagination Information
+
+- Current page: {page} / {totalPages}
+- Items per page: {pageSize}
+- Total results: {totalTasks}
+
+You can specify the page parameter to view more results.
+
+## Related Operation Tips
+
+- Use `get_task_detail {taskID}` to view complete task details
+- Use `list_tasks` to view all tasks

package/dist/prompts/templates/v1/templates_en/queryTask/notFound.md

@@ -0,0 +1,15 @@
+# Task Query Results
+
+## No Matching Results
+
+No tasks matching "{query}" were found.
+
+### Possible Reasons:
+
+- The task ID you provided does not exist or is incorrectly formatted
+- The task may have been deleted
+- The keyword spelling may be incorrect
+- Try using shorter or similar keywords
+- The task list may be empty
+
+You can use the `list_tasks` command to view all existing tasks or use other keywords to search the history.

package/dist/prompts/templates/v1/templates_en/queryTask/taskDetails.md

@@ -0,0 +1,5 @@
+### {taskName} (ID: {taskId})
+
+- Status: {taskStatus}
+- Description: {taskDescription}
+- Creation Time: {createdAt}

package/dist/prompts/templates/v1/templates_en/reflectTask/index.md

@@ -0,0 +1,57 @@
+## Reflection Results
+
+**Task Summary:** {summary}
+
+**Analysis Results:**
+
+{analysis}
+
+After receiving the solution and suggestions, conduct self-reflection and final confirmation, and submit the final results:
+
+1. **Requirements Alignment Check**
+
+   - Does the final solution fully satisfy user requirements and constraints?
+   - Are there any omissions or deviations from the original goals?
+
+2. **Architectural Consistency Check**
+
+   - Does the design follow the project's existing architectural patterns and design principles?
+   - Is it consistent with existing code style, naming conventions, and organizational structure?
+   - Does it appropriately utilize existing components rather than reimplementing them?
+   - Are new features properly integrated into the existing architecture?
+   - Is the clarity of module boundaries and responsibility divisions maintained?
+
+3. **Over-design Review**
+
+   - Is unnecessary complexity introduced?
+   - Is there excessive feature splitting or abstraction?
+
+4. **Simplicity and Implementability**
+
+   - Is the design concise and practically implementable?
+   - Is there sufficient space for future iterations?
+
+5. **Feedback and Confirmation**
+
+   - If there are deficiencies or over-design, list "Items Needing Adjustment" and explain the reasons
+   - If everything is satisfactory, generate a "Completion Confirmation Report"
+
+6. **Task Splitting Architectural Considerations**
+
+   - Task splitting should consider existing architectural module boundaries and responsibility divisions
+   - Each subtask should clearly specify its integration points and dependencies with existing code
+   - Clearly mark which subtasks involve reusing existing code and which require new implementation
+   - Maintain task granularity consistency, avoid excessive splitting or uneven granularity
+   - Ensure that the task group after splitting still maintains overall architectural consistency
+
+7. **Submit Final Results**
+   - **No Comments Allowed**: JSON does not support comments — Any use of `#` or `//` will cause parsing failures
+   - **Proper Escaping Required**: All special characters (e.g., double quotes `\"`, backslashes `\\`) must be properly escaped, or they will be considered invalid.
+   - **Line Breaks**: If you need line breaks, use escape sequences like \\n or \\r. Direct line breaks will cause parsing errors.
+   - Adjusted final solution + reflection report
+   - Call tool:
+   ```
+   split_tasks( ... )
+   ```
+
+**Now start calling `split_tasks`, strictly forbidden not to call the tool**

package/dist/prompts/templates/v1/templates_en/researchMode/index.md

@@ -0,0 +1,95 @@
+# Programming Research Mode
+
+You are an AI research assistant equipped with web search, codebase file lookup, and library API query capabilities.  
+You are now entering a specialized programming-focused **Research Mode**, similar to the research functions of ChatGPT or Perplexity, but focused on software development.  
+Your mission is to conduct in-depth and comprehensive research and analysis on the **Research Topic**, and ultimately propose a final design solution.
+
+In **Research Mode**, you should adopt an academic research mindset, maintaining **curiosity** and a **critical attitude** toward all retrieved information.  
+You must **continually search and verify facts**, rather than trusting search results directly.  
+Also, be mindful of the **timeliness** of the information — you are only interested in **the most up-to-date knowledge**.
+
+Current time: **`{time}`**
+Memory directory: **`{memoryDir}`**
+
+## Research Topic
+
+**{topic}**
+
+## Research State Management
+
+### Previous Research State
+
+{previousStateContent}
+
+### Current Execution State
+
+**Current Task:** {currentState}
+
+### Next Steps
+
+**Next Directions:** {nextSteps}
+
+## Research Guidelines
+
+### 1. Depth and Breadth Requirements
+
+- **Deep Exploration**: For every concept, technique, or solution found, use a **search strategy** to dig deeper into its principles, implementation details, pros and cons.
+- **Broad Exploration**: Use **search strategies** to explore alternatives, competing technologies, and related tools in the ecosystem.
+- **Continuous Exploration**: Every search result should trigger a desire to further explore, continuing until the topic is sufficiently covered.
+
+### 2. Search Strategy
+
+You have the following tools available:
+
+When searching, keep your **keywords concise and precise**.  
+**Avoid using too many keywords at once**. Limit each search to **2–4 keywords** to **prevent ineffective searches**.  
+Use **multiple searches**, refining the keywords based on previous results.  
+Whenever you feel **curious or uncertain about a search result**, you must **search again** multiple times to validate the content.
+
+- **Web Search Tools**: For the latest technical info, documentation, tutorials, best practices, such as `web_search` or any web search tool.
+- **Browser Operation Tools**: For browsing recent documentation or sites, such as `use_browser` or any browser automation tool.
+- **Code Search Tools**: For searching implementations, patterns, and examples in the existing project, such as `codebase_search`, `read_file`, or any relevant tool.
+
+### 3. Research Execution Flow
+
+1. **Understand Current State**: Clearly identify the task at hand.
+2. **Perform Search**: Use appropriate search tools to collect information.
+3. **Deep Analysis**: Analyze the results thoroughly and extract key insights.
+4. **Expand Breadth**: Identify additional directions for exploration based on the analysis.
+5. **Iterative Exploration**: Repeat the search and analysis process until sufficient information is gathered. Ensure at least 3 rounds of research for quality.
+6. **Synthesize Summary**: Integrate all findings into a valuable research outcome.
+
+### 4. Research Quality Standards
+
+- **Accuracy**: All information must come from reliable sources, avoiding outdated or incorrect content.
+- **Practicality**: The outcome must be of practical value to software development.
+- **Completeness**: Cover all critical aspects of the topic without missing key information.
+- **Timeliness**: Prioritize the most recent technical advancements and best practices.
+
+### 5. Avoiding Topic Deviation
+
+- Always remember the **Research Topic**
+- Ensure all searches and analysis stay relevant to the topic
+- Refer to **Next Steps** to maintain correct direction
+
+### 6. Final Report
+
+When the research is complete, you must generate a detailed research report in **Markdown** format and wait for the user's next instruction.
+
+## Execution Instructions
+
+**Immediately begin executing the task described in the Current State**:  
+{currentState}
+
+Remember:
+
+- Don’t settle for surface-level results — explore deeper.
+- After each search, reflect on what else might be worth exploring.
+- Maintain curiosity for new findings and expand the research scope.
+- Record important discoveries throughout the process for future state updates.
+- **Do not guess, hallucinate, or simulate** — all information **must be verified through web search tools**.
+- Throughout the process, continually call `research_mode` to log progress. **This is important!** You should call `research_mode` again after completing each stage to log detailed findings and determine the next direction.
+- When you feel the research is complete, generate the **Final Report**.
+
+**Start the research task now.**
+**⚠️ Critical Warning: You are only responsible for research, so you are strictly prohibited from using `editing tools` or `plan task`. You must complete your research and provide a final report, then wait for the user's next instruction.**

package/dist/prompts/templates/v1/templates_en/researchMode/previousState.md

@@ -0,0 +1,9 @@
+**Previous Research Results Summary:**
+
+{previousState}
+
+**Based on previous research, please note:**
+
+- Avoid repeating content that has already been explored
+- Deepen or expand based on previous research
+- If you find information that conflicts with previous research, pay special attention and verify

package/dist/prompts/templates/v1/templates_en/splitTasks/index.md

@@ -0,0 +1,34 @@
+## Task Splitting - {updateMode} Mode
+
+## Splitting Strategy
+
+1. **Functional Decomposition** - Independent testable sub-functions with clear inputs and outputs
+2. **Technical Layer Decomposition** - Separate tasks along architectural layers, ensuring clear interfaces
+3. **Development Stage Decomposition** - Core functionality first, optimization features later
+4. **Risk-based Decomposition** - Isolate high-risk parts, reduce overall risk
+
+## Task Quality Review
+
+1. **Task Atomicity** - Each task is small and specific enough to be completed independently
+2. **Dependencies** - Task dependencies form a directed acyclic graph, avoiding circular dependencies
+3. **Description Completeness** - Each task description is clear and accurate, including necessary context
+
+## Task List
+
+{tasksContent}
+
+## Dependency Management
+
+- Dependencies can be set using task names or task IDs
+- Minimize the number of dependencies, only set direct prerequisite tasks
+- Avoid circular dependencies, ensure the task graph is directed and acyclic
+- Balance the critical path, optimize possibilities for parallel execution
+
+## Decision Points
+
+- If task splitting is found unreasonable: call "split_tasks" again to adjust
+- If task splitting is confirmed to be sound: generate execution plan, determine priorities
+
+**Severe Warning** Each time you call split_tasks, the parameters you pass cannot exceed 5000 characters. If it exceeds 5000 characters, please call the tool multiple times to complete
+
+**If there are remaining tasks, please continue to call "split_tasks"**

package/dist/prompts/templates/v1/templates_en/splitTasks/taskDetails.md

@@ -0,0 +1,12 @@
+### Task {index}: {name}
+
+**ID:** `{id}`
+**Description:** {description}
+
+**Notes:** {notes}
+
+**Implementation Guide:** {implementationGuide}
+
+**Verification Criteria:** {verificationCriteria}
+
+**Dependencies:** {dependencies}

package/dist/prompts/templates/v1/templates_en/tests/basic.md

@@ -0,0 +1 @@
+Hello {name}.

package/dist/prompts/templates/v1/templates_en/toolsDescription/analyzeTask.md

@@ -0,0 +1 @@
+Deeply analyze task requirements and systematically examine the codebase, assess technical feasibility and potential risks, if code needs to be provided use pseudocode format and only provide high-level logic flow and key steps avoiding complete code

package/dist/prompts/templates/v1/templates_en/toolsDescription/clearAllTasks.md

@@ -0,0 +1 @@
+Clear incomplete tasks and reset the task list. This is a destructive operation that requires confirmation. Completed tasks will be backed up before clearing.

package/dist/prompts/templates/v1/templates_en/toolsDescription/deleteTask.md

@@ -0,0 +1 @@
+Delete incomplete tasks, but does not allow deleting completed tasks, ensuring the integrity of system records

package/dist/prompts/templates/v1/templates_en/toolsDescription/executeTask.md

@@ -0,0 +1 @@
+Retrieve the instructional guidance for a specific task. You will complete the programming task based on this guidance. You must strictly follow the feedback and instructions provided by the tool — it is designed to **guide you toward perfect task completion, not to execute the task for you**. Severe Warning: Calling the executeTask tool does not mean you have completed the task. You must follow the step-by-step guidance returned by the tool to complete the task properly.

package/dist/prompts/templates/v1/templates_en/toolsDescription/getTaskDetail.md

@@ -0,0 +1 @@
+Retrieve complete detailed information of a task based on task ID, including untruncated implementation guides and verification criteria

package/dist/prompts/templates/v1/templates_en/toolsDescription/initProjectRules.md

@@ -0,0 +1 @@
+Initialize project standards, call this tool when the user requests to generate or initialize a project standards document, also call this tool if the user requests to change or update project standards

package/dist/prompts/templates/v1/templates_en/toolsDescription/listTasks.md

@@ -0,0 +1 @@
+Generate structured task lists, including complete status tracking, priorities, and dependencies

package/dist/prompts/templates/v1/templates_en/toolsDescription/planTask.md

@@ -0,0 +1,3 @@
+When you need to plan tasks or construct complex features, you can use this tool to receive task planning guidance. You are expected to strictly follow the step-by-step instructions provided by the tool when organizing your tasks. You may optionally choose to reference existing tasks for extended planning.
+
+**Critical Warning**: All forms of `assumptions`, `guesses`, and `imagination` are strictly prohibited. You must use every `available tool` at your disposal to `gather real information`.

package/dist/prompts/templates/v1/templates_en/toolsDescription/processThought.md

@@ -0,0 +1 @@
+Conduct flexible and evolvable thinking processes, progressively deepen understanding and generate effective solutions through establishing, questioning, verifying, and correcting ideas. When encountering situations requiring data collection, analysis, or research, prioritize reviewing project-related code; if relevant code does not exist, query the web rather than speculate. Set nextThoughtNeeded to false when thinking is sufficient, otherwise adjust total_thoughts to extend the process

package/dist/prompts/templates/v1/templates_en/toolsDescription/queryTask.md

@@ -0,0 +1 @@
+Search for tasks based on keywords or ID, display abbreviated task information

package/dist/prompts/templates/v1/templates_en/toolsDescription/reflectTask.md

@@ -0,0 +1 @@
+Critically review analysis results, assess solution completeness and identify optimization opportunities, ensure solutions conform to best practices, if code needs to be provided use pseudocode format and only provide high-level logic flow and key steps avoiding complete code

package/dist/prompts/templates/v1/templates_en/toolsDescription/researchMode.md

@@ -0,0 +1 @@
+When you need to conduct in-depth research on programming-related topics, you can use this tool to enter a specialized research mode. This tool will guide you on how to use web search and code search tools to systematically research technical topics, ensuring research depth and breadth while avoiding topic deviation. Suitable for technical research, best practice exploration, solution comparison, and other scenarios.