torbjorn/my-pal-mcp-server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

WIP: tool description / schema updates

Browse Source
This commit is contained in:
Fahad
2025-08-22 06:53:05 +04:00
parent 12542054a2
commit 6921616db3
16 changed files with 48 additions and 244 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
tools/analyze.py
View File

@@ -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:

31
tools/challenge.py
View File

@@ -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:

15
tools/chat.py
View File

@@ -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:

20
tools/codereview.py
View File

@@ -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:

19
tools/consensus.py
View File

@@ -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:

20
tools/debug.py
View File

@@ -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:

20
tools/docgen.py
View File

@@ -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:

5
tools/listmodels.py
View File

@@ -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]:

24
tools/planner.py
View File

@@ -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:

24
tools/precommit.py
View File

@@ -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:

20
tools/refactor.py
View File

@@ -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:

20
tools/secaudit.py
View File

@@ -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:

15
tools/testgen.py
View File

@@ -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:

12
tools/thinkdeep.py
View File

@@ -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):

24
tools/tracer.py
View File

@@ -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:

3
tools/version.py
View File

@@ -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]: