moai-adk 0.8.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

moai_adk/astgrep/rules.py

@@ -0,0 +1,179 @@
+# AST-grep rule management
+"""Rule loading and management for AST-grep analyzer.
+
+This module provides classes for defining AST-grep rules and loading
+them from YAML configuration files.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+@dataclass
+class Rule:
+    """AST-grep rule definition.
+
+    Represents a single AST-grep rule that can be used for pattern
+    matching and code analysis.
+
+    Attributes:
+        id: Unique identifier for the rule.
+        language: Programming language this rule applies to.
+        severity: Severity level (error, warning, info, hint).
+        message: Human-readable description of the rule.
+        pattern: AST-grep pattern to match.
+        fix: Optional fix pattern for automatic correction.
+    """
+
+    id: str
+    language: str
+    severity: str  # error, warning, info, hint
+    message: str
+    pattern: str
+    fix: str | None = None
+
+
+class RuleLoader:
+    """Loader for AST-grep rules from various sources.
+
+    Supports loading rules from individual YAML files, directories
+    containing multiple rule files, and built-in rule sets.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the RuleLoader."""
+        self._rules: list[Rule] = []
+
+    def load_from_file(self, config_path: str) -> list[Rule]:
+        """Load rules from a YAML configuration file.
+
+        Supports both single-document and multi-document YAML files
+        (documents separated by ---).
+
+        Args:
+            config_path: Path to the YAML configuration file.
+
+        Returns:
+            List of Rule objects loaded from the file.
+
+        Raises:
+            FileNotFoundError: If the file does not exist.
+            ValueError: If the YAML content is invalid.
+        """
+        path = Path(config_path)
+        if not path.exists():
+            raise FileNotFoundError(f"Rule file not found: {config_path}")
+
+        try:
+            content = path.read_text()
+            documents = list(yaml.safe_load_all(content))
+        except yaml.YAMLError as e:
+            raise ValueError(f"Invalid YAML in {config_path}: {e}") from e
+
+        rules: list[Rule] = []
+        for doc in documents:
+            if doc is None:
+                continue
+            rule = self._parse_rule_document(doc)
+            if rule:
+                rules.append(rule)
+
+        self._rules.extend(rules)
+        return rules
+
+    def _parse_rule_document(self, doc: dict[str, Any]) -> Rule | None:
+        """Parse a single rule document from YAML.
+
+        Args:
+            doc: Dictionary representing a rule document.
+
+        Returns:
+            Rule object or None if parsing fails.
+        """
+        if not isinstance(doc, dict):
+            return None
+
+        rule_id = doc.get("id")
+        language = doc.get("language")
+        severity = doc.get("severity", "warning")
+        message = doc.get("message", "")
+
+        # Extract pattern from rule.pattern or direct pattern field
+        pattern = None
+        if "rule" in doc and isinstance(doc["rule"], dict):
+            pattern = doc["rule"].get("pattern")
+        elif "pattern" in doc:
+            pattern = doc["pattern"]
+
+        # Extract fix if present
+        fix = doc.get("fix")
+
+        if not rule_id or not language or not pattern:
+            return None
+
+        return Rule(
+            id=rule_id,
+            language=language,
+            severity=severity,
+            message=message,
+            pattern=pattern,
+            fix=fix,
+        )
+
+    def load_builtin_rules(self) -> list[Rule]:
+        """Load built-in rules.
+
+        Returns the default set of rules bundled with the analyzer.
+        Currently returns an empty list; built-in rules can be added
+        in future versions.
+
+        Returns:
+            List of built-in Rule objects.
+        """
+        # Built-in rules can be defined here or loaded from bundled files
+        builtin_rules: list[Rule] = []
+        self._rules.extend(builtin_rules)
+        return builtin_rules
+
+    def get_rules_for_language(self, language: str) -> list[Rule]:
+        """Get all rules for a specific programming language.
+
+        Args:
+            language: The programming language to filter by.
+
+        Returns:
+            List of Rule objects for the specified language.
+        """
+        return [rule for rule in self._rules if rule.language == language]
+
+    def load_from_directory(self, directory_path: str) -> list[Rule]:
+        """Load rules from all YAML files in a directory.
+
+        Scans the directory for .yml and .yaml files and loads rules
+        from each one.
+
+        Args:
+            directory_path: Path to the directory containing rule files.
+
+        Returns:
+            List of all Rule objects loaded from the directory.
+
+        Raises:
+            FileNotFoundError: If the directory does not exist.
+        """
+        path = Path(directory_path)
+        if not path.exists():
+            raise FileNotFoundError(f"Directory not found: {directory_path}")
+
+        rules: list[Rule] = []
+        for yaml_file in path.glob("*.yml"):
+            rules.extend(self.load_from_file(str(yaml_file)))
+        for yaml_file in path.glob("*.yaml"):
+            rules.extend(self.load_from_file(str(yaml_file)))
+
+        return rules

moai_adk/cli/__init__.py

@@ -1,2 +1,6 @@
-# @CODE:PY314-001 | SPEC: SPEC-PY314-001.md | TEST: tests/unit/test_foundation.py
-"""CLI module: Click-based command-line interface"""
+"""MoAI-ADK CLI Tools
+
+Command-line interface utilities for MoAI-ADK project management.
+"""
+
+__all__ = ["spec_status"]

moai_adk/cli/commands/__init__.py

@@ -1,4 +1,3 @@
-# @CODE:CLI-001 | SPEC: SPEC-CLI-001/spec.md | TEST: tests/unit/test_cli_commands.py
 """CLI command module
 
 Core commands:
@@ -6,15 +5,13 @@ Core commands:
 - doctor: run system diagnostics
 - status: show project status
 - update: update templates to latest version
-- backup: create project backups
 
 Note: restore functionality is handled by checkpoint system in core.git.checkpoint
 """
 
-from moai_adk.cli.commands.backup import backup
 from moai_adk.cli.commands.doctor import doctor
 from moai_adk.cli.commands.init import init
 from moai_adk.cli.commands.status import status
 from moai_adk.cli.commands.update import update
 
-__all__ = ["init", "doctor", "status", "update", "backup"]
+__all__ = ["init", "doctor", "status", "update"]

moai_adk/cli/commands/analyze.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+"""
+Analyze command for MoAI-ADK
+
+Analyze Claude Code sessions and generate improvement suggestions.
+"""
+
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from moai_adk.core.analysis.session_analyzer import SessionAnalyzer
+
+# Force UTF-8 encoding for Windows compatibility
+# Windows PowerShell/Console uses 'charmap' by default, which can't encode emojis
+if sys.platform == "win32":
+    console = Console(force_terminal=True, legacy_windows=False)
+else:
+    console = Console()
+
+
+@click.command()
+@click.option("--days", "-d", default=7, help="Number of days to analyze (default: 7)")
+@click.option("--output", "-o", type=click.Path(), help="Output file path")
+@click.option("--verbose", "-v", is_flag=True, help="Verbose output")
+@click.option("--report-only", "-r", is_flag=True, help="Generate report only (no console output)")
+@click.option(
+    "--project-path",
+    "-p",
+    type=click.Path(),
+    help="Project root path (default: current directory)",
+)
+def analyze(
+    days: int,
+    output: Optional[Path],
+    verbose: bool,
+    report_only: bool,
+    project_path: Optional[Path],
+):
+    """
+    Analyze Claude Code sessions from the last N days
+
+    Analyzes Claude Code session logs to identify usage patterns,
+    error frequencies, and generate improvement suggestions.
+
+    Examples:
+        moai-adk analyze session
+        moai-adk analyze session --days 14 --verbose
+        moai-adk analyze session --output /path/to/report.md
+    """
+    if project_path is None:
+        project_path = Path(os.getcwd())
+    elif isinstance(project_path, str):
+        project_path = Path(project_path)
+
+    # Validate project path
+    if not (project_path / ".moai").exists():
+        console.print("[red]Error:[/red] Not a MoAI-ADK project (missing .moai directory)")
+        console.print(f"[blue]Current path:[/blue] {project_path}")
+        return
+
+    # Initialize analyzer
+    analyzer = SessionAnalyzer(days_back=days, verbose=verbose)
+
+    if not report_only:
+        console.print(f"[blue]📊 Analyzing sessions from last {days} days...[/blue]")
+
+    # Parse sessions
+    patterns = analyzer.parse_sessions()
+
+    if not report_only:
+        console.print(f"[green]✅ Analyzed {patterns['total_sessions']} sessions[/green]")
+        console.print(f"[blue]   Total events: {patterns['total_events']}[/blue]")
+
+        # Display summary table
+        table = Table(title="Session Summary")
+        table.add_column("Metric", style="cyan")
+        table.add_column("Value", style="green")
+
+        table.add_row("Total Sessions", str(patterns["total_sessions"]))
+        table.add_row("Total Events", str(patterns["total_events"]))
+        table.add_row("Failed Sessions", str(patterns["failed_sessions"]))
+        table.add_row("Success Rate", f"{patterns.get('success_rate', 0):.1f}%")
+
+        console.print(table)
+
+        # Show top tools
+        if patterns["tool_usage"]:
+            console.print("\n[bold]🔧 Top Tools Used:[/bold]")
+            top_tools = sorted(patterns["tool_usage"].items(), key=lambda x: x[1], reverse=True)[:10]
+
+            tools_table = Table()
+            tools_table.add_column("Tool", style="cyan")
+            tools_table.add_column("Usage", style="green")
+
+            for tool, count in top_tools:
+                tools_table.add_row(f"`{tool}`", str(count))
+
+            console.print(tools_table)
+
+    # Save report
+    output_path_obj = Path(output) if output else None
+    report_path = analyzer.save_report(output_path_obj, project_path)
+
+    if not report_only:
+        console.print(f"\n[green]📄 Report saved: {report_path}[/green]")
+
+        # Show key suggestions
+        report_content = analyzer.generate_report()
+        if "💡 Improvement Suggestions" in report_content:
+            console.print("\n[bold yellow]💡 Key Suggestions:[/bold yellow]")
+            # Extract suggestions section
+            suggestions_start = report_content.find("💡 Improvement Suggestions")
+            if suggestions_start != -1:
+                suggestions_section = report_content[suggestions_start:]
+                # Extract first few suggestions
+                lines = suggestions_section.split("\n")[2:]  # Skip header and empty line
+                for line in lines[:10]:  # Show first 10 lines
+                    if line.strip() and not line.startswith("---"):
+                        console.print(line)

moai_adk/cli/commands/doctor.py

@@ -1,5 +1,3 @@
-# @CODE:CLI-001 | SPEC: SPEC-CLI-001/spec.md | TEST: tests/unit/test_doctor.py
-# @CODE:CLAUDE-COMMANDS-001:CLI | SPEC: SPEC-CLAUDE-COMMANDS-001/spec.md | TEST: tests/unit/test_slash_commands.py
 """MoAI-ADK doctor command
 
 System diagnostics command:
@@ -35,6 +33,7 @@ System diagnostics command:
 """
 
 import json
+import sys
 from pathlib import Path
 
 import click
@@ -45,16 +44,32 @@ from rich.table import Table
 from moai_adk.core.project.checker import SystemChecker, check_environment
 from moai_adk.core.project.detector import detect_project_language
 
-console = Console()
+# Force UTF-8 encoding for Windows compatibility
+# Windows PowerShell/Console uses 'charmap' by default, which can't encode emojis
+if sys.platform == "win32":
+    console = Console(force_terminal=True, legacy_windows=False)
+else:
+    console = Console()
 
 
 @click.command()
-@click.option("--verbose", "-v", is_flag=True, help="Show detailed tool versions and language detection")
+@click.option(
+    "--verbose",
+    "-v",
+    is_flag=True,
+    help="Show detailed tool versions and language detection",
+)
 @click.option("--fix", is_flag=True, help="Suggest fixes for missing tools")
 @click.option("--export", type=click.Path(), help="Export diagnostics to JSON file")
 @click.option("--check", type=str, help="Check specific tool only")
 @click.option("--check-commands", is_flag=True, help="Diagnose slash command loading issues")
-def doctor(verbose: bool, fix: bool, export: str | None, check: str | None, check_commands: bool) -> None:
+def doctor(
+    verbose: bool,
+    fix: bool,
+    export: str | None,
+    check: str | None,
+    check_commands: bool,
+) -> None:
     """Check system requirements and project health
 
     Verifies:
@@ -110,7 +125,10 @@ def doctor(verbose: bool, fix: bool, export: str | None, check: str | None, chec
 
         # In fix mode, suggest installation commands for missing tools
         if fix and "language_tools" in diagnostics_data:
-            _suggest_fixes(diagnostics_data["language_tools"], diagnostics_data.get("detected_language"))
+            _suggest_fixes(
+                diagnostics_data["language_tools"],
+                diagnostics_data.get("detected_language"),
+            )
 
         # When exporting, write diagnostics to JSON
         if export: