claude-mpm 5.1.9__py3-none-any.whl → 5.4.22__py3-none-any.whl

claude_mpm/cli/commands/summarize.py

@@ -0,0 +1,413 @@
+"""
+Document Summarization Command.
+
+Shell-based alternative to MCP document_summarizer tool.
+Provides algorithmic summarization without ML dependencies.
+
+Design Decision: Uses simple text processing techniques:
+- Brief: First paragraph extraction
+- Detailed: Key sentence extraction based on position and length
+- Bullet Points: Convert to markdown bullet list
+- Executive: Opening + conclusion extraction
+
+Why: Lightweight, fast, no dependencies, works offline.
+"""
+
+import json
+import re
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+
+
+class SummaryStyle(str, Enum):
+    """Summary output styles."""
+
+    BRIEF = "brief"
+    DETAILED = "detailed"
+    BULLET_POINTS = "bullet_points"
+    EXECUTIVE = "executive"
+
+
+class OutputFormat(str, Enum):
+    """Output format types."""
+
+    TEXT = "text"
+    JSON = "json"
+    MARKDOWN = "markdown"
+
+
+class DocumentSummarizer:
+    """
+    Algorithmic document summarizer.
+
+    Design Decision: Use simple heuristics instead of ML:
+    - Position-based extraction (opening, closing paragraphs)
+    - Length-based filtering (key sentences)
+    - Structure detection (headings, lists)
+
+    Trade-offs:
+    - Performance: O(n) single pass vs. complex NLP models
+    - Accuracy: ~70% vs. ~90% for ML models
+    - Simplicity: Zero dependencies vs. heavy ML packages
+    """
+
+    def __init__(self, max_words: int = 150):
+        """Initialize summarizer with word limit."""
+        self.max_words = max_words
+
+    def summarize(
+        self, content: str, style: SummaryStyle, lines_limit: Optional[int] = None
+    ) -> str:
+        """
+        Summarize document content.
+
+        Args:
+            content: Document text to summarize
+            style: Summary style (brief, detailed, bullet_points, executive)
+            lines_limit: Optional line limit (reads first N lines only)
+
+        Returns:
+            Summary text
+
+        Complexity: O(n) where n is content length
+        """
+        # Apply line limit if specified
+        if lines_limit:
+            content = self._limit_lines(content, lines_limit)
+
+        # Route to style-specific summarizer
+        summarizers = {
+            SummaryStyle.BRIEF: self._summarize_brief,
+            SummaryStyle.DETAILED: self._summarize_detailed,
+            SummaryStyle.BULLET_POINTS: self._summarize_bullet_points,
+            SummaryStyle.EXECUTIVE: self._summarize_executive,
+        }
+
+        summary = summarizers[style](content)
+        return self._truncate_to_word_limit(summary)
+
+    def _limit_lines(self, content: str, limit: int) -> str:
+        """Limit content to first N lines."""
+        lines = content.split("\n")
+        return "\n".join(lines[:limit])
+
+    def _truncate_to_word_limit(self, text: str) -> str:
+        """Truncate text to max_words limit."""
+        words = text.split()
+        if len(words) <= self.max_words:
+            return text
+
+        # Truncate and add ellipsis
+        truncated = " ".join(words[: self.max_words])
+        return f"{truncated}..."
+
+    def _summarize_brief(self, content: str) -> str:
+        """
+        Brief summary: Extract first paragraph.
+
+        Heuristic: First non-empty paragraph usually introduces document.
+        """
+        paragraphs = self._extract_paragraphs(content)
+        if not paragraphs:
+            return content.strip()
+
+        return paragraphs[0]
+
+    def _summarize_detailed(self, content: str) -> str:
+        """
+        Detailed summary: Extract key sentences.
+
+        Heuristics:
+        - First paragraph (introduction)
+        - Sentences with important markers (however, therefore, important)
+        - Last paragraph (conclusion)
+        """
+        paragraphs = self._extract_paragraphs(content)
+        if not paragraphs:
+            return content.strip()
+
+        key_sentences = []
+
+        # Add first paragraph
+        if paragraphs:
+            key_sentences.append(paragraphs[0])
+
+        # Add sentences with key markers from middle paragraphs
+        if len(paragraphs) > 2:
+            key_markers = [
+                "however",
+                "therefore",
+                "important",
+                "note",
+                "critical",
+                "key",
+                "must",
+                "should",
+                "recommended",
+            ]
+
+            for para in paragraphs[1:-1]:
+                sentences = self._split_sentences(para)
+                for sentence in sentences:
+                    if any(marker in sentence.lower() for marker in key_markers):
+                        key_sentences.append(sentence)
+                        break  # One sentence per paragraph max
+
+        # Add last paragraph
+        if len(paragraphs) > 1:
+            key_sentences.append(paragraphs[-1])
+
+        return " ".join(key_sentences)
+
+    def _summarize_bullet_points(self, content: str) -> str:
+        """
+        Bullet point summary: Convert paragraphs to markdown list.
+
+        Heuristic: Each paragraph becomes a bullet point.
+        """
+        paragraphs = self._extract_paragraphs(content)
+        if not paragraphs:
+            return content.strip()
+
+        # Take key paragraphs (first, middle with markers, last)
+        key_paragraphs = []
+
+        # Always include first
+        if paragraphs:
+            key_paragraphs.append(paragraphs[0])
+
+        # Include middle paragraphs with key content
+        if len(paragraphs) > 2:
+            key_markers = ["however", "therefore", "important", "note", "critical"]
+            for para in paragraphs[1:-1]:
+                if any(marker in para.lower() for marker in key_markers):
+                    # Take first sentence only for bullet point
+                    first_sentence = self._split_sentences(para)[0]
+                    key_paragraphs.append(first_sentence)
+
+        # Include last if different from first
+        if len(paragraphs) > 1:
+            key_paragraphs.append(paragraphs[-1])
+
+        # Format as markdown bullets
+        bullets = [f"- {para}" for para in key_paragraphs]
+        return "\n".join(bullets)
+
+    def _summarize_executive(self, content: str) -> str:
+        """
+        Executive summary: Opening + conclusion.
+
+        Heuristic: First and last paragraphs capture overview and conclusion.
+        """
+        paragraphs = self._extract_paragraphs(content)
+        if not paragraphs:
+            return content.strip()
+
+        if len(paragraphs) == 1:
+            return paragraphs[0]
+
+        # Opening paragraph + conclusion paragraph
+        return f"{paragraphs[0]}\n\n{paragraphs[-1]}"
+
+    def _extract_paragraphs(self, content: str) -> list[str]:
+        """
+        Extract paragraphs from content.
+
+        Filters out:
+        - Empty lines
+        - Short lines (< 40 chars, likely headers/formatting artifacts)
+        - Code blocks (lines with multiple indentation)
+        - Lines that look like code (contain def, class, =, {, etc.)
+        """
+        # Split on double newlines for paragraph boundaries
+        raw_paragraphs = re.split(r"\n\s*\n", content)
+
+        paragraphs = []
+        for para in raw_paragraphs:
+            # Clean and normalize whitespace
+            para = " ".join(para.split())
+
+            # Skip empty or very short paragraphs (likely headers)
+            if len(para) < 40:
+                continue
+
+            # Skip code blocks (heuristic: contains code-like patterns)
+            code_indicators = ["def ", "class ", " = ", "{", "}", "return ", "import "]
+            if any(indicator in para for indicator in code_indicators):
+                continue
+
+            paragraphs.append(para)
+
+        return paragraphs
+
+    def _split_sentences(self, text: str) -> list[str]:
+        """
+        Split text into sentences.
+
+        Simple heuristic: Split on '. ' but handle common abbreviations.
+        """
+        # Handle common abbreviations to avoid false splits
+        text = text.replace("Dr.", "Dr<DOT>")
+        text = text.replace("Mr.", "Mr<DOT>")
+        text = text.replace("Mrs.", "Mrs<DOT>")
+        text = text.replace("e.g.", "e<DOT>g<DOT>")
+        text = text.replace("i.e.", "i<DOT>e<DOT>")
+
+        # Split on sentence boundaries
+        sentences = re.split(r"(?<=[.!?])\s+", text)
+
+        # Restore abbreviations
+        sentences = [s.replace("<DOT>", ".") for s in sentences]
+
+        return [s.strip() for s in sentences if s.strip()]
+
+
+def format_output(summary: str, output_format: OutputFormat, file_path: Path) -> str:
+    """
+    Format summary output.
+
+    Args:
+        summary: Summary text
+        output_format: Output format (text, json, markdown)
+        file_path: Original file path for metadata
+
+    Returns:
+        Formatted output string
+    """
+    if output_format == OutputFormat.TEXT:
+        return summary
+
+    if output_format == OutputFormat.JSON:
+        result = {
+            "file": str(file_path),
+            "summary": summary,
+            "word_count": len(summary.split()),
+        }
+        return json.dumps(result, indent=2)
+
+    if output_format == OutputFormat.MARKDOWN:
+        return f"# Summary: {file_path.name}\n\n{summary}\n"
+
+    return summary
+
+
+def summarize_command(args) -> int:
+    """
+    Execute summarize command.
+
+    Args:
+        args: Parsed command line arguments with:
+            - file_path: Path to file to summarize
+            - style: Summary style
+            - max_words: Maximum words in summary
+            - output: Output format
+            - lines: Optional line limit
+
+    Returns:
+        Exit code (0 for success, 1 for error)
+    """
+    file_path = Path(args.file_path)
+
+    # Validate file exists
+    if not file_path.exists():
+        print(f"Error: File not found: {file_path}")
+        return 1
+
+    if not file_path.is_file():
+        print(f"Error: Not a file: {file_path}")
+        return 1
+
+    try:
+        # Read file content
+        content = file_path.read_text(encoding="utf-8")
+
+        # Create summarizer
+        summarizer = DocumentSummarizer(max_words=args.max_words)
+
+        # Generate summary
+        summary = summarizer.summarize(
+            content, style=SummaryStyle(args.style), lines_limit=args.lines
+        )
+
+        # Format output
+        output = format_output(summary, OutputFormat(args.output), file_path)
+
+        # Print result
+        print(output)
+
+        return 0
+
+    except UnicodeDecodeError:
+        print(f"Error: Cannot read file (not valid UTF-8): {file_path}")
+        return 1
+    except Exception as e:
+        print(f"Error: {e}")
+        return 1
+
+
+def add_summarize_parser(subparsers) -> None:
+    """
+    Add summarize subcommand parser.
+
+    Args:
+        subparsers: Subparsers object from argparse
+    """
+    parser = subparsers.add_parser(
+        "summarize",
+        help="Summarize document content (shell-based alternative to MCP document_summarizer)",
+        description="""
+Algorithmic document summarization without ML dependencies.
+
+Styles:
+  brief         - First paragraph only (quick overview)
+  detailed      - Key sentences from opening, middle, closing
+  bullet_points - Markdown bullet list of key points
+  executive     - Opening + conclusion (for quick decisions)
+
+Examples:
+  claude-mpm summarize README.md
+  claude-mpm summarize docs/guide.md --style detailed --max-words 200
+  claude-mpm summarize src/main.py --style bullet_points --output markdown
+  claude-mpm summarize large.txt --lines 100 --style brief
+        """,
+        formatter_class=lambda prog: __import__("argparse").RawDescriptionHelpFormatter(
+            prog, max_help_position=40
+        ),
+    )
+
+    # Required arguments
+    parser.add_argument("file_path", type=str, help="Path to file to summarize")
+
+    # Optional arguments
+    parser.add_argument(
+        "--style",
+        type=str,
+        choices=["brief", "detailed", "bullet_points", "executive"],
+        default="brief",
+        help="Summary style (default: brief)",
+    )
+
+    parser.add_argument(
+        "--max-words",
+        type=int,
+        default=150,
+        help="Maximum words in summary (default: 150)",
+    )
+
+    parser.add_argument(
+        "--output",
+        type=str,
+        choices=["text", "json", "markdown"],
+        default="text",
+        help="Output format (default: text)",
+    )
+
+    parser.add_argument(
+        "--lines",
+        type=int,
+        default=None,
+        help="Limit to first N lines of file (default: no limit)",
+    )
+
+    parser.set_defaults(command="summarize")

claude_mpm/cli/executor.py

@@ -24,6 +24,7 @@ from .commands import (
     show_info,
 )
 from .commands.analyze_code import manage_analyze_code
+from .commands.config import manage_config
 from .commands.dashboard import manage_dashboard
 from .commands.skills import manage_skills
 from .commands.upgrade import upgrade
@@ -141,6 +142,14 @@ def execute_command(command: str, args) -> int:
         result = agent_source_command(args)
         return result if result is not None else 0
 
+    # Handle summarize command with lazy import
+    if command == "summarize":
+        # Lazy import to avoid loading unless needed
+        from .commands.summarize import summarize_command
+
+        result = summarize_command(args)
+        return result if result is not None else 0
+
     # Handle auto-configure command with lazy import
     if command == "auto-configure":
         # Lazy import to avoid loading unless needed
@@ -228,9 +237,8 @@ def execute_command(command: str, args) -> int:
         CLICommands.MEMORY.value: manage_memory,
         CLICommands.MONITOR.value: manage_monitor,
         CLICommands.DASHBOARD.value: manage_dashboard,
-        # Configuration management commands (synonymous)
-        # Both 'config' and 'configure' launch the interactive configuration TUI
-        CLICommands.CONFIG.value: manage_configure,  # Alias to configure
+        # Configuration management commands
+        CLICommands.CONFIG.value: manage_config,  # Unified config with subcommands
         CLICommands.CONFIGURE.value: manage_configure,  # Interactive configuration TUI
         CLICommands.AGGREGATE.value: aggregate_command,
         CLICommands.ANALYZE_CODE.value: manage_analyze_code,

claude_mpm/cli/parsers/agents_parser.py

@@ -406,15 +406,6 @@ Available commands:
         help="Show descriptions and metadata for each agent",
     )
 
-    # Auto-configuration commands (TSK-0054 Phase 5)
-    from .auto_configure_parser import (
-        add_agents_detect_subparser,
-        add_agents_recommend_subparser,
-    )
-
-    add_agents_detect_subparser(agents_subparsers)
-    add_agents_recommend_subparser(agents_subparsers)
-
     # Phase 3: Agent Selection Modes (single-tier deployment)
     # Minimal configuration - deploy 6 core agents
     deploy_minimal_parser = agents_subparsers.add_parser(

claude_mpm/cli/parsers/auto_configure_parser.py

@@ -118,141 +118,3 @@ Examples:
     )
 
     return auto_configure_parser
-
-
-def add_agents_detect_subparser(agents_subparsers) -> argparse.ArgumentParser:
-    """
-    Add the agents detect subparser for toolchain detection.
-
-    WHY: Allows users to see what toolchain is detected without making changes,
-    useful for debugging and verification.
-
-    Args:
-        agents_subparsers: The agents subparsers object
-
-    Returns:
-        The configured detect subparser
-    """
-    detect_parser = agents_subparsers.add_parser(
-        "detect",
-        help="Detect project toolchain without deploying",
-        description="""
-Detect and display project toolchain without making any changes.
-
-This command analyzes your project to detect:
-  • Programming languages and versions
-  • Frameworks and libraries
-  • Deployment targets and platforms
-
-Useful for debugging toolchain detection and verifying what would be
-detected before running auto-configure.
-        """,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  # Detect toolchain in current directory
-  claude-mpm agents detect
-
-  # Detect with verbose output showing evidence
-  claude-mpm agents detect --verbose
-
-  # JSON output for scripting
-  claude-mpm agents detect --json
-
-  # Detect specific project
-  claude-mpm agents detect --project-path /path/to/project
-        """,
-    )
-    add_common_arguments(detect_parser)
-
-    detect_parser.add_argument(
-        "--project-path",
-        type=Path,
-        metavar="PATH",
-        help="Project path to analyze (default: current directory)",
-    )
-
-    return detect_parser
-
-
-def add_agents_recommend_subparser(
-    agents_subparsers,
-) -> argparse.ArgumentParser:
-    """
-    Add the agents recommend subparser for agent recommendations.
-
-    WHY: Allows users to see what agents would be recommended without deploying,
-    useful for reviewing recommendations before committing to deployment.
-
-    Args:
-        agents_subparsers: The agents subparsers object
-
-    Returns:
-        The configured recommend subparser
-    """
-    recommend_parser = agents_subparsers.add_parser(
-        "recommend",
-        help="Show recommended agents without deploying",
-        description="""
-Show recommended agents based on project toolchain without deploying.
-
-This command analyzes your project toolchain and recommends appropriate
-agents with detailed reasoning for each recommendation. No changes are
-made to your project.
-
-Useful for:
-  • Reviewing recommendations before deployment
-  • Understanding why agents are recommended
-  • Adjusting confidence thresholds
-        """,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  # Show recommendations with reasoning
-  claude-mpm agents recommend
-
-  # Require 90% confidence for recommendations
-  claude-mpm agents recommend --min-confidence 0.9
-
-  # JSON output for scripting
-  claude-mpm agents recommend --json
-
-  # Hide detailed reasoning
-  claude-mpm agents recommend --no-reasoning
-
-  # Recommend for specific project
-  claude-mpm agents recommend --project-path /path/to/project
-        """,
-    )
-    add_common_arguments(recommend_parser)
-
-    recommend_parser.add_argument(
-        "--project-path",
-        type=Path,
-        metavar="PATH",
-        help="Project path to analyze (default: current directory)",
-    )
-
-    recommend_parser.add_argument(
-        "--min-confidence",
-        type=float,
-        default=0.8,
-        metavar="FLOAT",
-        help="Minimum confidence threshold for recommendations (0.0-1.0, default: 0.8)",
-    )
-
-    recommend_parser.add_argument(
-        "--show-reasoning",
-        action="store_true",
-        default=True,
-        help="Show detailed reasoning for recommendations (default)",
-    )
-
-    recommend_parser.add_argument(
-        "--no-reasoning",
-        dest="show_reasoning",
-        action="store_false",
-        help="Hide detailed reasoning for recommendations",
-    )
-
-    return recommend_parser

claude_mpm/cli/parsers/base_parser.py

@@ -594,6 +594,11 @@ def create_parser(
             action="store_true",
             help="Skip confirmation prompts",
         )
+
+        # Add summarize command
+        from ..commands.summarize import add_summarize_parser
+
+        add_summarize_parser(subparsers)
     except ImportError:
         # Commands module may not be available during testing or refactoring
         pass