claude-code-tools 1.0.6__py3-none-any.whl → 1.4.1__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

@@ -216,6 +216,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 +228,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,
@@ -278,10 +283,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 +322,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)

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":

claude_code_tools/gdoc2md.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""
+gdoc2md: Download Google Docs as Markdown files.
+
+This tool uses the Google Drive API to export Google Docs as Markdown,
+using Google's native markdown export (same as File → Download → Markdown).
+
+Prerequisites:
+- First run: Will open browser for OAuth authentication (one-time setup)
+- Credentials stored in .gdoc-credentials.json (local) or ~/.config/md2gdoc/
+"""
+
+import argparse
+import sys
+from pathlib import Path
+from typing import Optional
+
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+# Import shared utilities from md2gdoc
+from claude_code_tools.md2gdoc import (
+    SCOPES,
+    check_dependencies,
+    get_credentials,
+    get_drive_service,
+    find_folder_id,
+)
+
+
+def find_doc_by_name(
+    service, folder_id: Optional[str], doc_name: str
+) -> Optional[dict]:
+    """Find a Google Doc by name in a folder. Returns file metadata or None."""
+    parent = folder_id if folder_id else "root"
+    query = (
+        f"name = '{doc_name}' and "
+        f"'{parent}' in parents and "
+        f"mimeType = 'application/vnd.google-apps.document' and "
+        f"trashed = false"
+    )
+    results = (
+        service.files()
+        .list(q=query, fields="files(id, name)", pageSize=1)
+        .execute()
+    )
+    files = results.get("files", [])
+    return files[0] if files else None
+
+
+def list_docs_in_folder(service, folder_id: Optional[str]) -> list[dict]:
+    """List all Google Docs in a folder."""
+    parent = folder_id if folder_id else "root"
+    query = (
+        f"'{parent}' in parents and "
+        f"mimeType = 'application/vnd.google-apps.document' and "
+        f"trashed = false"
+    )
+    results = (
+        service.files()
+        .list(q=query, fields="files(id, name)", pageSize=100, orderBy="name")
+        .execute()
+    )
+    return results.get("files", [])
+
+
+def download_doc_as_markdown(service, file_id: str) -> Optional[str]:
+    """Download a Google Doc as Markdown content."""
+    try:
+        # Export as markdown
+        content = (
+            service.files()
+            .export(fileId=file_id, mimeType="text/markdown")
+            .execute()
+        )
+        # Content is returned as bytes
+        if isinstance(content, bytes):
+            return content.decode("utf-8")
+        return content
+    except Exception as e:
+        console.print(f"[red]Export error:[/red] {e}")
+        return None
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Download Google Docs as Markdown files.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  gdoc2md "My Document"                        # Download from root
+  gdoc2md "My Document" --folder "OTA/Reports" # Download from folder
+  gdoc2md "My Document" -o report.md           # Save with custom name
+  gdoc2md --list --folder OTA                  # List docs in folder
+
+Credentials (in order of precedence):
+  1. .gdoc-token.json in current directory (project-specific)
+  2. ~/.config/md2gdoc/token.json (global)
+  3. Application Default Credentials (gcloud)
+        """,
+    )
+
+    parser.add_argument(
+        "doc_name",
+        type=str,
+        nargs="?",
+        help="Name of the Google Doc to download",
+    )
+
+    parser.add_argument(
+        "--folder",
+        "-f",
+        type=str,
+        default="",
+        help="Folder in Google Drive (e.g., 'OTA/Reports')",
+    )
+
+    parser.add_argument(
+        "--output",
+        "-o",
+        type=str,
+        default="",
+        help="Output filename (default: <doc_name>.md)",
+    )
+
+    parser.add_argument(
+        "--list",
+        "-l",
+        action="store_true",
+        help="List Google Docs in the folder instead of downloading",
+    )
+
+    args = parser.parse_args()
+
+    # Check dependencies
+    if not check_dependencies():
+        sys.exit(1)
+
+    # Need either doc_name or --list
+    if not args.doc_name and not args.list:
+        parser.print_help()
+        sys.exit(1)
+
+    # Get Drive service
+    service = get_drive_service()
+    if not service:
+        sys.exit(1)
+
+    # Find folder if specified
+    folder_id = None
+    if args.folder:
+        console.print(f"[dim]Finding folder: {args.folder}[/dim]")
+        folder_id = find_folder_id(service, args.folder, create_if_missing=False)
+        if folder_id is None:
+            console.print(f"[red]Error:[/red] Folder not found: {args.folder}")
+            sys.exit(1)
+
+    # List mode
+    if args.list:
+        docs = list_docs_in_folder(service, folder_id)
+        if not docs:
+            console.print("[yellow]No Google Docs found in this folder.[/yellow]")
+            sys.exit(0)
+
+        console.print(f"\n[bold]Google Docs in {args.folder or 'My Drive'}:[/bold]\n")
+        for doc in docs:
+            console.print(f"  • {doc['name']}")
+        console.print(f"\n[dim]Total: {len(docs)} document(s)[/dim]")
+        sys.exit(0)
+
+    # Download mode
+    console.print(f"[dim]Looking for: {args.doc_name}[/dim]")
+    doc = find_doc_by_name(service, folder_id, args.doc_name)
+
+    if not doc:
+        console.print(f"[red]Error:[/red] Document not found: {args.doc_name}")
+        # Suggest listing
+        console.print(f"[dim]Use --list to see available documents[/dim]")
+        sys.exit(1)
+
+    # Download as markdown
+    console.print(f"[cyan]Downloading[/cyan] {doc['name']} → Markdown...")
+    content = download_doc_as_markdown(service, doc["id"])
+
+    if content is None:
+        sys.exit(1)
+
+    # Determine output filename
+    if args.output:
+        output_path = Path(args.output)
+    else:
+        # Use doc name, sanitize for filesystem
+        safe_name = "".join(c if c.isalnum() or c in "._- " else "_" for c in doc["name"])
+        output_path = Path(f"{safe_name}.md")
+
+    # Check if file exists
+    if output_path.exists():
+        console.print(
+            f"[yellow]Warning:[/yellow] {output_path} already exists, overwriting"
+        )
+
+    # Write file
+    output_path.write_text(content, encoding="utf-8")
+
+    console.print()
+    console.print(
+        Panel(
+            f"[green]Successfully downloaded![/green]\n\n"
+            f"[dim]Document:[/dim] {doc['name']}\n"
+            f"[dim]Saved to:[/dim] {output_path}",
+            title="Done",
+            border_style="green",
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()