ai-worklog 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-worklog",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "AI 对话工作日志自动收集工具 —— 从 Claude Code / Codex 对话记录生成每日工作日志并推送到 GitLab",
   "bin": {
     "ai-worklog": "./bin/index.js"

package/scripts/collect_work_log.py

@@ -102,32 +102,84 @@ def utc_to_local_date(utc_ts: str) -> Optional[str]:
 
 # ─── Claude Code 数据收集 ─────────────────────────────────────────────────────
 
-def collect_claude_sessions(target_date: str) -> dict[str, list[str]]:
+def collect_claude_sessions(
+    target_date: str,
+    prev_file_counts: Optional[dict[str, int]] = None,
+) -> tuple[dict[str, list[list[tuple[str, str]]]], dict[str, int]]:
     """
-    遍历 ~/.claude/projects/ 下所有 jsonl，
-    按 message timestamp 过滤当天（UTC→本地），提取 user 消息，
-    按项目名（cwd basename）分组。
+    遍历 ~/.claude/projects/ 下所有 jsonl，提取当天的对话轮次对。
 
-    返回: {project_name: [message1, message2, ...]}
+    prev_file_counts: 上次生成时各文件已处理的轮次数。
+                      传入时只返回新增轮次（增量模式）。
+
+    返回:
+      sessions:    {project_name: [session, ...]}，session = [(user, assistant), ...]
+      file_counts: {jsonl_file_path: 本次处理的总轮次数}（用于保存 checkpoint）
     """
-    results: dict[str, list[str]] = {}
+    sessions: dict[str, list[list[tuple[str, str]]]] = {}
+    file_counts: dict[str, int] = {}
 
     if not CLAUDE_PROJECTS_DIR.exists():
-        return results
+        return sessions, file_counts
 
     for project_dir in CLAUDE_PROJECTS_DIR.iterdir():
         if not project_dir.is_dir():
             continue
         for jsonl_file in project_dir.glob("*.jsonl"):
-            _parse_claude_jsonl(jsonl_file, target_date, results)
+            turns, cwd = _parse_claude_jsonl(jsonl_file, target_date)
+            file_key = str(jsonl_file)
+            file_counts[file_key] = len(turns)
 
-    return results
+            prev = (prev_file_counts or {}).get(file_key, 0)
+            new_turns = turns[prev:]  # 增量模式下只取新增部分；首次 prev=0 取全部
+
+            if new_turns:
+                project_name = os.path.basename(cwd) if cwd else "unknown"
+                sessions.setdefault(project_name, []).append(new_turns)
+
+    return sessions, file_counts
+
+
+def _extract_user_text(content) -> str:
+    """从 message.content 中提取用户文字（过滤 tool_result 等结构）"""
+    texts = []
+    if isinstance(content, str):
+        texts = [content]
+    elif isinstance(content, list):
+        for c in content:
+            if isinstance(c, dict) and c.get("type") == "text":
+                texts.append(c.get("text", ""))
+            elif isinstance(c, str):
+                texts.append(c)
+    return " ".join(t for t in texts if t).strip()
+
+
+def _extract_assistant_text(content) -> str:
+    """从 assistant message.content 中提取最终文字回复，跳过 thinking 和 tool_use"""
+    if not isinstance(content, list):
+        return ""
+    parts = [
+        c.get("text", "").strip()
+        for c in content
+        if isinstance(c, dict) and c.get("type") == "text" and c.get("text", "").strip()
+    ]
+    return " ".join(parts)
 
 
 def _parse_claude_jsonl(
-    jsonl_file: Path, target_date: str, results: dict[str, list[str]]
-) -> None:
-    """解析单个 Claude Code jsonl 文件"""
+    jsonl_file: Path, target_date: str
+) -> tuple[list[tuple[str, str]], str]:
+    """
+    解析单个 Claude Code jsonl 文件。
+    返回 (当天所有轮次对, cwd)。
+    Claude 回复只取 text 块，跳过 thinking 和 tool_use。
+    """
+    turns: list[tuple[str, str]] = []
+    pending_user: str = ""
+    pending_user_date: str = ""
+    pending_assistant: str = ""
+    cwd: str = ""
+
     try:
         with open(jsonl_file, encoding="utf-8", errors="ignore") as f:
             for line in f:
@@ -139,38 +191,45 @@ def _parse_claude_jsonl(
                 except json.JSONDecodeError:
                     continue
 
-                if entry.get("type") != "user":
-                    continue
+                if entry.get("cwd"):
+                    cwd = entry["cwd"]
 
-                # 按时间戳过滤日期
-                ts = entry.get("timestamp", "")
-                if ts and utc_to_local_date(ts) != target_date:
-                    continue
+                entry_type = entry.get("type", "")
 
-                # 提取项目名
-                cwd = entry.get("cwd", "")
-                project_name = os.path.basename(cwd) if cwd else "unknown"
+                if entry_type == "user":
+                    user_text = _extract_user_text(entry.get("message", {}).get("content", ""))
 
-                # 提取消息内容
-                message = entry.get("message", {})
-                content = message.get("content", "")
-                texts = []
-                if isinstance(content, str):
-                    texts = [content]
-                elif isinstance(content, list):
-                    for c in content:
-                        if isinstance(c, dict) and c.get("type") == "text":
-                            texts.append(c.get("text", ""))
-                        elif isinstance(c, str):
-                            texts.append(c)
-
-                for text in texts:
-                    if text and not is_system_message(text):
-                        results.setdefault(project_name, []).append(text.strip())
+                    if not user_text or is_system_message(user_text):
+                        continue  # tool_result 或系统消息，跳过
+
+                    # 保存上一个 turn（日期匹配才入列）
+                    if pending_user and pending_user_date == target_date:
+                        turns.append((pending_user, pending_assistant))
+
+                    # 开始新 turn
+                    ts = entry.get("timestamp", "")
+                    pending_user = user_text
+                    pending_user_date = utc_to_local_date(ts) if ts else ""
+                    pending_assistant = ""
+
+                elif entry_type == "assistant":
+                    if not pending_user:
+                        continue
+                    assistant_text = _extract_assistant_text(
+                        entry.get("message", {}).get("content", [])
+                    )
+                    if assistant_text:
+                        pending_assistant = assistant_text  # 多步工具调用后取最终回复
+
+        # 最后一个 pending turn
+        if pending_user and pending_user_date == target_date:
+            turns.append((pending_user, pending_assistant))
 
     except Exception as e:
         print(f"警告: 解析 {jsonl_file} 失败: {e}", file=sys.stderr)
 
+    return turns, cwd
+
 
 # ─── Codex 数据收集 ───────────────────────────────────────────────────────────
 
@@ -259,51 +318,68 @@ def _call_api_claude_cli(prompt: str) -> str:
 
 def generate_summary(
     target_date: str,
-    claude_data: dict[str, list[str]],
+    claude_data: dict[str, list[list[tuple[str, str]]]],
     codex_data: dict[str, list[str]],
 ) -> str:
     """调用 Claude API 生成结构化工作日志"""
 
     # 合并数据（同项目名合并）
     all_projects: dict[str, dict] = {}
-    for proj, msgs in claude_data.items():
-        all_projects.setdefault(proj, {"claude": [], "codex": []})["claude"].extend(msgs)
+    for proj, sessions in claude_data.items():
+        all_projects.setdefault(proj, {"sessions": [], "codex": []})["sessions"].extend(sessions)
     for proj, msgs in codex_data.items():
-        all_projects.setdefault(proj, {"claude": [], "codex": []})["codex"].extend(msgs)
+        all_projects.setdefault(proj, {"sessions": [], "codex": []})["codex"].extend(msgs)
 
-    total_claude = sum(len(v["claude"]) for v in all_projects.values())
-    total_codex = sum(len(v["codex"]) for v in all_projects.values())
+    total_claude = sum(
+        sum(len(turns) for turns in data["sessions"])
+        for data in all_projects.values()
+    )
+    total_codex = sum(len(data["codex"]) for data in all_projects.values())
     total_sessions = total_claude + total_codex
 
     if total_sessions == 0:
         return _generate_empty_log(target_date)
 
-    # 构建给 AI 的原始数据（去重 + 截断，控制 token 消耗）
+    def trim(text: str, max_chars: int) -> str:
+        return text if len(text) <= max_chars else text[:max_chars] + "…"
+
     def dedup_and_trim(msgs: list[str], max_chars: int = 200) -> list[str]:
         seen: set[str] = set()
         result = []
         for m in msgs:
-            key = m[:80]  # 用前 80 字符去重
+            key = m[:80]
             if key in seen:
                 continue
             seen.add(key)
-            result.append(m if len(m) <= max_chars else m[:max_chars] + "…")
+            result.append(trim(m, max_chars))
         return result
 
     project_sections = []
     for proj_name, data in all_projects.items():
-        msgs_parts = []
-        if data["claude"]:
-            trimmed = dedup_and_trim(data["claude"])
-            msgs_parts.append(f"[Claude Code {len(data['claude'])} 条，去重后 {len(trimmed)} 条]")
-            for i, m in enumerate(trimmed, 1):
-                msgs_parts.append(f"  {i}. {m}")
+        parts = []
+
+        # Claude 对话：按 session 分，每个 session 里是轮次对
+        for si, turns in enumerate(data["sessions"], 1):
+            parts.append(f"  [对话 {si}]（{len(turns)} 轮）")
+            for user_msg, asst_msg in turns:
+                parts.append(f"    [用户] {trim(user_msg, 200)}")
+                if asst_msg:
+                    parts.append(f"    [Claude] {trim(asst_msg, 150)}")
+
+        # Codex 对话：没有回复，直接列用户消息
         if data["codex"]:
             trimmed = dedup_and_trim(data["codex"])
-            msgs_parts.append(f"[Codex {len(data['codex'])} 条，去重后 {len(trimmed)} 条]")
-            for i, m in enumerate(trimmed, 1):
-                msgs_parts.append(f"  {i}. {m}")
-        project_sections.append(f"项目: {proj_name}\n" + "\n".join(msgs_parts))
+            parts.append(f"  [Codex 对话]（{len(data['codex'])} 条）")
+            for m in trimmed:
+                parts.append(f"    [用户] {m}")
+
+        total_turns = sum(len(t) for t in data["sessions"])
+        header = (
+            f"项目: {proj_name}"
+            f"（Claude {len(data['sessions'])} 个对话 {total_turns} 轮，"
+            f"Codex {len(data['codex'])} 条）"
+        )
+        project_sections.append(header + "\n" + "\n".join(parts))
 
     raw_data = "\n\n".join(project_sections)
 
@@ -395,6 +471,90 @@ def save_log(target_date: str, content: str) -> Path:
     return log_file
 
 
+# ─── Checkpoint（增量更新支持）────────────────────────────────────────────────
+
+def _checkpoint_path(target_date: str) -> Path:
+    year = target_date[:4]
+    return LOGS_DIR / year / f"{target_date}.meta.json"
+
+
+def load_checkpoint(target_date: str) -> Optional[dict]:
+    """读取上次生成的 checkpoint，不存在或解析失败返回 None"""
+    path = _checkpoint_path(target_date)
+    if not path.exists():
+        return None
+    try:
+        return json.loads(path.read_text())
+    except Exception:
+        return None
+
+
+def save_checkpoint(target_date: str, file_counts: dict[str, int]) -> None:
+    """保存本次处理的 checkpoint（各文件已处理轮次数）"""
+    path = _checkpoint_path(target_date)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    data = {
+        "generated_at": datetime.now().isoformat(timespec="seconds"),
+        "file_counts": file_counts,
+    }
+    path.write_text(json.dumps(data, ensure_ascii=False, indent=2))
+
+
+def generate_incremental_update(
+    target_date: str,
+    existing_log: str,
+    new_claude_data: dict[str, list[list[tuple[str, str]]]],
+    new_codex_data: dict[str, list[str]],
+) -> str:
+    """基于已有日志 + 新增对话，调用 AI 生成更新后的完整日志"""
+
+    def trim(text: str, max_chars: int) -> str:
+        return text if len(text) <= max_chars else text[:max_chars] + "…"
+
+    project_sections = []
+    for proj_name, sessions in new_claude_data.items():
+        parts = []
+        for si, turns in enumerate(sessions, 1):
+            parts.append(f"  [新增对话 {si}]（{len(turns)} 轮）")
+            for user_msg, asst_msg in turns:
+                parts.append(f"    [用户] {trim(user_msg, 200)}")
+                if asst_msg:
+                    parts.append(f"    [Claude] {trim(asst_msg, 150)}")
+        total_turns = sum(len(t) for t in sessions)
+        project_sections.append(
+            f"项目: {proj_name}（新增 {len(sessions)} 个对话 {total_turns} 轮）\n" + "\n".join(parts)
+        )
+    for proj_name, msgs in new_codex_data.items():
+        parts = [f"  [Codex] {trim(m, 200)}" for m in msgs]
+        project_sections.append(f"项目: {proj_name}（Codex 新增 {len(msgs)} 条）\n" + "\n".join(parts))
+
+    new_data_text = "\n\n".join(project_sections)
+    now_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    prompt = f"""以下是今天已生成的工作日志：
+
+{existing_log}
+
+---
+以下是在上次生成之后新增的 AI 对话记录：
+
+{new_data_text}
+
+请在已有日志基础上进行更新，要求：
+1. 更新「今日概览」中的统计数字（累计到最新）
+2. 在对应项目的「主要工作」中追加新工作内容（保留原有内容，不要重复）
+3. 如有新项目，新增对应章节
+4. 更新「今日总结」以反映全天整体工作
+5. 将页脚的生成时间改为 {now_str}
+6. 只输出完整的更新后日志，不要加任何额外说明"""
+
+    try:
+        return _call_api_claude_cli(prompt)
+    except Exception as e:
+        print(f"API 请求失败: {e}", file=sys.stderr)
+        return existing_log  # 失败时保留原有日志
+
+
 GITLAB_HOST = "gitcode.lingjingai.cn"
 
 
@@ -583,31 +743,60 @@ def main():
     target_date = parse_date_arg(args.date)
     print(f"=== 收集 {target_date} 的工作日志 ===")
 
-    # 1. 收集数据
+    # 1. 检查是否存在 checkpoint（判断是否为增量更新）
+    checkpoint = load_checkpoint(target_date)
+    is_incremental = checkpoint is not None
+    prev_file_counts = checkpoint["file_counts"] if is_incremental else {}
+
+    if is_incremental:
+        print(f"检测到已有日志（生成于 {checkpoint['generated_at']}），进入增量更新模式")
+
+    # 2. 收集数据（增量模式只返回新增轮次）
     print("收集 Claude Code 对话记录...")
-    claude_data = collect_claude_sessions(target_date)
-    total_claude = sum(len(v) for v in claude_data.values())
-    print(f"  找到 {len(claude_data)} 个项目，{total_claude} 条消息")
+    claude_data, file_counts = collect_claude_sessions(target_date, prev_file_counts if is_incremental else None)
+    total_claude_turns = sum(sum(len(t) for t in s) for s in claude_data.values())
+    total_claude_sessions = sum(len(s) for s in claude_data.values())
+    label = "新增" if is_incremental else "找到"
+    print(f"  {label} {len(claude_data)} 个项目，{total_claude_sessions} 个对话，{total_claude_turns} 轮交互")
 
     print("收集 Codex 对话记录...")
     codex_data = collect_codex_sessions(target_date)
     total_codex = sum(len(v) for v in codex_data.values())
-    print(f"  找到 {len(codex_data)} 个项目，{total_codex} 条消息")
+    print(f"  {label} {len(codex_data)} 个项目，{total_codex} 条消息")
 
     if args.dry_run:
-        print("\n[dry-run] 数据预览：")
-        for proj, msgs in {**claude_data, **codex_data}.items():
-            print(f"  [{proj}] {len(msgs)} 条")
+        print(f"\n[dry-run] {'新增' if is_incremental else ''}数据预览：")
+        for proj, sessions in claude_data.items():
+            total_turns = sum(len(t) for t in sessions)
+            print(f"  [Claude/{proj}] {len(sessions)} 个对话，{total_turns} 轮")
+            for si, turns in enumerate(sessions[:2], 1):
+                print(f"    对话{si}: {len(turns)} 轮")
+                for user_msg, asst_msg in turns[:2]:
+                    print(f"      [用户] {user_msg[:60]}")
+                    if asst_msg:
+                        print(f"      [Claude] {asst_msg[:60]}")
+        for proj, msgs in codex_data.items():
+            print(f"  [Codex/{proj}] {len(msgs)} 条")
             for m in msgs[:2]:
-                print(f"    - {m[:80]}")
+                print(f"    - {m[:60]}")
         return
 
-    # 2. 生成摘要（通过 claude -p 复用 Claude Code CLI 认证）
-    print("调用 Claude API 生成摘要...")
-    content = generate_summary(target_date, claude_data, codex_data)
+    # 3. 生成日志内容
+    if is_incremental:
+        if total_claude_turns == 0 and total_codex == 0:
+            print("没有新增内容，无需更新")
+            return
+        print("调用 Claude API 更新日志（增量）...")
+        log_file_path = LOGS_DIR / target_date[:4] / f"{target_date}.md"
+        existing_log = log_file_path.read_text(encoding="utf-8") if log_file_path.exists() else ""
+        content = generate_incremental_update(target_date, existing_log, claude_data, codex_data)
+    else:
+        print("调用 Claude API 生成摘要...")
+        content = generate_summary(target_date, claude_data, codex_data)
 
-    # 4. 保存文件
+    # 4. 保存文件 + checkpoint
     log_file = save_log(target_date, content)
+    save_checkpoint(target_date, file_counts)
 
     # 5. Git 操作
     if not args.no_git: