aicodestat 0.0.1__py3-none-any.whl

storage/db.py

@@ -0,0 +1,156 @@
+"""数据库连接管理、建表/迁移初始化逻辑"""
+import sqlite3
+import logging
+from pathlib import Path
+from typing import Optional
+from config import get_database_config
+
+logger = logging.getLogger(__name__)
+
+
+class Database:
+    """数据库连接管理类"""
+    
+    def __init__(self, db_path: Optional[str] = None):
+        """
+        初始化数据库连接
+        
+        Args:
+            db_path: 数据库文件路径，如果为None则从配置读取
+        """
+        if db_path is None:
+            config = get_database_config()
+            db_path = config["path"]
+        
+        self.db_path = Path(db_path)
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._connection: Optional[sqlite3.Connection] = None
+    
+    def connect(self) -> sqlite3.Connection:
+        """获取数据库连接（单例模式）"""
+        if self._connection is None:
+            self._connection = sqlite3.connect(
+                str(self.db_path),
+                check_same_thread=False
+            )
+            self._connection.row_factory = sqlite3.Row
+            # 启用外键约束
+            self._connection.execute("PRAGMA foreign_keys = ON")
+        return self._connection
+    
+    def close(self):
+        """关闭数据库连接"""
+        if self._connection:
+            self._connection.close()
+            self._connection = None
+    
+    def initialize(self):
+        """初始化数据库，创建所有表"""
+        conn = self.connect()
+        cursor = conn.cursor()
+        
+        try:
+            # 1. 临时表：存储编辑前的完整代码
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS temp_before_edit (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    session_id TEXT NOT NULL,
+                    file_path TEXT NOT NULL,
+                    code_before TEXT NOT NULL,
+                    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    UNIQUE(session_id, file_path)
+                )
+            """)
+            
+            # 2. 会话汇总表
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS session_summary (
+                    session_id TEXT NOT NULL,
+                    file_path TEXT NOT NULL,
+                    add_lines_count INTEGER NOT NULL DEFAULT 0,
+                    modify_lines_count INTEGER NOT NULL DEFAULT 0,
+                    total_lines_after INTEGER NOT NULL,
+                    session_info TEXT,
+                    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    PRIMARY KEY (session_id, file_path)
+                )
+            """)
+            
+            # 创建索引
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_session_id 
+                ON session_summary(session_id)
+            """)
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_file_path 
+                ON session_summary(file_path)
+            """)
+            
+            # 3. 差异行明细表
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS code_diff_lines (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    session_id TEXT NOT NULL,
+                    file_path TEXT NOT NULL,
+                    diff_type TEXT NOT NULL CHECK (diff_type IN ('add', 'modify')),
+                    line_content TEXT NOT NULL,
+                    line_number INTEGER NOT NULL,
+                    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (session_id, file_path) 
+                    REFERENCES session_summary(session_id, file_path) 
+                    ON DELETE CASCADE
+                )
+            """)
+            
+            # 创建索引
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_diff_session_file 
+                ON code_diff_lines(session_id, file_path)
+            """)
+            
+            # 4. 数据备份记录表
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS backup_record (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    backup_path TEXT NOT NULL,
+                    backup_time DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    backup_size INTEGER NOT NULL
+                )
+            """)
+            
+            conn.commit()
+            logger.info(f"Database initialized successfully at {self.db_path}")
+            
+        except Exception as e:
+            conn.rollback()
+            logger.error(f"Failed to initialize database: {e}")
+            raise
+    
+    def execute(self, sql: str, params: tuple = ()) -> sqlite3.Cursor:
+        """执行SQL语句"""
+        conn = self.connect()
+        return conn.execute(sql, params)
+    
+    def commit(self):
+        """提交事务"""
+        if self._connection:
+            self._connection.commit()
+    
+    def rollback(self):
+        """回滚事务"""
+        if self._connection:
+            self._connection.rollback()
+
+
+# 全局数据库实例
+_db_instance: Optional[Database] = None
+
+
+def get_db() -> Database:
+    """获取全局数据库实例（单例模式）"""
+    global _db_instance
+    if _db_instance is None:
+        _db_instance = Database()
+        _db_instance.initialize()
+    return _db_instance
+

storage/models.py

@@ -0,0 +1,338 @@
+"""面向业务的DAO函数"""
+import logging
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+from storage.db import get_db
+from utils.time_utils import get_current_time
+
+logger = logging.getLogger(__name__)
+
+
+def save_before_edit(session_id: str, file_path: str, code_before: str) -> bool:
+    """
+    保存编辑前的代码到临时表
+    
+    Args:
+        session_id: 会话ID
+        file_path: 文件路径
+        code_before: 编辑前的代码内容
+    
+    Returns:
+        是否成功
+    """
+    db = get_db()
+    try:
+        cursor = db.execute("""
+            INSERT OR REPLACE INTO temp_before_edit 
+            (session_id, file_path, code_before, create_time)
+            VALUES (?, ?, ?, ?)
+        """, (session_id, file_path, code_before, get_current_time()))
+        db.commit()
+        logger.debug(f"Saved before_edit for session={session_id}, file={file_path}")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to save before_edit: {e}")
+        db.rollback()
+        return False
+
+
+def get_before_edit(session_id: str, file_path: str) -> Optional[str]:
+    """
+    获取编辑前的代码
+    
+    Args:
+        session_id: 会话ID
+        file_path: 文件路径
+    
+    Returns:
+        编辑前的代码内容，如果不存在则返回None
+    """
+    db = get_db()
+    try:
+        cursor = db.execute("""
+            SELECT code_before FROM temp_before_edit
+            WHERE session_id = ? AND file_path = ?
+        """, (session_id, file_path))
+        row = cursor.fetchone()
+        if row:
+            return row[0]
+        return None
+    except Exception as e:
+        logger.error(f"Failed to get before_edit: {e}")
+        return None
+
+
+def delete_before_edit(session_id: str, file_path: str) -> bool:
+    """
+    删除编辑前的代码记录
+    
+    Args:
+        session_id: 会话ID
+        file_path: 文件路径
+    
+    Returns:
+        是否成功
+    """
+    db = get_db()
+    try:
+        db.execute("""
+            DELETE FROM temp_before_edit
+            WHERE session_id = ? AND file_path = ?
+        """, (session_id, file_path))
+        db.commit()
+        logger.debug(f"Deleted before_edit for session={session_id}, file={file_path}")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to delete before_edit: {e}")
+        db.rollback()
+        return False
+
+
+def save_session_summary(
+    session_id: str,
+    file_path: str,
+    add_lines_count: int,
+    modify_lines_count: int,
+    total_lines_after: int,
+    session_info: Optional[str] = None
+) -> bool:
+    """
+    保存会话汇总信息
+    
+    Args:
+        session_id: 会话ID
+        file_path: 文件路径
+        add_lines_count: 新增行数
+        modify_lines_count: 修改行数
+        total_lines_after: 编辑后文件总行数
+        session_info: 会话补充信息（可选）
+    
+    Returns:
+        是否成功
+    """
+    db = get_db()
+    try:
+        db.execute("""
+            INSERT OR REPLACE INTO session_summary
+            (session_id, file_path, add_lines_count, modify_lines_count, 
+             total_lines_after, session_info, create_time)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+        """, (
+            session_id, file_path, add_lines_count, modify_lines_count,
+            total_lines_after, session_info, get_current_time()
+        ))
+        db.commit()
+        logger.debug(f"Saved session_summary for session={session_id}, file={file_path}")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to save session_summary: {e}")
+        db.rollback()
+        return False
+
+
+def save_code_diff_lines(
+    session_id: str,
+    file_path: str,
+    diff_lines: List[Dict[str, Any]]
+) -> bool:
+    """
+    批量保存差异行明细
+    
+    Args:
+        session_id: 会话ID
+        file_path: 文件路径
+        diff_lines: 差异行列表，每个元素包含 diff_type, line_content, line_number
+    
+    Returns:
+        是否成功
+    """
+    if not diff_lines:
+        return True
+    
+    db = get_db()
+    try:
+        cursor = db.connect().cursor()
+        cursor.executemany("""
+            INSERT INTO code_diff_lines
+            (session_id, file_path, diff_type, line_content, line_number, create_time)
+            VALUES (?, ?, ?, ?, ?, ?)
+        """, [
+            (
+                session_id,
+                file_path,
+                diff_line["diff_type"],
+                diff_line["line_content"],
+                diff_line["line_number"],
+                get_current_time()
+            )
+            for diff_line in diff_lines
+        ])
+        db.commit()
+        logger.debug(f"Saved {len(diff_lines)} diff_lines for session={session_id}, file={file_path}")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to save code_diff_lines: {e}")
+        db.rollback()
+        return False
+
+
+def get_session_summaries(
+    session_id: Optional[str] = None,
+    file_path: Optional[str] = None,
+    start_time: Optional[datetime] = None,
+    end_time: Optional[datetime] = None
+) -> List[Dict[str, Any]]:
+    """
+    查询会话汇总信息
+    
+    Args:
+        session_id: 会话ID（可选，用于过滤）
+        file_path: 文件路径（可选，用于过滤）
+        start_time: 开始时间（可选）
+        end_time: 结束时间（可选）
+    
+    Returns:
+        会话汇总列表
+    """
+    db = get_db()
+    try:
+        conditions = []
+        params = []
+        
+        if session_id:
+            conditions.append("session_id = ?")
+            params.append(session_id)
+        
+        if file_path:
+            conditions.append("file_path = ?")
+            params.append(file_path)
+        
+        if start_time:
+            conditions.append("create_time >= ?")
+            params.append(start_time)
+        
+        if end_time:
+            conditions.append("create_time <= ?")
+            params.append(end_time)
+        
+        where_clause = " WHERE " + " AND ".join(conditions) if conditions else ""
+        
+        cursor = db.execute(f"""
+            SELECT session_id, file_path, add_lines_count, modify_lines_count,
+                   total_lines_after, session_info, create_time
+            FROM session_summary
+            {where_clause}
+            ORDER BY create_time DESC
+        """, tuple(params))
+        
+        rows = cursor.fetchall()
+        return [
+            {
+                "session_id": row[0],
+                "file_path": row[1],
+                "add_lines_count": row[2],
+                "modify_lines_count": row[3],
+                "total_lines_after": row[4],
+                "session_info": row[5],
+                "create_time": row[6]
+            }
+            for row in rows
+        ]
+    except Exception as e:
+        logger.error(f"Failed to get session_summaries: {e}")
+        return []
+
+
+def get_code_diff_lines(
+    session_id: Optional[str] = None,
+    file_path: Optional[str] = None
+) -> List[Dict[str, Any]]:
+    """
+    查询差异行明细
+    
+    Args:
+        session_id: 会话ID（可选）
+        file_path: 文件路径（可选）
+    
+    Returns:
+        差异行列表
+    """
+    db = get_db()
+    try:
+        conditions = []
+        params = []
+        
+        if session_id:
+            conditions.append("session_id = ?")
+            params.append(session_id)
+        
+        if file_path:
+            conditions.append("file_path = ?")
+            params.append(file_path)
+        
+        where_clause = " WHERE " + " AND ".join(conditions) if conditions else ""
+        
+        cursor = db.execute(f"""
+            SELECT id, session_id, file_path, diff_type, line_content, line_number, create_time
+            FROM code_diff_lines
+            {where_clause}
+            ORDER BY line_number ASC
+        """, tuple(params))
+        
+        rows = cursor.fetchall()
+        return [
+            {
+                "id": row[0],
+                "session_id": row[1],
+                "file_path": row[2],
+                "diff_type": row[3],
+                "line_content": row[4],
+                "line_number": row[5],
+                "create_time": row[6]
+            }
+            for row in rows
+        ]
+    except Exception as e:
+        logger.error(f"Failed to get code_diff_lines: {e}")
+        return []
+
+
+def delete_sessions(
+    session_ids: Optional[List[str]] = None,
+    before_time: Optional[datetime] = None
+) -> int:
+    """
+    删除会话数据（级联删除差异行）
+    
+    Args:
+        session_ids: 会话ID列表（可选）
+        before_time: 删除指定时间之前的数据（可选）
+    
+    Returns:
+        删除的记录数
+    """
+    db = get_db()
+    try:
+        if session_ids:
+            placeholders = ",".join("?" * len(session_ids))
+            cursor = db.execute(f"""
+                DELETE FROM session_summary
+                WHERE session_id IN ({placeholders})
+            """, tuple(session_ids))
+        elif before_time:
+            cursor = db.execute("""
+                DELETE FROM session_summary
+                WHERE create_time < ?
+            """, (before_time,))
+        else:
+            return 0
+        
+        deleted_count = cursor.rowcount
+        db.commit()
+        logger.info(f"Deleted {deleted_count} session records")
+        return deleted_count
+    except Exception as e:
+        logger.error(f"Failed to delete sessions: {e}")
+        db.rollback()
+        return 0
+

storage/scheduler.py

@@ -0,0 +1,111 @@
+"""定时任务：自动备份和清理"""
+import logging
+import threading
+import time
+from datetime import datetime, timedelta
+from typing import Optional
+from storage.backup import backup_database
+from storage.models import delete_sessions
+from config import get_database_config
+from utils.time_utils import get_time_range_days
+
+logger = logging.getLogger(__name__)
+
+
+class Scheduler:
+    """定时任务调度器"""
+    
+    def __init__(self):
+        self._running = False
+        self._thread: Optional[threading.Thread] = None
+        self._stop_event = threading.Event()
+    
+    def start(self):
+        """启动定时任务"""
+        if self._running:
+            logger.warning("Scheduler is already running")
+            return
+        
+        self._running = True
+        self._stop_event.clear()
+        self._thread = threading.Thread(target=self._run, daemon=True)
+        self._thread.start()
+        logger.info("Scheduler started")
+    
+    def stop(self):
+        """停止定时任务"""
+        if not self._running:
+            return
+        
+        self._running = False
+        self._stop_event.set()
+        if self._thread:
+            self._thread.join(timeout=5)
+        logger.info("Scheduler stopped")
+    
+    def _run(self):
+        """定时任务主循环"""
+        # 计算到下一个凌晨的时间
+        now = datetime.now()
+        next_backup_time = (now + timedelta(days=1)).replace(hour=2, minute=0, second=0, microsecond=0)
+        wait_seconds = (next_backup_time - now).total_seconds()
+        
+        logger.info(f"Next backup scheduled at {next_backup_time}, waiting {wait_seconds:.0f} seconds")
+        
+        while self._running and not self._stop_event.is_set():
+            # 等待到下一个备份时间或停止信号
+            if self._stop_event.wait(timeout=min(wait_seconds, 3600)):  # 最多等待1小时检查一次
+                break
+            
+            now = datetime.now()
+            if now >= next_backup_time:
+                try:
+                    # 执行备份
+                    logger.info("Starting scheduled backup...")
+                    backup_path = backup_database()
+                    if backup_path:
+                        logger.info(f"Scheduled backup completed: {backup_path}")
+                    else:
+                        logger.error("Scheduled backup failed")
+                    
+                    # 执行清理
+                    config = get_database_config()
+                    clean_cycle = config.get("clean_cycle", 30)
+                    logger.info(f"Starting scheduled cleanup (removing data older than {clean_cycle} days)...")
+                    _, before_time = get_time_range_days(clean_cycle)
+                    deleted = delete_sessions(before_time=before_time)
+                    logger.info(f"Scheduled cleanup completed: {deleted} records deleted")
+                    
+                except Exception as e:
+                    logger.error(f"Scheduled task error: {e}", exc_info=True)
+                
+                # 计算下一个备份时间（明天凌晨2点）
+                next_backup_time = (now + timedelta(days=1)).replace(hour=2, minute=0, second=0, microsecond=0)
+                wait_seconds = (next_backup_time - now).total_seconds()
+                logger.info(f"Next backup scheduled at {next_backup_time}")
+
+
+# 全局调度器实例
+_scheduler: Optional[Scheduler] = None
+
+
+def get_scheduler() -> Scheduler:
+    """获取全局调度器实例"""
+    global _scheduler
+    if _scheduler is None:
+        _scheduler = Scheduler()
+    return _scheduler
+
+
+def start_scheduler():
+    """启动定时任务"""
+    scheduler = get_scheduler()
+    scheduler.start()
+
+
+def stop_scheduler():
+    """停止定时任务"""
+    global _scheduler
+    if _scheduler:
+        _scheduler.stop()
+

utils/__init__.py

@@ -0,0 +1,2 @@
+"""工具模块"""
+

utils/port_utils.py

@@ -0,0 +1,59 @@
+"""Port utility functions for checking port availability"""
+import socket
+import random
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def is_port_available(host: str, port: int) -> bool:
+    """
+    Check if a port is available
+    
+    Args:
+        host: Host address
+        port: Port number
+    
+    Returns:
+        True if port is available, False otherwise
+    """
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.settimeout(1)
+            result = s.connect_ex((host, port))
+            return result != 0  # 0 means port is in use
+    except Exception as e:
+        logger.warning(f"Error checking port {port}: {e}")
+        return False
+
+
+def find_available_port(host: str, preferred_port: int, max_attempts: int = 100) -> int:
+    """
+    Find an available port, starting with preferred port
+    
+    Args:
+        host: Host address
+        preferred_port: Preferred port number
+        max_attempts: Maximum attempts to find available port
+    
+    Returns:
+        Available port number
+    """
+    # First try preferred port
+    if is_port_available(host, preferred_port):
+        logger.info(f"Preferred port {preferred_port} is available")
+        return preferred_port
+    
+    logger.warning(f"Preferred port {preferred_port} is in use, searching for alternative...")
+    
+    # Try random ports in a reasonable range (49152-65535 for dynamic/private ports)
+    for _ in range(max_attempts):
+        # Use a range that's less likely to conflict
+        random_port = random.randint(49152, 65535)
+        if is_port_available(host, random_port):
+            logger.info(f"Found available port: {random_port}")
+            return random_port
+    
+    # If no port found, raise exception
+    raise RuntimeError(f"Could not find an available port after {max_attempts} attempts")
+

utils/time_utils.py

@@ -0,0 +1,37 @@
+"""时间、日期、格式化工具"""
+from datetime import datetime, timedelta
+from typing import Optional, Tuple
+
+
+def get_current_time() -> datetime:
+    """获取当前时间"""
+    return datetime.now()
+
+
+def format_datetime(dt: datetime, fmt: str = "%Y-%m-%d %H:%M:%S") -> str:
+    """格式化datetime为字符串"""
+    return dt.strftime(fmt)
+
+
+def parse_datetime(dt_str: str, fmt: str = "%Y-%m-%d %H:%M:%S") -> Optional[datetime]:
+    """解析字符串为datetime"""
+    try:
+        return datetime.strptime(dt_str, fmt)
+    except ValueError:
+        return None
+
+
+def get_time_range_days(days: int) -> Tuple[datetime, datetime]:
+    """获取指定天数前到现在的时间范围"""
+    end_time = get_current_time()
+    start_time = end_time - timedelta(days=days)
+    return start_time, end_time
+
+
+def is_expired(create_time: datetime, days: int) -> bool:
+    """判断创建时间是否已过期（超过指定天数）"""
+    if create_time is None:
+        return True
+    expire_time = get_current_time() - timedelta(days=days)
+    return create_time < expire_time
+