greenmining 0.1.4__py3-none-any.whl

greenmining/main.py

@@ -0,0 +1,37 @@
+"""Main entry point for Green Microservices Mining CLI."""
+
+import sys
+
+from cli import cli
+
+from greenmining.utils import colored_print, print_banner
+
+
+def main():
+    """Main entry point with error handling."""
+    try:
+        print_banner("🌱 Green Microservices Mining Tool")
+        colored_print("Analyze GitHub repositories for sustainability practices\n", "cyan")
+
+        cli(obj={})
+
+    except KeyboardInterrupt:
+        colored_print("\n\n⚠️  Operation cancelled by user", "yellow")
+        sys.exit(130)
+
+    except Exception as e:
+        colored_print(f"\n❌ Unexpected error: {e}", "red")
+
+        if "--verbose" in sys.argv or "-v" in sys.argv:
+            import traceback
+
+            colored_print("\nFull traceback:", "red")
+            traceback.print_exc()
+        else:
+            colored_print("Run with --verbose for detailed error information", "yellow")
+
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

greenmining/models/__init__.py

@@ -0,0 +1,12 @@
+"""
+Models Package - Data models and entities for green microservices mining.
+
+This package contains all data structures and domain models following MCP architecture.
+"""
+
+from .aggregated_stats import AggregatedStats
+from .analysis_result import AnalysisResult
+from .commit import Commit
+from .repository import Repository
+
+__all__ = ["Repository", "Commit", "AnalysisResult", "AggregatedStats"]

greenmining/models/aggregated_stats.py

@@ -0,0 +1,30 @@
+"""Aggregated Statistics Model - Represents aggregated analysis data."""
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class AggregatedStats:
+    """Data model for aggregated statistics."""
+
+    summary: dict = field(default_factory=dict)
+    known_patterns: dict = field(default_factory=dict)
+    repositories: list[dict] = field(default_factory=list)
+    languages: dict = field(default_factory=dict)
+    timestamp: Optional[str] = None
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        return {
+            "summary": self.summary,
+            "known_patterns": self.known_patterns,
+            "repositories": self.repositories,
+            "languages": self.languages,
+            "timestamp": self.timestamp,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "AggregatedStats":
+        """Create from dictionary."""
+        return cls(**{k: v for k, v in data.items() if k in cls.__annotations__})

greenmining/models/analysis_result.py

@@ -0,0 +1,48 @@
+"""Analysis Result Model - Represents commit analysis output."""
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class AnalysisResult:
+    """Data model for commit analysis results."""
+
+    commit_id: str
+    repo_name: str
+    date: str
+    commit_message: str
+    green_aware: bool
+    green_evidence: Optional[str] = None
+    known_pattern: Optional[str] = None
+    pattern_confidence: Optional[str] = None
+    emergent_pattern: Optional[str] = None
+    files_changed: list = None
+    lines_added: int = 0
+    lines_deleted: int = 0
+
+    def __post_init__(self):
+        if self.files_changed is None:
+            self.files_changed = []
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        return {
+            "commit_id": self.commit_id,
+            "repo_name": self.repo_name,
+            "date": self.date,
+            "commit_message": self.commit_message,
+            "green_aware": self.green_aware,
+            "green_evidence": self.green_evidence,
+            "known_pattern": self.known_pattern,
+            "pattern_confidence": self.pattern_confidence,
+            "emergent_pattern": self.emergent_pattern,
+            "files_changed": self.files_changed,
+            "lines_added": self.lines_added,
+            "lines_deleted": self.lines_deleted,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "AnalysisResult":
+        """Create from dictionary."""
+        return cls(**{k: v for k, v in data.items() if k in cls.__annotations__})

greenmining/models/commit.py

@@ -0,0 +1,71 @@
+"""Commit Model - Represents a Git commit."""
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Commit:
+    """Data model for a Git commit."""
+
+    commit_id: str
+    repo_name: str
+    date: str
+    author: str
+    author_email: str
+    message: str
+    files_changed: list[str] = field(default_factory=list)
+    lines_added: int = 0
+    lines_deleted: int = 0
+    insertions: int = 0
+    deletions: int = 0
+    is_merge: bool = False
+    branches: list[str] = field(default_factory=list)
+    in_main_branch: bool = True
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        return {
+            "commit_id": self.commit_id,
+            "repo_name": self.repo_name,
+            "date": self.date,
+            "author": self.author,
+            "author_email": self.author_email,
+            "message": self.message,
+            "files_changed": self.files_changed,
+            "lines_added": self.lines_added,
+            "lines_deleted": self.lines_deleted,
+            "insertions": self.insertions,
+            "deletions": self.deletions,
+            "is_merge": self.is_merge,
+            "branches": self.branches,
+            "in_main_branch": self.in_main_branch,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Commit":
+        """Create from dictionary."""
+        return cls(**{k: v for k, v in data.items() if k in cls.__annotations__})
+
+    @classmethod
+    def from_pydriller_commit(cls, commit, repo_name: str) -> "Commit":
+        """Create from PyDriller commit object."""
+        return cls(
+            commit_id=commit.hash,
+            repo_name=repo_name,
+            date=(
+                commit.committer_date.isoformat()
+                if commit.committer_date
+                else commit.author_date.isoformat()
+            ),
+            author=commit.author.name,
+            author_email=commit.author.email,
+            message=commit.msg,
+            files_changed=[f.new_path or f.filename for f in commit.modified_files],
+            lines_added=commit.insertions,
+            lines_deleted=commit.deletions,
+            insertions=commit.insertions,
+            deletions=commit.deletions,
+            is_merge=commit.merge,
+            branches=commit.branches if hasattr(commit, "branches") else [],
+            in_main_branch=commit.in_main_branch if hasattr(commit, "in_main_branch") else True,
+        )

greenmining/models/repository.py

@@ -0,0 +1,89 @@
+"""Repository Model - Represents a GitHub repository."""
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class Repository:
+    """Data model for a GitHub repository."""
+
+    repo_id: int
+    name: str
+    owner: str
+    full_name: str
+    url: str
+    clone_url: str
+    language: Optional[str]
+    stars: int
+    forks: int
+    watchers: int
+    open_issues: int
+    last_updated: str
+    created_at: str
+    description: Optional[str]
+    main_branch: str
+    topics: list[str] = field(default_factory=list)
+    size: int = 0
+    has_issues: bool = True
+    has_wiki: bool = True
+    archived: bool = False
+    license: Optional[str] = None
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        return {
+            "repo_id": self.repo_id,
+            "name": self.name,
+            "owner": self.owner,
+            "full_name": self.full_name,
+            "url": self.url,
+            "clone_url": self.clone_url,
+            "language": self.language,
+            "stars": self.stars,
+            "forks": self.forks,
+            "watchers": self.watchers,
+            "open_issues": self.open_issues,
+            "last_updated": self.last_updated,
+            "created_at": self.created_at,
+            "description": self.description,
+            "main_branch": self.main_branch,
+            "topics": self.topics,
+            "size": self.size,
+            "has_issues": self.has_issues,
+            "has_wiki": self.has_wiki,
+            "archived": self.archived,
+            "license": self.license,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Repository":
+        """Create from dictionary."""
+        return cls(**{k: v for k, v in data.items() if k in cls.__annotations__})
+
+    @classmethod
+    def from_github_repo(cls, repo, repo_id: int) -> "Repository":
+        """Create from PyGithub repository object."""
+        return cls(
+            repo_id=repo_id,
+            name=repo.name,
+            owner=repo.owner.login,
+            full_name=repo.full_name,
+            url=repo.html_url,
+            clone_url=repo.clone_url,
+            language=repo.language,
+            stars=repo.stargazers_count,
+            forks=repo.forks_count,
+            watchers=repo.watchers_count,
+            open_issues=repo.open_issues_count,
+            last_updated=repo.updated_at.isoformat() if repo.updated_at else None,
+            created_at=repo.created_at.isoformat() if repo.created_at else None,
+            description=repo.description,
+            main_branch=repo.default_branch,
+            topics=repo.topics or [],
+            size=repo.size,
+            has_issues=repo.has_issues,
+            has_wiki=repo.has_wiki,
+            archived=repo.archived,
+            license=repo.license.key if repo.license else None,
+        )

greenmining/presenters/__init__.py

@@ -0,0 +1,11 @@
+"""
+Presenters Package - UI/CLI presentation layer.
+
+Presenters handle output formatting and user interaction.
+"""
+
+from .console_presenter import ConsolePresenter
+
+__all__ = [
+    "ConsolePresenter",
+]

greenmining/presenters/console_presenter.py

@@ -0,0 +1,141 @@
+"""Console Presenter - Handles console output formatting."""
+
+from typing import Any
+
+from tabulate import tabulate
+
+from greenmining.utils import colored_print
+
+
+class ConsolePresenter:
+    """Presenter for console/terminal output."""
+
+    @staticmethod
+    def show_banner():
+        """Display application banner."""
+        banner = """
+╔══════════════════════════════════════════════════════════╗
+║           Green Microservices Mining                     ║
+╚══════════════════════════════════════════════════════════╝
+        """
+        colored_print(banner, "green")
+
+    @staticmethod
+    def show_repositories(repositories: list[dict], limit: int = 10):
+        """Display repository table."""
+        if not repositories:
+            colored_print("No repositories to display", "yellow")
+            return
+
+        colored_print(f"\n📊 Top {min(limit, len(repositories))} Repositories:\n", "cyan")
+
+        table_data = []
+        for repo in repositories[:limit]:
+            table_data.append(
+                [
+                    repo.get("full_name", "N/A"),
+                    repo.get("language", "N/A"),
+                    f"{repo.get('stars', 0):,}",
+                    (
+                        repo.get("description", "")[:50] + "..."
+                        if len(repo.get("description", "")) > 50
+                        else repo.get("description", "")
+                    ),
+                ]
+            )
+
+        headers = ["Repository", "Language", "Stars", "Description"]
+        print(tabulate(table_data, headers=headers, tablefmt="grid"))
+
+    @staticmethod
+    def show_commit_stats(stats: dict[str, Any]):
+        """Display commit statistics."""
+        colored_print("\n📈 Commit Statistics:\n", "cyan")
+
+        table_data = [
+            ["Total Commits", f"{stats.get('total_commits', 0):,}"],
+            ["Repositories", stats.get("total_repos", 0)],
+            ["Avg per Repo", f"{stats.get('avg_per_repo', 0):.1f}"],
+            ["Date Range", stats.get("date_range", "N/A")],
+        ]
+
+        print(tabulate(table_data, headers=["Metric", "Value"], tablefmt="grid"))
+
+    @staticmethod
+    def show_analysis_results(results: dict[str, Any]):
+        """Display analysis results."""
+        colored_print("\n🔬 Analysis Results:\n", "cyan")
+
+        summary = results.get("summary", {})
+        table_data = [
+            ["Total Commits Analyzed", f"{summary.get('total_commits', 0):,}"],
+            ["Green-Aware Commits", f"{summary.get('green_commits', 0):,}"],
+            ["Green Rate", f"{summary.get('green_commit_rate', 0):.1%}"],
+            ["Patterns Detected", len(results.get("known_patterns", {}))],
+        ]
+
+        print(tabulate(table_data, headers=["Metric", "Value"], tablefmt="grid"))
+
+    @staticmethod
+    def show_pattern_distribution(patterns: dict[str, Any], limit: int = 10):
+        """Display pattern distribution."""
+        if not patterns:
+            colored_print("No patterns to display", "yellow")
+            return
+
+        colored_print(f"\n🎯 Top {limit} Green Patterns:\n", "cyan")
+
+        # Sort by count
+        sorted_patterns = sorted(
+            patterns.items(), key=lambda x: x[1].get("count", 0), reverse=True
+        )[:limit]
+
+        table_data = []
+        for pattern_name, data in sorted_patterns:
+            table_data.append(
+                [
+                    pattern_name,
+                    data.get("count", 0),
+                    f"{data.get('percentage', 0):.1f}%",
+                    data.get("confidence_distribution", {}).get("HIGH", 0),
+                ]
+            )
+
+        headers = ["Pattern", "Count", "Percentage", "High Confidence"]
+        print(tabulate(table_data, headers=headers, tablefmt="grid"))
+
+    @staticmethod
+    def show_pipeline_status(status: dict[str, Any]):
+        """Display pipeline status."""
+        colored_print("\n⚙️  Pipeline Status:\n", "cyan")
+
+        table_data = []
+        for phase, info in status.items():
+            status_icon = "✅" if info.get("completed") else "⏳"
+            table_data.append(
+                [status_icon, phase, info.get("file", "N/A"), info.get("size", "N/A")]
+            )
+
+        headers = ["Status", "Phase", "Output File", "Size"]
+        print(tabulate(table_data, headers=headers, tablefmt="grid"))
+
+    @staticmethod
+    def show_progress_message(phase: str, current: int, total: int):
+        """Display progress message."""
+        percentage = (current / total * 100) if total > 0 else 0
+        colored_print(f"[{phase}] Progress: {current}/{total} ({percentage:.1f}%)", "cyan")
+
+    @staticmethod
+    def show_error(message: str):
+        """Display error message."""
+        colored_print(f"❌ Error: {message}", "red")
+
+    @staticmethod
+    def show_success(message: str):
+        """Display success message."""
+        colored_print(f"✅ {message}", "green")
+
+    @staticmethod
+    def show_warning(message: str):
+        """Display warning message."""
+        colored_print(f"⚠️  Warning: {message}", "yellow")

greenmining/services/__init__.py

@@ -0,0 +1,13 @@
+"""
+Services Package - Core business logic and data processing services.
+
+Services implement the actual mining, extraction, analysis operations.
+"""
+
+from .commit_extractor import CommitExtractor
+from .data_aggregator import DataAggregator
+from .data_analyzer import DataAnalyzer
+from .github_fetcher import GitHubFetcher
+from .reports import ReportGenerator
+
+__all__ = ["GitHubFetcher", "CommitExtractor", "DataAnalyzer", "DataAggregator", "ReportGenerator"]