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

gitflow_analytics/models/database.py

@@ -3,9 +3,9 @@
 import logging
 import os
 import tempfile
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any
+from typing import Any, Optional
 
 from sqlalchemy import (
     JSON,
@@ -28,6 +28,19 @@ logger = logging.getLogger(__name__)
 Base: Any = declarative_base()
 
 
+def utcnow_tz_aware() -> datetime:
+    """Return current UTC time as timezone-aware datetime.
+
+    WHY: SQLAlchemy DateTime(timezone=True) requires timezone-aware datetimes.
+    Using timezone-naive datetime.utcnow() causes query mismatches when filtering
+    by timezone-aware date ranges.
+
+    Returns:
+        Timezone-aware datetime in UTC
+    """
+    return datetime.now(timezone.utc)
+
+
 class CachedCommit(Base):
     """Cached commit analysis results."""
 
@@ -44,7 +57,7 @@ class CachedCommit(Base):
     author_name = Column(String)
     author_email = Column(String)
     message = Column(String)
-    timestamp = Column(DateTime)
+    timestamp = Column(DateTime(timezone=True))  # CRITICAL: Preserve timezone for date filtering
     branch = Column(String)
     is_merge = Column(Boolean, default=False)
 
@@ -62,7 +75,7 @@ class CachedCommit(Base):
     ticket_references = Column(JSON)  # List of ticket IDs
 
     # Cache metadata
-    cached_at = Column(DateTime, default=datetime.utcnow)
+    cached_at = Column(DateTime(timezone=True), default=utcnow_tz_aware)
     cache_version = Column(String, default="1.0")
 
     # Indexes for performance
@@ -87,12 +100,12 @@ class DeveloperIdentity(Base):
     # Statistics
     total_commits = Column(Integer, default=0)
     total_story_points = Column(Integer, default=0)
-    first_seen = Column(DateTime, default=datetime.utcnow)
-    last_seen = Column(DateTime, default=datetime.utcnow)
+    first_seen = Column(DateTime(timezone=True), default=utcnow_tz_aware)
+    last_seen = Column(DateTime(timezone=True), default=utcnow_tz_aware)
 
     # Metadata
-    created_at = Column(DateTime, default=datetime.utcnow)
-    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    created_at = Column(DateTime(timezone=True), default=utcnow_tz_aware)
+    updated_at = Column(DateTime(timezone=True), default=utcnow_tz_aware, onupdate=utcnow_tz_aware)
 
     __table_args__ = (
         Index("idx_primary_email", "primary_email"),
@@ -130,8 +143,8 @@ class PullRequestCache(Base):
     title = Column(String)
     description = Column(String)
     author = Column(String)
-    created_at = Column(DateTime)
-    merged_at = Column(DateTime, nullable=True)
+    created_at = Column(DateTime(timezone=True))
+    merged_at = Column(DateTime(timezone=True), nullable=True)
 
     # Extracted data
     story_points = Column(Integer, nullable=True)
@@ -141,7 +154,7 @@ class PullRequestCache(Base):
     commit_hashes = Column(JSON)  # List of commit hashes
 
     # Cache metadata
-    cached_at = Column(DateTime, default=datetime.utcnow)
+    cached_at = Column(DateTime(timezone=True), default=utcnow_tz_aware)
 
     __table_args__ = (Index("idx_repo_pr", "repo_path", "pr_number", unique=True),)
 
@@ -163,9 +176,9 @@ class IssueCache(Base):
     description = Column(String)
     status = Column(String)
     assignee = Column(String, nullable=True)
-    created_at = Column(DateTime)
-    updated_at = Column(DateTime)
-    resolved_at = Column(DateTime, nullable=True)
+    created_at = Column(DateTime(timezone=True))
+    updated_at = Column(DateTime(timezone=True))
+    resolved_at = Column(DateTime(timezone=True), nullable=True)
 
     # Extracted data
     story_points = Column(Integer, nullable=True)
@@ -175,7 +188,7 @@ class IssueCache(Base):
     platform_data = Column(JSON)  # Additional platform-specific fields
 
     # Cache metadata
-    cached_at = Column(DateTime, default=datetime.utcnow)
+    cached_at = Column(DateTime(timezone=True), default=utcnow_tz_aware)
 
     __table_args__ = (
         Index("idx_platform_issue", "platform", "issue_id", unique=True),
@@ -215,7 +228,7 @@ class QualitativeCommitData(Base):
     confidence_score = Column(Float, nullable=False)
 
     # Timestamps
-    analyzed_at = Column(DateTime, default=datetime.utcnow)
+    analyzed_at = Column(DateTime(timezone=True), default=utcnow_tz_aware)
     analysis_version = Column(String, default="1.0")
 
     # Indexes for efficient querying
@@ -250,8 +263,8 @@ class PatternCache(Base):
 
     # Usage tracking for cache management
     hit_count = Column(Integer, default=1)
-    last_used = Column(DateTime, default=datetime.utcnow)
-    created_at = Column(DateTime, default=datetime.utcnow)
+    last_used = Column(DateTime(timezone=True), default=utcnow_tz_aware)
+    created_at = Column(DateTime(timezone=True), default=utcnow_tz_aware)
 
     # Source tracking
     source_method = Column(String, nullable=False)  # 'nlp' or 'llm'
@@ -284,7 +297,7 @@ class LLMUsageStats(Base):
     # API call metadata
     model_name = Column(String, nullable=False)
     api_provider = Column(String, default="openrouter")
-    timestamp = Column(DateTime, default=datetime.utcnow)
+    timestamp = Column(DateTime(timezone=True), default=utcnow_tz_aware)
 
     # Usage metrics
     input_tokens = Column(Integer, nullable=False)
@@ -342,8 +355,8 @@ class TrainingData(Base):
 
     # Training metadata
     training_session_id = Column(String, nullable=False)  # Groups related training data
-    created_at = Column(DateTime, default=datetime.utcnow)
-    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    created_at = Column(DateTime(timezone=True), default=utcnow_tz_aware)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=utcnow_tz_aware)
 
     # Quality assurance
     validated = Column(Boolean, default=False)  # Human validation flag
@@ -399,7 +412,7 @@ class RepositoryAnalysisStatus(Base):
     unique_developers = Column(Integer, default=0)
 
     # Analysis metadata
-    last_updated = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    last_updated = Column(DateTime, default=datetime.utcnow, onupdate=utcnow_tz_aware)
     analysis_version = Column(String, default="2.0")  # For tracking schema changes
 
     # Configuration hash to detect config changes
@@ -438,8 +451,8 @@ class TrainingSession(Base):
     session_id = Column(String, unique=True, nullable=False)
 
     # Session metadata
-    started_at = Column(DateTime, default=datetime.utcnow)
-    completed_at = Column(DateTime)
+    started_at = Column(DateTime(timezone=True), default=utcnow_tz_aware)
+    completed_at = Column(DateTime(timezone=True))
     status = Column(String, default="running")  # running, completed, failed
 
     # Configuration
@@ -500,7 +513,7 @@ class ClassificationModel(Base):
     name = Column(String, nullable=False)
     version = Column(String, nullable=False)
     model_type = Column(String, nullable=False)  # 'sklearn', 'spacy', 'custom'
-    created_at = Column(DateTime, default=datetime.utcnow)
+    created_at = Column(DateTime(timezone=True), default=utcnow_tz_aware)
 
     # Training information
     training_session_id = Column(String, ForeignKey("training_sessions.session_id"))
@@ -521,7 +534,7 @@ class ClassificationModel(Base):
     # Usage tracking
     active = Column(Boolean, default=True)  # Whether model is active
     usage_count = Column(Integer, default=0)  # Number of times used
-    last_used = Column(DateTime)
+    last_used = Column(DateTime(timezone=True))
 
     # Model validation
     cross_validation_scores = Column(JSON)  # Cross-validation results
@@ -564,11 +577,11 @@ class DailyCommitBatch(Base):
     unique_tickets = Column(JSON)  # List of ticket IDs referenced on this day
 
     # Processing status
-    fetched_at = Column(DateTime, default=datetime.utcnow)
+    fetched_at = Column(DateTime(timezone=True), default=utcnow_tz_aware)
     classification_status = Column(
         String, default="pending"
     )  # pending, processing, completed, failed
-    classified_at = Column(DateTime, nullable=True)
+    classified_at = Column(DateTime(timezone=True), nullable=True)
 
     # Batch context for LLM classification
     context_summary = Column(String, nullable=True)  # Brief summary of day's activity
@@ -613,9 +626,9 @@ class DetailedTicketData(Base):
     # People and dates
     assignee = Column(String, nullable=True)
     reporter = Column(String, nullable=True)
-    created_at = Column(DateTime)
-    updated_at = Column(DateTime)
-    resolved_at = Column(DateTime, nullable=True)
+    created_at = Column(DateTime(timezone=True))
+    updated_at = Column(DateTime(timezone=True))
+    resolved_at = Column(DateTime(timezone=True), nullable=True)
 
     # Metrics for classification context
     story_points = Column(Integer, nullable=True)
@@ -636,7 +649,7 @@ class DetailedTicketData(Base):
     platform_data = Column(JSON)  # Additional platform-specific fields
 
     # Fetch metadata
-    fetched_at = Column(DateTime, default=datetime.utcnow)
+    fetched_at = Column(DateTime(timezone=True), default=utcnow_tz_aware)
     fetch_version = Column(String, default="2.0")  # Version for schema evolution
 
     # Indexes for efficient lookup and context building
@@ -683,8 +696,8 @@ class CommitClassificationBatch(Base):
 
     # Processing results
     processing_status = Column(String, default="pending")  # pending, processing, completed, failed
-    started_at = Column(DateTime, default=datetime.utcnow)
-    completed_at = Column(DateTime, nullable=True)
+    started_at = Column(DateTime(timezone=True), default=utcnow_tz_aware)
+    completed_at = Column(DateTime(timezone=True), nullable=True)
     processing_time_ms = Column(Float, nullable=True)
 
     # Quality metrics
@@ -741,7 +754,7 @@ class CommitTicketCorrelation(Base):
     matching_pattern = Column(String, nullable=True)  # Regex pattern that matched
 
     # Timestamps
-    created_at = Column(DateTime, default=datetime.utcnow)
+    created_at = Column(DateTime(timezone=True), default=utcnow_tz_aware)
     validated = Column(Boolean, default=False)  # Manual validation flag
 
     # Indexes for efficient correlation lookup
@@ -801,8 +814,8 @@ class DailyMetrics(Base):
     complex_commits = Column(Integer, default=0)  # Commits with >5 files changed
 
     # Metadata
-    created_at = Column(DateTime, default=datetime.utcnow)
-    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    created_at = Column(DateTime(timezone=True), default=utcnow_tz_aware)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=utcnow_tz_aware)
 
     # Indexes for efficient querying
     __table_args__ = (
@@ -846,7 +859,7 @@ class WeeklyTrends(Base):
     avg_commits_per_day = Column(Float, default=0.0)
 
     # Metadata
-    calculated_at = Column(DateTime, default=datetime.utcnow)
+    calculated_at = Column(DateTime(timezone=True), default=utcnow_tz_aware)
 
     # Indexes for trend queries
     __table_args__ = (
@@ -856,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.
@@ -936,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
@@ -975,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
@@ -1010,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
@@ -1104,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"]