claude-code-tools 1.0.6__py3-none-any.whl → 1.4.6__py3-none-any.whl

claude_code_tools/claude_continue.py

@@ -192,6 +192,10 @@ def claude_continue(
                 try:
                     # Parse first line and add metadata fields
                     first_line_data = json.loads(lines[0])
+                    # Remove trim_metadata if present - a session is either continued
+                    # OR trimmed, not both. continue_metadata.parent_session_file
+                    # preserves ancestry.
+                    first_line_data.pop("trim_metadata", None)
                     first_line_data.update(metadata_fields)
                     lines[0] = json.dumps(first_line_data) + "\n"
 

claude_code_tools/codex_continue.py

@@ -11,12 +11,14 @@ the context limit. It:
 """
 
 import argparse
+import datetime
 import json
 import os
 import re
 import shlex
 import subprocess
 import sys
+from datetime import timezone
 from pathlib import Path
 from typing import List, Optional
 
@@ -24,6 +26,7 @@ from claude_code_tools.export_codex_session import resolve_session_path
 from claude_code_tools.session_utils import (
     build_rollover_prompt,
     build_session_file_list,
+    get_session_uuid,
 )
 
 
@@ -177,6 +180,51 @@ def codex_continue(
         print(f"❌ Error: {e}", file=sys.stderr)
         sys.exit(1)
 
+    # Inject continue_metadata into new session file
+    try:
+        new_session_file = resolve_session_path(thread_id, codex_home)
+
+        # Create metadata
+        metadata_fields = {
+            "continue_metadata": {
+                "parent_session_id": get_session_uuid(session_file.name),
+                "parent_session_file": str(session_file.absolute()),
+                "continued_at": datetime.datetime.now(timezone.utc).isoformat(),
+            }
+        }
+
+        # Read the new session file and modify first line
+        if new_session_file.exists():
+            with open(new_session_file, "r") as f:
+                lines = f.readlines()
+
+            if lines:
+                try:
+                    # Parse first line and add metadata fields
+                    first_line_data = json.loads(lines[0])
+                    # Remove trim_metadata if present - a session is either continued
+                    # OR trimmed, not both. continue_metadata.parent_session_file
+                    # preserves ancestry.
+                    first_line_data.pop("trim_metadata", None)
+                    first_line_data.update(metadata_fields)
+                    lines[0] = json.dumps(first_line_data) + "\n"
+
+                    # Write back the modified file
+                    with open(new_session_file, "w") as f:
+                        f.writelines(lines)
+
+                    if verbose:
+                        print(f"✅ Added continue_metadata to new session")
+                        print()
+                except json.JSONDecodeError:
+                    # If first line is malformed, skip adding metadata
+                    if verbose:
+                        print(f"⚠️  Could not add metadata (first line malformed)", file=sys.stderr)
+    except Exception as e:
+        # Don't fail the whole operation if metadata injection fails
+        if verbose:
+            print(f"⚠️  Could not add continue_metadata: {e}", file=sys.stderr)
+
     # Step 3: Resume in interactive mode - hand off to Codex
     # Resume with default model (not the mini model used for analysis)
     from claude_code_tools.config import codex_default_model

claude_code_tools/export_session.py

@@ -2,11 +2,39 @@
 
 import json
 import os
+import re
 from datetime import datetime
 from io import StringIO
 from pathlib import Path
 from typing import Any, Optional
 
+# Known system-injected XML tags that appear at the start of messages.
+# Using a whitelist of specific tags avoids filtering legitimate user
+# messages that start with HTML/XML like <div> or <svg>.
+NON_GENUINE_XML_TAGS = {
+    # Claude system tags (local command execution)
+    "command-name",
+    "command-message",
+    "command-args",
+    "local-command-stdout",
+    "bash-input",
+    "bash-stdout",
+    "bash-stderr",
+    "bash-notification",
+    # Codex system tags (environment/context injection)
+    "environment_context",
+    "user_instructions",
+    "user_shell_command",
+}
+
+# Regex patterns for non-genuine user messages (system-injected content).
+# Messages matching any of these patterns are filtered out when finding
+# the first real user message. Used for both Claude and Codex sessions.
+NON_GENUINE_MSG_PATTERNS = [
+    re.compile(r"^Caveat:", re.IGNORECASE),  # Caveat warnings about local commands
+    re.compile(r"^\s*\[SESSION LINEAGE\]", re.IGNORECASE),  # Session continuation context
+]
+
 # Lazy import yaml to allow module to load even if not installed
 try:
     import yaml
@@ -139,22 +167,60 @@ def _extract_codex_message_text(data: dict) -> Optional[str]:
     return None
 
 
+def _is_meta_user_message(data: dict, text: str) -> bool:
+    """
+    Check if a user message is a meta/system-injected message.
+
+    These include local command injections that Claude Code records
+    in the session file but aren't actual user queries.
+
+    Args:
+        data: The parsed JSON data for the message
+        text: The extracted text content
+
+    Returns:
+        True if this is a meta message that should be skipped
+    """
+    # Check isMeta flag
+    if data.get("isMeta") is True:
+        return True
+
+    # Check against regex patterns (Caveat, SESSION LINEAGE, etc.)
+    for pattern in NON_GENUINE_MSG_PATTERNS:
+        if pattern.search(text):
+            return True
+
+    # Check if message starts with a known system-injected XML tag
+    text_stripped = text.strip()
+    match = re.match(r"^<([a-z][a-z0-9_-]*)>", text_stripped)
+    if match and match.group(1) in NON_GENUINE_XML_TAGS:
+        return True
+
+    return False
+
+
 def extract_first_last_messages(
     session_file: Path, agent: str
-) -> tuple[Optional[dict[str, str]], Optional[dict[str, str]]]:
+) -> tuple[
+    Optional[dict[str, str]],
+    Optional[dict[str, str]],
+    Optional[dict[str, str]],
+]:
     """
-    Extract first and last user/assistant messages from a session.
+    Extract first/last messages and the first real user message from a session.
 
     Args:
         session_file: Path to session JSONL file
         agent: Agent type ('claude' or 'codex')
 
     Returns:
-        Tuple of (first_msg, last_msg) where each is a dict with 'role' and
-        'content' keys, or None if not found
+        Tuple of (first_msg, last_msg, first_user_msg) where each is a dict
+        with 'role' and 'content' keys, or None if not found.
+        first_user_msg skips meta messages (local command injections).
     """
     first_msg: Optional[dict[str, str]] = None
     last_msg: Optional[dict[str, str]] = None
+    first_user_msg: Optional[dict[str, str]] = None
 
     try:
         with open(session_file, "r", encoding="utf-8") as f:
@@ -190,13 +256,20 @@ def extract_first_last_messages(
                     }
                     if first_msg is None:
                         first_msg = msg_dict
+                    # Track first real user message (skip meta messages)
+                    if (
+                        role == "user"
+                        and first_user_msg is None
+                        and not _is_meta_user_message(data, text)
+                    ):
+                        first_user_msg = msg_dict
                     # Always update last_msg to get the last one
                     last_msg = msg_dict
 
     except (OSError, IOError):
         pass
 
-    return first_msg, last_msg
+    return first_msg, last_msg, first_user_msg
 
 
 def extract_session_metadata(session_file: Path, agent: str) -> dict[str, Any]:
@@ -216,6 +289,11 @@ def extract_session_metadata(session_file: Path, agent: str) -> dict[str, Any]:
     Returns:
         Dict with extracted metadata
     """
+    # Detect sidechain from filename pattern (agent-* prefix)
+    # This is more reliable than checking isSidechain field in JSON,
+    # which can be set on individual messages within main sessions
+    is_sidechain = session_file.name.startswith("agent-")
+
     metadata: dict[str, Any] = {
         "session_id": session_file.stem,
         "agent": agent,
@@ -223,7 +301,7 @@ def extract_session_metadata(session_file: Path, agent: str) -> dict[str, Any]:
         "cwd": None,
         "branch": None,
         "derivation_type": None,
-        "is_sidechain": False,
+        "is_sidechain": is_sidechain,
         "session_type": None,  # "helper" for SDK/headless sessions
         "parent_session_id": None,
         "parent_session_file": None,
@@ -231,6 +309,7 @@ def extract_session_metadata(session_file: Path, agent: str) -> dict[str, Any]:
         "trim_stats": None,
         "first_msg": None,
         "last_msg": None,
+        "first_user_msg": None,
     }
 
     # Track session start timestamp from JSON metadata
@@ -278,10 +357,6 @@ def extract_session_metadata(session_file: Path, agent: str) -> dict[str, Any]:
                     metadata["parent_session_id"] = cm.get("parent_session_id")
                     metadata["parent_session_file"] = cm.get("parent_session_file")
 
-                # Check if sidechain (sub-agent session)
-                if "isSidechain" in data and data["isSidechain"] is True:
-                    metadata["is_sidechain"] = True
-
                 # Extract sessionType (e.g., "helper" for SDK/headless sessions)
                 if "sessionType" in data and metadata["session_type"] is None:
                     metadata["session_type"] = data["sessionType"]
@@ -321,6 +396,9 @@ def extract_session_metadata(session_file: Path, agent: str) -> dict[str, Any]:
     except (OSError, IOError):
         pass
 
+    # Note: customTitle extraction is done in search_index.py's _extract_session_content
+    # during the single-pass content extraction, to avoid an extra file scan here.
+
     # Get modified time from last JSONL entry's timestamp (reflects actual session
     # activity, portable across machines). Fall back to file mtime if not found.
     last_timestamp = _get_last_line_timestamp(session_file)
@@ -367,9 +445,12 @@ def extract_session_metadata(session_file: Path, agent: str) -> dict[str, Any]:
         metadata["project"] = Path(metadata["cwd"]).name
 
     # Extract first and last messages
-    first_msg, last_msg = extract_first_last_messages(session_file, agent)
+    first_msg, last_msg, first_user_msg = extract_first_last_messages(
+        session_file, agent
+    )
     metadata["first_msg"] = first_msg
     metadata["last_msg"] = last_msg
+    metadata["first_user_msg"] = first_user_msg
 
     return metadata
 
@@ -454,6 +535,8 @@ def generate_yaml_frontmatter(metadata: dict[str, Any]) -> str:
         yaml_data["first_msg"] = metadata["first_msg"]
     if metadata.get("last_msg"):
         yaml_data["last_msg"] = metadata["last_msg"]
+    if metadata.get("first_user_msg"):
+        yaml_data["first_user_msg"] = metadata["first_user_msg"]
 
     # Trim stats (only for trimmed sessions)
     if metadata.get("trim_stats"):

claude_code_tools/find_claude_session.py

@@ -92,12 +92,6 @@ def prompt_post_action() -> str:
         return "back"
     return "exit"
 
-# Try to import TUI - it's optional
-try:
-    from claude_code_tools.session_tui import run_session_tui
-    TUI_AVAILABLE = True
-except ImportError:
-    TUI_AVAILABLE = False
 from claude_code_tools.smart_trim_core import identify_trimmable_lines_cli
 from claude_code_tools.smart_trim import trim_lines
 from claude_code_tools.session_utils import (
@@ -833,6 +827,19 @@ def handle_suppress_resume_claude(
         print(f"❌ Error trimming session: {e}")
         return None
 
+    # Check if nothing to trim (savings below threshold)
+    from claude_code_tools.node_menu_ui import run_trim_confirm_ui
+    if result.get("nothing_to_trim"):
+        print(f"   Savings too small ({result['tokens_saved']} tokens)")
+        action = run_trim_confirm_ui(
+            nothing_to_trim=True,
+            original_session_id=session_id,
+        )
+        if action == 'resume':
+            resume_session(session_id, project_path, claude_home=claude_home)
+            return None
+        return 'back'
+
     new_session_id = result["session_id"]
     new_session_file = Path(result["output_file"])
 
@@ -840,7 +847,6 @@ def handle_suppress_resume_claude(
     total_trimmed = result['num_tools_trimmed'] + result['num_assistant_trimmed']
 
     # Show confirmation UI
-    from claude_code_tools.node_menu_ui import run_trim_confirm_ui
     action = run_trim_confirm_ui(
         new_session_id=new_session_id,
         lines_trimmed=total_trimmed,
@@ -1300,8 +1306,12 @@ def create_action_handler(claude_home: Optional[str] = None, nonlaunch_flag: Opt
     """
     def handle_session_action(
         session: Tuple, action: str, kwargs: Optional[dict] = None
-    ) -> None:
-        """Handle actions for a selected session."""
+    ) -> str | None:
+        """Handle actions for a selected session.
+
+        Returns:
+            'back' if the action wants to return to resume menu, None otherwise.
+        """
         kwargs = kwargs or {}
 
         if isinstance(session, dict):
@@ -1320,13 +1330,13 @@ def create_action_handler(claude_home: Optional[str] = None, nonlaunch_flag: Opt
             if tools is None and threshold is None and trim_assistant is None:
                 options = prompt_suppress_options()
                 if not options:
-                    return
+                    return None
                 tools, threshold, trim_assistant = options
-            handle_suppress_resume_claude(
+            return handle_suppress_resume_claude(
                 session_id, project_path, tools, threshold or 500, trim_assistant, claude_home
             )
         elif action == "smart_trim_resume":
-            handle_smart_trim_resume_claude(session_id, project_path, claude_home)
+            return handle_smart_trim_resume_claude(session_id, project_path, claude_home)
         elif action == "path":
             # handled in Node UI via RPC
             if nonlaunch_flag is not None:
@@ -1581,6 +1591,19 @@ To persist directory changes when resuming sessions:
     rpc_path = str(Path(__file__).parent / "action_rpc.py")
 
     if not args.simple_ui:
+        from claude_code_tools.export_session import extract_session_metadata
+
+        def get_custom_title(session_id: str, cwd: str) -> str:
+            """Extract custom title from session file if present."""
+            try:
+                fp = get_session_file_path(session_id, cwd, args.claude_home)
+                if fp:
+                    meta = extract_session_metadata(Path(fp), "claude")
+                    return meta.get("customTitle", "")
+            except Exception:
+                pass
+            return ""
+
         limited = [
             {
                 "agent": "claude",
@@ -1598,6 +1621,7 @@ To persist directory changes when resuming sessions:
                 "is_trimmed": s[8] if len(s) > 8 else False,
                 "derivation_type": None,
                 "is_sidechain": s[9] if len(s) > 9 else False,
+                "custom_title": get_custom_title(s[0], s[6]),
             }
             for s in matching_sessions[: args.num_matches]
         ]

claude_code_tools/find_codex_session.py

@@ -65,6 +65,7 @@ from claude_code_tools.smart_trim_core import (
 from claude_code_tools.smart_trim import trim_lines
 from claude_code_tools.session_utils import (
     get_codex_home,
+    get_session_uuid,
     format_session_id_display,
     filter_sessions_by_time,
 )
@@ -78,14 +79,6 @@ try:
 except ImportError:
     RICH_AVAILABLE = False
 
-try:
-    from claude_code_tools.session_tui import run_session_tui
-
-    TUI_AVAILABLE = True
-except ImportError:
-    TUI_AVAILABLE = False
-
-
 def extract_session_id_from_filename(filename: str) -> Optional[str]:
     """
     Extract session ID from Codex session filename.
@@ -585,6 +578,19 @@ def handle_suppress_resume_codex(
         print(f"❌ Error trimming session: {e}")
         return None
 
+    # Check if nothing to trim (savings below threshold)
+    from claude_code_tools.node_menu_ui import run_trim_confirm_ui
+    if result.get("nothing_to_trim"):
+        print(f"   Savings too small ({result['tokens_saved']} tokens)")
+        action = run_trim_confirm_ui(
+            nothing_to_trim=True,
+            original_session_id=match["session_id"],
+        )
+        if action == 'resume':
+            resume_session(match["session_id"], match["cwd"])
+            return None
+        return 'back'
+
     new_session_id = result["session_id"]
     new_session_file = Path(result["output_file"])
 
@@ -592,7 +598,6 @@ def handle_suppress_resume_codex(
     total_trimmed = result['num_tools_trimmed'] + result['num_assistant_trimmed']
 
     # Show confirmation UI
-    from claude_code_tools.node_menu_ui import run_trim_confirm_ui
     action = run_trim_confirm_ui(
         new_session_id=new_session_id,
         lines_trimmed=total_trimmed,
@@ -689,11 +694,17 @@ def handle_smart_trim_resume_codex(
         }
 
         # Generate new session ID (UUID only) and filename with Codex format
-        timestamp = datetime.now().strftime("%Y-%m-%dT%H-%M-%S")
+        # New session goes in today's date folder (YYYY/MM/DD)
+        now = datetime.now()
+        timestamp = now.strftime("%Y-%m-%dT%H-%M-%S")
+        date_path = now.strftime("%Y/%m/%d")
         new_session_id = str(uuid.uuid4())
 
-        # Create output path in same directory as original
-        output_file = session_file.parent / f"rollout-{timestamp}-{new_session_id}.jsonl"
+        # Find sessions root by going up from input file (sessions/YYYY/MM/DD/file.jsonl)
+        sessions_root = session_file.parent.parent.parent.parent
+        output_dir = sessions_root / date_path
+        output_dir.mkdir(parents=True, exist_ok=True)
+        output_file = output_dir / f"rollout-{timestamp}-{new_session_id}.jsonl"
 
         # Perform trimming
         stats = trim_lines(
@@ -760,7 +771,7 @@ def handle_export_session(session_file_path: str, dest_override: str | None = No
 
     # Generate default export path using session's project directory
     session_file = Path(session_file_path)
-    session_id = session_file.stem
+    session_id = get_session_uuid(session_file.name)
     today = datetime.now().strftime("%Y%m%d")
 
     # Infer project directory from session metadata
@@ -977,8 +988,12 @@ def resume_session(
 
 def create_action_handler(shell_mode: bool = False, codex_home: Optional[Path] = None, nonlaunch_flag: Optional[dict] = None):
     """Create an action handler for the TUI."""
-    def action_handler(session, action: str, kwargs: Optional[dict] = None) -> None:
-        """Handle actions from the TUI - session can be tuple or dict."""
+    def action_handler(session, action: str, kwargs: Optional[dict] = None) -> str | None:
+        """Handle actions from the TUI - session can be tuple or dict.
+
+        Returns:
+            'back' if the action wants to return to resume menu, None otherwise.
+        """
         kwargs = kwargs or {}
         # Ensure session is a dict
         if not isinstance(session, dict):
@@ -999,14 +1014,14 @@ def create_action_handler(shell_mode: bool = False, codex_home: Optional[Path] =
             if tools is None and threshold is None and trim_assistant is None:
                 options = prompt_suppress_options()
                 if not options:
-                    return
+                    return None
                 tools, threshold, trim_assistant = options
-            handle_suppress_resume_codex(
+            return handle_suppress_resume_codex(
                 session, tools, threshold or 500, trim_assistant, codex_home
             )
         elif action == "smart_trim_resume":
             # Smart trim using parallel agents
-            handle_smart_trim_resume_codex(session, codex_home)
+            return handle_smart_trim_resume_codex(session, codex_home)
         elif action == "path":
             if nonlaunch_flag is not None:
                 nonlaunch_flag["done"] = True

claude_code_tools/find_session.py

@@ -70,14 +70,6 @@ try:
 except ImportError:
     RICH_AVAILABLE = False
 
-try:
-    from claude_code_tools.session_tui import run_session_tui
-
-    TUI_AVAILABLE = True
-except ImportError:
-    TUI_AVAILABLE = False
-
-
 @dataclass
 class AgentConfig:
     """Configuration for a coding agent."""
@@ -570,6 +562,18 @@ def handle_suppress_resume(
         print(f"❌ Error trimming session: {e}", file=output)
         return
 
+    # Check if nothing to trim (savings below threshold)
+    if result.get("nothing_to_trim"):
+        print(f"\n{'='*70}", file=output)
+        print(f"⚠️  NOTHING TO TRIM", file=output)
+        print(f"{'='*70}", file=output)
+        print(
+            f"   Savings too small ({result['tokens_saved']} tokens) - "
+            f"no new session created",
+            file=output,
+        )
+        return
+
     new_session_id = result["session_id"]
     new_session_file = result["output_file"]
 
@@ -625,8 +629,12 @@ def create_action_handler(
 ):
     """Create an action handler for the TUI or Node UI."""
 
-    def action_handler(session, action: str, kwargs: Optional[dict] = None) -> None:
-        """Handle actions from the UI - session can be tuple or dict."""
+    def action_handler(session, action: str, kwargs: Optional[dict] = None) -> str | None:
+        """Handle actions from the UI - session can be tuple or dict.
+
+        Returns:
+            'back' if the action wants to return to resume menu, None otherwise.
+        """
         # Convert session to dict if it's a tuple or dict-like
         if isinstance(session, dict):
             session_dict = session
@@ -634,7 +642,7 @@ def create_action_handler(
             # Shouldn't happen in unified find, but handle gracefully
             session_dict = {"session_id": str(session), "agent": "unknown"}
 
-        handle_action(
+        result = handle_action(
             session_dict, action, shell_mode=shell_mode, action_kwargs=kwargs or {}
         )
 
@@ -642,13 +650,19 @@ def create_action_handler(
             nonlaunch_flag["done"] = True
             nonlaunch_flag["session_id"] = session_dict.get("session_id")
 
+        return result
+
     return action_handler
 
 
 def handle_action(
     session: dict, action: str, shell_mode: bool = False, action_kwargs: Optional[dict] = None
-) -> None:
-    """Handle the selected action based on agent type."""
+) -> str | None:
+    """Handle the selected action based on agent type.
+
+    Returns:
+        'back' if the action wants to return to resume menu, None otherwise.
+    """
     agent = session["agent"]
     action_kwargs = action_kwargs or {}
 
@@ -675,14 +689,14 @@ def handle_action(
             if options:
                 tools, threshold, trim_assistant = options
             else:
-                return
+                return None
         handle_suppress_resume(
             session, tools, threshold or 500, trim_assistant, shell_mode
         )
 
     elif action == "smart_trim_resume":
         if agent == "claude":
-            handle_smart_trim_resume_claude(
+            return handle_smart_trim_resume_claude(
                 session["session_id"],
                 session["cwd"],
                 session.get("claude_home"),
@@ -690,7 +704,7 @@ def handle_action(
         elif agent == "codex":
             # Get file path for codex
             file_path = session.get("file_path", "")
-            handle_smart_trim_resume_codex(file_path)
+            return handle_smart_trim_resume_codex(file_path)
 
     elif action == "path":
         if agent == "claude":