thread-archive 0.0.2__py3-none-any.whl

thread_archive/_importers/_titles.py

@@ -0,0 +1,179 @@
+"""Title + one-line-description extraction for Claude Code import.
+
+Ported from canonical ``streaming/incremental_import/_titles.py`` (+ the
+command-title helper from ``importer.py``): derive a thread title or description
+from raw CC session lines — the ``custom-title`` / ``ai-title`` rows CC writes,
+else the first non-XML line of the first user message (or a bare slash-command's
+name). Pure helpers; no store access, so they stay separately testable.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Optional
+
+from thread_archive._thread_import.parsers.base import NormalizedMessage
+from thread_archive._thread_import.parsers.claude_code import ClaudeCodeParser
+
+# CC records a slash-command invocation as a user turn whose content is
+# ``<command-name>/x</command-name>`` (plus optional args). The parser strips those
+# tags, leaving the turn with empty content_text — and the next turn is usually
+# injected content (a skill doc). Recover the command so it, not the injected doc,
+# becomes the title.
+_CC_COMMAND_NAME_RE = re.compile(r"<command-name>\s*(/[^<\n]+?)\s*</command-name>")
+_CC_COMMAND_ARGS_RE = re.compile(r"<command-args>\s*(.*?)\s*</command-args>", re.DOTALL)
+
+
+def _cc_command_title(msg: NormalizedMessage) -> Optional[str]:
+    """A slash-command title (e.g. ``/garden``) for a user turn whose raw content
+    is a bare CC command invocation, else None. Keeps the injected skill doc that
+    follows the command out of the thread list."""
+    provider_data = msg.get("provider_data")
+    if not isinstance(provider_data, dict):
+        return None
+    raw_line = provider_data.get("line")
+    if not isinstance(raw_line, dict):
+        return None
+    message = raw_line.get("message")
+    if not isinstance(message, dict):
+        return None
+    content = message.get("content")
+    if not isinstance(content, str):
+        return None
+    name_match = _CC_COMMAND_NAME_RE.search(content)
+    if not name_match:
+        return None
+    title = name_match.group(1).strip()
+    args_match = _CC_COMMAND_ARGS_RE.search(content)
+    if args_match:
+        args = args_match.group(1).strip()
+        if args:
+            title = f"{title} {args}"
+    return title[:100]
+
+
+def _extract_ai_title(lines: list[dict]) -> Optional[str]:
+    """The current ``ai-title`` value from a CC JSONL. CC writes a single-row
+    ``{"type": "ai-title", "aiTitle": "..."}`` line each time the auto-titler
+    refines the title; the **last** such row wins."""
+    latest: Optional[str] = None
+    for line in lines:
+        if line.get("type") == "ai-title":
+            value = line.get("aiTitle")
+            if isinstance(value, str) and value.strip():
+                latest = value.strip()
+    return latest
+
+
+def _extract_custom_title(lines: list[dict]) -> Optional[str]:
+    """The latest user rename from a CC JSONL ``custom-title`` row. The **last**
+    such row wins; a returned ``""`` is CC's "clear the rename" signal."""
+    latest: Optional[str] = None
+    for line in lines:
+        if line.get("type") == "custom-title":
+            value = line.get("customTitle")
+            if isinstance(value, str):
+                latest = value.strip()
+    return latest
+
+
+def extract_session_title(lines: list[dict]) -> Optional[str]:
+    """The effective CC session title: a non-empty user rename (``custom-title``)
+    wins over the auto-titler's ``ai-title``, matching CC's reader precedence.
+    Returns None when neither is present."""
+    custom = _extract_custom_title(lines)
+    if custom:
+        return custom
+    return _extract_ai_title(lines)
+
+
+def _title_from_messages(messages: list[NormalizedMessage]) -> Optional[str]:
+    """First-user-message title fallback: the first non-XML line of the first user
+    message (truncated to 100 + "..."), or a bare slash-command's name. Returns
+    None when no user message yields a title."""
+    for msg in messages:
+        if msg.get("role") != "user":
+            continue
+        text_blob = msg.get("content_text", "").strip()
+        if not text_blob:
+            # Bare slash-command (e.g. `/garden`): title it with the command, not
+            # the skill doc that gets injected on the next turn.
+            cmd_title = _cc_command_title(msg)
+            if cmd_title:
+                return cmd_title
+            continue
+        for line in text_blob.split("\n"):
+            stripped = line.strip()
+            if not stripped:
+                continue
+            if stripped.startswith("<") and ">" in stripped:
+                continue
+            title = stripped[:100]
+            if len(stripped) > 100:
+                title += "..."
+            return title
+    return None
+
+
+def extract_title(lines: list[dict]) -> str:
+    """A title for a new thread. Preferred: the session title CC stores (a user
+    rename wins over the auto-titler). Falls back to the first non-XML line of the
+    first user message, then to ``"Claude Code Session"``."""
+    resolved = extract_session_title(lines)
+    if resolved:
+        return resolved[:100]
+
+    parser = ClaudeCodeParser()
+    session_data = {
+        "provider": "claude-code",
+        "sessions": [{"session_id": "temp", "project": "temp", "lines": lines[:20]}],
+    }
+    try:
+        messages = parser.parse_export(session_data)
+    except Exception:
+        return "Claude Code Session"
+    return _title_from_messages(messages) or "Claude Code Session"
+
+
+def _user_content_texts(content: Any) -> list[str]:
+    """The text strings of a CC user-message ``content``: the string itself when
+    content is a str, or every ``{"type": "text"}`` block's text when it is a list."""
+    texts: list[str] = []
+    if isinstance(content, str):
+        texts.append(content)
+    elif isinstance(content, list):
+        for block in content:
+            if isinstance(block, dict) and block.get("type") == "text":
+                texts.append(block.get("text", ""))
+    return texts
+
+
+def _description_from_texts(texts: list[str]) -> Optional[str]:
+    """The first meaningful (non-blank, non-XML, non-continuation) line across these
+    text blocks, truncated to 200 (+"..."). Returns None when none match."""
+    for t in texts:
+        for text_line in t.split("\n"):
+            stripped = text_line.strip()
+            if not stripped:
+                continue
+            if stripped.startswith("<") and ">" in stripped:
+                continue
+            if stripped.startswith("This session is being continued"):
+                continue
+            if len(stripped) > 200:
+                return stripped[:197] + "..."
+            return stripped
+    return None
+
+
+def extract_description(lines: list[dict]) -> Optional[str]:
+    """A one-line description from the first user message: its first meaningful
+    line of content, truncated to 200 chars. None when none found."""
+    for line in lines[:20]:
+        if line.get("type") != "user":
+            continue
+        texts = _user_content_texts(line.get("message", {}).get("content", ""))
+        desc = _description_from_texts(texts)
+        if desc is not None:
+            return desc
+    return None

thread_archive/_importers/antigravity.py

@@ -0,0 +1,254 @@
+"""Antigravity (Gemini CLI) incremental session import + assembler.
+
+Pure ``_antigravity_*`` / ``_build_antigravity_messages`` helpers; orchestration
+wired onto the shared scaffold.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from typing import Any, Optional
+
+from thread_archive._thread_import import DefaultEventBuilder
+
+from ._events import assemble_events
+from ._line_stream import import_line_stream_session
+from ._result import IncrementalImportResult
+
+logger = logging.getLogger(__name__)
+
+
+def import_antigravity_session_incremental(session_path, source_id: str, *, session=None) -> IncrementalImportResult:
+    """Import an Antigravity (Gemini agentic CLI) transcript.jsonl into the event log."""
+
+    def _do_import(sess, thread_id, all_lines, new_lines, _ctx):
+        messages = _build_antigravity_messages(new_lines, all_lines, source_id)
+        return assemble_events(sess, thread_id, messages, DefaultEventBuilder())
+
+    return import_line_stream_session(
+        source="antigravity",
+        source_id=source_id,
+        session_path=session_path,
+        session=session,
+        not_found_msg=f"Antigravity session file not found: {session_path}",
+        has_importable_content=_antigravity_has_importable_content,
+        make_title=lambda all_lines, _ctx: _antigravity_title(all_lines),
+        import_lines=_do_import,
+    )
+
+
+_ANTIGRAVITY_USER_REQUEST_RE = re.compile(r"<USER_REQUEST>\s*(.*?)\s*</USER_REQUEST>", re.DOTALL)
+_ANTIGRAVITY_MODEL_RE = re.compile(r"changed setting `Model Selection` from .*? to (.+?)\.\s")
+# MODEL step `type` values that are the model's natural-language turn; everything
+# else a MODEL step emits is a tool action/result.
+_ANTIGRAVITY_TEXT_TYPES = {"PLANNER_RESPONSE"}
+
+
+def _antigravity_kind(line: dict) -> Optional[str]:
+    source = line.get("source")
+    line_type = line.get("type")
+    if source == "USER_EXPLICIT" or line_type == "USER_INPUT":
+        return "user"
+    if source == "MODEL":
+        return "assistant" if line_type in _ANTIGRAVITY_TEXT_TYPES else "tool_result"
+    if line_type == "ERROR_MESSAGE":
+        return "error"
+    return None
+
+
+def _antigravity_content(line: dict) -> str:
+    content = line.get("content")
+    if not isinstance(content, str) or not content.strip():
+        return ""
+    if _antigravity_kind(line) == "user":
+        m = _ANTIGRAVITY_USER_REQUEST_RE.search(content)
+        if m:
+            return m.group(1).strip()
+    return content.strip()
+
+
+def _antigravity_tool_args(args: Any) -> dict[str, Any]:
+    """Antigravity tool_call args arrive double-JSON-encoded; unwrap each string once."""
+    if not isinstance(args, dict):
+        return {}
+    out: dict[str, Any] = {}
+    for k, v in args.items():
+        if isinstance(v, str):
+            try:
+                out[k] = json.loads(v)
+            except (json.JSONDecodeError, ValueError):
+                out[k] = v
+        else:
+            out[k] = v
+    return out
+
+
+def _antigravity_model(lines: list[dict]) -> str:
+    model = "gemini"
+    for line in lines:
+        content = line.get("content")
+        if not isinstance(content, str):
+            continue
+        m = _ANTIGRAVITY_MODEL_RE.search(content)
+        if m:
+            model = m.group(1).strip()[:80]
+    return model
+
+
+def _antigravity_has_importable_content(lines: list[dict]) -> bool:
+    for line in lines:
+        kind = _antigravity_kind(line)
+        if kind == "user" and _antigravity_content(line):
+            return True
+        if kind == "assistant" and (_antigravity_content(line) or line.get("tool_calls")):
+            return True
+    return False
+
+
+def _antigravity_title(lines: list[dict]) -> str:
+    for line in lines:
+        if _antigravity_kind(line) == "user":
+            text_content = _antigravity_content(line)
+            if text_content:
+                first = next((part.strip() for part in text_content.splitlines() if part.strip()), "")
+                return (first[:97] + "...") if len(first) > 100 else first
+    return "Antigravity Session"
+
+
+def _antigravity_preserved_message(line: dict, ts: Optional[str]) -> dict[str, Any]:
+    """Preserve an antigravity step the importer doesn't model, rather than drop it.
+
+    ``_antigravity_kind`` only maps user/model/error steps; any other step (a
+    ``Model Selection`` setting change, a system notice, a future step kind) returns
+    None and would be skipped. Kept here as a ``role="unknown"`` message so the
+    builder emits a ``message`` event carrying the step's text plus the raw step
+    verbatim under ``content_blocks`` — nothing silently lost, and idempotent because
+    the raw step is inside the dedup-hashed ``content_blocks``."""
+    content = line.get("content")
+    text = content.strip() if isinstance(content, str) else ""
+    return {
+        "role": "unknown",
+        "created_at": ts,
+        "content_text": text,
+        "content_blocks": [{
+            "type": "antigravity_step",
+            "source": line.get("source"),
+            "step_type": line.get("type"),
+            "raw": line,
+            "start_timestamp": ts,
+        }],
+        "provider_message_id": ts or "",
+        "provider_data": {"provider": "antigravity"},
+    }
+
+
+def _build_antigravity_messages(
+    new_lines: list[dict],
+    all_lines: list[dict],
+    source_id: str,
+) -> list[dict[str, Any]]:
+    """Assemble antigravity's transcript steps into canonical NormalizedMessages.
+
+    Tool calls carry no id and their result arrives as a later step, so each
+    PLANNER_RESPONSE turn mints a deterministic id per tool_use (``agtool-<n>`` by
+    document order, stable across re-imports so the dedup key holds), and each
+    following tool/error step is paired FIFO and folded back as a tool_result.
+    """
+    messages: list[dict[str, Any]] = []
+    model = _antigravity_model(all_lines)
+    cur: Optional[dict[str, Any]] = None
+    pending: list[tuple[str, Optional[str], dict[str, Any]]] = []
+    tool_seq = 0
+
+    def new_assistant(ts: Optional[str]) -> dict[str, Any]:
+        turn = {
+            "role": "assistant",
+            "created_at": ts,
+            "content_text": "",
+            "content_blocks": [],
+            "provider_message_id": ts or "",
+            "provider_data": {"provider": "antigravity", "model": model},
+        }
+        messages.append(turn)
+        return turn
+
+    def handle_assistant(line: dict, ts: Optional[str], content: str) -> None:
+        nonlocal cur, tool_seq
+        tool_calls = [tc for tc in (line.get("tool_calls") or []) if isinstance(tc, dict)]
+        if not content and not tool_calls:
+            return
+        cur = new_assistant(ts)
+        if content:
+            cur["content_blocks"].append({"type": "text", "text": content, "start_timestamp": ts})
+        for tc in tool_calls:
+            tid = f"agtool-{tool_seq}"
+            tool_seq += 1
+            name = tc.get("name") or "unknown"
+            cur["content_blocks"].append({
+                "type": "tool_use", "id": tid, "name": name,
+                "input": _antigravity_tool_args(tc.get("args")),
+                "start_timestamp": ts,
+            })
+            pending.append((tid, name, cur))
+
+    def handle_outcome(line: dict, kind: str, ts: Optional[str], content: str) -> None:
+        # An empty outcome still records that a tool completed/errored — and dropping
+        # it would leave its tool_use unpaired, so the NEXT outcome would mis-pair to
+        # it FIFO. Keep it: pop the pending call (honest empty content), never drop.
+        nonlocal tool_seq
+        if pending:
+            tid, call_name, owner = pending.pop(0)
+        else:
+            owner = cur if cur is not None else new_assistant(ts)
+            tid, call_name = f"agorphan-{tool_seq}", None
+            tool_seq += 1
+        owner["content_blocks"].append({
+            "type": "tool_result",
+            "tool_use_id": tid,
+            "name": call_name or str(line.get("type") or "tool").lower(),
+            "content": content,
+            "is_error": kind == "error",
+            "start_timestamp": ts,
+        })
+
+    for line in new_lines:
+        if not isinstance(line, dict):
+            continue
+        kind = _antigravity_kind(line)
+        ts = line.get("created_at")
+
+        if kind is None:
+            # A step the importer doesn't model (setting change, system notice, a
+            # future kind). Preserve it unless it's a genuinely-empty record with
+            # nothing to keep.
+            if line:
+                messages.append(_antigravity_preserved_message(line, ts))
+            continue
+
+        content = _antigravity_content(line)
+
+        if kind == "user":
+            if not content:
+                continue
+            cur = None
+            messages.append({
+                "role": "user",
+                "created_at": ts,
+                "content_text": content,
+                "content_blocks": [],
+                "provider_message_id": ts or "",
+                "provider_data": {"provider": "antigravity"},
+            })
+        elif kind == "assistant":
+            handle_assistant(line, ts, content)
+        else:
+            handle_outcome(line, kind, ts, content)
+
+    # Keep every user turn, plus any turn carrying SOME content (blocks or text);
+    # only a truly-empty non-user turn (no blocks, no text) is dropped.
+    return [
+        m for m in messages
+        if m["role"] == "user" or m["content_blocks"] or m.get("content_text", "").strip()
+    ]