claude-mpm 4.24.0__py3-none-any.whl → 5.4.41__py3-none-any.whl

claude_mpm/cli/commands/mpm_init/prompts.py

@@ -10,7 +10,9 @@ from pathlib import Path
 from typing import Any, Dict, Optional
 
 __all__ = [
+    "build_enhanced_update_prompt",
     "build_initialization_prompt",
+    "build_prompt_engineer_optimization_prompt",
     "build_research_context_prompt",
     "build_update_prompt",
 ]
@@ -250,9 +252,9 @@ Update Mode: Smart merge with existing content
 
     prompt += f"""
 Existing Documentation Analysis:
-- Current CLAUDE.md: {doc_analysis.get('size', 0):,} characters, {doc_analysis.get('lines', 0)} lines
-- Has Priority Index: {'Yes' if doc_analysis.get('has_priority_index') else 'No'}
-- Custom Sections: {len(doc_analysis.get('custom_sections', []))} found
+- Current CLAUDE.md: {doc_analysis.get("size", 0):,} characters, {doc_analysis.get("lines", 0)} lines
+- Has Priority Index: {"Yes" if doc_analysis.get("has_priority_index") else "No"}
+- Custom Sections: {len(doc_analysis.get("custom_sections", []))} found
 """
     if preserve_custom and doc_analysis.get("custom_sections"):
         prompt += f"- Preserve Custom Sections: {', '.join(doc_analysis['custom_sections'][:5])}\n"
@@ -305,6 +307,208 @@ preserving valuable project-specific information while refreshing standard secti
     return prompt
 
 
+def build_enhanced_update_prompt(
+    project_path: Path,
+    doc_analysis: Dict[str, Any],
+    git_insights: Dict[str, Any],
+    log_insights: Dict[str, Any],
+    memory_insights: Dict[str, Any],
+    project_type: Optional[str] = None,
+    framework: Optional[str] = None,
+    ast_analysis: bool = True,
+    preserve_custom: bool = True,
+) -> str:
+    """
+    Build enhanced update prompt with extracted knowledge from multiple sources.
+
+    This is the AUTO-DETECTED update mode that enriches CLAUDE.md with:
+    - Git history insights (architectural decisions, tech changes, workflows)
+    - Session log learnings (completed work, patterns)
+    - Memory file knowledge (accumulated project wisdom)
+
+    Args:
+        project_path: Path to the project directory
+        doc_analysis: Analysis results from DocumentationManager
+        git_insights: Extracted git history insights
+        log_insights: Extracted session log insights
+        memory_insights: Extracted memory file insights
+        project_type: Type of project (web, api, cli, library, etc.)
+        framework: Specific framework if applicable
+        ast_analysis: Enable AST analysis for enhanced documentation
+        preserve_custom: Preserve custom sections when updating
+
+    Returns:
+        Formatted prompt string for enhanced update mode
+    """
+    prompt = f"""Please delegate this task to the Agentic Coder Optimizer agent:
+
+ENHANCED UPDATE of existing CLAUDE.md documentation with extracted project knowledge.
+
+Project Path: {project_path}
+Update Mode: Knowledge-enriched smart merge
+"""
+    if project_type:
+        prompt += f"Project Type: {project_type}\n"
+    if framework:
+        prompt += f"Framework: {framework}\n"
+
+    prompt += f"""
+Existing Documentation Analysis:
+- Current CLAUDE.md: {doc_analysis.get("size", 0):,} characters, {doc_analysis.get("lines", 0)} lines
+- Has Priority Index: {"Yes" if doc_analysis.get("has_priority_index") else "No"}
+- Custom Sections: {len(doc_analysis.get("custom_sections", []))} found
+"""
+    if preserve_custom and doc_analysis.get("custom_sections"):
+        prompt += f"- Preserve Custom Sections: {', '.join(doc_analysis['custom_sections'][:5])}\n"
+
+    # Add extracted knowledge sections
+    prompt += "\n## Extracted Project Knowledge\n\n"
+
+    # Git insights
+    if git_insights.get("available"):
+        prompt += "### From Git History (last 90 days):\n\n"
+
+        if git_insights.get("architectural_decisions"):
+            prompt += "**Architectural Patterns Detected:**\n"
+            for decision in git_insights["architectural_decisions"][:10]:
+                prompt += f"- {decision}\n"
+            prompt += "\n"
+
+        if git_insights.get("tech_stack_changes"):
+            prompt += "**Tech Stack Changes:**\n"
+            for change in git_insights["tech_stack_changes"][:10]:
+                prompt += f"- {change}\n"
+            prompt += "\n"
+
+        if git_insights.get("workflow_patterns"):
+            prompt += "**Common Workflows:**\n"
+            for workflow in git_insights["workflow_patterns"][:8]:
+                prompt += f"- {workflow}\n"
+            prompt += "\n"
+
+        if git_insights.get("hot_files"):
+            prompt += "**Hot Files (frequently modified):**\n"
+            for file_info in git_insights["hot_files"][:10]:
+                prompt += (
+                    f"- {file_info['path']} ({file_info['modifications']} changes)\n"
+                )
+            prompt += "\n"
+
+    # Session log insights
+    if log_insights.get("available") and log_insights.get("learnings"):
+        prompt += "### From Session Logs:\n\n"
+        prompt += "**Recent Learnings from PM Summaries:**\n"
+        for learning in log_insights["learnings"][:10]:
+            source = learning.get("source", "unknown")
+            content = learning.get("content", "")
+            # Truncate long content
+            if len(content) > 200:
+                content = content[:200] + "..."
+            prompt += f"- [{source}] {content}\n"
+        prompt += "\n"
+
+        if log_insights.get("common_patterns"):
+            prompt += "**Common Task Patterns:**\n"
+            prompt += f"- {', '.join(log_insights['common_patterns'][:10])}\n\n"
+
+    # Memory insights
+    if memory_insights.get("available"):
+        has_content = False
+
+        if memory_insights.get("architectural_knowledge"):
+            has_content = True
+            prompt += "### From Agent Memories:\n\n"
+            prompt += "**Architectural Knowledge:**\n"
+            for item in memory_insights["architectural_knowledge"][:8]:
+                prompt += f"- {item}\n"
+            prompt += "\n"
+
+        if memory_insights.get("implementation_guidelines"):
+            if not has_content:
+                prompt += "### From Agent Memories:\n\n"
+                has_content = True
+            prompt += "**Implementation Guidelines:**\n"
+            for item in memory_insights["implementation_guidelines"][:8]:
+                prompt += f"- {item}\n"
+            prompt += "\n"
+
+        if memory_insights.get("common_mistakes"):
+            if not has_content:
+                prompt += "### From Agent Memories:\n\n"
+                has_content = True
+            prompt += "**Common Mistakes to Avoid:**\n"
+            for item in memory_insights["common_mistakes"][:8]:
+                prompt += f"- {item}\n"
+            prompt += "\n"
+
+        if memory_insights.get("technical_context"):
+            if not has_content:
+                prompt += "### From Agent Memories:\n\n"
+            prompt += "**Current Technical Context:**\n"
+            for item in memory_insights["technical_context"][:8]:
+                prompt += f"- {item}\n"
+            prompt += "\n"
+
+    # Add update instructions
+    prompt += """
+## UPDATE Tasks with Knowledge Integration:
+
+1. **Review Existing Content**:
+   - Analyze current CLAUDE.md structure and content
+   - Identify outdated or missing information
+   - Preserve valuable custom sections and project-specific knowledge
+
+2. **Integrate Extracted Knowledge**:
+   - Merge architectural decisions from git history into Architecture section
+   - Add tech stack changes to Technology/Dependencies sections
+   - Update workflow patterns in Development Guidelines
+   - Incorporate session learnings into relevant sections
+   - Merge memory insights into appropriate documentation areas
+   - Highlight hot files as critical components
+
+3. **Smart Content Merge**:
+   - Update project overview with recent developments
+   - Refresh architecture documentation with detected patterns
+   - Update development workflows with discovered common patterns
+   - Ensure single-path principle (ONE way to do each task)
+   - Remove duplicate or contradictory information
+
+4. **Update Priority Organization**:
+   - Reorganize content with priority markers (🔴🟡🟢⚪)
+   - Ensure critical instructions are at the top
+   - Update priority index with all important items
+   - Promote frequently-modified files to IMPORTANT sections
+
+5. **Refresh Technical Content**:
+   - Update build/test/deploy commands based on workflow patterns
+   - Verify tool configurations match tech stack changes
+   - Update dependency information with detected changes
+   - Refresh API documentation if applicable
+"""
+    if ast_analysis:
+        prompt += """
+6. **Update Code Documentation** (using Code Analyzer agent):
+   - Re-analyze code structure for changes
+   - Update API documentation
+   - Refresh architecture diagrams
+   - Document hot files and critical components
+"""
+    prompt += """
+7. **Final Optimization**:
+   - Ensure single-path principle throughout
+   - Validate all links and references
+   - Add/update timestamp in meta section
+   - Add "Last Updated" note mentioning knowledge extraction
+   - Verify AI agent readability
+
+IMPORTANT: This is an ENHANCED UPDATE operation with extracted knowledge.
+Intelligently merge insights from git history, session logs, and agent memories
+into the existing CLAUDE.md while preserving valuable custom content.
+The goal is to create a living document that reflects actual project evolution.
+"""
+    return prompt
+
+
 def build_research_context_prompt(git_analysis: Dict[str, Any], days: int) -> str:
     """
     Build structured Research agent delegation prompt from git analysis.
@@ -334,12 +538,12 @@ You are Research agent analyzing git history to provide PM with intelligent proj
     if git_analysis.get("adaptive_mode"):
         actual_days = git_analysis.get("actual_time_span", "extended period")
         prompt += f""" (adaptive: {actual_days} days analyzed)
-- **Note**: {git_analysis.get('reason', 'Analysis window adjusted to ensure meaningful context')}"""
+- **Note**: {git_analysis.get("reason", "Analysis window adjusted to ensure meaningful context")}"""
 
     prompt += f"""
 - **Commits Analyzed**: {len(commits)} commits
-- **Branches**: {', '.join(branches[:5]) if branches else 'main'}
-- **Contributors**: {', '.join(contributors.keys()) if contributors else 'Unknown'}
+- **Branches**: {", ".join(branches[:5]) if branches else "main"}
+- **Contributors**: {", ".join(contributors.keys()) if contributors else "Unknown"}
 
 ## Your Mission
 
@@ -440,3 +644,79 @@ Keep it concise (<1000 words) but actionable.
 """
 
     return prompt
+
+
+def build_prompt_engineer_optimization_prompt(
+    content: str, estimated_tokens: int
+) -> str:
+    """
+    Build prompt for prompt-engineer to optimize CLAUDE.md.
+
+    Args:
+        content: Current CLAUDE.md content to optimize
+        estimated_tokens: Estimated token count of current content
+
+    Returns:
+        Formatted prompt string for prompt-engineer optimization
+    """
+    return f"""Please delegate this task to the Prompt Engineer agent:
+
+Optimize this CLAUDE.md file for conciseness, clarity, and token efficiency while preserving all critical information.
+
+## Current CLAUDE.md Statistics
+- Estimated tokens: {estimated_tokens:,}
+- Target reduction: 20-30% if possible
+- Priority: Preserve ALL CRITICAL (🔴) and IMPORTANT (🟡) information
+
+## Optimization Goals
+
+1. **Remove Redundancy**:
+   - Eliminate duplicate information across sections
+   - Consolidate similar instructions
+   - Remove verbose explanations where brevity suffices
+
+2. **Tighten Language**:
+   - Use fewer words to convey the same meaning
+   - Replace wordy phrases with concise alternatives
+   - Remove filler words and unnecessary qualifiers
+
+3. **Improve Structure**:
+   - Ensure clear hierarchical organization
+   - Use priority markers (🔴 🟡 🟢 ⚪) effectively
+   - Group related information logically
+   - Maintain scannable headings
+
+4. **Preserve Critical Content**:
+   - Keep ALL security and data handling rules (🔴)
+   - Maintain core business logic and constraints (🔴)
+   - Preserve architectural decisions (🟡)
+   - Keep essential workflows intact (🟡)
+
+5. **Apply Claude Best Practices**:
+   - Use high-level guidance over prescriptive checklists
+   - Provide context for WHY, not just WHAT
+   - Ensure instructions are actionable and unambiguous
+   - Optimize for AI agent understanding
+
+## Current CLAUDE.md Content
+
+{content}
+
+## Output Requirements
+
+Return ONLY the optimized CLAUDE.md content with NO additional explanations.
+The optimized version should:
+- Reduce token count by 20-30% if feasible
+- Maintain all CRITICAL and IMPORTANT instructions
+- Improve clarity and scannability
+- Follow the same structural template (Priority Index, sections with markers)
+
+## Quality Criteria
+
+✅ All 🔴 CRITICAL items preserved
+✅ All 🟡 IMPORTANT items preserved
+✅ No contradictory instructions
+✅ Clear, concise language throughout
+✅ Logical organization maintained
+✅ Token count reduced meaningfully
+"""