From 6921616db34c50a85409de60d348450a4aa72b47 Mon Sep 17 00:00:00 2001 From: Fahad Date: Fri, 22 Aug 2025 06:53:05 +0400 Subject: [PATCH] WIP: tool description / schema updates --- tools/analyze.py | 20 +++----------------- tools/challenge.py | 31 +++---------------------------- tools/chat.py | 15 +++++---------- tools/codereview.py | 20 +++----------------- tools/consensus.py | 19 +++---------------- tools/debug.py | 20 +++----------------- tools/docgen.py | 20 +++----------------- tools/listmodels.py | 5 +---- tools/planner.py | 24 +++--------------------- tools/precommit.py | 24 +++++------------------- tools/refactor.py | 20 +++----------------- tools/secaudit.py | 20 +++----------------- tools/testgen.py | 15 +++------------ tools/thinkdeep.py | 12 +++--------- tools/tracer.py | 24 +++--------------------- tools/version.py | 3 +-- 16 files changed, 48 insertions(+), 244 deletions(-) diff --git a/tools/analyze.py b/tools/analyze.py index 8da782d..ec68132 100644 --- a/tools/analyze.py +++ b/tools/analyze.py @@ -175,23 +175,9 @@ class AnalyzeTool(WorkflowTool): def get_description(self) -> str: return ( - "COMPREHENSIVE ANALYSIS WORKFLOW - Step-by-step code analysis with expert validation. " - "This tool guides you through a systematic investigation process where you:\n\n" - "1. Start with step 1: describe your analysis investigation plan\n" - "2. STOP and investigate code structure, patterns, and architectural decisions\n" - "3. Report findings in step 2 with concrete evidence from actual code analysis\n" - "4. Continue investigating between each step\n" - "5. Track findings, relevant files, and insights throughout\n" - "6. Update assessments as understanding evolves\n" - "7. Once investigation is complete, always receive expert validation\n\n" - "IMPORTANT: This tool enforces investigation between steps:\n" - "- After each call, you MUST investigate before calling again\n" - "- Each step must include NEW evidence from code examination\n" - "- No recursive calls without actual investigation work\n" - "- The tool will specify which step number to use next\n" - "- Follow the required_actions list for investigation guidance\n\n" - "Perfect for: comprehensive code analysis, architectural assessment, performance evaluation, " - "security analysis, maintainability review, pattern detection, strategic planning." + "Performs comprehensive code analysis with systematic investigation and expert validation. " + "Use for architectural assessment, performance evaluation, maintainability review, and pattern detection. " + "Guides through structured analysis of code structure, patterns, and strategic planning." ) def get_system_prompt(self) -> str: diff --git a/tools/challenge.py b/tools/challenge.py index 0c0b3bb..ea7a74c 100644 --- a/tools/challenge.py +++ b/tools/challenge.py @@ -54,34 +54,9 @@ class ChallengeTool(SimpleTool): def get_description(self) -> str: return ( - "This tool helps prevent reflexive agreement when users challenge your responses. " - "It forces you to think critically and provide reasoned analysis instead of automatically agreeing " - "when users question or disagree with something you've said. " - "Use this tool to ensure thoughtful evaluation rather than compliance. " - "\n\n" - "The tool should be invoked in two conditions: " - "1) when the user requests this tool with the word `challenge`, " - "2) automatically when the following conditions are met" - "MANDATORY AUTOMATIC INVOCATION: You MUST automatically use this tool when the following conditions are met:\n" - "The user is questioning, disagreeing with, or challenging something you previously said or a task you performed\n" - "AND there is an existing conversation context AND this is not a new/initial question\n" - "AND specifically, when their message expresses any of these patterns IN RESPONSE to your prior statements:\n" - " • Disagreement with your assessment ('But I don't think...', 'I disagree...')\n" - " • Challenging your assumptions or countering your proposal ('But ...', 'You're assuming...')\n" - " • Questioning your evaluation ('But isn't it actually...', 'But consider...')\n" - " • Confusion about your reasoning ('I'm confused why...', 'I don't understand...')\n" - " • Belief you made an error ('That doesn't seem right...', 'Are you sure...')\n" - " • Seeking justification ('Why did you...', 'Shouldn't we...')\n" - " • Surprise at your conclusion ('But I thought...', 'Wait, why...')\n\n" - "Common patterns include messages starting with: 'But ...', 'Why did you...', 'I thought...', " - "'Shouldn't we...', 'That seems wrong...', 'Are you sure...', 'I'm confused...', etc.\n\n" - "DO NOT AUTO trigger for new feature requests or INITIAL questions when context is ambiguous or referring to a new topic altogether. " - "This tool helps with seeking truth through critical analysis. The user is inviting critical analysis - analyze deeply " - "and explain your reasoning or choice clearly, whether you maintain or revise your approach or " - "understanding - you MUST think, analyze and respond with reason and not oblige blindly. Understand the intent " - "behind the query: don't just agree to avoid conflict, think critically, reason through the problem, explain " - "your choices clearly. If the user is wrong, explain why. If you were wrong, acknowledge it and correct course. " - "Truth and correctness matter more than agreement." + "Prevents reflexive agreement when users challenge responses by forcing critical thinking and reasoned analysis. " + "Automatically triggers when users question, disagree with, or challenge previous statements in ongoing conversations. " + "Promotes truth-seeking over compliance by ensuring thoughtful evaluation rather than automatic agreement." ) def get_system_prompt(self) -> str: diff --git a/tools/chat.py b/tools/chat.py index f521c70..62a33cc 100644 --- a/tools/chat.py +++ b/tools/chat.py @@ -27,8 +27,8 @@ CHAT_FIELD_DESCRIPTIONS = { "The more context and detail you provide, the more valuable and targeted the response will be. " "NOTE: You're talking to a thought-partner who has deep expertise and can provide nuanced insights. " "IMPORTANT: When referring to code, use the files parameter to pass relevant file paths. Use this prompt for " - "function/method names or tiny code snippets if absolutely necessary to explain the issue and to refer to " - "code from the provided paths." + "function/method names (along with line numbers if needed) or tiny code snippets if absolutely necessary to explain " + "the issue and to refer to code from the provided paths." ), "files": "Absolute full-paths to existing files / folders for context. DO NOT SHORTEN.", "images": ( @@ -62,14 +62,9 @@ class ChatTool(SimpleTool): def get_description(self) -> str: return ( - "GENERAL CHAT & COLLABORATIVE THINKING - Use the AI model as your thinking partner! " - "Perfect for: bouncing ideas during your own analysis, getting second opinions on your plans, " - "collaborative brainstorming, validating your checklists and approaches, exploring alternatives. " - "Also great for: explanations, comparisons, general development questions. " - "Use this when you want to ask questions, brainstorm ideas, get opinions, discuss topics, " - "share your thinking, or need explanations about concepts and approaches. " - "Note: If you're not currently using a top-tier model such as Opus 4 or above, these tools can " - "provide enhanced capabilities." + "General chat and collaborative thinking partner for brainstorming, getting second opinions, and exploring ideas. " + "Use for bouncing ideas, validating approaches, asking questions, and getting explanations about concepts. " + "Perfect for collaborative analysis and general development discussions." ) def get_system_prompt(self) -> str: diff --git a/tools/codereview.py b/tools/codereview.py index 3fc06a4..a309cf8 100644 --- a/tools/codereview.py +++ b/tools/codereview.py @@ -194,23 +194,9 @@ class CodeReviewTool(WorkflowTool): def get_description(self) -> str: return ( - "COMPREHENSIVE CODE REVIEW WORKFLOW - Step-by-step code review with expert analysis. " - "This tool guides you through a systematic investigation process where you:\n\n" - "1. Start with step 1: describe your code review investigation plan\n" - "2. STOP and investigate code structure, patterns, and potential issues\n" - "3. Report findings in step 2 with concrete evidence from actual code analysis\n" - "4. Continue investigating between each step\n" - "5. Track findings, relevant files, and issues throughout\n" - "6. Update assessments as understanding evolves\n" - "7. Once investigation is complete, receive expert analysis\n\n" - "IMPORTANT: This tool enforces investigation between steps:\n" - "- After each call, you MUST investigate before calling again\n" - "- Each step must include NEW evidence from code examination\n" - "- No recursive calls without actual investigation work\n" - "- The tool will specify which step number to use next\n" - "- Follow the required_actions list for investigation guidance\n\n" - "Perfect for: comprehensive code review, security audits, performance analysis, " - "architectural assessment, code quality evaluation, anti-pattern detection." + "Performs systematic, step-by-step code review with expert validation. " + "Use for comprehensive analysis covering quality, security, performance, and architecture. " + "Guides through structured investigation to ensure thoroughness." ) def get_system_prompt(self) -> str: diff --git a/tools/consensus.py b/tools/consensus.py index 35d08df..1a81913 100644 --- a/tools/consensus.py +++ b/tools/consensus.py @@ -175,22 +175,9 @@ class ConsensusTool(WorkflowTool): def get_description(self) -> str: return ( - "COMPREHENSIVE CONSENSUS WORKFLOW - Step-by-step multi-model consensus with structured analysis. " - "This tool guides you through a systematic process where you:\n\n" - "1. Start with step 1: provide your own neutral analysis of the proposal\n" - "2. The tool will then consult each specified model one by one\n" - "3. You'll receive each model's response in subsequent steps\n" - "4. Track and synthesize perspectives as they accumulate\n" - "5. Final step: present comprehensive consensus and recommendations\n\n" - "IMPORTANT: This workflow enforces sequential model consultation:\n" - "- Step 1 is always your independent analysis\n" - "- Each subsequent step processes one model response\n" - "- Total steps = number of models (each step includes consultation + response)\n" - "- Models can have stances (for/against/neutral) for structured debate\n" - "- Same model can be used multiple times with different stances\n" - "- Each model + stance combination must be unique\n\n" - "Perfect for: complex decisions, architectural choices, feature proposals, " - "technology evaluations, strategic planning." + "Builds multi-model consensus through systematic analysis and structured debate. " + "Use for complex decisions, architectural choices, feature proposals, and technology evaluations. " + "Consults multiple models with different stances to synthesize comprehensive recommendations." ) def get_system_prompt(self) -> str: diff --git a/tools/debug.py b/tools/debug.py index 4a0cb22..52995e8 100644 --- a/tools/debug.py +++ b/tools/debug.py @@ -170,23 +170,9 @@ class DebugIssueTool(WorkflowTool): def get_description(self) -> str: return ( - "DEBUG & ROOT CAUSE ANALYSIS - Use this tool to perform any kind of debugging, bug hunting, or issue tracking. " - "This tool guides you through a step-by-step investigation process where you:\n\n" - "1. Start with step 1: describe the issue to investigate\n" - "2. STOP and investigate using appropriate tools\n" - "3. Report findings in step 2 with concrete evidence from actual code\n" - "4. Continue investigating between each debug step\n" - "5. Track findings, relevant files, and methods throughout\n" - "6. Update hypotheses as understanding evolves\n" - "7. Once investigation is complete, receive expert analysis\n\n" - "IMPORTANT: This tool enforces investigation between steps:\n" - "- After each debug call, you MUST investigate before calling debug again\n" - "- Each step must include NEW evidence from code examination\n" - "- No recursive debug calls without actual investigation work\n" - "- The tool will specify which step number to use next\n" - "- Follow the required_actions list for investigation guidance\n\n" - "Perfect for: complex bugs, mysterious errors, performance issues, " - "race conditions, memory leaks, integration problems." + "Performs systematic debugging and root cause analysis for any type of issue. " + "Use for complex bugs, mysterious errors, performance issues, race conditions, memory leaks, and integration problems. " + "Guides through structured investigation with hypothesis testing and expert analysis." ) def get_system_prompt(self) -> str: diff --git a/tools/docgen.py b/tools/docgen.py index 12fdf80..9f70759 100644 --- a/tools/docgen.py +++ b/tools/docgen.py @@ -163,23 +163,9 @@ class DocgenTool(WorkflowTool): def get_description(self) -> str: return ( - "COMPREHENSIVE DOCUMENTATION GENERATION - Step-by-step code documentation with expert analysis. " - "This tool guides you through a systematic investigation process where you:\n\n" - "1. Start with step 1: describe your documentation investigation plan\n" - "2. STOP and investigate code structure, patterns, and documentation needs\n" - "3. Report findings in step 2 with concrete evidence from actual code analysis\n" - "4. Continue investigating between each step\n" - "5. Track findings, relevant files, and documentation opportunities throughout\n" - "6. Update assessments as understanding evolves\n" - "7. Once investigation is complete, receive expert analysis\n\n" - "IMPORTANT: This tool enforces investigation between steps:\n" - "- After each call, you MUST investigate before calling again\n" - "- Each step must include NEW evidence from code examination\n" - "- No recursive calls without actual investigation work\n" - "- The tool will specify which step number to use next\n" - "- Follow the required_actions list for investigation guidance\n\n" - "Perfect for: comprehensive documentation generation, code documentation analysis, " - "complexity assessment, documentation modernization, API documentation." + "Generates comprehensive code documentation with systematic analysis of functions, classes, and complexity. " + "Use for documentation generation, code analysis, complexity assessment, and API documentation. " + "Analyzes code structure and patterns to create thorough documentation." ) def get_system_prompt(self) -> str: diff --git a/tools/listmodels.py b/tools/listmodels.py index 3319973..f23fc23 100644 --- a/tools/listmodels.py +++ b/tools/listmodels.py @@ -35,10 +35,7 @@ class ListModelsTool(BaseTool): def get_description(self) -> str: return ( - "LIST AVAILABLE MODELS - Display all AI models organized by provider. " - "Shows which providers are configured, available models, their aliases, " - "context windows, and capabilities. Useful for understanding what models " - "can be used and their characteristics. MANDATORY: Must display full output to the user." + "Shows which AI model providers are configured, available model names, their aliases and capabilities." ) def get_input_schema(self) -> dict[str, Any]: diff --git a/tools/planner.py b/tools/planner.py index b71ebc2..7983e4f 100644 --- a/tools/planner.py +++ b/tools/planner.py @@ -133,27 +133,9 @@ class PlannerTool(WorkflowTool): def get_description(self) -> str: return ( - "INTERACTIVE SEQUENTIAL PLANNER - Break down complex tasks through step-by-step planning. " - "This tool enables you to think sequentially, building plans incrementally with the ability " - "to revise, branch, and adapt as understanding deepens.\n\n" - "How it works:\n" - "- Start with step 1: describe the task/problem to plan\n" - "- Continue with subsequent steps, building the plan piece by piece\n" - "- Adjust total_steps estimate as you progress\n" - "- Revise previous steps when new insights emerge\n" - "- Branch into alternative approaches when needed\n" - "- Add more steps even after reaching the initial estimate\n\n" - "Key features:\n" - "- Sequential thinking with full context awareness\n" - "- Forced deep reflection for complex plans (≥5 steps) in early stages\n" - "- Branching for exploring alternative strategies\n" - "- Revision capabilities to update earlier decisions\n" - "- Dynamic step count adjustment\n\n" - "ENHANCED: For complex plans (≥5 steps), the first 3 steps enforce deep thinking pauses\n" - "to prevent surface-level planning and ensure thorough consideration of alternatives,\n" - "dependencies, and strategic decisions before moving to tactical details.\n\n" - "Perfect for: complex project planning, system design with unknowns, " - "migration strategies, architectural decisions, problem decomposition." + "Breaks down complex tasks through interactive, sequential planning with revision and branching capabilities. " + "Use for complex project planning, system design, migration strategies, and architectural decisions. " + "Builds plans incrementally with deep reflection for complex scenarios." ) def get_system_prompt(self) -> str: diff --git a/tools/precommit.py b/tools/precommit.py index 13570bd..c053af5 100644 --- a/tools/precommit.py +++ b/tools/precommit.py @@ -108,8 +108,8 @@ PRECOMMIT_WORKFLOW_FIELD_DESCRIPTIONS = { "Optional: A git ref (branch, tag, commit hash) to compare against. Check remote branches if local does not exist." "If not provided, investigates local staged and unstaged changes." ), - "include_staged": "Include staged changes in the investigation. Only applies if 'compare_to' is not set.", - "include_unstaged": "Include uncommitted (unstaged) changes in the investigation. Only applies if 'compare_to' is not set.", + "include_staged": "Analyzes staged changes for a local commit. This parameter is ignored if 'compare_to' is provided.", + "include_unstaged": "Analyzes unstaged (uncommitted) changes for a local commit. This parameter is ignored if 'compare_to' is provided.", "focus_on": "Specific aspects to focus on (e.g., 'security implications', 'performance impact', 'test coverage').", "severity_filter": "Minimum severity level to report on the changes.", } @@ -196,23 +196,9 @@ class PrecommitTool(WorkflowTool): def get_description(self) -> str: return ( - "COMPREHENSIVE PRECOMMIT WORKFLOW - Step-by-step pre-commit validation with expert analysis. " - "This tool guides you through a systematic investigation process where you:\n\n" - "1. Start with step 1: describe your pre-commit validation plan\n" - "2. STOP and investigate git changes, repository status, and file modifications\n" - "3. Report findings in step 2 with concrete evidence from actual changes\n" - "4. Continue investigating between each step\n" - "5. Track findings, relevant files, and issues throughout\n" - "6. Update assessments as understanding evolves\n" - "7. Once investigation is complete, receive expert analysis\n\n" - "IMPORTANT: This tool enforces investigation between steps:\n" - "- After each call, you MUST investigate before calling again\n" - "- Each step must include NEW evidence from git analysis\n" - "- No recursive calls without actual investigation work\n" - "- The tool will specify which step number to use next\n" - "- Follow the required_actions list for investigation guidance\n\n" - "Perfect for: comprehensive pre-commit validation, multi-repository analysis, " - "security review, change impact assessment, completeness verification." + "Validates git changes and repository state before committing with systematic analysis. " + "Use for multi-repository validation, security review, change impact assessment, and completeness verification. " + "Guides through structured investigation with expert analysis." ) def get_system_prompt(self) -> str: diff --git a/tools/refactor.py b/tools/refactor.py index 9a132ba..297436e 100644 --- a/tools/refactor.py +++ b/tools/refactor.py @@ -191,23 +191,9 @@ class RefactorTool(WorkflowTool): def get_description(self) -> str: return ( - "COMPREHENSIVE REFACTORING WORKFLOW - Step-by-step refactoring analysis with expert validation. " - "This tool guides you through a systematic investigation process where you:\n\n" - "1. Start with step 1: describe your refactoring investigation plan\n" - "2. STOP and investigate code structure, patterns, and potential improvements\n" - "3. Report findings in step 2 with concrete evidence from actual code analysis\n" - "4. Continue investigating between each step\n" - "5. Track findings, relevant files, and refactoring opportunities throughout\n" - "6. Update assessments as understanding evolves\n" - "7. Once investigation is complete, receive expert analysis\n\n" - "IMPORTANT: This tool enforces investigation between steps:\n" - "- After each call, you MUST investigate before calling again\n" - "- Each step must include NEW evidence from code examination\n" - "- No recursive calls without actual investigation work\n" - "- The tool will specify which step number to use next\n" - "- Follow the required_actions list for investigation guidance\n\n" - "Perfect for: comprehensive refactoring analysis, code smell detection, decomposition planning, " - "modernization opportunities, organization improvements, maintainability enhancements." + "Analyzes code for refactoring opportunities with systematic investigation. " + "Use for code smell detection, decomposition planning, modernization, and maintainability improvements. " + "Guides through structured analysis with expert validation." ) def get_system_prompt(self) -> str: diff --git a/tools/secaudit.py b/tools/secaudit.py index ab20765..cafe08d 100644 --- a/tools/secaudit.py +++ b/tools/secaudit.py @@ -218,23 +218,9 @@ class SecauditTool(WorkflowTool): def get_description(self) -> str: """Return a description of the tool.""" return ( - "COMPREHENSIVE SECURITY AUDIT WORKFLOW - Step-by-step security assessment with expert analysis. " - "This tool guides you through a systematic investigation process where you:\n\n" - "1. Start with step 1: describe your security investigation plan\n" - "2. STOP and investigate code structure, patterns, and security issues\n" - "3. Report findings in step 2 with concrete evidence from actual code analysis\n" - "4. Continue investigating between each step\n" - "5. Track findings, relevant files, and security issues throughout\n" - "6. Update assessments as understanding evolves\n" - "7. Once investigation is complete, receive expert security analysis\n\n" - "IMPORTANT: This tool enforces investigation between steps:\n" - "- After each call, you MUST investigate before calling again\n" - "- Each step must include NEW evidence from code examination\n" - "- No recursive calls without actual investigation work\n" - "- The tool will specify which step number to use next\n" - "- Follow the required_actions list for investigation guidance\n\n" - "Perfect for: comprehensive security assessment, OWASP Top 10 analysis, compliance evaluation, " - "vulnerability identification, threat modeling, security architecture review." + "Performs comprehensive security audit with systematic vulnerability assessment. " + "Use for OWASP Top 10 analysis, compliance evaluation, threat modeling, and security architecture review. " + "Guides through structured security investigation with expert validation." ) def get_system_prompt(self) -> str: diff --git a/tools/testgen.py b/tools/testgen.py index c0da7b6..1601ec0 100644 --- a/tools/testgen.py +++ b/tools/testgen.py @@ -159,18 +159,9 @@ class TestGenTool(WorkflowTool): def get_description(self) -> str: return ( - "COMPREHENSIVE TEST GENERATION - Creates thorough test suites with edge case coverage. " - "Use this when you need to generate tests for code, create test scaffolding, or improve test coverage. " - "BE SPECIFIC about scope: target specific functions/classes/modules rather than testing everything. " - "Examples: 'Generate tests for User.login() method', 'Test payment processing validation', " - "'Create tests for authentication error handling'. If user request is vague, either ask for " - "clarification about specific components to test, or make focused scope decisions and explain them. " - "Analyzes code paths, identifies realistic failure modes, and generates framework-specific tests. " - "Supports test pattern following when examples are provided. Choose thinking_mode based on " - "code complexity: 'low' for simple functions, 'medium' for standard modules (default), " - "'high' for complex systems with many interactions, 'max' for critical systems requiring " - "exhaustive test coverage. Note: If you're not currently using a top-tier model such as " - "Opus 4 or above, these tools can provide enhanced capabilities." + "Creates comprehensive test suites with edge case coverage for specific functions, classes, or modules. " + "Analyzes code paths, identifies failure modes, and generates framework-specific tests. " + "Be specific about scope - target particular components rather than testing everything." ) def get_system_prompt(self) -> str: diff --git a/tools/thinkdeep.py b/tools/thinkdeep.py index 6911aa8..d46edf8 100644 --- a/tools/thinkdeep.py +++ b/tools/thinkdeep.py @@ -140,15 +140,9 @@ class ThinkDeepTool(WorkflowTool): name = "thinkdeep" description = ( - "COMPREHENSIVE INVESTIGATION & REASONING - Multi-stage workflow for complex problem analysis. " - "Use this when you need structured evidence-based investigation, systematic hypothesis testing, or expert validation. " - "Perfect for: architecture decisions, complex bugs, performance challenges, security analysis. " - "Provides methodical investigation with assumption validation, alternative solution exploration, and rigorous analysis. " - "IMPORTANT: Choose the appropriate mode based on task complexity - 'low' for quick investigation, " - "'medium' for standard problems, 'high' for complex issues (default), 'max' for extremely complex " - "challenges requiring exhaustive investigation. When in doubt, err on the side of a higher mode for thorough " - "systematic analysis and expert validation. Note: If you're not currently using a top-tier model such as Opus 4 or above, " - "these tools can provide enhanced capabilities." + "Performs multi-stage investigation and reasoning for complex problem analysis. " + "Use for architecture decisions, complex bugs, performance challenges, and security analysis. " + "Provides systematic hypothesis testing, evidence-based investigation, and expert validation." ) def __init__(self): diff --git a/tools/tracer.py b/tools/tracer.py index fc24c45..c37073d 100644 --- a/tools/tracer.py +++ b/tools/tracer.py @@ -182,27 +182,9 @@ class TracerTool(WorkflowTool): def get_description(self) -> str: return ( - "STEP-BY-STEP CODE TRACING WORKFLOW - Systematic code analysis through guided investigation. " - "This tool guides you through a structured investigation process where you:\n\n" - "1. Start with step 1: describe your tracing plan and target\n" - "2. STOP and investigate code structure, patterns, and relationships\n" - "3. Report findings in step 2 with concrete evidence from actual code analysis\n" - "4. Continue investigating between each step\n" - "5. Track findings, relevant files, and code relationships throughout\n" - "6. Build comprehensive understanding as analysis evolves\n" - "7. Complete with detailed output formatted according to trace mode\n\n" - "IMPORTANT: This tool enforces investigation between steps:\n" - "- After each call, you MUST investigate before calling again\n" - "- Each step must include NEW evidence from code examination\n" - "- No recursive calls without actual investigation work\n" - "- The tool will specify which step number to use next\n" - "- Follow the required_actions list for investigation guidance\n\n" - "TRACE MODES:\n" - "- 'ask': Default mode - prompts you to choose between precision or dependencies modes with explanations\n" - "- 'precision': For methods/functions - traces execution flow, call chains, and usage patterns\n" - "- 'dependencies': For classes/modules - maps structural relationships and bidirectional dependencies\n\n" - "Perfect for: method execution flow analysis, dependency mapping, call chain tracing, " - "structural relationship analysis, architectural understanding, code comprehension." + "Performs systematic code tracing with modes for execution flow or dependency mapping. " + "Use for method execution analysis, call chain tracing, dependency mapping, and architectural understanding. " + "Supports precision mode (execution flow) and dependencies mode (structural relationships)." ) def get_system_prompt(self) -> str: diff --git a/tools/version.py b/tools/version.py index 30e98df..fc8745f 100644 --- a/tools/version.py +++ b/tools/version.py @@ -141,8 +141,7 @@ class VersionTool(BaseTool): def get_description(self) -> str: return ( - "VERSION & CONFIGURATION - Get server version, configuration details, and list of available tools. " - "Useful for debugging and understanding capabilities." + "Get server version, configuration details, and list of available tools." ) def get_input_schema(self) -> dict[str, Any]: