c960bcb720
* WIP: new workflow architecture * WIP: further improvements and cleanup * WIP: cleanup and docks, replace old tool with new * WIP: cleanup and docks, replace old tool with new * WIP: new planner implementation using workflow * WIP: precommit tool working as a workflow instead of a basic tool Support for passing False to use_assistant_model to skip external models completely and use Claude only * WIP: precommit workflow version swapped with old * WIP: codereview * WIP: replaced codereview * WIP: replaced codereview * WIP: replaced refactor * WIP: workflow for thinkdeep * WIP: ensure files get embedded correctly * WIP: thinkdeep replaced with workflow version * WIP: improved messaging when an external model's response is received * WIP: analyze tool swapped * WIP: updated tests * Extract only the content when building history * Use "relevant_files" for workflow tools only * WIP: updated tests * Extract only the content when building history * Use "relevant_files" for workflow tools only * WIP: fixed get_completion_next_steps_message missing param * Fixed tests Request for files consistently * Fixed tests Request for files consistently * Fixed tests * New testgen workflow tool Updated docs * Swap testgen workflow * Fix CI test failures by excluding API-dependent tests - Update GitHub Actions workflow to exclude simulation tests that require API keys - Fix collaboration tests to properly mock workflow tool expert analysis calls - Update test assertions to handle new workflow tool response format - Ensure unit tests run without external API dependencies in CI 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com> * WIP - Update tests to match new tools * WIP - Update tests to match new tools * WIP - Update tests to match new tools * Should help with https://github.com/BeehiveInnovations/zen-mcp-server/issues/97 Clear python cache when running script: https://github.com/BeehiveInnovations/zen-mcp-server/issues/96 Improved retry error logging Cleanup * WIP - chat tool using new architecture and improved code sharing * Removed todo * Removed todo * Cleanup old name * Tweak wordings * Tweak wordings Migrate old tests * Support for Flash 2.0 and Flash Lite 2.0 * Support for Flash 2.0 and Flash Lite 2.0 * Support for Flash 2.0 and Flash Lite 2.0 Fixed test * Improved consensus to use the workflow base class * Improved consensus to use the workflow base class * Allow images * Allow images * Replaced old consensus tool * Cleanup tests * Tests for prompt size * New tool: docgen Tests for prompt size Fixes: https://github.com/BeehiveInnovations/zen-mcp-server/issues/107 Use available token size limits: https://github.com/BeehiveInnovations/zen-mcp-server/issues/105 * Improved docgen prompt Exclude TestGen from pytest inclusion * Updated errors * Lint * DocGen instructed not to fix bugs, surface them and stick to d * WIP * Stop claude from being lazy and only documenting a small handful * More style rules --------- Co-authored-by: Claude <noreply@anthropic.com>
691 lines
36 KiB
Python
691 lines
36 KiB
Python
"""
|
|
Refactor tool - Step-by-step refactoring analysis with expert validation
|
|
|
|
This tool provides a structured workflow for comprehensive code refactoring analysis.
|
|
It guides Claude through systematic investigation steps with forced pauses between each step
|
|
to ensure thorough code examination, refactoring opportunity identification, and quality
|
|
assessment before proceeding. The tool supports complex refactoring scenarios including
|
|
code smell detection, decomposition planning, modernization opportunities, and organization improvements.
|
|
|
|
Key features:
|
|
- Step-by-step refactoring investigation workflow with progress tracking
|
|
- Context-aware file embedding (references during investigation, full content for analysis)
|
|
- Automatic refactoring opportunity tracking with type and severity classification
|
|
- Expert analysis integration with external models
|
|
- Support for focused refactoring types (codesmells, decompose, modernize, organization)
|
|
- Confidence-based workflow optimization with refactor completion tracking
|
|
"""
|
|
|
|
import logging
|
|
from typing import TYPE_CHECKING, Any, Literal, Optional
|
|
|
|
from pydantic import Field, model_validator
|
|
|
|
if TYPE_CHECKING:
|
|
from tools.models import ToolModelCategory
|
|
|
|
from config import TEMPERATURE_ANALYTICAL
|
|
from systemprompts import REFACTOR_PROMPT
|
|
from tools.shared.base_models import WorkflowRequest
|
|
|
|
from .workflow.base import WorkflowTool
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# Tool-specific field descriptions for refactor tool
|
|
REFACTOR_FIELD_DESCRIPTIONS = {
|
|
"step": (
|
|
"Describe what you're currently investigating for refactoring by thinking deeply about the code structure, "
|
|
"patterns, and potential improvements. In step 1, clearly state your refactoring investigation plan and begin "
|
|
"forming a systematic approach after thinking carefully about what needs to be analyzed. CRITICAL: Remember to "
|
|
"thoroughly examine code quality, performance implications, maintainability concerns, and architectural patterns. "
|
|
"Consider not only obvious code smells and issues but also opportunities for decomposition, modernization, "
|
|
"organization improvements, and ways to reduce complexity while maintaining functionality. Map out the codebase "
|
|
"structure, understand the business logic, and identify areas requiring refactoring. In all later steps, continue "
|
|
"exploring with precision: trace dependencies, verify assumptions, and adapt your understanding as you uncover "
|
|
"more refactoring opportunities."
|
|
),
|
|
"step_number": (
|
|
"The index of the current step in the refactoring investigation sequence, beginning at 1. Each step should "
|
|
"build upon or revise the previous one."
|
|
),
|
|
"total_steps": (
|
|
"Your current estimate for how many steps will be needed to complete the refactoring investigation. "
|
|
"Adjust as new opportunities emerge."
|
|
),
|
|
"next_step_required": (
|
|
"Set to true if you plan to continue the investigation with another step. False means you believe the "
|
|
"refactoring analysis is complete and ready for expert validation."
|
|
),
|
|
"findings": (
|
|
"Summarize everything discovered in this step about refactoring opportunities in the code. Include analysis of "
|
|
"code smells, decomposition opportunities, modernization possibilities, organization improvements, architectural "
|
|
"patterns, design decisions, potential performance optimizations, and maintainability enhancements. Be specific "
|
|
"and avoid vague language—document what you now know about the code and how it could be improved. IMPORTANT: "
|
|
"Document both positive aspects (good patterns, well-designed components) and improvement opportunities "
|
|
"(code smells, overly complex functions, outdated patterns, organization issues). In later steps, confirm or "
|
|
"update past findings with additional evidence."
|
|
),
|
|
"files_checked": (
|
|
"List all files (as absolute paths, do not clip or shrink file names) examined during the refactoring "
|
|
"investigation so far. Include even files ruled out or found to need no refactoring, as this tracks your "
|
|
"exploration path."
|
|
),
|
|
"relevant_files": (
|
|
"Subset of files_checked (as full absolute paths) that contain code requiring refactoring or are directly "
|
|
"relevant to the refactoring opportunities identified. Only list those that are directly tied to specific "
|
|
"refactoring opportunities, code smells, decomposition needs, or improvement areas. This could include files "
|
|
"with code smells, overly large functions/classes, outdated patterns, or organization issues."
|
|
),
|
|
"relevant_context": (
|
|
"List methods, functions, classes, or modules that are central to the refactoring opportunities identified, "
|
|
"in the format 'ClassName.methodName', 'functionName', or 'module.ClassName'. Prioritize those that contain "
|
|
"code smells, need decomposition, could benefit from modernization, or require organization improvements."
|
|
),
|
|
"issues_found": (
|
|
"List of refactoring opportunities identified during the investigation. Each opportunity should be a dictionary "
|
|
"with 'severity' (critical, high, medium, low), 'type' (codesmells, decompose, modernize, organization), and "
|
|
"'description' fields. Include code smells, decomposition opportunities, modernization possibilities, "
|
|
"organization improvements, performance optimizations, maintainability enhancements, etc."
|
|
),
|
|
"confidence": (
|
|
"Indicate your current confidence in the refactoring analysis completeness. Use: 'exploring' (starting "
|
|
"analysis), 'incomplete' (just started or significant work remaining), 'partial' (some refactoring "
|
|
"opportunities identified but more analysis needed), 'complete' (comprehensive refactoring analysis "
|
|
"finished with all major opportunities identified and Claude can handle 100% confidently without help). "
|
|
"Use 'complete' ONLY when you have fully analyzed all code, identified all significant refactoring "
|
|
"opportunities, and can provide comprehensive recommendations without expert assistance. When files are "
|
|
"too large to read fully or analysis is uncertain, use 'partial'. Using 'complete' prevents expert "
|
|
"analysis to save time and money."
|
|
),
|
|
"backtrack_from_step": (
|
|
"If an earlier finding or assessment needs to be revised or discarded, specify the step number from which to "
|
|
"start over. Use this to acknowledge investigative dead ends and correct the course."
|
|
),
|
|
"images": (
|
|
"Optional list of absolute paths to architecture diagrams, UI mockups, design documents, or visual references "
|
|
"that help with refactoring context. Only include if they materially assist understanding or assessment."
|
|
),
|
|
"refactor_type": "Type of refactoring analysis to perform (codesmells, decompose, modernize, organization)",
|
|
"focus_areas": "Specific areas to focus on (e.g., 'performance', 'readability', 'maintainability', 'security')",
|
|
"style_guide_examples": (
|
|
"Optional existing code files to use as style/pattern reference (must be FULL absolute paths to real files / "
|
|
"folders - DO NOT SHORTEN). These files represent the target coding style and patterns for the project."
|
|
),
|
|
}
|
|
|
|
|
|
class RefactorRequest(WorkflowRequest):
|
|
"""Request model for refactor workflow investigation steps"""
|
|
|
|
# Required fields for each investigation step
|
|
step: str = Field(..., description=REFACTOR_FIELD_DESCRIPTIONS["step"])
|
|
step_number: int = Field(..., description=REFACTOR_FIELD_DESCRIPTIONS["step_number"])
|
|
total_steps: int = Field(..., description=REFACTOR_FIELD_DESCRIPTIONS["total_steps"])
|
|
next_step_required: bool = Field(..., description=REFACTOR_FIELD_DESCRIPTIONS["next_step_required"])
|
|
|
|
# Investigation tracking fields
|
|
findings: str = Field(..., description=REFACTOR_FIELD_DESCRIPTIONS["findings"])
|
|
files_checked: list[str] = Field(default_factory=list, description=REFACTOR_FIELD_DESCRIPTIONS["files_checked"])
|
|
relevant_files: list[str] = Field(default_factory=list, description=REFACTOR_FIELD_DESCRIPTIONS["relevant_files"])
|
|
relevant_context: list[str] = Field(
|
|
default_factory=list, description=REFACTOR_FIELD_DESCRIPTIONS["relevant_context"]
|
|
)
|
|
issues_found: list[dict] = Field(default_factory=list, description=REFACTOR_FIELD_DESCRIPTIONS["issues_found"])
|
|
confidence: Optional[Literal["exploring", "incomplete", "partial", "complete"]] = Field(
|
|
"incomplete", description=REFACTOR_FIELD_DESCRIPTIONS["confidence"]
|
|
)
|
|
|
|
# Optional backtracking field
|
|
backtrack_from_step: Optional[int] = Field(None, description=REFACTOR_FIELD_DESCRIPTIONS["backtrack_from_step"])
|
|
|
|
# Optional images for visual context
|
|
images: Optional[list[str]] = Field(default=None, description=REFACTOR_FIELD_DESCRIPTIONS["images"])
|
|
|
|
# Refactor-specific fields (only used in step 1 to initialize)
|
|
refactor_type: Optional[Literal["codesmells", "decompose", "modernize", "organization"]] = Field(
|
|
"codesmells", description=REFACTOR_FIELD_DESCRIPTIONS["refactor_type"]
|
|
)
|
|
focus_areas: Optional[list[str]] = Field(None, description=REFACTOR_FIELD_DESCRIPTIONS["focus_areas"])
|
|
style_guide_examples: Optional[list[str]] = Field(
|
|
None, description=REFACTOR_FIELD_DESCRIPTIONS["style_guide_examples"]
|
|
)
|
|
|
|
# Override inherited fields to exclude them from schema (except model which needs to be available)
|
|
temperature: Optional[float] = Field(default=None, exclude=True)
|
|
thinking_mode: Optional[str] = Field(default=None, exclude=True)
|
|
use_websearch: Optional[bool] = Field(default=None, exclude=True)
|
|
|
|
@model_validator(mode="after")
|
|
def validate_step_one_requirements(self):
|
|
"""Ensure step 1 has required relevant_files field."""
|
|
if self.step_number == 1 and not self.relevant_files:
|
|
raise ValueError(
|
|
"Step 1 requires 'relevant_files' field to specify code files or directories to analyze for refactoring"
|
|
)
|
|
return self
|
|
|
|
|
|
class RefactorTool(WorkflowTool):
|
|
"""
|
|
Refactor tool for step-by-step refactoring analysis and expert validation.
|
|
|
|
This tool implements a structured refactoring workflow that guides users through
|
|
methodical investigation steps, ensuring thorough code examination, refactoring opportunity
|
|
identification, and improvement assessment before reaching conclusions. It supports complex
|
|
refactoring scenarios including code smell detection, decomposition planning, modernization
|
|
opportunities, and organization improvements.
|
|
"""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.initial_request = None
|
|
self.refactor_config = {}
|
|
|
|
def get_name(self) -> str:
|
|
return "refactor"
|
|
|
|
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."
|
|
)
|
|
|
|
def get_system_prompt(self) -> str:
|
|
return REFACTOR_PROMPT
|
|
|
|
def get_default_temperature(self) -> float:
|
|
return TEMPERATURE_ANALYTICAL
|
|
|
|
def get_model_category(self) -> "ToolModelCategory":
|
|
"""Refactor workflow requires thorough analysis and reasoning"""
|
|
from tools.models import ToolModelCategory
|
|
|
|
return ToolModelCategory.EXTENDED_REASONING
|
|
|
|
def get_workflow_request_model(self):
|
|
"""Return the refactor workflow-specific request model."""
|
|
return RefactorRequest
|
|
|
|
def get_input_schema(self) -> dict[str, Any]:
|
|
"""Generate input schema using WorkflowSchemaBuilder with refactor-specific overrides."""
|
|
from .workflow.schema_builders import WorkflowSchemaBuilder
|
|
|
|
# Refactor workflow-specific field overrides
|
|
refactor_field_overrides = {
|
|
"step": {
|
|
"type": "string",
|
|
"description": REFACTOR_FIELD_DESCRIPTIONS["step"],
|
|
},
|
|
"step_number": {
|
|
"type": "integer",
|
|
"minimum": 1,
|
|
"description": REFACTOR_FIELD_DESCRIPTIONS["step_number"],
|
|
},
|
|
"total_steps": {
|
|
"type": "integer",
|
|
"minimum": 1,
|
|
"description": REFACTOR_FIELD_DESCRIPTIONS["total_steps"],
|
|
},
|
|
"next_step_required": {
|
|
"type": "boolean",
|
|
"description": REFACTOR_FIELD_DESCRIPTIONS["next_step_required"],
|
|
},
|
|
"findings": {
|
|
"type": "string",
|
|
"description": REFACTOR_FIELD_DESCRIPTIONS["findings"],
|
|
},
|
|
"files_checked": {
|
|
"type": "array",
|
|
"items": {"type": "string"},
|
|
"description": REFACTOR_FIELD_DESCRIPTIONS["files_checked"],
|
|
},
|
|
"relevant_files": {
|
|
"type": "array",
|
|
"items": {"type": "string"},
|
|
"description": REFACTOR_FIELD_DESCRIPTIONS["relevant_files"],
|
|
},
|
|
"confidence": {
|
|
"type": "string",
|
|
"enum": ["exploring", "incomplete", "partial", "complete"],
|
|
"default": "incomplete",
|
|
"description": REFACTOR_FIELD_DESCRIPTIONS["confidence"],
|
|
},
|
|
"backtrack_from_step": {
|
|
"type": "integer",
|
|
"minimum": 1,
|
|
"description": REFACTOR_FIELD_DESCRIPTIONS["backtrack_from_step"],
|
|
},
|
|
"issues_found": {
|
|
"type": "array",
|
|
"items": {"type": "object"},
|
|
"description": REFACTOR_FIELD_DESCRIPTIONS["issues_found"],
|
|
},
|
|
"images": {
|
|
"type": "array",
|
|
"items": {"type": "string"},
|
|
"description": REFACTOR_FIELD_DESCRIPTIONS["images"],
|
|
},
|
|
# Refactor-specific fields (for step 1)
|
|
# Note: Use relevant_files field instead of files for consistency
|
|
"refactor_type": {
|
|
"type": "string",
|
|
"enum": ["codesmells", "decompose", "modernize", "organization"],
|
|
"default": "codesmells",
|
|
"description": REFACTOR_FIELD_DESCRIPTIONS["refactor_type"],
|
|
},
|
|
"focus_areas": {
|
|
"type": "array",
|
|
"items": {"type": "string"},
|
|
"description": REFACTOR_FIELD_DESCRIPTIONS["focus_areas"],
|
|
},
|
|
"style_guide_examples": {
|
|
"type": "array",
|
|
"items": {"type": "string"},
|
|
"description": REFACTOR_FIELD_DESCRIPTIONS["style_guide_examples"],
|
|
},
|
|
}
|
|
|
|
# Use WorkflowSchemaBuilder with refactor-specific tool fields
|
|
return WorkflowSchemaBuilder.build_schema(
|
|
tool_specific_fields=refactor_field_overrides,
|
|
model_field_schema=self.get_model_field_schema(),
|
|
auto_mode=self.is_effective_auto_mode(),
|
|
tool_name=self.get_name(),
|
|
)
|
|
|
|
def get_required_actions(self, step_number: int, confidence: str, findings: str, total_steps: int) -> list[str]:
|
|
"""Define required actions for each investigation phase."""
|
|
if step_number == 1:
|
|
# Initial refactoring investigation tasks
|
|
return [
|
|
"Read and understand the code files specified for refactoring analysis",
|
|
"Examine the overall structure, architecture, and design patterns used",
|
|
"Identify potential code smells: long methods, large classes, duplicate code, complex conditionals",
|
|
"Look for decomposition opportunities: oversized components that could be broken down",
|
|
"Check for modernization opportunities: outdated patterns, deprecated features, newer language constructs",
|
|
"Assess organization: logical grouping, file structure, naming conventions, module boundaries",
|
|
"Document specific refactoring opportunities with file locations and line numbers",
|
|
]
|
|
elif confidence in ["exploring", "incomplete"]:
|
|
# Need deeper investigation
|
|
return [
|
|
"Examine specific code sections you've identified as needing refactoring",
|
|
"Analyze code smells in detail: complexity, coupling, cohesion issues",
|
|
"Investigate decomposition opportunities: identify natural breaking points for large components",
|
|
"Look for modernization possibilities: language features, patterns, libraries that could improve the code",
|
|
"Check organization issues: related functionality that could be better grouped or structured",
|
|
"Trace dependencies and relationships between components to understand refactoring impact",
|
|
"Prioritize refactoring opportunities by impact and effort required",
|
|
]
|
|
elif confidence == "partial":
|
|
# Close to completion - need final verification
|
|
return [
|
|
"Verify all identified refactoring opportunities have been properly documented with locations",
|
|
"Check for any missed opportunities in areas not yet thoroughly examined",
|
|
"Confirm that refactoring suggestions align with the specified refactor_type and focus_areas",
|
|
"Ensure refactoring opportunities are prioritized by severity and impact",
|
|
"Validate that proposed changes would genuinely improve code quality without breaking functionality",
|
|
"Double-check that all relevant files and code elements are captured in your analysis",
|
|
]
|
|
else:
|
|
# General investigation needed
|
|
return [
|
|
"Continue examining the codebase for additional refactoring opportunities",
|
|
"Gather more evidence using appropriate code analysis techniques",
|
|
"Test your assumptions about code quality and improvement possibilities",
|
|
"Look for patterns that confirm or refute your current refactoring assessment",
|
|
"Focus on areas that haven't been thoroughly examined for refactoring potential",
|
|
]
|
|
|
|
def should_call_expert_analysis(self, consolidated_findings, request=None) -> bool:
|
|
"""
|
|
Decide when to call external model based on investigation completeness.
|
|
|
|
Don't call expert analysis if Claude has certain confidence and complete refactoring - trust their judgment.
|
|
"""
|
|
# Check if user requested to skip assistant model
|
|
if request and not self.get_request_use_assistant_model(request):
|
|
return False
|
|
|
|
# Check if refactoring work is complete
|
|
if request and request.confidence == "complete":
|
|
return False
|
|
|
|
# Check if we have meaningful investigation data
|
|
return (
|
|
len(consolidated_findings.relevant_files) > 0
|
|
or len(consolidated_findings.findings) >= 2
|
|
or len(consolidated_findings.issues_found) > 0
|
|
)
|
|
|
|
def prepare_expert_analysis_context(self, consolidated_findings) -> str:
|
|
"""Prepare context for external model call for final refactoring validation."""
|
|
context_parts = [
|
|
f"=== REFACTORING ANALYSIS REQUEST ===\\n{self.initial_request or 'Refactoring workflow initiated'}\\n=== END REQUEST ==="
|
|
]
|
|
|
|
# Add investigation summary
|
|
investigation_summary = self._build_refactoring_summary(consolidated_findings)
|
|
context_parts.append(
|
|
f"\\n=== CLAUDE'S REFACTORING INVESTIGATION ===\\n{investigation_summary}\\n=== END INVESTIGATION ==="
|
|
)
|
|
|
|
# Add refactor configuration context if available
|
|
if self.refactor_config:
|
|
config_text = "\\n".join(f"- {key}: {value}" for key, value in self.refactor_config.items() if value)
|
|
context_parts.append(f"\\n=== REFACTOR CONFIGURATION ===\\n{config_text}\\n=== END CONFIGURATION ===")
|
|
|
|
# Add relevant code elements if available
|
|
if consolidated_findings.relevant_context:
|
|
methods_text = "\\n".join(f"- {method}" for method in consolidated_findings.relevant_context)
|
|
context_parts.append(f"\\n=== RELEVANT CODE ELEMENTS ===\\n{methods_text}\\n=== END CODE ELEMENTS ===")
|
|
|
|
# Add refactoring opportunities found if available
|
|
if consolidated_findings.issues_found:
|
|
opportunities_text = "\\n".join(
|
|
f"[{issue.get('severity', 'unknown').upper()}] {issue.get('type', 'unknown').upper()}: {issue.get('description', 'No description')}"
|
|
for issue in consolidated_findings.issues_found
|
|
)
|
|
context_parts.append(
|
|
f"\\n=== REFACTORING OPPORTUNITIES ===\\n{opportunities_text}\\n=== END OPPORTUNITIES ==="
|
|
)
|
|
|
|
# Add assessment evolution if available
|
|
if consolidated_findings.hypotheses:
|
|
assessments_text = "\\n".join(
|
|
f"Step {h['step']} ({h['confidence']} confidence): {h['hypothesis']}"
|
|
for h in consolidated_findings.hypotheses
|
|
)
|
|
context_parts.append(f"\\n=== ASSESSMENT EVOLUTION ===\\n{assessments_text}\\n=== END ASSESSMENTS ===")
|
|
|
|
# Add images if available
|
|
if consolidated_findings.images:
|
|
images_text = "\\n".join(f"- {img}" for img in consolidated_findings.images)
|
|
context_parts.append(
|
|
f"\\n=== VISUAL REFACTORING INFORMATION ===\\n{images_text}\\n=== END VISUAL INFORMATION ==="
|
|
)
|
|
|
|
return "\\n".join(context_parts)
|
|
|
|
def _build_refactoring_summary(self, consolidated_findings) -> str:
|
|
"""Prepare a comprehensive summary of the refactoring investigation."""
|
|
summary_parts = [
|
|
"=== SYSTEMATIC REFACTORING INVESTIGATION SUMMARY ===",
|
|
f"Total steps: {len(consolidated_findings.findings)}",
|
|
f"Files examined: {len(consolidated_findings.files_checked)}",
|
|
f"Relevant files identified: {len(consolidated_findings.relevant_files)}",
|
|
f"Code elements analyzed: {len(consolidated_findings.relevant_context)}",
|
|
f"Refactoring opportunities identified: {len(consolidated_findings.issues_found)}",
|
|
"",
|
|
"=== INVESTIGATION PROGRESSION ===",
|
|
]
|
|
|
|
for finding in consolidated_findings.findings:
|
|
summary_parts.append(finding)
|
|
|
|
return "\\n".join(summary_parts)
|
|
|
|
def should_include_files_in_expert_prompt(self) -> bool:
|
|
"""Include files in expert analysis for comprehensive refactoring validation."""
|
|
return True
|
|
|
|
def should_embed_system_prompt(self) -> bool:
|
|
"""Embed system prompt in expert analysis for proper context."""
|
|
return True
|
|
|
|
def get_expert_thinking_mode(self) -> str:
|
|
"""Use high thinking mode for thorough refactoring analysis."""
|
|
return "high"
|
|
|
|
def get_expert_analysis_instruction(self) -> str:
|
|
"""Get specific instruction for refactoring expert analysis."""
|
|
return (
|
|
"Please provide comprehensive refactoring analysis based on the investigation findings. "
|
|
"Focus on validating the identified opportunities, ensuring completeness of the analysis, "
|
|
"and providing final recommendations for refactoring implementation, following the structured "
|
|
"format specified in the system prompt."
|
|
)
|
|
|
|
# Hook method overrides for refactor-specific behavior
|
|
|
|
def prepare_step_data(self, request) -> dict:
|
|
"""
|
|
Map refactor workflow-specific fields for internal processing.
|
|
"""
|
|
step_data = {
|
|
"step": request.step,
|
|
"step_number": request.step_number,
|
|
"findings": request.findings,
|
|
"files_checked": request.files_checked,
|
|
"relevant_files": request.relevant_files,
|
|
"relevant_context": request.relevant_context,
|
|
"issues_found": request.issues_found,
|
|
"confidence": request.confidence,
|
|
"hypothesis": request.findings, # Map findings to hypothesis for compatibility
|
|
"images": request.images or [],
|
|
}
|
|
return step_data
|
|
|
|
def should_skip_expert_analysis(self, request, consolidated_findings) -> bool:
|
|
"""
|
|
Refactor workflow skips expert analysis when Claude has "complete" confidence.
|
|
"""
|
|
return request.confidence == "complete" and not request.next_step_required
|
|
|
|
def store_initial_issue(self, step_description: str):
|
|
"""Store initial request for expert analysis."""
|
|
self.initial_request = step_description
|
|
|
|
# Inheritance hook methods for refactor-specific behavior
|
|
|
|
# Override inheritance hooks for refactor-specific behavior
|
|
|
|
def get_completion_status(self) -> str:
|
|
"""Refactor tools use refactor-specific status."""
|
|
return "refactoring_analysis_complete_ready_for_implementation"
|
|
|
|
def get_completion_data_key(self) -> str:
|
|
"""Refactor uses 'complete_refactoring' key."""
|
|
return "complete_refactoring"
|
|
|
|
def get_final_analysis_from_request(self, request):
|
|
"""Refactor tools use 'findings' field."""
|
|
return request.findings
|
|
|
|
def get_confidence_level(self, request) -> str:
|
|
"""Refactor tools use 'complete' for high confidence."""
|
|
return "complete"
|
|
|
|
def get_completion_message(self) -> str:
|
|
"""Refactor-specific completion message."""
|
|
return (
|
|
"Refactoring analysis complete with COMPLETE confidence. You have identified all significant "
|
|
"refactoring opportunities and provided comprehensive analysis. MANDATORY: Present the user with "
|
|
"the complete refactoring results organized by type and severity, and IMMEDIATELY proceed with "
|
|
"implementing the highest priority refactoring opportunities or provide specific guidance for "
|
|
"improvements. Focus on actionable refactoring steps."
|
|
)
|
|
|
|
def get_skip_reason(self) -> str:
|
|
"""Refactor-specific skip reason."""
|
|
return "Claude completed comprehensive refactoring analysis with full confidence"
|
|
|
|
def get_skip_expert_analysis_status(self) -> str:
|
|
"""Refactor-specific expert analysis skip status."""
|
|
return "skipped_due_to_complete_refactoring_confidence"
|
|
|
|
def prepare_work_summary(self) -> str:
|
|
"""Refactor-specific work summary."""
|
|
return self._build_refactoring_summary(self.consolidated_findings)
|
|
|
|
def get_completion_next_steps_message(self, expert_analysis_used: bool = False) -> str:
|
|
"""
|
|
Refactor-specific completion message.
|
|
|
|
Args:
|
|
expert_analysis_used: True if expert analysis was successfully executed
|
|
"""
|
|
base_message = (
|
|
"REFACTORING ANALYSIS IS COMPLETE. You MUST now summarize and present ALL refactoring opportunities "
|
|
"organized by type (codesmells → decompose → modernize → organization) and severity (Critical → High → "
|
|
"Medium → Low), specific code locations with line numbers, and exact recommendations for improvement. "
|
|
"Clearly prioritize the top 3 refactoring opportunities that need immediate attention. Provide concrete, "
|
|
"actionable guidance for each opportunity—make it easy for a developer to understand exactly what needs "
|
|
"to be refactored and how to implement the improvements."
|
|
)
|
|
|
|
# Add expert analysis guidance only when expert analysis was actually used
|
|
if expert_analysis_used:
|
|
expert_guidance = self.get_expert_analysis_guidance()
|
|
if expert_guidance:
|
|
return f"{base_message}\n\n{expert_guidance}"
|
|
|
|
return base_message
|
|
|
|
def get_expert_analysis_guidance(self) -> str:
|
|
"""
|
|
Get additional guidance for handling expert analysis results in refactor context.
|
|
|
|
Returns:
|
|
Additional guidance text for validating and using expert analysis findings
|
|
"""
|
|
return (
|
|
"IMPORTANT: Expert refactoring analysis has been provided above. You MUST review "
|
|
"the expert's architectural insights and refactoring recommendations. Consider whether "
|
|
"the expert's suggestions align with the codebase's evolution trajectory and current "
|
|
"team priorities. Pay special attention to any breaking changes, migration complexity, "
|
|
"or performance implications highlighted by the expert. Present a balanced view that "
|
|
"considers both immediate benefits and long-term maintainability."
|
|
)
|
|
|
|
def get_step_guidance_message(self, request) -> str:
|
|
"""
|
|
Refactor-specific step guidance with detailed investigation instructions.
|
|
"""
|
|
step_guidance = self.get_refactor_step_guidance(request.step_number, request.confidence, request)
|
|
return step_guidance["next_steps"]
|
|
|
|
def get_refactor_step_guidance(self, step_number: int, confidence: str, request) -> dict[str, Any]:
|
|
"""
|
|
Provide step-specific guidance for refactor workflow.
|
|
"""
|
|
# Generate the next steps instruction based on required actions
|
|
required_actions = self.get_required_actions(step_number, confidence, request.findings, request.total_steps)
|
|
|
|
if step_number == 1:
|
|
next_steps = (
|
|
f"MANDATORY: DO NOT call the {self.get_name()} tool again immediately. You MUST first examine "
|
|
f"the code files thoroughly for refactoring opportunities using appropriate tools. CRITICAL AWARENESS: "
|
|
f"You need to identify code smells, decomposition opportunities, modernization possibilities, and "
|
|
f"organization improvements across the specified refactor_type. Look for complexity issues, outdated "
|
|
f"patterns, oversized components, and structural problems. Use file reading tools, code analysis, and "
|
|
f"systematic examination to gather comprehensive refactoring information. Only call {self.get_name()} "
|
|
f"again AFTER completing your investigation. When you call {self.get_name()} next time, use "
|
|
f"step_number: {step_number + 1} and report specific files examined, refactoring opportunities found, "
|
|
f"and improvement assessments discovered."
|
|
)
|
|
elif confidence in ["exploring", "incomplete"]:
|
|
next_steps = (
|
|
f"STOP! Do NOT call {self.get_name()} again yet. Based on your findings, you've identified areas that need "
|
|
f"deeper refactoring analysis. MANDATORY ACTIONS before calling {self.get_name()} step {step_number + 1}:\\n"
|
|
+ "\\n".join(f"{i+1}. {action}" for i, action in enumerate(required_actions))
|
|
+ f"\\n\\nOnly call {self.get_name()} again with step_number: {step_number + 1} AFTER "
|
|
+ "completing these refactoring analysis tasks."
|
|
)
|
|
elif confidence == "partial":
|
|
next_steps = (
|
|
f"WAIT! Your refactoring analysis needs final verification. DO NOT call {self.get_name()} immediately. REQUIRED ACTIONS:\\n"
|
|
+ "\\n".join(f"{i+1}. {action}" for i, action in enumerate(required_actions))
|
|
+ f"\\n\\nREMEMBER: Ensure you have identified all significant refactoring opportunities across all types and "
|
|
f"verified the completeness of your analysis. Document opportunities with specific file references and "
|
|
f"line numbers where applicable, then call {self.get_name()} with step_number: {step_number + 1}."
|
|
)
|
|
else:
|
|
next_steps = (
|
|
f"PAUSE REFACTORING ANALYSIS. Before calling {self.get_name()} step {step_number + 1}, you MUST examine more code thoroughly. "
|
|
+ "Required: "
|
|
+ ", ".join(required_actions[:2])
|
|
+ ". "
|
|
+ f"Your next {self.get_name()} call (step_number: {step_number + 1}) must include "
|
|
f"NEW evidence from actual refactoring analysis, not just theories. NO recursive {self.get_name()} calls "
|
|
f"without investigation work!"
|
|
)
|
|
|
|
return {"next_steps": next_steps}
|
|
|
|
def customize_workflow_response(self, response_data: dict, request) -> dict:
|
|
"""
|
|
Customize response to match refactor workflow format.
|
|
"""
|
|
# Store initial request on first step
|
|
if request.step_number == 1:
|
|
self.initial_request = request.step
|
|
# Store refactor configuration for expert analysis
|
|
if request.relevant_files:
|
|
self.refactor_config = {
|
|
"relevant_files": request.relevant_files,
|
|
"refactor_type": request.refactor_type,
|
|
"focus_areas": request.focus_areas,
|
|
"style_guide_examples": request.style_guide_examples,
|
|
}
|
|
|
|
# Convert generic status names to refactor-specific ones
|
|
tool_name = self.get_name()
|
|
status_mapping = {
|
|
f"{tool_name}_in_progress": "refactoring_analysis_in_progress",
|
|
f"pause_for_{tool_name}": "pause_for_refactoring_analysis",
|
|
f"{tool_name}_required": "refactoring_analysis_required",
|
|
f"{tool_name}_complete": "refactoring_analysis_complete",
|
|
}
|
|
|
|
if response_data["status"] in status_mapping:
|
|
response_data["status"] = status_mapping[response_data["status"]]
|
|
|
|
# Rename status field to match refactor workflow
|
|
if f"{tool_name}_status" in response_data:
|
|
response_data["refactoring_status"] = response_data.pop(f"{tool_name}_status")
|
|
# Add refactor-specific status fields
|
|
refactor_types = {}
|
|
for issue in self.consolidated_findings.issues_found:
|
|
issue_type = issue.get("type", "unknown")
|
|
if issue_type not in refactor_types:
|
|
refactor_types[issue_type] = 0
|
|
refactor_types[issue_type] += 1
|
|
response_data["refactoring_status"]["opportunities_by_type"] = refactor_types
|
|
response_data["refactoring_status"]["refactor_confidence"] = request.confidence
|
|
|
|
# Map complete_refactor to complete_refactoring
|
|
if f"complete_{tool_name}" in response_data:
|
|
response_data["complete_refactoring"] = response_data.pop(f"complete_{tool_name}")
|
|
|
|
# Map the completion flag to match refactor workflow
|
|
if f"{tool_name}_complete" in response_data:
|
|
response_data["refactoring_complete"] = response_data.pop(f"{tool_name}_complete")
|
|
|
|
return response_data
|
|
|
|
# Required abstract methods from BaseTool
|
|
def get_request_model(self):
|
|
"""Return the refactor workflow-specific request model."""
|
|
return RefactorRequest
|
|
|
|
async def prepare_prompt(self, request) -> str:
|
|
"""Not used - workflow tools use execute_workflow()."""
|
|
return "" # Workflow tools use execute_workflow() directly
|