aicodestat 0.0.1__py3-none-any.whl

cli/views.py

@@ -0,0 +1,277 @@
+"""Table, bar chart, and color rendering based on rich"""
+import logging
+from typing import Dict, Any, List
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+from rich.bar import Bar
+from rich import box
+
+logger = logging.getLogger(__name__)
+
+console = Console()
+
+
+def format_percentage(value: float) -> str:
+    """Format percentage with color markers"""
+    if value >= 80:
+        return f"[green]{value:.2f}%[/green]"
+    elif value >= 50:
+        return f"[yellow]{value:.2f}%[/yellow]"
+    else:
+        return f"[red]{value:.2f}%[/red]"
+
+
+def display_service_status(status: Dict[str, Any]):
+    """Display MCP service status"""
+    table = Table(title="MCP Service Status", box=box.ROUNDED, show_header=True, header_style="bold magenta")
+    table.add_column("Item", style="cyan", no_wrap=True)
+    table.add_column("Value", style="green")
+    
+    table.add_row("Running Status", "✅ Running" if status["running"] else "❌ Not Running")
+    if status["running"]:
+        table.add_row("Process ID", str(status["pid"]))
+    table.add_row("Listen Address", f"{status['host']}:{status['port']}")
+    table.add_row("PID File", status["pid_file"])
+    
+    console.print(table)
+    
+    if status["running"]:
+        # Test if service is accessible
+        try:
+            import requests
+            response = requests.get(
+                f"http://{status['host']}:{status['port']}/health",
+                timeout=2
+            )
+            if response.status_code == 200:
+                console.print("[green]✅ Service health check passed[/green]")
+                health_data = response.json()
+                console.print(f"[dim]Version: {health_data.get('version', 'unknown')}[/dim]")
+            else:
+                console.print(f"[yellow]⚠️  Service response abnormal: {response.status_code}[/yellow]")
+        except ImportError:
+            console.print("[yellow]⚠️  Cannot perform health check (requests library missing)[/yellow]")
+        except Exception as e:
+            console.print(f"[red]❌ Cannot connect to service: {e}[/red]")
+
+
+def display_metrics_table(metrics: Dict[str, Any], title: str = "Metrics Statistics"):
+    """
+    Display metrics overview table
+    
+    Args:
+        metrics: Metrics data
+        title: Table title
+    """
+    table = Table(title=title, box=box.ROUNDED, show_header=True, header_style="bold magenta")
+    table.add_column("Metric Name", style="cyan", no_wrap=True)
+    table.add_column("Value", style="green", justify="right")
+    
+    table.add_row("AI Generated Lines", f"{metrics.get('ai_total_lines', 0)} lines")
+    table.add_row("Adopted Lines", f"{metrics.get('adopted_lines', 0)} lines")
+    table.add_row("Code Adoption Rate", format_percentage(metrics.get('adoption_rate', 0.0)))
+    table.add_row("Code Generation Rate", format_percentage(metrics.get('generation_rate', 0.0)))
+    
+    if "file_count" in metrics:
+        table.add_row("Files Involved", f"{metrics.get('file_count', 0)} files")
+    
+    if "session_count" in metrics:
+        table.add_row("Sessions", f"{metrics.get('session_count', 0)} sessions")
+    
+    console.print(table)
+
+
+def display_global_dashboard(metrics: Dict[str, Any]):
+    """Display a concise global dashboard for all local data."""
+    from rich.layout import Layout
+
+    layout = Layout()
+    layout.split_column(
+        Layout(name="summary", size=8),
+        Layout(name="details"),
+    )
+
+    # Top summary panel
+    summary_table = Table(
+        title="Global Summary",
+        box=box.ROUNDED,
+        show_header=False,
+        header_style="bold magenta",
+    )
+    summary_table.add_column("Metric", style="cyan")
+    summary_table.add_column("Value", style="green", justify="right")
+
+    summary_table.add_row("AI Generated Lines", f"{metrics.get('ai_total_lines', 0)}")
+    summary_table.add_row("Adopted Lines", f"{metrics.get('adopted_lines', 0)}")
+    summary_table.add_row(
+        "Adoption Rate", format_percentage(metrics.get("adoption_rate", 0.0))
+    )
+    summary_table.add_row(
+        "Generation Rate", format_percentage(metrics.get("generation_rate", 0.0))
+    )
+    summary_table.add_row(
+        "Files Involved", str(metrics.get("file_count", 0))
+    )
+    summary_table.add_row(
+        "Sessions", str(metrics.get("session_count", 0))
+    )
+
+    layout["summary"].update(summary_table)
+
+    # Bottom: simple bar chart for quick visual
+    bar_data = {
+        "AI Lines": float(metrics.get("ai_total_lines", 0)),
+        "Adopted": float(metrics.get("adopted_lines", 0)),
+    }
+    # Avoid all zeros
+    bar_data = {k: v for k, v in bar_data.items() if v > 0}
+
+    if bar_data:
+        from rich.table import Table as RichTable
+
+        max_value = max(bar_data.values())
+        bar_table = RichTable(
+            title="Adoption Overview",
+            box=box.SIMPLE,
+            show_header=False,
+        )
+        bar_table.add_column("Item", style="cyan")
+        bar_table.add_column("Chart", style="blue")
+        bar_table.add_column("Value", style="green", justify="right")
+
+        for label, value in bar_data.items():
+            length = int((value / max_value) * 40) if max_value > 0 else 0
+            bar = "█" * length
+            bar_table.add_row(label, bar, f"{int(value)}")
+
+        layout["details"].update(bar_table)
+    else:
+        layout["details"].update(
+            Panel("[yellow]No global data yet. Generate some AI code to see stats here.[/yellow]")
+        )
+
+    console.print(layout)
+
+
+def display_session_info(summaries: List[Dict[str, Any]]):
+    """Display session details"""
+    if not summaries:
+        return
+    
+    summary = summaries[0]  # Take first session info
+    session_info = summary.get("session_info", "")
+    create_time = summary.get("create_time", "")
+    
+    info_text = Text()
+    if session_info:
+        info_text.append("🤖 Agent Info: ", style="bold")
+        info_text.append(f"{session_info}\n", style="cyan")
+    if create_time:
+        info_text.append("📅 Operation Time: ", style="bold")
+        info_text.append(f"{create_time}\n", style="cyan")
+    
+    if info_text:
+        panel = Panel(info_text, title="Session Details", border_style="blue")
+        console.print(panel)
+
+
+def display_diff_lines_table(diff_lines: List[Dict[str, Any]], limit: int = 20):
+    """
+    Display diff lines details table
+    
+    Args:
+        diff_lines: Diff lines list
+        limit: Display line limit
+    """
+    if not diff_lines:
+        console.print("[yellow]No diff lines data[/yellow]")
+        return
+    
+    table = Table(title=f"Diff Lines Details (showing first {min(limit, len(diff_lines))} lines)", box=box.ROUNDED)
+    table.add_column("Diff Type", style="cyan", width=10)
+    table.add_column("Line Number", style="green", justify="right", width=8)
+    table.add_column("Code Content", style="white", overflow="fold")
+    
+    for diff_line in diff_lines[:limit]:
+        diff_type = diff_line.get("diff_type", "")
+        line_number = diff_line.get("line_number", "")
+        line_content = diff_line.get("line_content", "")
+        
+        # Type color markers
+        if diff_type == "add":
+            type_style = "[green]add[/green]"
+        elif diff_type == "modify":
+            type_style = "[yellow]modify[/yellow]"
+        else:
+            type_style = diff_type
+        
+        table.add_row(type_style, str(line_number), line_content)
+    
+    console.print(table)
+    
+    if len(diff_lines) > limit:
+        console.print(f"[dim]... {len(diff_lines) - limit} more lines not shown[/dim]")
+
+
+def display_simple_bar_chart(data: Dict[str, float], title: str = "Metrics Comparison"):
+    """
+    Display simple bar chart
+    
+    Args:
+        data: Data dictionary, keys are labels, values are numbers
+        title: Chart title
+    """
+    if not data:
+        console.print("[yellow]No data to display[/yellow]")
+        return
+    
+    # Calculate max value for normalization
+    max_value = max(data.values()) if data.values() else 1
+    
+    table = Table(title=title, box=box.SIMPLE)
+    table.add_column("Item", style="cyan")
+    table.add_column("Value", style="green", justify="right")
+    table.add_column("Chart", style="blue")
+    
+    for label, value in sorted(data.items(), key=lambda x: x[1], reverse=True):
+        # Calculate bar length (assuming max width of 50)
+        bar_length = int((value / max_value) * 50) if max_value > 0 else 0
+        bar = "█" * bar_length
+        table.add_row(label, f"{value:.2f}", bar)
+    
+    console.print(table)
+
+
+def display_agent_comparison(metrics_list: List[Dict[str, Any]]):
+    """
+    Display cross-agent metrics comparison
+    
+    Args:
+        metrics_list: Metrics list, each element contains session_id and metrics data
+    """
+    if not metrics_list:
+        console.print("[yellow]No comparison data[/yellow]")
+        return
+    
+    table = Table(title="Cross-Agent Metrics Comparison", box=box.ROUNDED)
+    table.add_column("Session ID", style="cyan")
+    table.add_column("AI Generated Lines", style="green", justify="right")
+    table.add_column("Adopted Lines", style="green", justify="right")
+    table.add_column("Adoption Rate", style="green", justify="right")
+    table.add_column("Generation Rate", style="green", justify="right")
+    
+    for item in metrics_list:
+        session_id = item.get("session_id", "unknown")
+        metrics = item.get("metrics", {})
+        
+        table.add_row(
+            session_id[:30] + "..." if len(session_id) > 30 else session_id,
+            str(metrics.get("ai_total_lines", 0)),
+            str(metrics.get("adopted_lines", 0)),
+            format_percentage(metrics.get("adoption_rate", 0.0)),
+            format_percentage(metrics.get("generation_rate", 0.0))
+        )
+    
+    console.print(table)

compute/__init__.py

@@ -0,0 +1,2 @@
+"""计算层模块"""
+

compute/cache.py

@@ -0,0 +1,90 @@
+"""简单内存缓存，按会话/文件维度缓存5分钟内的计算结果"""
+import time
+import logging
+from typing import Any, Optional
+from datetime import datetime, timedelta
+
+logger = logging.getLogger(__name__)
+
+
+class SimpleCache:
+    """简单内存缓存实现"""
+    
+    def __init__(self, default_ttl: int = 300):
+        """
+        初始化缓存
+        
+        Args:
+            default_ttl: 默认过期时间（秒），默认5分钟
+        """
+        self._cache: dict[str, tuple[Any, float]] = {}
+        self.default_ttl = default_ttl
+    
+    def get(self, key: str) -> Optional[Any]:
+        """
+        获取缓存值
+        
+        Args:
+            key: 缓存键
+        
+        Returns:
+            缓存值，如果不存在或已过期则返回None
+        """
+        if key not in self._cache:
+            return None
+        
+        value, expire_time = self._cache[key]
+        
+        if time.time() > expire_time:
+            # 已过期，删除
+            del self._cache[key]
+            return None
+        
+        return value
+    
+    def set(self, key: str, value: Any, ttl: Optional[int] = None):
+        """
+        设置缓存值
+        
+        Args:
+            key: 缓存键
+            value: 缓存值
+            ttl: 过期时间（秒），如果为None则使用默认值
+        """
+        if ttl is None:
+            ttl = self.default_ttl
+        
+        expire_time = time.time() + ttl
+        self._cache[key] = (value, expire_time)
+    
+    def clear(self):
+        """清空所有缓存"""
+        self._cache.clear()
+    
+    def delete(self, key: str):
+        """删除指定缓存"""
+        if key in self._cache:
+            del self._cache[key]
+    
+    def cleanup_expired(self):
+        """清理过期缓存"""
+        current_time = time.time()
+        expired_keys = [
+            key for key, (_, expire_time) in self._cache.items()
+            if current_time > expire_time
+        ]
+        for key in expired_keys:
+            del self._cache[key]
+        
+        if expired_keys:
+            logger.debug(f"Cleaned up {len(expired_keys)} expired cache entries")
+
+
+# 全局缓存实例
+_metrics_cache = SimpleCache(default_ttl=300)
+
+
+def get_cache() -> SimpleCache:
+    """获取全局缓存实例"""
+    return _metrics_cache
+

compute/diff_engine.py

@@ -0,0 +1,69 @@
+"""差异提取引擎：封装 extract_diff_lines，用 difflib 实现精准差分"""
+import difflib
+import logging
+from typing import List, Dict, Any
+
+logger = logging.getLogger(__name__)
+
+
+def extract_diff_lines(code_before: str, code_after: str) -> List[Dict[str, Any]]:
+    """
+    提取具体差异行（新增/修改），返回差异行列表
+    
+    Args:
+        code_before: 编辑前的代码
+        code_after: 编辑后的代码
+    
+    Returns:
+        差异行列表，每个元素包含：
+        - diff_type: 'add' 或 'modify'
+        - line_content: 差异行内容
+        - line_number: 差异行在编辑后文件中的行号
+    """
+    # 拆分代码为行列表（保留空行、原始格式）
+    before_lines = code_before.split("\n")
+    after_lines = code_after.split("\n")
+    
+    diff_lines = []
+    
+    # 使用 SequenceMatcher 计算差异
+    matcher = difflib.SequenceMatcher(None, before_lines, after_lines)
+    
+    # 追踪编辑后文件的行号
+    current_after_line = 0
+    
+    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+        if tag == 'equal':
+            # 相同部分，更新行号
+            current_after_line += (j2 - j1)
+        elif tag == 'delete':
+            # 删除的行，不记录（因为我们要的是新增/修改）
+            pass
+        elif tag == 'insert':
+            # 新增的行
+            for idx, line in enumerate(after_lines[j1:j2]):
+                line_content = line.strip()
+                if line_content:  # 过滤空的新增行
+                    diff_lines.append({
+                        "diff_type": "add",
+                        "line_content": line_content,
+                        "line_number": current_after_line + idx + 1
+                    })
+            current_after_line += (j2 - j1)
+        elif tag == 'replace':
+            # 修改的行（先删后加）
+            # 我们记录新增的内容作为修改后的差异行
+            for idx, line in enumerate(after_lines[j1:j2]):
+                line_content = line.strip()
+                if line_content:  # 过滤空的修改行
+                    diff_lines.append({
+                        "diff_type": "modify",
+                        "line_content": line_content,
+                        "line_number": current_after_line + idx + 1
+                    })
+            current_after_line += (j2 - j1)
+    
+    logger.debug(f"Extracted {len(diff_lines)} diff lines: {sum(1 for d in diff_lines if d['diff_type'] == 'add')} add, {sum(1 for d in diff_lines if d['diff_type'] == 'modify')} modify")
+    
+    return diff_lines
+

compute/lcs_engine.py

@@ -0,0 +1,73 @@
+"""LCS算法引擎：实现 lcs_calculate 与批量计算接口"""
+import logging
+from typing import List
+
+logger = logging.getLogger(__name__)
+
+
+def lcs_calculate(ai_diff_lines: List[str], latest_file_lines: List[str]) -> int:
+    """
+    计算AI生成的差异行与文件最新内容的最长公共子序列（公共行数）
+    
+    Args:
+        ai_diff_lines: AI生成的差异行列表（从code_diff_lines表读取）
+        latest_file_lines: 文件最新的代码行列表（读取本地文件）
+    
+    Returns:
+        公共行数（采纳行数）
+    """
+    # 简化处理：提取非空代码行，去除首尾空白
+    ai_lines = [line.strip() for line in ai_diff_lines if line.strip()]
+    latest_lines = [line.strip() for line in latest_file_lines if line.strip()]
+    
+    if not ai_lines or not latest_lines:
+        return 0
+    
+    # 构建LCS动态规划表
+    m, n = len(ai_lines), len(latest_lines)
+    dp = [[0] * (n + 1) for _ in range(m + 1)]
+    
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+            if ai_lines[i-1] == latest_lines[j-1]:
+                dp[i][j] = dp[i-1][j-1] + 1
+            else:
+                dp[i][j] = max(dp[i-1][j], dp[i][j-1])
+    
+    lcs_length = dp[m][n]
+    logger.debug(f"LCS calculation: {len(ai_lines)} AI lines vs {len(latest_lines)} latest lines, LCS={lcs_length}")
+    
+    return lcs_length
+
+
+def calculate_adoption_rate(ai_total_lines: int, adopted_lines: int) -> float:
+    """
+    计算采纳率
+    
+    Args:
+        ai_total_lines: AI生成总行数
+        adopted_lines: 采纳行数
+    
+    Returns:
+        采纳率（0-100）
+    """
+    if ai_total_lines == 0:
+        return 0.0
+    return round((adopted_lines / ai_total_lines) * 100, 2)
+
+
+def calculate_generation_rate(ai_total_lines: int, file_total_lines: int) -> float:
+    """
+    计算生成率
+    
+    Args:
+        ai_total_lines: AI生成总行数
+        file_total_lines: 文件最新总行数
+    
+    Returns:
+        生成率（0-100）
+    """
+    if file_total_lines == 0:
+        return 0.0
+    return round((ai_total_lines / file_total_lines) * 100, 2)
+