aicodestat 0.0.1__py3-none-any.whl

mcp/routes_after.py

@@ -0,0 +1,121 @@
+"""RecordAfterEdit 相关 FastAPI 路由，调用差异提取与存储层"""
+import logging
+from fastapi import APIRouter, HTTPException
+from mcp.api_schemas import RecordAfterEditRequest, MCPResponse
+from storage.models import (
+    get_before_edit,
+    delete_before_edit,
+    save_session_summary,
+    save_code_diff_lines
+)
+from compute.diff_engine import extract_diff_lines
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/mcp", tags=["MCP Tools"])
+
+
+@router.post("/record_after", response_model=MCPResponse)
+async def record_after_edit(request: RecordAfterEditRequest):
+    """
+    RecordAfterEdit Tool: 记录文件编辑后的代码，提取差异行并存储
+    
+    该Tool由Agent在编辑文件后调用，会：
+    1. 从临时表读取编辑前的代码
+    2. 计算差异行（新增/修改）
+    3. 存储到会话汇总表和差异行明细表
+    4. 清理临时数据
+    """
+    try:
+        # 参数校验
+        if not request.session_id or not request.session_id.strip():
+            raise HTTPException(
+                status_code=400,
+                detail="session_id不能为空"
+            )
+        
+        if not request.file_path or not request.file_path.strip():
+            raise HTTPException(
+                status_code=400,
+                detail="file_path不能为空"
+            )
+        
+        if not request.code_after:
+            raise HTTPException(
+                status_code=400,
+                detail="code_after不能为空"
+            )
+        
+        # 获取编辑前的代码
+        code_before = get_before_edit(request.session_id, request.file_path)
+        if code_before is None:
+            raise HTTPException(
+                status_code=404,
+                detail=f"未找到编辑前的代码记录，请先调用RecordBeforeEdit Tool (session_id={request.session_id}, file_path={request.file_path})"
+            )
+        
+        # 提取差异行
+        diff_lines = extract_diff_lines(code_before, request.code_after)
+        
+        # 统计新增和修改行数
+        add_lines_count = sum(1 for d in diff_lines if d["diff_type"] == "add")
+        modify_lines_count = sum(1 for d in diff_lines if d["diff_type"] == "modify")
+        
+        # 计算编辑后文件总行数
+        total_lines_after = len(request.code_after.split("\n"))
+        
+        # 保存会话汇总
+        success = save_session_summary(
+            session_id=request.session_id,
+            file_path=request.file_path,
+            add_lines_count=add_lines_count,
+            modify_lines_count=modify_lines_count,
+            total_lines_after=total_lines_after,
+            session_info=request.session_info
+        )
+        
+        if not success:
+            raise HTTPException(
+                status_code=500,
+                detail="保存会话汇总失败"
+            )
+        
+        # 保存差异行明细
+        if diff_lines:
+            success = save_code_diff_lines(
+                session_id=request.session_id,
+                file_path=request.file_path,
+                diff_lines=diff_lines
+            )
+            
+            if not success:
+                logger.warning("保存差异行明细失败，但会话汇总已保存")
+        
+        # 清理临时数据
+        delete_before_edit(request.session_id, request.file_path)
+        
+        logger.info(
+            f"RecordAfterEdit: session={request.session_id}, file={request.file_path}, "
+            f"add={add_lines_count}, modify={modify_lines_count}, total_diff={len(diff_lines)}"
+        )
+        
+        return MCPResponse(
+            status="success",
+            message="编辑后代码记录成功，差异行已提取并存储",
+            data={
+                "add_lines_count": add_lines_count,
+                "modify_lines_count": modify_lines_count,
+                "total_diff_lines": len(diff_lines),
+                "total_lines_after": total_lines_after
+            }
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"RecordAfterEdit error: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail=f"内部错误: {str(e)}"
+        )
+

mcp/routes_before.py

@@ -0,0 +1,68 @@
+"""RecordBeforeEdit 相关 FastAPI 路由与业务逻辑"""
+import logging
+from fastapi import APIRouter, HTTPException
+from mcp.api_schemas import RecordBeforeEditRequest, MCPResponse
+from storage.models import save_before_edit
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/mcp", tags=["MCP Tools"])
+
+
+@router.post("/record_before", response_model=MCPResponse)
+async def record_before_edit(request: RecordBeforeEditRequest):
+    """
+    RecordBeforeEdit Tool: 记录文件编辑前的代码
+    
+    该Tool由Agent在编辑文件前调用，用于临时存储编辑前的代码内容，
+    后续RecordAfterEdit Tool会使用此数据进行差异计算。
+    """
+    try:
+        # 参数校验
+        if not request.session_id or not request.session_id.strip():
+            raise HTTPException(
+                status_code=400,
+                detail="session_id不能为空"
+            )
+        
+        if not request.file_path or not request.file_path.strip():
+            raise HTTPException(
+                status_code=400,
+                detail="file_path不能为空"
+            )
+        
+        if not request.code_before:
+            raise HTTPException(
+                status_code=400,
+                detail="code_before不能为空"
+            )
+        
+        # 保存编辑前代码
+        success = save_before_edit(
+            session_id=request.session_id,
+            file_path=request.file_path,
+            code_before=request.code_before
+        )
+        
+        if not success:
+            raise HTTPException(
+                status_code=500,
+                detail="保存编辑前代码失败"
+            )
+        
+        logger.info(f"RecordBeforeEdit: session={request.session_id}, file={request.file_path}")
+        
+        return MCPResponse(
+            status="success",
+            message="编辑前代码记录成功"
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"RecordBeforeEdit error: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail=f"内部错误: {str(e)}"
+        )
+

mcp/routes_tools.py

@@ -0,0 +1,100 @@
+"""MCP Tool发现端点，返回可用工具列表"""
+from fastapi import APIRouter
+from typing import List, Dict, Any
+
+router = APIRouter(prefix="/mcp", tags=["MCP Tools"])
+
+
+@router.get("/tools", response_model=Dict[str, Any])
+async def list_tools():
+    """
+    MCP Tool发现端点
+    
+    返回所有可用的MCP Tools列表，供Agent自动发现和注册
+    """
+    tools = [
+        {
+            "name": "RecordBeforeEdit",
+            "description": "记录文件编辑前的完整代码内容（仅本地临时存储，后续自动清理，不冗余保留）",
+            "schema_version": "v1",
+            "capabilities": ["read"],
+            "endpoint": "/mcp/record_before",
+            "method": "POST",
+            "actions": [
+                {
+                    "name": "record_before",
+                    "description": "记录文件编辑前的代码，用于后续对比差异",
+                    "parameters": [
+                        {
+                            "name": "session_id",
+                            "type": "string",
+                            "required": True,
+                            "description": "当前会话ID，由Agent生成，需与RecordAfterEdit的session_id一致，用于关联同一编辑操作"
+                        },
+                        {
+                            "name": "file_path",
+                            "type": "string",
+                            "required": True,
+                            "description": "目标文件的绝对路径（如/Users/xxx/project/test.py），用于关联文件"
+                        },
+                        {
+                            "name": "code_before",
+                            "type": "string",
+                            "required": True,
+                            "description": "文件编辑前的完整代码内容（保留原始格式、空行，确保行号精准）"
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            "name": "RecordAfterEdit",
+            "description": "记录文件编辑后的完整代码，提取具体差异行（新增/修改）及行号，清理临时数据，仅保留差异信息",
+            "schema_version": "v1",
+            "capabilities": ["write"],
+            "endpoint": "/mcp/record_after",
+            "method": "POST",
+            "actions": [
+                {
+                    "name": "record_after_and_calc_diff",
+                    "description": "记录编辑后代码，计算并存储具体差异行，清理编辑前的完整代码",
+                    "parameters": [
+                        {
+                            "name": "session_id",
+                            "type": "string",
+                            "required": True,
+                            "description": "当前会话ID，需与RecordBeforeEdit的session_id一致，用于关联同一编辑操作"
+                        },
+                        {
+                            "name": "file_path",
+                            "type": "string",
+                            "required": True,
+                            "description": "目标文件的绝对路径，需与RecordBeforeEdit的file_path一致"
+                        },
+                        {
+                            "name": "code_after",
+                            "type": "string",
+                            "required": True,
+                            "description": "文件编辑后的完整代码内容（保留原始格式、空行，确保行号精准）"
+                        },
+                        {
+                            "name": "session_info",
+                            "type": "string",
+                            "required": False,
+                            "description": "会话补充信息（如用户指令、Agent类型、操作时间），用于后续统计筛选"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+    
+    return {
+        "version": "1.0.0",
+        "tools": tools,
+        "server_info": {
+            "name": "本地MCP Server AI代码统计系统",
+            "description": "基于MCP协议的AI代码统计工具"
+        }
+    }
+

service_manager.py

@@ -0,0 +1,221 @@
+"""MCP服务进程管理器"""
+import os
+import sys
+import subprocess
+import signal
+import time
+import json
+import logging
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+# 添加项目根目录到Python路径
+_project_root = Path(__file__).parent
+if str(_project_root) not in sys.path:
+    sys.path.insert(0, str(_project_root))
+
+from config import get_server_config
+
+logger = logging.getLogger(__name__)
+
+
+class ServiceManager:
+    """MCP服务进程管理器"""
+    
+    def __init__(self, pid_file: Optional[str] = None):
+        """
+        初始化服务管理器
+        
+        Args:
+            pid_file: PID文件路径，用于存储进程ID
+        """
+        if pid_file is None:
+            # 默认PID文件路径
+            pid_file = Path.home() / ".local-mcp-server" / "server.pid"
+        
+        self.pid_file = Path(pid_file)
+        self.pid_file.parent.mkdir(parents=True, exist_ok=True)
+        self._process: Optional[subprocess.Popen] = None
+    
+    def get_pid(self) -> Optional[int]:
+        """从PID文件读取进程ID"""
+        if not self.pid_file.exists():
+            return None
+        
+        try:
+            with open(self.pid_file, 'r') as f:
+                pid = int(f.read().strip())
+            return pid
+        except (ValueError, IOError) as e:
+            logger.warning(f"Failed to read PID file: {e}")
+            return None
+    
+    def is_running(self) -> bool:
+        """检查服务是否正在运行"""
+        pid = self.get_pid()
+        if pid is None:
+            return False
+        
+        try:
+            # 检查进程是否存在
+            os.kill(pid, 0)
+            return True
+        except (OSError, ProcessLookupError):
+            # 进程不存在，清理PID文件
+            if self.pid_file.exists():
+                self.pid_file.unlink()
+            return False
+    
+    def get_status(self) -> Dict[str, Any]:
+        """
+        获取服务状态
+        
+        Returns:
+            状态字典，包含 running, pid, port, host 等信息
+        """
+        server_config = get_server_config()
+        status = {
+            "running": False,
+            "pid": None,
+            "host": server_config["host"],
+            "port": server_config["port"],
+            "pid_file": str(self.pid_file)
+        }
+        
+        if self.is_running():
+            status["running"] = True
+            status["pid"] = self.get_pid()
+        
+        return status
+    
+    def start(self, background: bool = True) -> bool:
+        """
+        启动MCP服务
+        
+        Args:
+            background: 是否后台运行
+        
+        Returns:
+            是否成功启动
+        """
+        if self.is_running():
+            logger.warning("Service is already running")
+            return False
+        
+        try:
+            # 获取服务器配置
+            server_config = get_server_config()
+            host = server_config["host"]
+            port = server_config["port"]
+            
+            # 构建启动命令
+            script_path = Path(__file__).parent / "local_mcp_server.py"
+            cmd = [sys.executable, str(script_path), "start", "--host", host, "--port", str(port)]
+            
+            if background:
+                # 后台运行
+                if sys.platform == "win32":
+                    # Windows: 使用CREATE_NEW_PROCESS_GROUP和DETACHED_PROCESS
+                    creationflags = subprocess.CREATE_NEW_PROCESS_GROUP | subprocess.DETACHED_PROCESS
+                    process = subprocess.Popen(
+                        cmd,
+                        stdout=subprocess.DEVNULL,
+                        stderr=subprocess.DEVNULL,
+                        creationflags=creationflags,
+                        start_new_session=True
+                    )
+                else:
+                    # Unix: 使用nohup和后台运行
+                    process = subprocess.Popen(
+                        cmd,
+                        stdout=subprocess.DEVNULL,
+                        stderr=subprocess.DEVNULL,
+                        start_new_session=True
+                    )
+                
+                # 等待一下确保进程启动
+                time.sleep(0.5)
+                
+                if process.poll() is None:
+                    # 进程仍在运行，保存PID
+                    pid = process.pid
+                    with open(self.pid_file, 'w') as f:
+                        f.write(str(pid))
+                    logger.info(f"MCP Server started in background (PID: {pid})")
+                    return True
+                else:
+                    logger.error("Failed to start MCP Server (process exited immediately)")
+                    return False
+            else:
+                # 前台运行（用于测试）
+                self._process = subprocess.Popen(cmd)
+                return True
+        
+        except Exception as e:
+            logger.error(f"Failed to start MCP Server: {e}", exc_info=True)
+            return False
+    
+    def stop(self) -> bool:
+        """
+        停止MCP服务
+        
+        Returns:
+            是否成功停止
+        """
+        pid = self.get_pid()
+        if pid is None:
+            logger.warning("Service is not running (no PID file)")
+            return False
+        
+        try:
+            if sys.platform == "win32":
+                # Windows: 使用taskkill
+                subprocess.run(
+                    ["taskkill", "/F", "/T", "/PID", str(pid)],
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    check=False
+                )
+            else:
+                # Unix: 发送SIGTERM
+                os.kill(pid, signal.SIGTERM)
+                # 等待进程结束
+                try:
+                    os.waitpid(pid, 0)
+                except ChildProcessError:
+                    pass
+            
+            # 清理PID文件
+            if self.pid_file.exists():
+                self.pid_file.unlink()
+            
+            logger.info(f"MCP Server stopped (PID: {pid})")
+            return True
+        
+        except (OSError, ProcessLookupError) as e:
+            logger.warning(f"Process {pid} not found: {e}")
+            # 清理PID文件
+            if self.pid_file.exists():
+                self.pid_file.unlink()
+            return False
+        except Exception as e:
+            logger.error(f"Failed to stop MCP Server: {e}", exc_info=True)
+            return False
+    
+    def restart(self) -> bool:
+        """
+        重启MCP服务
+        
+        Returns:
+            是否成功重启
+        """
+        if self.is_running():
+            self.stop()
+            time.sleep(1)
+        return self.start()
+
+
+def get_service_manager() -> ServiceManager:
+    """获取全局服务管理器实例"""
+    return ServiceManager()
+

storage/__init__.py

@@ -0,0 +1,2 @@
+"""存储层模块"""
+

storage/backup.py

@@ -0,0 +1,185 @@
+"""备份记录读写、导出/导入JSON实现"""
+import json
+import logging
+import shutil
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+from storage.db import get_db
+from storage.models import (
+    get_session_summaries,
+    get_code_diff_lines,
+    save_session_summary,
+    save_code_diff_lines
+)
+from utils.time_utils import get_current_time, format_datetime
+
+logger = logging.getLogger(__name__)
+
+
+def backup_database(backup_path: Optional[str] = None) -> Optional[str]:
+    """
+    备份数据库到JSON文件
+    
+    Args:
+        backup_path: 备份文件路径（可选，如果为None则从配置读取）
+    
+    Returns:
+        备份文件路径，如果失败则返回None
+    """
+    from config import get_database_config
+    
+    db = get_db()
+    config = get_database_config()
+    
+    if backup_path is None:
+        backup_dir = Path(config["backup_path"])
+        backup_dir.mkdir(parents=True, exist_ok=True)
+        timestamp = format_datetime(get_current_time(), "%Y%m%d_%H%M%S")
+        backup_path = str(backup_dir / f"backup_{timestamp}.json")
+    
+    backup_file = Path(backup_path)
+    backup_file.parent.mkdir(parents=True, exist_ok=True)
+    
+    try:
+        # 导出所有数据
+        summaries = get_session_summaries()
+        all_diff_lines = get_code_diff_lines()
+        
+        # 组织数据
+        backup_data = {
+            "backup_time": format_datetime(get_current_time()),
+            "version": "1.0.0",
+            "summaries": summaries,
+            "diff_lines": all_diff_lines
+        }
+        
+        # 写入JSON文件
+        with open(backup_file, 'w', encoding='utf-8') as f:
+            json.dump(backup_data, f, ensure_ascii=False, indent=2)
+        
+        # 记录备份信息
+        backup_size = backup_file.stat().st_size // 1024  # KB
+        record_backup(str(backup_file), backup_size)
+        
+        logger.info(f"Database backed up to {backup_file} ({backup_size} KB)")
+        return str(backup_file)
+        
+    except Exception as e:
+        logger.error(f"Failed to backup database: {e}")
+        return None
+
+
+def restore_database(backup_path: str) -> bool:
+    """
+    从JSON文件恢复数据库
+    
+    Args:
+        backup_path: 备份文件路径
+    
+    Returns:
+        是否成功
+    """
+    backup_file = Path(backup_path)
+    
+    if not backup_file.exists():
+        logger.error(f"Backup file not found: {backup_path}")
+        return False
+    
+    try:
+        # 读取备份数据
+        with open(backup_file, 'r', encoding='utf-8') as f:
+            backup_data = json.load(f)
+        
+        # 清空现有数据（可选，根据需求决定）
+        # 这里我们选择追加模式，不删除现有数据
+        
+        # 恢复会话汇总
+        summaries = backup_data.get("summaries", [])
+        for summary in summaries:
+            save_session_summary(
+                session_id=summary["session_id"],
+                file_path=summary["file_path"],
+                add_lines_count=summary["add_lines_count"],
+                modify_lines_count=summary["modify_lines_count"],
+                total_lines_after=summary["total_lines_after"],
+                session_info=summary.get("session_info")
+            )
+        
+        # 恢复差异行
+        diff_lines = backup_data.get("diff_lines", [])
+        # 按session_id和file_path分组
+        grouped = {}
+        for diff_line in diff_lines:
+            key = (diff_line["session_id"], diff_line["file_path"])
+            if key not in grouped:
+                grouped[key] = []
+            grouped[key].append({
+                "diff_type": diff_line["diff_type"],
+                "line_content": diff_line["line_content"],
+                "line_number": diff_line["line_number"]
+            })
+        
+        for (session_id, file_path), lines in grouped.items():
+            save_code_diff_lines(session_id, file_path, lines)
+        
+        logger.info(f"Database restored from {backup_path}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Failed to restore database: {e}")
+        return False
+
+
+def record_backup(backup_path: str, backup_size: int):
+    """
+    记录备份操作到数据库
+    
+    Args:
+        backup_path: 备份文件路径
+        backup_size: 备份文件大小（KB）
+    """
+    db = get_db()
+    try:
+        db.execute("""
+            INSERT INTO backup_record (backup_path, backup_time, backup_size)
+            VALUES (?, ?, ?)
+        """, (backup_path, get_current_time(), backup_size))
+        db.commit()
+    except Exception as e:
+        logger.error(f"Failed to record backup: {e}")
+
+
+def get_backup_records(limit: int = 10) -> List[Dict[str, Any]]:
+    """
+    获取备份记录列表
+    
+    Args:
+        limit: 返回记录数限制
+    
+    Returns:
+        备份记录列表
+    """
+    db = get_db()
+    try:
+        cursor = db.execute("""
+            SELECT id, backup_path, backup_time, backup_size
+            FROM backup_record
+            ORDER BY backup_time DESC
+            LIMIT ?
+        """, (limit,))
+        
+        rows = cursor.fetchall()
+        return [
+            {
+                "id": row[0],
+                "backup_path": row[1],
+                "backup_time": row[2],
+                "backup_size": row[3]
+            }
+            for row in rows
+        ]
+    except Exception as e:
+        logger.error(f"Failed to get backup records: {e}")
+        return []
+