gitflow-analytics 3.6.2__py3-none-any.whl → 3.7.0__py3-none-any.whl

gitflow_analytics/models/database.py

@@ -5,7 +5,7 @@ import os
 import tempfile
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any
+from typing import Any, Optional
 
 from sqlalchemy import (
     JSON,
@@ -869,9 +869,30 @@ class WeeklyTrends(Base):
     )
 
 
+class SchemaVersion(Base):
+    """Track database schema versions for automatic migrations.
+
+    WHY: Schema changes (like timezone-aware timestamps) require migration
+    to ensure old cache databases work correctly without user intervention.
+    This table tracks the current schema version to trigger automatic upgrades.
+    """
+
+    __tablename__ = "schema_version"
+
+    id = Column(Integer, primary_key=True)
+    version = Column(String, nullable=False)  # e.g., "2.0"
+    upgraded_at = Column(DateTime(timezone=True), default=utcnow_tz_aware)
+    previous_version = Column(String, nullable=True)
+    migration_notes = Column(String, nullable=True)
+
+
 class Database:
     """Database connection manager with robust permission handling."""
 
+    # Schema version constants
+    CURRENT_SCHEMA_VERSION = "2.0"  # Timezone-aware timestamps
+    LEGACY_SCHEMA_VERSION = "1.0"  # Timezone-naive timestamps
+
     def __init__(self, db_path: Path):
         """
         Initialize database connection with proper error handling.
@@ -949,10 +970,21 @@ class Database:
                 },
             )
 
-            # Test the connection and create tables
-            Base.metadata.create_all(self.engine)
+            # Check schema version BEFORE creating tables to detect legacy databases
             self.SessionLocal = sessionmaker(bind=self.engine)
-            # Apply migrations for existing databases
+            needs_migration = self._check_schema_version_before_create()
+
+            # Create/update tables
+            Base.metadata.create_all(self.engine)
+
+            # Perform migration if needed (after tables are created/updated)
+            if needs_migration:
+                self._perform_schema_migration()
+            else:
+                # No migration needed - record current schema version if not already recorded
+                self._ensure_schema_version_recorded()
+
+            # Apply other migrations for existing databases
             self._apply_migrations()
 
             # Test that we can actually write to the database
@@ -988,9 +1020,21 @@ class Database:
                 },
             )
 
-            Base.metadata.create_all(self.engine)
+            # Check schema version BEFORE creating tables to detect legacy databases
             self.SessionLocal = sessionmaker(bind=self.engine)
-            # Apply migrations for existing databases
+            needs_migration = self._check_schema_version_before_create()
+
+            # Create/update tables
+            Base.metadata.create_all(self.engine)
+
+            # Perform migration if needed (after tables are created/updated)
+            if needs_migration:
+                self._perform_schema_migration()
+            else:
+                # No migration needed - record current schema version if not already recorded
+                self._ensure_schema_version_recorded()
+
+            # Apply other migrations for existing databases
             self._apply_migrations()
 
             # Test write capability
@@ -1023,9 +1067,21 @@ class Database:
                 "sqlite:///:memory:", connect_args={"check_same_thread": False}
             )
 
-            Base.metadata.create_all(self.engine)
+            # Check schema version BEFORE creating tables to detect legacy databases
             self.SessionLocal = sessionmaker(bind=self.engine)
-            # Apply migrations for existing databases
+            needs_migration = self._check_schema_version_before_create()
+
+            # Create/update tables
+            Base.metadata.create_all(self.engine)
+
+            # Perform migration if needed (after tables are created/updated)
+            if needs_migration:
+                self._perform_schema_migration()
+            else:
+                # No migration needed - record current schema version if not already recorded
+                self._ensure_schema_version_recorded()
+
+            # Apply other migrations for existing databases
             self._apply_migrations()
 
             self.is_readonly_fallback = True
@@ -1117,9 +1173,174 @@ class Database:
 
     def init_db(self) -> None:
         """Initialize database tables and apply migrations."""
+        needs_migration = self._check_schema_version_before_create()
         Base.metadata.create_all(self.engine)
+        if needs_migration:
+            self._perform_schema_migration()
+        else:
+            self._ensure_schema_version_recorded()
         self._apply_migrations()
 
+    def _check_schema_version_before_create(self) -> bool:
+        """Check if database needs migration BEFORE create_all is called.
+
+        WHY: We need to check for legacy databases BEFORE creating new tables,
+        otherwise we can't distinguish between a fresh database and a legacy one.
+
+        Returns:
+            True if migration is needed, False otherwise
+        """
+        try:
+            with self.engine.connect() as conn:
+                # Check if schema_version table exists
+                result = conn.execute(
+                    text(
+                        "SELECT name FROM sqlite_master WHERE type='table' AND name='schema_version'"
+                    )
+                )
+                schema_table_exists = result.fetchone() is not None
+
+                if schema_table_exists:
+                    # Check current version
+                    result = conn.execute(
+                        text("SELECT version FROM schema_version ORDER BY id DESC LIMIT 1")
+                    )
+                    row = result.fetchone()
+
+                    if row and row[0] != self.CURRENT_SCHEMA_VERSION:
+                        # Version mismatch - needs migration
+                        logger.warning(
+                            f"⚠️  Schema version mismatch: {row[0]} → {self.CURRENT_SCHEMA_VERSION}"
+                        )
+                        return True
+                    # else: Already at current version or no version record yet
+                    return False
+                else:
+                    # No schema_version table - check if this is legacy or new
+                    result = conn.execute(
+                        text(
+                            "SELECT name FROM sqlite_master WHERE type='table' AND name='cached_commits'"
+                        )
+                    )
+                    has_cached_commits = result.fetchone() is not None
+
+                    if has_cached_commits:
+                        # Check if table has data
+                        result = conn.execute(text("SELECT COUNT(*) FROM cached_commits"))
+                        commit_count = result.fetchone()[0]
+
+                        if commit_count > 0:
+                            # Legacy database with data - needs migration
+                            logger.warning("⚠️  Old cache schema detected (v1.0 → v2.0)")
+                            logger.info("   This is a one-time operation due to timezone fix")
+                            return True
+
+                    # New database or empty legacy database - no migration needed
+                    return False
+
+        except Exception as e:
+            # Don't fail initialization due to schema check issues
+            logger.debug(f"Schema version check failed: {e}")
+            return False
+
+    def _perform_schema_migration(self) -> None:
+        """Perform the actual schema migration after tables are created.
+
+        WHY: Separating migration from detection allows us to update table schemas
+        via create_all before clearing/migrating data.
+        """
+        try:
+            with self.engine.connect() as conn:
+                logger.info("🔄 Automatically upgrading cache database...")
+                logger.info("   Clearing old cache data (timezone schema incompatible)...")
+
+                # Clear cached data tables
+                conn.execute(text("DELETE FROM cached_commits"))
+                conn.execute(text("DELETE FROM pull_request_cache"))
+                conn.execute(text("DELETE FROM issue_cache"))
+                conn.execute(text("DELETE FROM repository_analysis_status"))
+
+                # Also clear qualitative analysis data if it exists
+                try:
+                    conn.execute(text("DELETE FROM qualitative_commits"))
+                    conn.execute(text("DELETE FROM pattern_cache"))
+                except Exception:
+                    # These tables might not exist in all databases
+                    pass
+
+                conn.commit()
+
+                # Record the schema upgrade
+                self._record_schema_version(
+                    conn,
+                    self.CURRENT_SCHEMA_VERSION,
+                    self.LEGACY_SCHEMA_VERSION,
+                    "Migrated to timezone-aware timestamps (v2.0)",
+                )
+
+                logger.info("   Migration complete - cache will be rebuilt on next analysis")
+                logger.info("✅ Cache database upgraded successfully")
+
+        except Exception as e:
+            logger.error(f"Migration failed: {e}")
+            # Don't raise - let the system continue and rebuild cache from scratch
+
+    def _ensure_schema_version_recorded(self) -> None:
+        """Ensure schema version is recorded for databases that didn't need migration.
+
+        WHY: Fresh databases and already-migrated databases need to have their
+        schema version recorded for future migration detection.
+        """
+        try:
+            with self.engine.connect() as conn:
+                # Check if version is already recorded
+                result = conn.execute(text("SELECT COUNT(*) FROM schema_version"))
+                count = result.fetchone()[0]
+
+                if count == 0:
+                    # No version recorded - this is a fresh database
+                    self._record_schema_version(
+                        conn, self.CURRENT_SCHEMA_VERSION, None, "Initial schema creation"
+                    )
+                    logger.debug(f"Recorded initial schema version: {self.CURRENT_SCHEMA_VERSION}")
+
+        except Exception as e:
+            # Don't fail if we can't record version
+            logger.debug(f"Could not ensure schema version recorded: {e}")
+
+    def _record_schema_version(
+        self, conn, version: str, previous_version: Optional[str], notes: Optional[str]
+    ) -> None:
+        """Record schema version in the database.
+
+        Args:
+            conn: Database connection
+            version: New schema version
+            previous_version: Previous schema version (None for initial)
+            notes: Migration notes
+        """
+        try:
+            from datetime import datetime, timezone
+
+            # Insert new schema version record
+            conn.execute(
+                text(
+                    """
+                INSERT INTO schema_version (version, upgraded_at, previous_version, migration_notes)
+                VALUES (:version, :upgraded_at, :previous_version, :notes)
+            """
+                ),
+                {
+                    "version": version,
+                    "upgraded_at": datetime.now(timezone.utc),
+                    "previous_version": previous_version,
+                    "notes": notes,
+                },
+            )
+            conn.commit()
+        except Exception as e:
+            logger.debug(f"Could not record schema version: {e}")
+
     def _apply_migrations(self) -> None:
         """Apply database migrations for backward compatibility.
 

gitflow_analytics/security/reports/__init__.py

@@ -0,0 +1,5 @@
+"""Security reporting module."""
+
+from .security_report import SecurityReportGenerator
+
+__all__ = ["SecurityReportGenerator"]

gitflow_analytics/security/reports/security_report.py

@@ -0,0 +1,358 @@
+"""Generate security analysis reports."""
+
+import json
+import csv
+from typing import List, Dict, Any, Optional
+from pathlib import Path
+from datetime import datetime
+from ..security_analyzer import SecurityAnalysis
+
+
+class SecurityReportGenerator:
+    """Generate various format reports for security findings."""
+
+    def __init__(self, output_dir: Optional[Path] = None):
+        """Initialize report generator.
+
+        Args:
+            output_dir: Directory for report output
+        """
+        self.output_dir = output_dir or Path("reports")
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+    def generate_reports(self, analyses: List[SecurityAnalysis], summary: Dict[str, Any]) -> Dict[str, Path]:
+        """Generate all report formats.
+
+        Args:
+            analyses: List of security analyses
+            summary: Summary statistics
+
+        Returns:
+            Dictionary of report type to file path
+        """
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        reports = {}
+
+        # Generate Markdown report
+        md_path = self.output_dir / f"security_report_{timestamp}.md"
+        self._generate_markdown_report(analyses, summary, md_path)
+        reports["markdown"] = md_path
+
+        # Generate JSON report
+        json_path = self.output_dir / f"security_findings_{timestamp}.json"
+        self._generate_json_report(analyses, summary, json_path)
+        reports["json"] = json_path
+
+        # Generate CSV report
+        csv_path = self.output_dir / f"security_issues_{timestamp}.csv"
+        self._generate_csv_report(analyses, csv_path)
+        reports["csv"] = csv_path
+
+        # Generate SARIF report if requested
+        if any(a.total_findings > 0 for a in analyses):
+            sarif_path = self.output_dir / f"security_sarif_{timestamp}.json"
+            self._generate_sarif_report(analyses, sarif_path)
+            reports["sarif"] = sarif_path
+
+        return reports
+
+    def _generate_markdown_report(self, analyses: List[SecurityAnalysis], summary: Dict, path: Path) -> None:
+        """Generate comprehensive Markdown security report."""
+        with open(path, 'w') as f:
+            # Header
+            f.write("# 🔒 Security Analysis Report\n\n")
+            f.write(f"**Generated**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
+
+            # Executive Summary
+            f.write("## 📊 Executive Summary\n\n")
+            f.write(f"- **Commits Analyzed**: {summary['total_commits']}\n")
+            f.write(f"- **Commits with Issues**: {summary['commits_with_issues']}\n")
+            f.write(f"- **Total Findings**: {summary['total_findings']}\n")
+            f.write(f"- **Risk Level**: **{summary['risk_level']}** (Score: {summary['average_risk_score']})\n\n")
+
+            # Risk Assessment
+            self._write_risk_assessment(f, summary)
+
+            # Severity Distribution
+            f.write("## 🎯 Severity Distribution\n\n")
+            severity = summary['severity_distribution']
+            if severity['critical'] > 0:
+                f.write(f"- 🔴 **Critical**: {severity['critical']}\n")
+            if severity['high'] > 0:
+                f.write(f"- 🟠 **High**: {severity['high']}\n")
+            if severity['medium'] > 0:
+                f.write(f"- 🟡 **Medium**: {severity['medium']}\n")
+            if severity['low'] > 0:
+                f.write(f"- 🟢 **Low**: {severity['low']}\n")
+            f.write("\n")
+
+            # Top Issues
+            if summary['top_issues']:
+                f.write("## 🔝 Top Security Issues\n\n")
+                f.write("| Issue Type | Severity | Occurrences | Affected Files |\n")
+                f.write("|------------|----------|-------------|----------------|\n")
+                for issue in summary['top_issues']:
+                    f.write(f"| {issue['type']} | {issue['severity'].upper()} | "
+                           f"{issue['occurrences']} | {issue['affected_files']} |\n")
+                f.write("\n")
+
+            # Detailed Findings by Category
+            self._write_detailed_findings(f, analyses)
+
+            # LLM Insights
+            if 'llm_insights' in summary and summary['llm_insights']:
+                f.write("## 🤖 AI Security Insights\n\n")
+                f.write(summary['llm_insights'])
+                f.write("\n\n")
+
+            # Recommendations
+            f.write("## 💡 Recommendations\n\n")
+            for rec in summary['recommendations']:
+                f.write(f"- {rec}\n")
+            f.write("\n")
+
+            # Appendix - All Findings
+            f.write("## 📋 Detailed Findings\n\n")
+            self._write_all_findings(f, analyses)
+
+    def _write_risk_assessment(self, f, summary: Dict) -> None:
+        """Write risk assessment section."""
+        risk_level = summary['risk_level']
+        score = summary['average_risk_score']
+
+        f.write("## ⚠️ Risk Assessment\n\n")
+
+        if risk_level == "CRITICAL":
+            f.write("### 🚨 CRITICAL RISK DETECTED\n\n")
+            f.write("Immediate action required. Critical security vulnerabilities have been identified "
+                   "that could lead to severe security breaches.\n\n")
+        elif risk_level == "HIGH":
+            f.write("### 🔴 High Risk\n\n")
+            f.write("Significant security issues detected that should be addressed urgently.\n\n")
+        elif risk_level == "MEDIUM":
+            f.write("### 🟡 Medium Risk\n\n")
+            f.write("Moderate security concerns identified that should be addressed in the near term.\n\n")
+        else:
+            f.write("### 🟢 Low Risk\n\n")
+            f.write("Minor security issues detected. Continue with regular security practices.\n\n")
+
+        # Risk score visualization
+        f.write("**Risk Score Breakdown**:\n")
+        f.write("```\n")
+        bar_length = 50
+        filled = int(score / 100 * bar_length)
+        bar = "█" * filled + "░" * (bar_length - filled)
+        f.write(f"[{bar}] {score:.1f}/100\n")
+        f.write("```\n\n")
+
+    def _write_detailed_findings(self, f, analyses: List[SecurityAnalysis]) -> None:
+        """Write detailed findings by category."""
+        # Aggregate findings
+        all_secrets = []
+        all_vulnerabilities = []
+        all_dependencies = []
+        all_llm = []
+
+        for analysis in analyses:
+            all_secrets.extend(analysis.secrets)
+            all_vulnerabilities.extend(analysis.vulnerabilities)
+            all_dependencies.extend(analysis.dependency_issues)
+            all_llm.extend(analysis.llm_findings)
+
+        # Secrets Section
+        if all_secrets:
+            f.write("## 🔑 Exposed Secrets\n\n")
+            f.write(f"**Total**: {len(all_secrets)} potential secrets detected\n\n")
+
+            # Group by secret type
+            by_type = {}
+            for secret in all_secrets:
+                secret_type = secret.get('secret_type', 'unknown')
+                if secret_type not in by_type:
+                    by_type[secret_type] = []
+                by_type[secret_type].append(secret)
+
+            for secret_type, secrets in sorted(by_type.items()):
+                f.write(f"### {secret_type.replace('_', ' ').title()}\n")
+                for s in secrets[:5]:  # Show first 5 of each type
+                    f.write(f"- **File**: `{s.get('file', 'unknown')}`\n")
+                    f.write(f"  - Line: {s.get('line', 'N/A')}\n")
+                    f.write(f"  - Pattern: `{s.get('match', 'N/A')}`\n")
+                if len(secrets) > 5:
+                    f.write(f"  - *... and {len(secrets) - 5} more*\n")
+                f.write("\n")
+
+        # Vulnerabilities Section
+        if all_vulnerabilities:
+            f.write("## 🛡️ Code Vulnerabilities\n\n")
+            f.write(f"**Total**: {len(all_vulnerabilities)} vulnerabilities detected\n\n")
+
+            # Group by vulnerability type
+            by_type = {}
+            for vuln in all_vulnerabilities:
+                vuln_type = vuln.get('vulnerability_type', 'unknown')
+                if vuln_type not in by_type:
+                    by_type[vuln_type] = []
+                by_type[vuln_type].append(vuln)
+
+            for vuln_type, vulns in sorted(by_type.items()):
+                f.write(f"### {vuln_type.replace('_', ' ').title()}\n")
+                for v in vulns[:5]:
+                    f.write(f"- **File**: `{v.get('file', 'unknown')}:{v.get('line', 'N/A')}`\n")
+                    f.write(f"  - Tool: {v.get('tool', 'N/A')}\n")
+                    f.write(f"  - Message: {v.get('message', 'N/A')}\n")
+                if len(vulns) > 5:
+                    f.write(f"  - *... and {len(vulns) - 5} more*\n")
+                f.write("\n")
+
+        # Dependencies Section
+        if all_dependencies:
+            f.write("## 📦 Vulnerable Dependencies\n\n")
+            f.write(f"**Total**: {len(all_dependencies)} vulnerable dependencies\n\n")
+
+            for dep in all_dependencies[:10]:
+                f.write(f"- **{dep.get('package', 'unknown')}** @ {dep.get('version', 'unknown')}\n")
+                f.write(f"  - File: `{dep.get('file', 'unknown')}`\n")
+                if dep.get('cve'):
+                    f.write(f"  - CVE: {dep['cve']}\n")
+                f.write(f"  - Message: {dep.get('message', 'N/A')}\n")
+            if len(all_dependencies) > 10:
+                f.write(f"\n*... and {len(all_dependencies) - 10} more vulnerable dependencies*\n")
+            f.write("\n")
+
+    def _write_all_findings(self, f, analyses: List[SecurityAnalysis]) -> None:
+        """Write all findings in detail."""
+        for analysis in analyses:
+            if analysis.total_findings == 0:
+                continue
+
+            f.write(f"### Commit: `{analysis.commit_hash[:8]}`\n")
+            f.write(f"**Time**: {analysis.timestamp.strftime('%Y-%m-%d %H:%M:%S')}\n")
+            f.write(f"**Files Changed**: {len(analysis.files_changed)}\n")
+            f.write(f"**Risk Score**: {analysis.risk_score:.1f}\n\n")
+
+            if analysis.secrets:
+                f.write("**Secrets**:\n")
+                for s in analysis.secrets:
+                    f.write(f"- {s.get('secret_type', 'unknown')}: {s.get('file', 'N/A')}\n")
+
+            if analysis.vulnerabilities:
+                f.write("**Vulnerabilities**:\n")
+                for v in analysis.vulnerabilities:
+                    f.write(f"- {v.get('vulnerability_type', 'unknown')}: {v.get('file', 'N/A')}\n")
+
+            f.write("\n---\n\n")
+
+    def _generate_json_report(self, analyses: List[SecurityAnalysis], summary: Dict, path: Path) -> None:
+        """Generate JSON report with all findings."""
+        report = {
+            "metadata": {
+                "generated": datetime.now().isoformat(),
+                "version": "1.0.0"
+            },
+            "summary": summary,
+            "analyses": []
+        }
+
+        for analysis in analyses:
+            report["analyses"].append({
+                "commit_hash": analysis.commit_hash,
+                "timestamp": analysis.timestamp.isoformat(),
+                "files_changed": analysis.files_changed,
+                "risk_score": analysis.risk_score,
+                "findings": {
+                    "secrets": analysis.secrets,
+                    "vulnerabilities": analysis.vulnerabilities,
+                    "dependency_issues": analysis.dependency_issues,
+                    "llm_findings": analysis.llm_findings
+                },
+                "metrics": {
+                    "total": analysis.total_findings,
+                    "critical": analysis.critical_count,
+                    "high": analysis.high_count,
+                    "medium": analysis.medium_count,
+                    "low": analysis.low_count
+                }
+            })
+
+        with open(path, 'w') as f:
+            json.dump(report, f, indent=2)
+
+    def _generate_csv_report(self, analyses: List[SecurityAnalysis], path: Path) -> None:
+        """Generate CSV report of all findings."""
+        with open(path, 'w', newline='') as f:
+            writer = csv.DictWriter(f, fieldnames=[
+                'commit_hash', 'timestamp', 'type', 'severity',
+                'category', 'file', 'line', 'message', 'tool', 'confidence'
+            ])
+            writer.writeheader()
+
+            for analysis in analyses:
+                # Write all findings
+                for finding in (analysis.secrets + analysis.vulnerabilities +
+                              analysis.dependency_issues + analysis.llm_findings):
+                    writer.writerow({
+                        'commit_hash': analysis.commit_hash[:8],
+                        'timestamp': analysis.timestamp.isoformat(),
+                        'type': finding.get('type', 'unknown'),
+                        'severity': finding.get('severity', 'medium'),
+                        'category': finding.get('vulnerability_type',
+                                              finding.get('secret_type', 'unknown')),
+                        'file': finding.get('file', ''),
+                        'line': finding.get('line', ''),
+                        'message': finding.get('message', ''),
+                        'tool': finding.get('tool', finding.get('source', '')),
+                        'confidence': finding.get('confidence', '')
+                    })
+
+    def _generate_sarif_report(self, analyses: List[SecurityAnalysis], path: Path) -> None:
+        """Generate SARIF format report for GitHub Security tab integration."""
+        sarif = {
+            "$schema": "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
+            "version": "2.1.0",
+            "runs": [{
+                "tool": {
+                    "driver": {
+                        "name": "GitFlow Analytics Security",
+                        "version": "1.0.0",
+                        "informationUri": "https://github.com/yourusername/gitflow-analytics"
+                    }
+                },
+                "results": []
+            }]
+        }
+
+        for analysis in analyses:
+            for finding in (analysis.secrets + analysis.vulnerabilities):
+                result = {
+                    "ruleId": finding.get('vulnerability_type',
+                                        finding.get('secret_type', 'unknown')),
+                    "level": self._severity_to_sarif_level(finding.get('severity', 'medium')),
+                    "message": {
+                        "text": finding.get('message', 'Security issue detected')
+                    },
+                    "locations": [{
+                        "physicalLocation": {
+                            "artifactLocation": {
+                                "uri": finding.get('file', 'unknown')
+                            },
+                            "region": {
+                                "startLine": finding.get('line', 1)
+                            }
+                        }
+                    }]
+                }
+                sarif["runs"][0]["results"].append(result)
+
+        with open(path, 'w') as f:
+            json.dump(sarif, f, indent=2)
+
+    def _severity_to_sarif_level(self, severity: str) -> str:
+        """Convert severity to SARIF level."""
+        mapping = {
+            "critical": "error",
+            "high": "error",
+            "medium": "warning",
+            "low": "note"
+        }
+        return mapping.get(severity.lower(), "warning")

{gitflow_analytics-3.6.2.dist-info → gitflow_analytics-3.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitflow-analytics
-Version: 3.6.2
+Version: 3.7.0
 Summary: Analyze Git repositories for developer productivity insights
 Author-email: Bob Matyas <bobmatnyc@gmail.com>
 License: MIT
@@ -52,10 +52,8 @@ Requires-Dist: types-PyYAML>=6.0; extra == "dev"
 Requires-Dist: types-requests>=2.28; extra == "dev"
 Provides-Extra: github
 Requires-Dist: pygithub>=1.58; extra == "github"
-Provides-Extra: tui
-Requires-Dist: textual>=0.41.0; extra == "tui"
 Provides-Extra: all
-Requires-Dist: gitflow-analytics[github,tui]; extra == "all"
+Requires-Dist: gitflow-analytics[github]; extra == "all"
 Dynamic: license-file
 
 # GitFlow Analytics