@zhushanwen/pi-evolve-daily 0.1.0 → 0.1.4

package/README.md

@@ -0,0 +1,47 @@
+# evolve-daily
+
+每日进化数据采集器 — 每天首次 session 自动运行 Python 分析器，生成使用报告。
+
+## 功能
+
+- **自动采集**：每天首次启动 Pi 时自动运行 `analyze.py` 分析 session 数据
+- **JSON 报告**：输出到 `~/.pi/agent/evolution-data/daily-reports/YYYY-MM-DD.json`
+- **配套 skills**：内置 `/evolve`、`/evolve-apply`、`/evolve-report` 三个 skill
+
+## 安装
+
+```bash
+# symlink 方式（开发推荐）
+ln -s /path/to/xyz-pi-extensions-workspace/main/packages/evolve-daily \
+      ~/.pi/agent/extensions/evolve-daily
+
+# npm 方式（正式）
+pi install npm:@zhushanwen/pi-evolve-daily
+```
+
+## 使用
+
+安装后自动生效，无需手动操作。
+
+| Skill | 说明 |
+|-------|------|
+| `/evolve` | 分析使用模式，生成进化建议 |
+| `/evolve-apply` | 应用/跳过/回滚进化建议 |
+| `/evolve-report` | 查看每日报告和使用统计 |
+
+## 依赖
+
+- Python 3 + `analyze.py`（位于 `~/.pi/agent/scripts/pi-session-analyzer/`）
+
+## 文件结构
+
+```
+evolve-daily/
+├── index.ts
+├── src/
+│   └── index.ts    # 入口 — session_start 事件中触发分析
+└── skills/
+    ├── evolve/
+    ├── evolve-apply/
+    └── evolve-report/
+```

package/package.json

@@ -1,17 +1,33 @@
 {
   "name": "@zhushanwen/pi-evolve-daily",
-  "version": "0.1.0",
+  "version": "0.1.4",
   "description": "Daily evolution data collector — runs Python analyzer on first session of the day.",
+  "type": "module",
   "main": "src/index.ts",
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
+  "keywords": [
+    "pi-package"
+  ],
   "files": [
     "src/",
     "index.ts",
-    "skills/"
+    "skills/",
+    "scripts/**/*.py"
   ],
   "peerDependencies": {
     "@mariozechner/pi-coding-agent": "*"
   },
   "scripts": {
     "typecheck": "npx tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0"
   }
 }

package/scripts/analyze.py

@@ -0,0 +1,186 @@
+"""analyze.py — CLI 入口，编排 parser → extractors → miner → reporter pipeline。"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import random
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+# 将脚本目录加入 sys.path 以支持直接运行
+_SCRIPT_DIR = Path(__file__).resolve().parent
+sys.path.insert(0, str(_SCRIPT_DIR))
+
+from config import SESSIONS_DIR, REPORTS_DIR  # type: ignore[import-not-found]
+from parser import parse_all_sessions  # type: ignore[import-not-found]
+from extractors.tools import analyze_tool_usage  # type: ignore[import-not-found]
+from extractors.tokens import analyze_token_usage  # type: ignore[import-not-found]
+from extractors.errors import analyze_errors  # type: ignore[import-not-found]
+from extractors.users import analyze_user_patterns  # type: ignore[import-not-found]
+from extractors.skills import analyze_skill_usage  # type: ignore[import-not-found]
+from extractors.cross_project import analyze_cross_project  # type: ignore[import-not-found]
+from extractors.satisfaction import analyze_satisfaction  # type: ignore[import-not-found]
+from extractors.skill_state import analyze_skill_state  # type: ignore[import-not-found]
+from miner import mine_patterns  # type: ignore[import-not-found]
+from reporter import to_markdown, to_json_string  # type: ignore[import-not-found]
+
+# Extractor 失败时的空结果降级
+_EMPTY_TOOL = {"total_calls": 0, "by_tool": {}, "edit_retry_rate": 0,
+               "duplicate_reads": [], "bash_command_types": {}, "tool_sequences": []}
+_EMPTY_TOKEN = {"total_input": 0, "total_output": 0, "total_cache_read": 0,
+                "by_project": [], "by_model": [], "hotspots": [], "cost_total": 0}
+_EMPTY_ERROR = {"total_errors": 0, "by_tool": {}, "bash_failure_rate": 0,
+                "edit_match_failure_rate": 0, "top_error_patterns": [],
+                "self_correction_rate": 0, "by_project": [], "failure_refs": []}
+_EMPTY_USER = {"total_user_messages": 0, "avg_per_session": 0,
+               "corrections": {"total": 0, "by_keyword": {}},
+               "repeated_requests": [], "supplementary_instructions": {"total": 0}}
+_EMPTY_SKILL = {"installed_skills": 0, "triggered_skills": {}, "never_triggered": [],
+                "skill_file_sizes": {}, "total_skill_reads": 0, "by_project": {}}
+_EMPTY_CROSS = {"project_count": 0, "projects": [],
+                "common_tool_sequences": [], "project_type_distribution": {}}
+_EMPTY_SAT = {"total_sessions": 0, "single_turn_completion_rate": 0,
+              "avg_turns_per_session": 0, "avg_tool_calls_per_session": 0,
+              "session_duration_stats": {}, "by_project": []}
+_EMPTY_SKILL_STATE = {"total_tracked": 0, "unique_skills": 0,
+                      "by_skill": {}, "slow_skills": [], "error_skills": []}
+
+# users extractor 文本聚类在大 session 集上的性能限制
+_USERS_EXTRACTOR_SESSION_LIMIT = 200
+
+
+def _build_argparser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        description="Pi Session Analyzer — 离线分析 Pi Agent session 数据",
+    )
+    p.add_argument("--since", default="7d", help="起始时间 (ISO 格式或 Nd，默认 7d)")
+    p.add_argument("--until", default=None, help="结束时间 (ISO 格式，默认 now)")
+    p.add_argument("--project", default=None, help="项目名过滤 (子串匹配目录名)")
+    p.add_argument("--sample", type=int, default=None, help="抽样模式: 随机取 N 个 session")
+    p.add_argument("--output", default=None, help="输出文件路径 (默认 stdout)")
+    p.add_argument("--format", choices=["markdown", "json"], default="markdown",
+                   dest="fmt", help="输出格式 (默认 markdown)")
+    p.add_argument("--verbose", action="store_true", help="打印进度信息到 stderr")
+    return p
+
+
+def _verbose(msg: str, verbose: bool) -> None:
+    if verbose:
+        print(f"[analyze] {msg}", file=sys.stderr)
+
+
+def _safe_run(label: str, fn, fallback):
+    """运行 extractor，失败时打印 warning 并返回空结果。"""
+    try:
+        return fn()
+    except Exception as exc:
+        print(f"[analyze] Warning: {label} extractor 失败: {exc}", file=sys.stderr)
+        return fallback
+
+
+def _resolve_sessions(args, verbose: bool) -> tuple[list, bool, int | None]:
+    """解析 + 抽样 sessions，返回 (sessions, is_sample, sample_size)。"""
+    sessions = parse_all_sessions(since=args.since, until=args.until, project=args.project)
+    _verbose(f"解析完成: {len(sessions)} sessions", verbose)
+
+    is_sample, sample_size = False, None
+    if args.sample is not None:
+        actual = min(args.sample, len(sessions))
+        if actual < args.sample:
+            print(f"[analyze] Warning: --sample {args.sample} > 可用 sessions {len(sessions)}, "
+                  "降级为全量分析", file=sys.stderr)
+        else:
+            is_sample, sample_size = True, actual
+            sessions = random.sample(sessions, actual)
+            _verbose(f"抽样: {sample_size} sessions", verbose)
+
+    if not sessions:
+        print("[analyze] 无匹配 session，输出空报告", file=sys.stderr)
+
+    return sessions, is_sample, sample_size
+
+
+def _build_session_time_map(sessions: list) -> dict[str, str]:
+    """建立 session_id → start_time 映射（供 miner DORMANT 时间判定）。"""
+    time_map: dict[str, str] = {}
+    for s in sessions:
+        if hasattr(s, "session_id") and hasattr(s, "start_time") and s.start_time:
+            time_map[s.session_id] = s.start_time
+    return time_map
+
+
+def _run_extractors(sessions: list, verbose: bool) -> tuple[dict, ...]:
+    """运行 8 个 extractor（每个独立 try/except 降级），返回 8 个结果。"""
+    _verbose("运行 extractors...", verbose)
+
+    tool_stats = _safe_run("tools", lambda: analyze_tool_usage(sessions), _EMPTY_TOOL)
+    token_stats = _safe_run("tokens", lambda: analyze_token_usage(sessions), _EMPTY_TOKEN)
+    error_stats = _safe_run("errors", lambda: analyze_errors(sessions), _EMPTY_ERROR)
+
+    # users extractor 的文本聚类在大 session 集上很慢 (O(n*m))，限制输入量
+    if len(sessions) > _USERS_EXTRACTOR_SESSION_LIMIT:
+        users_subset = random.sample(sessions, _USERS_EXTRACTOR_SESSION_LIMIT)
+        _verbose(f"Users extractor: 使用 {len(users_subset)}/{len(sessions)} sessions (性能优化)",
+                 verbose)
+    else:
+        users_subset = sessions
+    user_patterns = _safe_run("users", lambda: analyze_user_patterns(users_subset), _EMPTY_USER)
+
+    skill_stats = _safe_run("skills", lambda: analyze_skill_usage(sessions), _EMPTY_SKILL)
+    cross_project = _safe_run("cross_project", lambda: analyze_cross_project(sessions), _EMPTY_CROSS)
+    satisfaction = _safe_run("satisfaction", lambda: analyze_satisfaction(sessions), _EMPTY_SAT)
+    skill_state = _safe_run("skill_state", lambda: analyze_skill_state(sessions), _EMPTY_SKILL_STATE)
+    _verbose("Extractors 完成", verbose)
+
+    return (tool_stats, token_stats, error_stats, user_patterns,
+            skill_stats, cross_project, satisfaction, skill_state)
+
+
+def _write_output(text: str, output_path: str | None, verbose: bool) -> None:
+    """写入输出文件或 stdout。"""
+    if output_path:
+        out = Path(output_path)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(text, encoding="utf-8")
+        _verbose(f"报告写入: {out}", verbose)
+    else:
+        print(text)
+
+
+def main(argv: list[str] | None = None) -> None:
+    args = _build_argparser().parse_args(argv)
+
+    # 检查 sessions 目录
+    if not Path(SESSIONS_DIR).exists():
+        print(f"错误: session 目录不存在: {SESSIONS_DIR}", file=sys.stderr)
+        sys.exit(1)
+
+    _verbose(f"解析 sessions (since={args.since}, until={args.until}, project={args.project})...",
+             args.verbose)
+    sessions, is_sample, sample_size = _resolve_sessions(args, args.verbose)
+    session_time_map = _build_session_time_map(sessions)
+    extractors = _run_extractors(sessions, args.verbose)
+
+    until_str = args.until or datetime.now(timezone.utc).isoformat()[:10]
+    _verbose("聚合分析...", args.verbose)
+    # 8 个 extractor 结果: 前 7 个位置参数 + skill_state 关键字参数
+    (tool_stats, token_stats, error_stats, user_patterns,
+     skill_stats, cross_project, satisfaction, skill_state) = extractors
+    aggregated = mine_patterns(
+        tool_stats, token_stats, error_stats, user_patterns,
+        skill_stats, cross_project, satisfaction,
+        skill_state=skill_state,
+        is_sample=is_sample, sample_size=sample_size,
+        total_sessions=len(sessions), since=args.since, until=until_str,
+        session_time_map=session_time_map,
+    )
+    _verbose("聚合完成", args.verbose)
+
+    output = to_json_string(aggregated) if args.fmt == "json" else to_markdown(aggregated)
+    _write_output(output, args.output, args.verbose)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/config.py

@@ -0,0 +1,50 @@
+"""配置：路径、阈值、常量。"""
+
+import os
+from pathlib import Path
+from datetime import timedelta
+
+# ── 路径 ──────────────────────────────────────────────
+PI_AGENT_DIR = Path(os.path.expanduser("~/.pi/agent"))
+SESSIONS_DIR = PI_AGENT_DIR / "sessions"
+EVOLUTION_DATA_DIR = PI_AGENT_DIR / "evolution-data"
+REPORTS_DIR = EVOLUTION_DATA_DIR / "reports"
+DAILY_DIR = EVOLUTION_DATA_DIR / "daily"
+
+# ── 信号提取阈值 ─────────────────────────────────────
+# Signal 1: 工具使用
+DUPLICATE_READ_THRESHOLD = 3  # 同一文件读取次数超过此值视为重复
+
+# Signal 2: Token
+TOKEN_HOTSPOT_PERCENTILE = 90  # token 消耗 top 百分位视为热点
+
+# Signal 3: 错误
+ERROR_KEYWORDS = [
+    "error", "fail", "failed", "exception",
+    "Could not find the exact text",
+    "ENOENT", "permission denied",
+    "non-zero exit code",
+]
+
+# Signal 4: 用户重复指令
+USER_CORRECTION_KEYWORDS = [
+    "不对", "不要", "别", "取消", "错了", "不是这样",
+    "no,", "wrong", "not like this", "don't",
+    "重新", "重来", "换个", "换一种",
+]
+
+# Signal 5: Skill
+SKILLS_DIR = PI_AGENT_DIR / "skills"
+SKILL_FILE_NAME = "SKILL.md"
+
+# Signal 7: 满意度隐式信号
+SINGLE_TURN_MAX_MESSAGES = 3  # user+assistant 消息数 <= 此值视为单轮完成
+
+# ── 报告 ──────────────────────────────────────────────
+TOP_N_PROBLEMS = 10
+TOP_N_PATTERNS = 10
+TOP_N_SKILLS = 20
+
+# ── 性能 ──────────────────────────────────────────────
+MAX_FILES_PARALLEL = 8  # 并行解析文件数
+BATCH_SIZE = 50  # 批量处理 session 数

package/scripts/extract_context.py

@@ -0,0 +1,350 @@
+"""extract_context.py — 根据 failure_ref 从 JSONL 中提取完整上下文。
+
+CLI 工具，供 evolve skill 通过 bash 调用：
+    python3 extract_context.py --session-id SID --tool-call-id TID [--context 5]
+
+也支持批量提取某个 error pattern 的典型案例：
+    python3 extract_context.py --pattern "Timeout" --from-report REPORT_JSON [--limit 2]
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+_SCRIPT_DIR = Path(__file__).resolve().parent
+sys.path.insert(0, str(_SCRIPT_DIR))
+
+from config import SESSIONS_DIR
+
+
+# ── JSONL 定位 ────────────────────────────────────────
+
+def _find_session_file(session_id: str) -> Path | None:
+    """根据 session_id 定位 JSONL 文件。session_id 嵌在文件名中。
+
+    如果匹配到多个文件（罕见情况），按 mtime 降序取最新的。
+    """
+    if not SESSIONS_DIR.exists():
+        return None
+
+    candidates: list[Path] = []
+    for project_dir in SESSIONS_DIR.iterdir():
+        if not project_dir.is_dir():
+            continue
+        # 跳过可能的符号链接循环
+        if project_dir.is_symlink() and project_dir.is_dir():
+            continue
+        for jsonl_file in project_dir.glob(f"*{session_id}*.jsonl"):
+            candidates.append(jsonl_file)
+
+    if not candidates:
+        return None
+    if len(candidates) == 1:
+        return candidates[0]
+
+    # 多个匹配，按 mtime 降序取最新的
+    candidates.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+    return candidates[0]
+
+
+# ── JSONL 上下文提取 ──────────────────────────────────
+
+def _extract_tool_call_from_content(content, tool_call_id: str) -> dict | None:
+    """从 assistant message 的 content list 中查找 toolCall。"""
+    if not isinstance(content, list):
+        return None
+    for item in content:
+        if (isinstance(item, dict)
+                and item.get("type") == "toolCall"
+                and item.get("id") == tool_call_id):
+            return {
+                "name": item.get("name", ""),
+                "arguments": item.get("arguments", {}),
+            }
+    return None
+
+
+def extract_tool_call_context(
+    jsonl_path: Path,
+    tool_call_id: str,
+    context_entries: int = 5,
+) -> dict | None:
+    """从 JSONL 文件中提取指定 tool_call_id 的完整上下文。
+
+    返回：
+    {
+        "session_id": "...",
+        "tool_call": {"name": "...", "arguments": {...}},
+        "tool_result": {"tool_name": "...", "is_error": true, "content": "..."},
+        "before_context": [{"role": "user/assistant", "text": "..."}],
+        "after_context": [{"role": "user/assistant", "text": "..."}],
+    }
+    """
+    entries = _parse_entries(jsonl_path)
+    if not entries:
+        return None
+
+    session_id = _extract_session_id(entries)
+
+    # 定位 toolCall 和 toolResult
+    call_idx = None
+    result_idx = None
+
+    for i, entry in enumerate(entries):
+        msg = entry.get("message", {})
+        role = msg.get("role", "")
+
+        # 找 toolCall
+        if role == "assistant":
+            content = msg.get("content", [])
+            if isinstance(content, list):
+                for item in content:
+                    if (isinstance(item, dict)
+                            and item.get("type") == "toolCall"
+                            and item.get("id") == tool_call_id):
+                        call_idx = i
+                        break
+
+        # 找 toolResult
+        if role in ("tool", "toolResult"):
+            if msg.get("toolCallId") == tool_call_id:
+                result_idx = i
+
+    if call_idx is None and result_idx is None:
+        return None
+
+    anchor_idx = result_idx if result_idx is not None else call_idx
+    # anchor_idx 不可能为 None，因为前一行确保了至少有一个非 None
+    if anchor_idx is None:
+        return None
+
+    # 提取 tool_call 信息
+    tool_call_info = None
+    if call_idx is not None:
+        call_msg = entries[call_idx].get("message", {})
+        tool_call_info = _extract_tool_call_from_content(
+            call_msg.get("content", []), tool_call_id
+        )
+
+    # 提取 tool_result 信息
+    tool_result_info = None
+    if result_idx is not None:
+        result_msg = entries[result_idx].get("message", {})
+        content_text = _extract_text(result_msg.get("content"))
+        tool_result_info = {
+            "tool_name": result_msg.get("toolName", ""),
+            "is_error": bool(result_msg.get("isError", False)),
+            "content": content_text[:2000],  # 限制长度
+        }
+
+    # 提取前后上下文
+    before = _extract_context_before(entries, anchor_idx, context_entries)
+    after = _extract_context_after(entries, anchor_idx + 1, context_entries)
+
+    return {
+        "session_id": session_id,
+        "tool_call": tool_call_info,
+        "tool_result": tool_result_info,
+        "before_context": before,
+        "after_context": after,
+    }
+
+
+# ── 内部辅助 ──────────────────────────────────────────
+
+def _parse_entries(jsonl_path: Path) -> list[dict]:
+    """解析 JSONL 文件的所有行。"""
+    entries = []
+    try:
+        with open(jsonl_path, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    entries.append(json.loads(line))
+                except json.JSONDecodeError:
+                    print(
+                        f"[extract_context] Warning: 忽略损坏的 JSON 行: "
+                        f"{line[:80]}...",
+                        file=sys.stderr,
+                    )
+                    continue
+    except OSError:
+        pass
+    return entries
+
+
+def _extract_session_id(entries: list[dict]) -> str:
+    """从 session 类型的 entry 中提取 session ID。"""
+    for entry in entries:
+        if entry.get("type") == "session":
+            return entry.get("id", "")
+    return ""
+
+
+def _extract_text(content) -> str:
+    """从 message.content 提取文本。"""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts = []
+        for item in content:
+            if isinstance(item, dict) and item.get("type") == "text":
+                parts.append(item.get("text", ""))
+        return "\n".join(parts)
+    return ""
+
+
+def _summarize_entry(entry: dict) -> dict | None:
+    """将单条 entry 转为摘要 dict。返回 None 如果是非 message 类型。"""
+    msg = entry.get("message", {})
+    role = msg.get("role", "")
+    entry_type = entry.get("type", "")
+
+    if entry_type != "message":
+        return None
+
+    summary: dict = {"role": role}
+
+    if role == "user":
+        text = _extract_text(msg.get("content"))
+        summary["text"] = text[:300]
+    elif role == "assistant":
+        content = msg.get("content", [])
+        if isinstance(content, list):
+            for item in content:
+                if isinstance(item, dict) and item.get("type") == "text":
+                    summary["text"] = item.get("text", "")[:300]
+                    break
+            # 列出 toolCalls（不包含完整 arguments）
+            tc_names = [
+                item.get("name", "")
+                for item in content
+                if isinstance(item, dict) and item.get("type") == "toolCall"
+            ]
+            if tc_names:
+                summary["tool_calls"] = tc_names
+    elif role in ("tool", "toolResult"):
+        summary["tool_name"] = msg.get("toolName", "")
+        summary["is_error"] = bool(msg.get("isError", False))
+        text = _extract_text(msg.get("content"))
+        summary["text"] = text[:200]
+
+    return summary
+
+
+def _extract_context_before(entries: list[dict], anchor: int, n: int) -> list[dict]:
+    """提取 anchor 位置之前的 N 条上下文。"""
+    begin = max(0, anchor - n)
+    result = []
+    for i in range(begin, anchor):
+        summary = _summarize_entry(entries[i])
+        if summary is not None:
+            result.append(summary)
+    return result
+
+
+def _extract_context_after(entries: list[dict], anchor: int, n: int) -> list[dict]:
+    """提取 anchor 位置之后的 N 条上下文。"""
+    end = min(len(entries), anchor + n)
+    result = []
+    for i in range(anchor, end):
+        summary = _summarize_entry(entries[i])
+        if summary is not None:
+            result.append(summary)
+    return result
+
+
+# ── 批量提取 ──────────────────────────────────────────
+
+def extract_pattern_cases(
+    report_path: str,
+    pattern: str,
+    limit: int = 2,
+) -> list[dict]:
+    """从 daily-report JSON 中提取指定 error pattern 的典型案例上下文。"""
+    try:
+        with open(report_path, "r", encoding="utf-8") as f:
+            report = json.load(f)
+    except (OSError, json.JSONDecodeError) as e:
+        return [{"error": f"无法读取报告 {report_path}: {e}"}]
+
+    refs = report.get("error_stats", {}).get("failure_refs", [])
+    matched = [r for r in refs if r.get("pattern") == pattern]
+
+    # 优先选未自我纠正的案例（更有分析价值）
+    matched.sort(key=lambda r: r.get("self_corrected", False))
+
+    results = []
+    for ref in matched[:limit]:
+        sid = ref.get("session_id", "")
+        tcid = ref.get("tool_call_id", "")
+
+        jsonl_path = _find_session_file(sid)
+        if not jsonl_path:
+            results.append({
+                "ref": ref,
+                "error": f"session file not found for {sid}",
+            })
+            continue
+
+        ctx = extract_tool_call_context(jsonl_path, tcid)
+        if ctx:
+            results.append({"ref": ref, "context": ctx})
+        else:
+            results.append({
+                "ref": ref,
+                "error": f"tool_call_id {tcid} not found in session",
+            })
+
+    return results
+
+
+# ── CLI ───────────────────────────────────────────────
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="从 Pi session JSONL 中提取 tool call 失败的完整上下文",
+    )
+    parser.add_argument("--session-id", help="Session ID (UUID)")
+    parser.add_argument("--tool-call-id", help="Tool call ID")
+    parser.add_argument("--context", type=int, default=5,
+                        help="前后各取 N 条 entries 作为上下文 (默认 5)")
+    parser.add_argument("--pattern", help="Error pattern，批量模式")
+    parser.add_argument("--from-report", help="daily-report JSON 路径，批量模式用")
+    parser.add_argument("--limit", type=int, default=2,
+                        help="批量模式下每种 pattern 最多取几个案例 (默认 2)")
+
+    args = parser.parse_args()
+
+    # 批量模式
+    if args.pattern and args.from_report:
+        cases = extract_pattern_cases(args.from_report, args.pattern, args.limit)
+        print(json.dumps(cases, ensure_ascii=False, indent=2))
+        return
+
+    # 单条模式
+    if not args.session_id or not args.tool_call_id:
+        print("错误: 单条模式需要 --session-id 和 --tool-call-id", file=sys.stderr)
+        print("批量模式需要 --pattern 和 --from-report", file=sys.stderr)
+        sys.exit(1)
+
+    jsonl_path = _find_session_file(args.session_id)
+    if not jsonl_path:
+        print(f"错误: 未找到 session {args.session_id} 的 JSONL 文件", file=sys.stderr)
+        sys.exit(1)
+
+    result = extract_tool_call_context(jsonl_path, args.tool_call_id, args.context)
+    if not result:
+        print(f"错误: 未在 session 中找到 tool_call_id={args.tool_call_id}", file=sys.stderr)
+        sys.exit(1)
+
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()