@zhushanwen/pi-evolve-daily 0.1.4 → 0.1.6

package/analyzer/__init__.py

@@ -0,0 +1,5 @@
+"""Evolve daily analyzer — Python 侧数据提取与规则挖掘。
+
+extractors/: 从 session JSONL 提取各维度统计数据。
+rules/: 从 daily-reports 中挖掘 actionable issues。
+"""

package/analyzer/analyze.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""Evolve Daily Analyzer - 使用新的 extractors 和 rules 分析 session JSONL。
+
+用法：
+    python3 analyze.py --since 1d --format json --output report.json
+    python3 analyze.py --input session.jsonl --format json --output report.json
+"""
+
+import argparse
+import json
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any
+
+# 添加当前目录到 Python 路径，以便导入 extractors 和 rules
+sys.path.insert(0, str(Path(__file__).parent))
+
+from extractors import run_extractors
+from rules import run_rules
+
+
+def load_sessions(since_days: int = 1, input_file: str | None = None) -> list[dict]:
+    """加载 session JSONL 数据。
+
+    Args:
+        since_days: 加载最近 N 天的数据。
+        input_file: 指定输入文件路径（优先级高于 since_days）。
+
+    Returns:
+        session 列表。
+    """
+    if input_file:
+        return _load_from_file(input_file)
+
+    # 从默认目录加载
+    sessions_dir = Path.home() / ".pi" / "agent" / "sessions"
+    if not sessions_dir.exists():
+        print(f"[evolve] Warning: Sessions directory not found: {sessions_dir}")
+        return []
+
+    cutoff = datetime.now() - timedelta(days=since_days)
+    sessions = []
+
+    for session_file in sessions_dir.glob("*.jsonl"):
+        try:
+            # 从文件名解析日期
+            file_date = datetime.fromisoformat(session_file.stem[:10])
+            if file_date < cutoff:
+                continue
+        except (ValueError, IndexError):
+            # 文件名不是日期格式，跳过
+            continue
+
+        session_data = _load_session_file(session_file)
+        if session_data:
+            sessions.append(session_data)
+
+    return sessions
+
+
+def _load_from_file(input_file: str) -> list[dict]:
+    """从单个文件加载 session 数据。"""
+    path = Path(input_file)
+    if not path.exists():
+        print(f"[evolve] Warning: Input file not found: {input_file}")
+        return []
+
+    if path.suffix == ".jsonl":
+        session_data = _load_session_file(path)
+        return [session_data] if session_data else []
+    elif path.suffix == ".json":
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                return [data] if isinstance(data, dict) else data
+        except Exception as e:
+            print(f"[evolve] Warning: Failed to load JSON file {input_file}: {e}")
+            return []
+    else:
+        print(f"[evolve] Warning: Unsupported file format: {path.suffix}")
+        return []
+
+
+def _load_session_file(file_path: Path) -> dict | None:
+    """加载单个 JSONL session 文件。"""
+    try:
+        messages = []
+        with open(file_path, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if line:
+                    try:
+                        messages.append(json.loads(line))
+                    except json.JSONDecodeError:
+                        continue
+
+        if not messages:
+            return None
+
+        return {
+            "session_id": file_path.stem,
+            "messages": messages,
+            "file_path": str(file_path),
+        }
+    except Exception as e:
+        print(f"[evolve] Warning: Failed to load session file {file_path}: {e}")
+        return None
+
+
+def generate_report(sessions: list[dict], format: str = "json") -> dict:
+    """生成分析报告。
+
+    Args:
+        sessions: session 列表。
+        format: 输出格式（json）。
+
+    Returns:
+        分析报告字典。
+    """
+    # 运行所有 extractors（传入当前工作目录作为 project_root）
+    project_root = str(Path.cwd())
+    extractor_results = run_extractors(sessions, project_root=project_root)
+
+
+    # 运行所有 miner rules
+    issues = run_rules(extractor_results)
+
+    # 生成报告
+    report = {
+        "generated_at": datetime.now().isoformat(),
+        "session_count": len(sessions),
+        "extractors": extractor_results,
+        "issues": issues,
+        "summary": {
+            "total_issues": len(issues),
+            "high_severity": sum(1 for i in issues if i.get("severity") == "high"),
+            "medium_severity": sum(1 for i in issues if i.get("severity") == "medium"),
+            "low_severity": sum(1 for i in issues if i.get("severity") == "low"),
+        },
+    }
+
+    return report
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Evolve Daily Analyzer")
+    parser.add_argument("--since", type=str, default="1d", help="分析最近 N 天的数据（如 1d, 7d）")
+    parser.add_argument("--input", type=str, help="指定输入文件路径")
+    parser.add_argument("--format", type=str, default="json", choices=["json"], help="输出格式")
+    parser.add_argument("--output", type=str, help="输出文件路径")
+    parser.add_argument("--verbose", action="store_true", help="详细输出")
+
+    args = parser.parse_args()
+
+    # 解析 since 参数
+    since_str = args.since.lower().rstrip("d")
+    try:
+        since_days = int(since_str)
+    except ValueError:
+        print(f"[evolve] Error: Invalid --since value: {args.since}")
+        sys.exit(1)
+
+    # 加载 sessions
+    if args.verbose:
+        print(f"[evolve] Loading sessions (since {since_days} days)...")
+    sessions = load_sessions(since_days=since_days, input_file=args.input)
+
+    if not sessions:
+        print("[evolve] Warning: No sessions found")
+        # 生成空报告
+        report = {
+            "generated_at": datetime.now().isoformat(),
+            "session_count": 0,
+            "extractors": {},
+            "issues": [],
+            "summary": {
+                "total_issues": 0,
+                "high_severity": 0,
+                "medium_severity": 0,
+                "low_severity": 0,
+            },
+        }
+    else:
+        if args.verbose:
+            print(f"[evolve] Found {len(sessions)} sessions")
+            print("[evolve] Running extractors...")
+        report = generate_report(sessions, format=args.format)
+
+    # 输出报告
+    if args.output:
+        output_path = Path(args.output)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(output_path, "w", encoding="utf-8") as f:
+            json.dump(report, f, ensure_ascii=False, indent=2)
+        if args.verbose:
+            print(f"[evolve] Report saved to {args.output}")
+    else:
+        print(json.dumps(report, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

package/analyzer/extractors/__init__.py

@@ -0,0 +1,61 @@
+"""Extractor 自动发现机制。
+
+通过 pkgutil.iter_modules 自动发现 extractors/ 目录下的所有模块，
+每个模块必须实现 extract(sessions: list[dict]) -> dict 接口。
+"""
+
+import pkgutil
+import importlib
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class BaseExtractor(Protocol):
+    """Extractor 协议：所有 extractor 必须实现 extract 方法。"""
+
+    def extract(self, sessions: list[dict]) -> dict: ...
+
+
+def discover_extractors() -> dict[str, object]:
+    """自动发现所有 extractor 模块。
+
+    Returns:
+        dict[str, module]: 模块名到模块对象的映射。
+    """
+    extractors: dict[str, object] = {}
+    for _importer, modname, _ispkg in pkgutil.iter_modules(__path__):
+        if modname.startswith("_"):
+            continue
+        try:
+            module = importlib.import_module(f".{modname}", __package__)
+            if hasattr(module, "extract"):
+                extractors[modname] = module
+        except Exception as exc:
+            print(f"[evolve] Warning: Failed to load extractor {modname}: {exc}")
+    return extractors
+
+
+def run_extractors(sessions: list[dict], project_root: str = "") -> dict:
+    """运行所有 extractor，每个 extractor 独立运行，失败时返回空结果。
+
+    Args:
+        sessions: session JSONL 解析后的字典列表。
+        project_root: 项目根目录路径（可选，用于 workflow extractor 扫描 .xyz-harness/）。
+
+    Returns:
+        合并后的提取结果，key 为 "{extractor_name}_stats"。
+    """
+    import inspect
+    results: dict = {}
+    extractors = discover_extractors()
+    for name, extractor in extractors.items():
+        try:
+            sig = inspect.signature(extractor.extract)
+            if "project_root" in sig.parameters:
+                results[f"{name}_stats"] = extractor.extract(sessions, project_root=project_root)  # type: ignore[attr-defined]
+            else:
+                results[f"{name}_stats"] = extractor.extract(sessions)  # type: ignore[attr-defined]
+        except Exception as exc:
+            print(f"[evolve] Warning: Extractor {name} failed: {exc}")
+            results[f"{name}_stats"] = {}
+    return results

package/analyzer/extractors/compact.py

@@ -0,0 +1,64 @@
+"""统计 session 中的 compactionSummary 消息。"""
+
+from typing import Any
+
+
+def extract(sessions: list[dict]) -> dict:
+    """从 session 列表中提取 compact 统计。
+
+    Args:
+        sessions: session JSONL 解析后的字典列表。
+
+    Returns:
+        包含 compact 频率、分布、触发时机等统计信息。
+    """
+    total_compacts = 0
+    compact_turn_indices: list[int] = []
+    sessions_with_compact = 0
+    total_sessions = len(sessions)
+
+    for session in sessions:
+        messages = session.get("messages", [])
+        session_compacts = 0
+
+        for i, msg in enumerate(messages):
+            if msg.get("type") == "compaction":
+                total_compacts += 1
+                session_compacts += 1
+                # turn 索引 = 消息序号 / 2（粗略估算）
+                compact_turn_indices.append(i // 2)
+
+        if session_compacts > 0:
+            sessions_with_compact += 1
+
+    # 计算分布
+    avg_compacts = total_compacts / max(total_sessions, 1)
+    per_session_counts = [
+        sum(1 for msg in s.get("messages", []) if msg.get("type") == "compaction")
+        for s in sessions
+    ]
+    max_compacts = max(per_session_counts) if per_session_counts else 0
+
+    # 分布桶：[0次, 1次, 2次, 3次, 4次, 5次, 6次+]
+    distribution = [0] * 7
+    for count in per_session_counts:
+        if count >= 6:
+            distribution[6] += 1
+        else:
+            distribution[count] += 1
+
+    # 早期触发统计（turn < 5 时触发 compact）
+    early_trigger_count = sum(1 for idx in compact_turn_indices if idx < 5)
+
+    return {
+        "total_compacts": total_compacts,
+        "compacts_per_session": {
+            "avg": avg_compacts,
+            "max": max_compacts,
+            "distribution": distribution,
+        },
+        "compact_turn_indices": compact_turn_indices,
+        "early_trigger_count": early_trigger_count,
+        "sessions_with_compact": sessions_with_compact,
+        "total_sessions": total_sessions,
+    }

package/analyzer/extractors/context.py

@@ -0,0 +1,139 @@
+"""计算估算的上下文窗口利用率。"""
+
+from typing import Any
+
+# 模型 context limit 映射（已知模型）
+MODEL_CONTEXT_LIMITS: dict[str, int] = {
+    "claude-sonnet-4": 200_000,
+    "claude-haiku-3.5": 200_000,
+    "deepseek-v3": 64_000,
+    "deepseek-r1": 64_000,
+    "gpt-4o": 128_000,
+    "gpt-4o-mini": 128_000,
+}
+
+
+def estimate_tokens_from_chars(char_count: int, text_sample: str = "") -> int:
+    """粗略估算 token 数。
+
+    如果有 text_sample，按中英文字符比例估算。
+    否则使用保守的混合比例 0.5 token/char。
+
+    Args:
+        char_count: 字符总数。
+        text_sample: 用于估算中英文比例的文本样本。
+
+    Returns:
+        估算的 token 数。
+    """
+    if char_count == 0:
+        return 0
+    if text_sample:
+        chinese_chars = sum(1 for c in text_sample if "\u4e00" <= c <= "\u9fff")
+        ratio = chinese_chars / len(text_sample)
+        # 混合比例：中文 ~1.5 token/char，英文 ~0.25 token/char
+        return int(char_count * (ratio * 1.5 + (1 - ratio) * 0.25))
+    # 无样本时使用保守的混合比例
+    return int(char_count * 0.5)
+
+
+def _extract_content_length(msg: dict) -> int:
+    """提取消息内容的字符数。"""
+    # 处理嵌套的消息格式 (msg.message.content)
+    message = msg.get("message", msg)
+    content = message.get("content", "")
+    if isinstance(content, str):
+        return len(content)
+    if isinstance(content, list):
+        return sum(
+            len(item.get("text", ""))
+            for item in content
+            if isinstance(item, dict) and "text" in item
+        )
+    return 0
+
+
+def extract(sessions: list[dict]) -> dict:
+    """从 session 列表中提取上下文利用率统计。
+
+    通过累积消息字符数估算上下文使用量，结合模型 context limit 计算利用率。
+
+    Args:
+        sessions: session JSONL 解析后的字典列表。
+
+    Returns:
+        包含上下文利用率分布、峰值、模型映射等统计信息。
+    """
+    models_used: set[str] = set()
+    context_limits: dict[str, int] = {}
+    utilization_samples: list[float] = []
+    compact_at_high_utilization = 0
+    total_compacts = 0
+
+    for session in sessions:
+        messages = session.get("messages", [])
+        current_model: str | None = None
+        cumulative_chars = 0
+
+        for msg in messages:
+            # 检查 model_change 事件
+            if msg.get("type") == "model_change":
+                model_id = msg.get("modelId", "")
+                if model_id:
+                    current_model = model_id
+                    models_used.add(model_id)
+                    if model_id in MODEL_CONTEXT_LIMITS:
+                        context_limits[model_id] = MODEL_CONTEXT_LIMITS[model_id]
+
+            # 累积消息字符数
+            cumulative_chars += _extract_content_length(msg)
+
+            # compact 事件
+            if msg.get("type") == "compaction":
+                total_compacts += 1
+                if current_model and current_model in MODEL_CONTEXT_LIMITS:
+                    limit = MODEL_CONTEXT_LIMITS[current_model]
+                    estimated_tokens = estimate_tokens_from_chars(cumulative_chars)
+                    utilization = estimated_tokens / limit
+                    if utilization >= 0.7:
+                        compact_at_high_utilization += 1
+                    utilization_samples.append(utilization)
+                # compact 后重置累积
+                cumulative_chars = 0
+
+        # session 结束时记录最终利用率
+        if (
+            current_model
+            and current_model in MODEL_CONTEXT_LIMITS
+            and cumulative_chars > 0
+        ):
+            limit = MODEL_CONTEXT_LIMITS[current_model]
+            estimated_tokens = estimate_tokens_from_chars(cumulative_chars)
+            utilization = estimated_tokens / limit
+            utilization_samples.append(utilization)
+
+    # 计算统计
+    avg_utilization = sum(utilization_samples) / max(len(utilization_samples), 1)
+    peak_utilization = max(utilization_samples) if utilization_samples else 0.0
+
+    # 分布桶
+    distribution = {"0-30%": 0, "30-60%": 0, "60-90%": 0, "90%+": 0}
+    for u in utilization_samples:
+        if u < 0.3:
+            distribution["0-30%"] += 1
+        elif u < 0.6:
+            distribution["30-60%"] += 1
+        elif u < 0.9:
+            distribution["60-90%"] += 1
+        else:
+            distribution["90%+"] += 1
+
+    return {
+        "models_used": sorted(models_used),
+        "context_limits": context_limits,
+        "avg_estimated_utilization": avg_utilization,
+        "peak_estimated_utilization": peak_utilization,
+        "utilization_distribution": distribution,
+        "compact_at_high_utilization": compact_at_high_utilization,
+        "total_compacts": total_compacts,
+    }

package/analyzer/extractors/goal_quality.py

@@ -0,0 +1,163 @@
+"""分析 Goal 任务拆分质量和 Todo 使用质量。"""
+
+import re
+from typing import Any
+
+
+def score_evidence(evidence: str) -> float:
+    """Evidence 质量评分 0.0-1.0。
+
+    评分维度：长度、路径引用、测试关键词、结果关键词、数值。
+
+    Args:
+        evidence: 任务的 evidence 文本。
+
+    Returns:
+        0.0-1.0 之间的质量评分。
+    """
+    if not evidence:
+        return 0.0
+    score = 0.0
+    if len(evidence) >= 20:
+        score += 0.3
+    if re.search(r"[/\\]", evidence):
+        score += 0.2
+    if re.search(r"test|spec|check", evidence, re.I):
+        score += 0.2
+    if re.search(r"pass|fail|success|error", evidence, re.I):
+        score += 0.2
+    if re.search(r"\d+", evidence):
+        score += 0.1
+    return min(score, 1.0)
+
+
+def _extract_text_from_content(content: Any) -> str:
+    """从消息 content 中提取纯文本。"""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        return " ".join(
+            item.get("text", "")
+            for item in content
+            if isinstance(item, dict) and "text" in item
+        )
+    return ""
+
+
+def extract(sessions: list[dict]) -> dict:
+    """从 session 列表中提取 Goal/Todo 质量统计。
+
+    分析 Goal 完成率、任务拆分质量、Evidence 质量、Stall 频率、Token 消耗，
+    以及 Todo 的完成率、放弃率等。
+
+    Args:
+        sessions: session JSONL 解析后的字典列表。
+
+    Returns:
+        包含 goal_quality_stats 和 todo_stats 两个维度。
+    """
+    goals_total = 0
+    goals_completed = 0
+    goals_budget_limited = 0
+    goals_cancelled = 0
+    all_tasks: list[dict] = []
+    all_evidence: list[str] = []
+    stall_count = 0
+    total_tokens = 0
+
+    todo_total = 0
+    todo_completed = 0
+    todo_abandoned = 0
+
+    for session in sessions:
+        messages = session.get("messages", [])
+
+        for msg in messages:
+            # Goal state entries
+            if msg.get("customType") == "goal-state":
+                goals_total += 1
+                state = msg.get("data", {})
+                status = state.get("status", "")
+
+                if status == "complete":
+                    goals_completed += 1
+                elif status == "budget_limited":
+                    goals_budget_limited += 1
+                elif status == "cancelled":
+                    goals_cancelled += 1
+
+                tasks = state.get("tasks", [])
+                for task in tasks:
+                    all_tasks.append(task)
+                    evidence = task.get("evidence", "")
+                    if evidence:
+                        all_evidence.append(evidence)
+
+                stall_count += state.get("stallCount", 0)
+                total_tokens += state.get("tokensUsed", 0)
+
+            # Todo tool calls
+            if (
+                msg.get("role") == "toolResult"
+                and msg.get("toolName") == "todo"
+            ):
+                content = _extract_text_from_content(msg.get("content", ""))
+
+                # 解析 todo 操作
+                if "add" in content.lower() or "添加" in content:
+                    todo_total += 1
+                if "completed" in content.lower() or "完成" in content:
+                    todo_completed += 1
+                if "delete" in content.lower() or "删除" in content:
+                    todo_abandoned += 1
+
+    # 任务统计
+    total_tasks = len(all_tasks)
+    completed_tasks = sum(1 for t in all_tasks if t.get("status") == "completed")
+    cancelled_tasks = sum(1 for t in all_tasks if t.get("status") == "cancelled")
+    pending_tasks = sum(1 for t in all_tasks if t.get("status") == "pending")
+
+    # Evidence 统计
+    tasks_with_evidence = len(all_evidence)
+    evidence_scores = [score_evidence(e) for e in all_evidence]
+    avg_evidence_score = sum(evidence_scores) / max(len(evidence_scores), 1)
+    low_quality_count = sum(1 for s in evidence_scores if s < 0.4)
+
+    return {
+        "goals_total": goals_total,
+        "goals_completed": goals_completed,
+        "goals_budget_limited": goals_budget_limited,
+        "goals_cancelled": goals_cancelled,
+        "completion_rate": goals_completed / max(goals_total, 1),
+        "avg_tasks_per_goal": total_tasks / max(goals_total, 1),
+        "task_stats": {
+            "total": total_tasks,
+            "completed": completed_tasks,
+            "cancelled": cancelled_tasks,
+            "pending": pending_tasks,
+            "completion_rate": completed_tasks / max(total_tasks, 1),
+            "cancel_rate": cancelled_tasks / max(total_tasks, 1),
+        },
+        "evidence_stats": {
+            "tasks_with_evidence": tasks_with_evidence,
+            "evidence_rate": tasks_with_evidence / max(total_tasks, 1),
+            "avg_evidence_score": avg_evidence_score,
+            "low_quality_evidence_count": low_quality_count,
+        },
+        "stall_stats": {
+            "goals_with_stall": 1 if stall_count > 0 else 0,
+            "stall_rate": (1 if stall_count > 0 else 0) / max(goals_total, 1),
+            "avg_stall_count": stall_count / max(goals_total, 1),
+        },
+        "token_stats": {
+            "avg_tokens_per_goal": total_tokens / max(goals_total, 1),
+            "avg_tokens_per_task": total_tokens / max(total_tasks, 1),
+        },
+        "todo_stats": {
+            "total_todos": todo_total,
+            "completed": todo_completed,
+            "abandoned": todo_abandoned,
+            "completion_rate": todo_completed / max(todo_total, 1),
+            "abandon_rate": todo_abandoned / max(todo_total, 1),
+        },
+    }