refactor: update prompts for analyzing, explaining, implementing, and planning features and bugs

Author: karthiknadig

.github/prompts/analyze.prompt.md

@@ -1,58 +1,32 @@
 ---
 agent: Maintainer
-description: Root cause analysis for a bug in the codebase.
+description: Root cause analysis for a bug or issue.
 tools:
   [
-    vscode/runCommand,
     vscode/askQuestions,
     read/problems,
     read/readFile,
     agent,
     search,
     web/fetch,
     github/issue_read,
-    github/list_issue_types,
     github/list_issues,
-    github/list_pull_requests,
     github/pull_request_read,
     github/search_issues,
-    github/search_pull_requests,
     todo,
   ]
 ---
 
-You are an expert in this codebase.
+Analyze the bug or issue. If a number is provided, treat it as a GitHub issue number.
 
-Your goal is to analyze a bug or add the new feature, for this you first need to:
+1. Read the issue description and relevant code
+2. Identify the root cause (for bugs) or clarify requirements (for features)
+3. Determine if this is by-design behavior or an actual bug
 
-- Understand the context of the bug or feature by reading the issue description and comments.
-- Ask for clarification from user only if the issue description is not clear.
-- Understand the codebase by reading the relevant instruction files and code.
-- If its a bug, then identify the root cause of the bug, and explain this to the user.
-- If just a number is provided by the user, assume it is an issue number and fetch the issue details.
+Output a markdown summary with:
 
-Based on your above understanding generate a summary of your analysis.
-Ensure the plan consists of a Markdown document that has the following sections:
+- **Overview**: What's the issue?
+- **Root Cause**: Why is this happening? (bugs only)
+- **Recommendation**: Should this be fixed? What are the risks?
 
-- Overview: A brief description of the bug/feature. If its a bug, then is this bydesign or a bug?
-- Root Cause: A detailed explanation of the root cause of the bug, including any relevant code snippets or references to the codebase. (only if it's a bug)
-- Requirements: A list of requirements to resolve the bug or add the new feature.
-- Additional Considerations: Mention any potential challenges or risks associated with the implementation.
-- Proposal: Can and should a solution be implemented? Is it a bug, or is this by design? What are the risks or challenges associated with a solution if it is a feature?
-
-Do not make any code edits, just generate a plan. Use thinking and reasoning skills to outline the steps needed to achieve the desired outcome.
-
-<reminder>
-MUST:
-- Read instruction file(s) before analyzing code
-- Understand codebase, issue and architecture thoroughly
-- Perform root cause analysis only if the issue is a bug
-- Never make any assumptions, always strive to be thorough and accurate
-- Avoid unnecessary repetition and verbosity
-- Be concise, but thorough.
-
-MUST NOT:
-
-- Make code changes
-- Mention all new or updated lines of code
-  </reminder>
+Do not make code changes.

.github/prompts/explain.prompt.md

@@ -1,57 +1,28 @@
 ---
 agent: Maintainer
-description: Analyze the codebase and explain a feature/component in detail.
+description: Explain a feature or component in the codebase.
 tools:
   [
-    vscode/runCommand,
     vscode/askQuestions,
-    read/problems,
     read/readFile,
-    read/terminalLastCommand,
     agent,
-    edit/editFiles,
     search,
-    web,
-    github/search_code,
+    web/fetch,
     github/search_issues,
     todo,
   ]
 ---
 
-# Code Explanation Guide
+Explain the requested feature or component. Use diagrams where helpful.
 
-You are an expert in this codebase.
-Your task is to analyze the user requests and explain the feature/component in detail. Where possible use diagrams to depict the architecture and or flow.
+1. Read relevant code and instruction files
+2. Identify key patterns and architectural decisions
+3. Trace data and control flow
 
-Start by first:
+Output a markdown explanation with:
 
-- Understand what needs explaining.
+- **Overview**: What does it do and why?
+- **Key Components**: Main pieces involved
+- **How It Works**: Data flow, control flow, integration points
 
-* Read instruction files for the relevant area
-* Examine code with appropriate tools
-* Understand the codebase by reading the relevant instruction files and code.
-* Identify design patterns and architectural decisions
-* Use available tools to gather information
-* Be thorough before presenting any explanation
-
-Based on your above understanding generate a markdown document that explains the feature/component in detail.
-Use thinking and reasoning skills when generating the explanation & ensure the document has the following sections:
-
-- Overview: Brief summary of the feature/component and its purpose.
-- Architecture: High-level architecture diagram (if applicable).
-- Key Components: List and describe key components involved.
-- Data Flow: Explain how data moves through the system.
-- Control Flow: Describe the control flow and how components interact.
-- Integration Points: Explain how this feature/component integrates with others.
-- Additional Considerations: Mention any potential challenges or risks associated with understanding or modifying this feature/component.
-  Mention any other relevant information that would help in understanding the feature/component.
-
-<reminder>
-MUST:
-- Do not make any other code edits.
-- Read instruction file(s) before analyzing code
-- Understand codebase, issue and architecture thoroughly
-- Never make any assumptions, always strive to be thorough and accurate
-- Avoid unnecessary repetition and verbosity
-- Be concise, but thorough.
-</reminder>
+Do not make code changes.

.github/prompts/implement.prompt.md

@@ -1,53 +1,34 @@
 ---
 agent: Maintainer
-description: Executed after a plan has been created to implement a bug fix or feature request.
+description: Implement a bug fix or feature.
 tools:
   [
     vscode/runCommand,
     vscode/askQuestions,
     execute/testFailure,
     execute/getTerminalOutput,
-    execute/awaitTerminal,
-    execute/killTerminal,
-    execute/createAndRunTask,
     execute/runInTerminal,
     read/problems,
     read/readFile,
-    read/terminalSelection,
     read/terminalLastCommand,
     agent,
-    edit/createDirectory,
     edit/createFile,
     edit/editFiles,
     search,
-    web,
-    github/add_comment_to_pending_review,
-    github/add_issue_comment,
-    github/assign_copilot_to_issue,
+    web/fetch,
     github/create_pull_request,
     github/issue_read,
-    github/issue_write,
-    github/list_issue_types,
-    github/list_issues,
-    github/list_pull_requests,
-    github/merge_pull_request,
-    github/pull_request_read,
-    github/pull_request_review_write,
-    github/request_copilot_review,
     github/search_issues,
-    github/search_pull_requests,
-    github/update_pull_request,
-    github/update_pull_request_branch,
-    github.vscode-pull-request-github/activePullRequest,
+    github/request_copilot_review,
     todo,
   ]
 ---
 
-You are an expert in this codebase.
-Your task is to now implement the solution.
+Implement the solution based on the plan or user request.
+
+1. Make focused code changes following project patterns
+2. Add or update tests as needed
+3. Run `cargo fmt --all` and `cargo clippy --all -- -D warnings` before committing
+4. Create a PR when complete
 
-<reminder>
-MUST:
-- Adhere to patterns and best practices of the project
-- Add required tests to ensure the fix works
-</reminder>
+Keep changes minimal and focused on the task.

.github/prompts/plan.prompt.md

@@ -1,60 +1,33 @@
 ---
 agent: Maintainer
-description: Analyze a bug/issue in the codebase and report findings without making code changes.
+description: Create an implementation plan for a bug fix or feature.
 tools:
   [
     vscode/askQuestions,
     read/problems,
     read/readFile,
     agent,
     search,
-    web,
+    web/fetch,
     github/issue_read,
-    github/list_issue_types,
     github/list_issues,
-    github/list_pull_requests,
     github/pull_request_read,
     github/search_issues,
-    github/search_pull_requests,
-    github.vscode-pull-request-github/activePullRequest,
     todo,
   ]
 ---
 
-You are an expert in this codebase.
+Create an implementation plan. If a number is provided, treat it as a GitHub issue number.
 
-Your goal is to prepare a detailed plan to fix the bug or add the new feature, for this you first need to:
+1. Read the issue description and relevant code
+2. Identify root cause (bugs) or clarify requirements (features)
+3. Outline implementation steps following project patterns
 
-- Understand the context of the bug or feature by reading the issue description and comments.
-- Ask for clarification from user only if the issue description is not clear.
-- Understand the codebase by reading the relevant instruction files and code.
-- If its a bug, then identify the root cause of the bug, and explain this to the user.
-- If just a number is provided by the user, assume it is an issue number and fetch the issue details.
+Output a markdown plan with:
 
-Based on your above understanding generate a plan to fix the bug or add the new feature.
-Ensure the plan consists of a Markdown document that has the following sections:
+- **Overview**: What needs to be done?
+- **Problem**: Root cause analysis (bugs only)
+- **Solution**: Approach and key changes needed
+- **Implementation Steps**: Ordered list of steps to complete the work
 
-- Overview: A brief description of the bug/feature.
-- Problem: A detailed explanation of the root cause of the bug, including any relevant code snippets or references to the codebase. (only if it's a bug)
-- Solution: A brief summary of the solution including a list of requirements to resolve the bug or add the new feature.
-- Additional Considerations: Mention any potential challenges or risks associated with the implementation.
-- Implementation Steps: A detailed list of steps to implement the bug fix or new feature.
-  Note: Limit information to what is necessary for developers and AI assistants to understand the implementation steps.
-  Note: Adhere to architecture, development and testing patterns in instruction files
-
-Do not make any code edits, just generate a plan. Use thinking and reasoning skills to outline the steps needed to achieve the desired outcome.
-
-<reminder>
-MUST:
-- Understand codebase, issue and architecture thoroughly
-- Adhere to patterns and best practices of the project
-- Perform root cause analysis only if the issue is a bug
-- Never make any assumptions, always strive to be thorough and accurate
-- Avoid unnecessary repetition and verbosity
-- Be concise, but thorough.
-
-MUST NOT:
-
-- Make code changes
-- Mention all new or updated lines of code
-  </reminder>
+Do not make code changes.