claude-code-tools 1.16.2__tar.gz → 1.17.0__tar.gz

{claude_code_tools-1.16.2 → claude_code_tools-1.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-tools
-Version: 1.16.2
+Version: 1.17.0
 Summary: Collection of tools for working with Claude Code
 License-File: LICENSE
 Requires-Python: >=3.11

{claude_code_tools-1.16.2 → claude_code_tools-1.17.0}/claude_code_tools/__init__.py

@@ -1,3 +1,3 @@
 """Claude Code Tools - Collection of utilities for Claude Code."""
 
-__version__ = "1.16.2"
+__version__ = "1.17.0"

{claude_code_tools-1.16.2 → claude_code_tools-1.17.0}/claude_code_tools/aichat.py

@@ -30,6 +30,26 @@ class SessionIDGroup(click.Group):
         return super().parse_args(ctx, args)
 
 
+class ResolveCommand(click.Command):
+    """Click command that renders resolver usage errors without usage text."""
+
+    def parse_args(self, ctx: click.Context, args: list[str]) -> list[str]:
+        """Parse arguments, converting Click usage failures to resolver errors."""
+        import sys
+
+        from claude_code_tools.resolve_session import _render_error
+
+        raw_args = tuple(args)
+        try:
+            return super().parse_args(ctx, args)
+        except click.UsageError as error:
+            pretty = "--pretty" in raw_args or (
+                "--json" not in raw_args and sys.stdout.isatty()
+            )
+            _render_error("invalid_input", error.format_message(), pretty)
+            ctx.exit(1)
+
+
 @click.group(cls=SessionIDGroup, invoke_without_command=True)
 @click.version_option()
 @click.option(
@@ -96,7 +116,11 @@ def main(ctx, claude_home, codex_home):
     # Skip for build-index/clear-index to avoid double-indexing or state conflicts
     # In JSON mode (-j/--json), suppress all output for clean parsing
     skip_auto_index_cmds = ['build-index', 'clear-index', 'index-stats']
-    should_skip = any(cmd in sys.argv for cmd in skip_auto_index_cmds)
+    should_skip = (
+        ctx.invoked_subcommand == 'resolve'
+        or ctx.invoked_subcommand in skip_auto_index_cmds
+        or any(cmd in sys.argv for cmd in skip_auto_index_cmds)
+    )
     json_mode = any(arg in sys.argv for arg in ['-j', '--json'])
     if not should_skip:
         try:
@@ -128,6 +152,54 @@ def main(ctx, claude_home, codex_home):
         )
 
 
+@main.command("resolve", cls=ResolveCommand)
+@click.argument("query")
+@click.option(
+    "--agent",
+    type=str,
+    metavar="claude|codex",
+    default="claude",
+    show_default=True,
+)
+@click.option(
+    "--home",
+    type=click.Path(readable=False),
+    help="Claude or Codex home directory to search.",
+)
+@click.option("--json", "json_output", is_flag=True, help="Force JSON output.")
+@click.option(
+    "--pretty",
+    "pretty_output",
+    is_flag=True,
+    help="Force human-readable output.",
+)
+@click.pass_context
+def resolve_session_cmd(
+    ctx: click.Context,
+    query: str,
+    agent: str,
+    home: str | None,
+    json_output: bool,
+    pretty_output: bool,
+) -> None:
+    """Resolve a name, full session ID, or partial session ID."""
+    import sys
+
+    from claude_code_tools.resolve_session import run
+
+    if json_output and pretty_output:
+        click.echo(
+            '{"error":"invalid_format",'
+            '"detail":"Choose only one of --json or --pretty."}'
+        )
+        sys.exit(1)
+    if home is None:
+        home_key = "codex_home" if agent.casefold() == "codex" else "claude_home"
+        home = ctx.ensure_object(dict).get(home_key)
+    fmt = "json" if json_output else "pretty" if pretty_output else "auto"
+    sys.exit(run(query, agent.lower(), home, fmt))
+
+
 # Shared help text for find commands
 _FIND_OPTIONS_COMMON = """
 Options:

{claude_code_tools-1.16.2 → claude_code_tools-1.17.0}/claude_code_tools/export_session.py

@@ -97,7 +97,10 @@ def _get_last_line_timestamp(file_path: Path) -> Optional[str]:
 
             # Parse JSON and extract timestamp
             data = json.loads(last_line)
-            return data.get("timestamp")
+            if not isinstance(data, dict):
+                return None
+            timestamp = data.get("timestamp")
+            return timestamp if isinstance(timestamp, str) and timestamp else None
 
     except (OSError, IOError, json.JSONDecodeError, UnicodeDecodeError):
         return None
@@ -114,6 +117,8 @@ def _extract_claude_message_text(data: dict) -> Optional[str]:
         Extracted text or None if not a text message
     """
     message = data.get("message", {})
+    if not isinstance(message, dict):
+        return None
     content = message.get("content")
 
     if not content:
@@ -129,8 +134,9 @@ def _extract_claude_message_text(data: dict) -> Optional[str]:
             if isinstance(block, str) and block.strip():
                 return block.strip()
             if isinstance(block, dict) and block.get("type") == "text":
-                text = block.get("text", "").strip()
-                if text:
+                text = block.get("text")
+                if isinstance(text, str) and text.strip():
+                    text = text.strip()
                     return text
 
     return None
@@ -147,6 +153,8 @@ def _extract_codex_message_text(data: dict) -> Optional[str]:
         Extracted text or None if not a text message
     """
     payload = data.get("payload", {})
+    if not isinstance(payload, dict):
+        return None
     if payload.get("type") != "message":
         return None
 
@@ -160,9 +168,9 @@ def _extract_codex_message_text(data: dict) -> Optional[str]:
         block_type = block.get("type")
         # Both input_text and output_text have text field
         if block_type in ("input_text", "output_text"):
-            text = block.get("text", "").strip()
-            if text:
-                return text
+            text = block.get("text")
+            if isinstance(text, str) and text.strip():
+                return text.strip()
 
     return None
 
@@ -236,6 +244,8 @@ def extract_first_last_messages(
                     data = json.loads(line)
                 except json.JSONDecodeError:
                     continue
+                if not isinstance(data, dict):
+                    continue
 
                 role: Optional[str] = None
                 text: Optional[str] = None
@@ -249,10 +259,17 @@ def extract_first_last_messages(
                 elif agent == "codex":
                     if data.get("type") == "response_item":
                         payload = data.get("payload", {})
-                        if payload.get("type") == "message":
-                            role = payload.get("role")
+                        if (
+                            isinstance(payload, dict)
+                            and payload.get("type") == "message"
+                        ):
+                            payload_role = payload.get("role")
+                            if isinstance(payload_role, str):
+                                role = payload_role
                             text = _extract_codex_message_text(data)
-                            timestamp = data.get("timestamp")
+                            raw_timestamp = data.get("timestamp")
+                            if isinstance(raw_timestamp, str):
+                                timestamp = raw_timestamp
 
                 if role and text:
                     msg_dict = {
@@ -334,7 +351,7 @@ def extract_session_metadata(session_file: Path, agent: str) -> dict[str, Any]:
 
     try:
         with open(session_file, "r", encoding="utf-8") as f:
-            for line_num, line in enumerate(f, 1):
+            for line in f:
                 line = line.strip()
                 if not line:
                     continue
@@ -343,40 +360,61 @@ def extract_session_metadata(session_file: Path, agent: str) -> dict[str, Any]:
                     data = json.loads(line)
                 except json.JSONDecodeError:
                     continue
+                if not isinstance(data, dict):
+                    continue
 
-                # Extract cwd (first line that has it)
-                if metadata["cwd"] is None and data.get("cwd"):
-                    metadata["cwd"] = data["cwd"]
+                # Extract cwd (first line with a non-empty string value)
+                cwd = data.get("cwd")
+                if (
+                    metadata["cwd"] is None
+                    and isinstance(cwd, str)
+                    and bool(cwd.strip())
+                ):
+                    metadata["cwd"] = cwd
 
                 # Extract git branch (first line that has it)
-                if metadata["branch"] is None and data.get("gitBranch"):
-                    metadata["branch"] = data["gitBranch"]
+                git_branch = data.get("gitBranch")
+                if (
+                    metadata["branch"] is None
+                    and isinstance(git_branch, str)
+                    and bool(git_branch.strip())
+                ):
+                    metadata["branch"] = git_branch
 
                 # Extract session ID from sessionId field if available
-                if data.get("sessionId"):
-                    metadata["session_id"] = data["sessionId"]
+                session_id = data.get("sessionId")
+                if isinstance(session_id, str) and session_id.strip():
+                    metadata["session_id"] = session_id
 
                 # Extract trim_metadata (for trimmed sessions)
-                if "trim_metadata" in data:
-                    tm = data["trim_metadata"]
+                tm = data.get("trim_metadata")
+                if isinstance(tm, dict):
                     metadata["derivation_type"] = "trimmed"
-                    metadata["parent_session_file"] = tm.get("parent_file")
-                    if tm.get("parent_file"):
-                        parent_path = Path(tm["parent_file"])
+                    parent_file = tm.get("parent_file")
+                    if isinstance(parent_file, str) and parent_file.strip():
+                        metadata["parent_session_file"] = parent_file
+                        parent_path = Path(parent_file)
                         metadata["parent_session_id"] = parent_path.stem
-                    if tm.get("stats"):
-                        metadata["trim_stats"] = tm["stats"]
+                    stats = tm.get("stats")
+                    if isinstance(stats, dict):
+                        metadata["trim_stats"] = stats
 
                 # Extract continue_metadata (for continued sessions)
-                if "continue_metadata" in data:
-                    cm = data["continue_metadata"]
+                cm = data.get("continue_metadata")
+                if isinstance(cm, dict):
                     metadata["derivation_type"] = "continued"
-                    metadata["parent_session_id"] = cm.get("parent_session_id")
-                    metadata["parent_session_file"] = cm.get("parent_session_file")
+                    parent_id = cm.get("parent_session_id")
+                    if isinstance(parent_id, str) and parent_id.strip():
+                        metadata["parent_session_id"] = parent_id
+                    parent_file = cm.get("parent_session_file")
+                    if isinstance(parent_file, str) and parent_file.strip():
+                        metadata["parent_session_file"] = parent_file
 
                 # Extract sessionType (e.g., "helper" for SDK/headless sessions)
                 if "sessionType" in data and metadata["session_type"] is None:
-                    metadata["session_type"] = data["sessionType"]
+                    session_type = data.get("sessionType")
+                    if isinstance(session_type, str) and session_type.strip():
+                        metadata["session_type"] = session_type
 
                 # Extract git branch for Claude from file-history-snapshot metadata
                 if (
@@ -384,33 +422,47 @@ def extract_session_metadata(session_file: Path, agent: str) -> dict[str, Any]:
                     and metadata["branch"] is None
                     and data.get("type") == "file-history-snapshot"
                 ):
-                    git_info = data.get("metadata", {}).get("git", {})
-                    if git_info.get("branch"):
-                        metadata["branch"] = git_info["branch"]
+                    nested_metadata = data.get("metadata")
+                    if isinstance(nested_metadata, dict):
+                        git_info = nested_metadata.get("git")
+                        if isinstance(git_info, dict):
+                            branch = git_info.get("branch")
+                            if isinstance(branch, str) and branch.strip():
+                                metadata["branch"] = branch
 
                 # Extract git branch for Codex sessions from session_meta
                 if agent == "codex" and data.get("type") == "session_meta":
-                    payload = data.get("payload", {})
-                    git_info = payload.get("git", {})
-                    if git_info.get("branch"):
-                        metadata["branch"] = git_info["branch"]
-                    if payload.get("cwd"):
-                        metadata["cwd"] = payload["cwd"]
-                    if payload.get("id"):
-                        metadata["session_id"] = payload["id"]
-                    if session_start_timestamp is None and data.get("timestamp"):
-                        session_start_timestamp = data["timestamp"]
+                    payload = data.get("payload")
+                    if isinstance(payload, dict):
+                        git_info = payload.get("git")
+                        if isinstance(git_info, dict):
+                            branch = git_info.get("branch")
+                            if isinstance(branch, str) and branch.strip():
+                                metadata["branch"] = branch
+                        payload_cwd = payload.get("cwd")
+                        if (
+                            isinstance(payload_cwd, str)
+                            and payload_cwd.strip()
+                        ):
+                            metadata["cwd"] = payload_cwd
+                        payload_id = payload.get("id")
+                        if isinstance(payload_id, str) and payload_id.strip():
+                            metadata["session_id"] = payload_id
 
                 # Extract session start timestamp from first entry with timestamp
-                if session_start_timestamp is None and data.get("timestamp"):
-                    session_start_timestamp = data["timestamp"]
+                timestamp = data.get("timestamp")
+                if (
+                    session_start_timestamp is None
+                    and isinstance(timestamp, str)
+                    and timestamp.strip()
+                ):
+                    session_start_timestamp = timestamp
 
-                # Stop once we have the essential metadata (cwd and branch)
-                # or after 500 lines as a safety limit
-                if (metadata["cwd"] and metadata["branch"]) or line_num >= 500:
+                # Stop once we have the essential metadata (cwd and branch).
+                if metadata["cwd"] and metadata["branch"]:
                     break
 
-    except (OSError, IOError):
+    except (OSError, IOError, UnicodeError):
         pass
 
     # Note: customTitle extraction is done in search_index.py's _extract_session_content
@@ -454,7 +506,7 @@ def extract_session_metadata(session_file: Path, agent: str) -> dict[str, Any]:
     try:
         with open(session_file, "r", encoding="utf-8") as f:
             metadata["lines"] = sum(1 for _ in f)
-    except (OSError, IOError):
+    except (OSError, IOError, UnicodeError):
         metadata["lines"] = 0
 
     # Derive project name from cwd

{claude_code_tools-1.16.2 → claude_code_tools-1.17.0}/claude_code_tools/find_claude_session.py

@@ -59,15 +59,17 @@ def get_session_start_timestamp(jsonl_file: Path) -> Optional[float]:
                     continue
                 try:
                     data = json.loads(line)
-                    if data.get("timestamp"):
-                        ts = data["timestamp"]
+                    if not isinstance(data, dict):
+                        continue
+                    ts = data.get("timestamp")
+                    if isinstance(ts, str) and ts:
                         # Parse ISO format (e.g., "2025-10-22T16:05:28.707Z")
                         if ts.endswith("Z"):
                             ts = ts[:-1] + "+00:00"
                         return datetime.fromisoformat(ts).timestamp()
                 except (json.JSONDecodeError, ValueError, TypeError):
                     continue
-    except (OSError, IOError):
+    except (OSError, IOError, UnicodeError):
         pass
     return None
 
@@ -216,6 +218,8 @@ def extract_project_name(original_path: str) -> str:
                 for line in f:
                     try:
                         data = json.loads(line.strip())
+                        if not isinstance(data, dict):
+                            continue
                         # Only count user/assistant messages
                         if data.get('type') in ('user', 'assistant'):
                             msg_count += 1
@@ -242,6 +246,8 @@ def extract_project_name(original_path: str) -> str:
 
                 try:
                     data = json.loads(line.strip())
+                    if not isinstance(data, dict):
+                        continue
                     # Only count user/assistant messages
                     if data.get('type') in ('user', 'assistant'):
                         msg_count += 1
@@ -288,22 +294,25 @@ def is_sidechain_session(filepath: Path) -> bool:
     Returns:
         True if session is a sidechain, False otherwise.
     """
+    if filepath.name.startswith("agent-"):
+        return True
+
     if not filepath.exists():
         return False
 
     try:
         with open(filepath, 'r', encoding='utf-8') as f:
-            # Check first few lines for isSidechain field
-            for i, line in enumerate(f):
-                if i >= 10:  # Only check first 10 lines
-                    break
+            for line in f:
                 try:
                     data = json.loads(line.strip())
-                    if "isSidechain" in data:
-                        return data["isSidechain"] is True
-                except (json.JSONDecodeError, KeyError):
+                    if (
+                        isinstance(data, dict)
+                        and data.get("isSidechain") is True
+                    ):
+                        return True
+                except (json.JSONDecodeError, TypeError):
                     continue
-    except (OSError, IOError):
+    except (OSError, IOError, UnicodeError):
         pass
 
     return False
@@ -332,6 +341,8 @@ def search_keywords_in_file(filepath: Path, keywords: List[str]) -> tuple[bool,
                 for line in f:
                     try:
                         data = json.loads(line.strip())
+                        if not isinstance(data, dict):
+                            continue
                         # Only count user/assistant messages
                         if data.get('type') in ('user', 'assistant'):
                             msg_count += 1
@@ -358,6 +369,8 @@ def search_keywords_in_file(filepath: Path, keywords: List[str]) -> tuple[bool,
 
                 try:
                     data = json.loads(line.strip())
+                    if not isinstance(data, dict):
+                        continue
                     # Only count user/assistant messages
                     if data.get('type') in ('user', 'assistant'):
                         msg_count += 1
@@ -389,10 +402,17 @@ def get_session_preview(filepath: Path) -> str:
             for line in f:
                 try:
                     data = json.loads(line.strip())
+                    if not isinstance(data, dict):
+                        continue
                     msg_type = data.get('type')
                     # Accept user or assistant messages
-                    if msg_type in ('user', 'assistant'):
-                        message = data.get('message', {})
+                    if isinstance(msg_type, str) and msg_type in (
+                        'user',
+                        'assistant',
+                    ):
+                        message = data.get('message')
+                        if not isinstance(message, dict):
+                            continue
                         content = message.get('content', '')
                         text = None
 
@@ -401,8 +421,13 @@ def get_session_preview(filepath: Path) -> str:
                         elif isinstance(content, list):
                             # Handle structured content
                             for item in content:
-                                if isinstance(item, dict) and item.get('type') == 'text':
-                                    text = item.get('text', '').strip()
+                                if not isinstance(item, dict):
+                                    continue
+                                if item.get('type') != 'text':
+                                    continue
+                                item_text = item.get('text')
+                                if isinstance(item_text, str):
+                                    text = item_text.strip()
                                     break
 
                         # Filter out system messages and keep updating to get LAST
@@ -498,7 +523,10 @@ def find_sessions(
                                     continue
 
                             session_id = jsonl_file.stem
-                            stat = jsonl_file.stat()
+                            try:
+                                stat = jsonl_file.stat()
+                            except OSError:
+                                continue
                             mod_time = stat.st_mtime
                             # Get session start timestamp from JSON metadata, fall back to file stats
                             create_time = get_session_start_timestamp(jsonl_file)
@@ -506,7 +534,10 @@ def find_sessions(
                                 create_time = getattr(stat, 'st_birthtime', stat.st_ctime)
                             preview = get_session_preview(jsonl_file)
                             # Extract actual cwd from session file - MUST NOT use reconstructed path as fallback
-                            actual_cwd = extract_cwd_from_session(jsonl_file)
+                            actual_cwd = extract_cwd_from_session(
+                                jsonl_file,
+                                agent="claude",
+                            )
                             if not actual_cwd:
                                 # Skip sessions without cwd metadata (shouldn't happen for valid Claude sessions)
                                 continue
@@ -547,7 +578,10 @@ def find_sessions(
                                 continue
 
                         session_id = jsonl_file.stem
-                        stat = jsonl_file.stat()
+                        try:
+                            stat = jsonl_file.stat()
+                        except OSError:
+                            continue
                         mod_time = stat.st_mtime
                         # Get session start timestamp from JSON metadata, fall back to file stats
                         create_time = get_session_start_timestamp(jsonl_file)
@@ -555,7 +589,10 @@ def find_sessions(
                             create_time = getattr(stat, 'st_birthtime', stat.st_ctime)
                         preview = get_session_preview(jsonl_file)
                         # Extract actual cwd from session file - MUST NOT use reconstructed path as fallback
-                        actual_cwd = extract_cwd_from_session(jsonl_file)
+                        actual_cwd = extract_cwd_from_session(
+                            jsonl_file,
+                            agent="claude",
+                        )
                         if not actual_cwd:
                             # Skip sessions without cwd metadata (shouldn't happen for valid Claude sessions)
                             continue
@@ -599,7 +636,10 @@ def find_sessions(
                         continue
 
                 session_id = jsonl_file.stem
-                stat = jsonl_file.stat()
+                try:
+                    stat = jsonl_file.stat()
+                except OSError:
+                    continue
                 mod_time = stat.st_mtime
                 # Get session start timestamp from JSON metadata, fall back to file stats
                 create_time = get_session_start_timestamp(jsonl_file)
@@ -607,7 +647,10 @@ def find_sessions(
                     create_time = getattr(stat, 'st_birthtime', stat.st_ctime)
                 preview = get_session_preview(jsonl_file)
                 # Extract actual cwd from session file for consistency
-                actual_cwd = extract_cwd_from_session(jsonl_file) or os.getcwd()
+                actual_cwd = (
+                    extract_cwd_from_session(jsonl_file, agent="claude")
+                    or os.getcwd()
+                )
                 matching_sessions.append((session_id, mod_time, create_time, line_count, project_name, preview, actual_cwd, git_branch, derivation_type, is_sidechain))
     
     # Sort by modification time (newest first)
@@ -1059,6 +1102,54 @@ def get_session_file_path(
         )
 
 
+def get_custom_title(
+    session_id: str,
+    cwd: str,
+    claude_home: Optional[str] = None,
+    session_file: Optional[Path] = None,
+) -> str:
+    """Return the most recent user-assigned name for a Claude session.
+
+    Claude writes names from ``/rename`` as ``custom-title`` records. Older
+    versions may mirror the value in an ``agent-name`` record. Automatic
+    ``ai-title`` records are deliberately ignored.
+
+    Args:
+        session_id: Full Claude session identifier.
+        cwd: Session working directory.
+        claude_home: Optional Claude home directory override.
+        session_file: Optional already-discovered transcript path. This avoids
+            reconstructing a stale path from the transcript's current cwd.
+
+    Returns:
+        The latest custom session name, or an empty string if none is found.
+    """
+    try:
+        path = session_file or Path(
+            get_session_file_path(session_id, cwd, claude_home)
+        )
+        custom_title = ""
+        with path.open("r", encoding="utf-8") as handle:
+            for line in handle:
+                try:
+                    data = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if not isinstance(data, dict):
+                    continue
+                if data.get("type") == "custom-title":
+                    value = data.get("customTitle")
+                elif data.get("type") == "agent-name":
+                    value = data.get("agentName")
+                else:
+                    continue
+                if isinstance(value, str) and value:
+                    custom_title = value
+        return custom_title
+    except (OSError, UnicodeError, ValueError):
+        return ""
+
+
 def handle_export_session(session_file_path: str, dest_override: str | None = None, silent: bool = False) -> None:
     """Export session to text file."""
     from claude_code_tools.export_claude_session import export_session_to_markdown as do_export
@@ -1071,7 +1162,7 @@ def handle_export_session(session_file_path: str, dest_override: str | None = No
         today = datetime.now().strftime("%Y%m%d")
 
         # Infer project directory from session metadata
-        project_dir = extract_cwd_from_session(session_file)
+        project_dir = extract_cwd_from_session(session_file, agent="claude")
         if project_dir:
             output_dir = Path(project_dir) / "exported-sessions"
         else:
@@ -1591,19 +1682,6 @@ 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",
@@ -1621,7 +1699,9 @@ 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]),
+                "custom_title": get_custom_title(
+                    s[0], s[6], args.claude_home
+                ),
             }
             for s in matching_sessions[: args.num_matches]
         ]