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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-tools
-Version: 1.16.1
+Version: 1.17.0
 Summary: Collection of tools for working with Claude Code
 License-File: LICENSE
 Requires-Python: >=3.11
@@ -115,10 +115,11 @@ codex-workflows show RUN_ID
 codex-workflows --all
 ```
 
-The default list contains only active workflows. Use `--all` to include
-completed and diagnostic history. The command reads durable workflow state and
-process metadata. It never changes a run, sends a signal, repairs state, or
-launches an agent. See the
+The default list contains only active workflows and identifies the project
+folder from which each workflow was launched. Use `show RUN_ID` for its full
+working directory, or `--all` to include completed and diagnostic history. The
+command reads durable workflow state and process metadata. It never changes a
+run, sends a signal, repairs state, or launches an agent. See the
 [codex-workflows reference][codex-workflows-reference] for filters, JSON output,
 and the complete versioned schema.
 

{claude_code_tools-1.16.1 → claude_code_tools-1.17.0}/README.md

@@ -89,10 +89,11 @@ codex-workflows show RUN_ID
 codex-workflows --all
 ```
 
-The default list contains only active workflows. Use `--all` to include
-completed and diagnostic history. The command reads durable workflow state and
-process metadata. It never changes a run, sends a signal, repairs state, or
-launches an agent. See the
+The default list contains only active workflows and identifies the project
+folder from which each workflow was launched. Use `show RUN_ID` for its full
+working directory, or `--all` to include completed and diagnostic history. The
+command reads durable workflow state and process metadata. It never changes a
+run, sends a signal, repairs state, or launches an agent. See the
 [codex-workflows reference][codex-workflows-reference] for filters, JSON output,
 and the complete versioned schema.
 

{claude_code_tools-1.16.1 → 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.1"
+__version__ = "1.17.0"

{claude_code_tools-1.16.1 → 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.1 → claude_code_tools-1.17.0}/claude_code_tools/codex_server_models.py

@@ -444,7 +444,7 @@ def clear_current_generation(base: ServerPaths) -> None:
 
 
 def all_server_paths(base: ServerPaths) -> list[ServerPaths]:
-    """Return bounded helper generations eligible for explicit cleanup."""
+    """Return bounded helper generations retaining state or a socket."""
     info = _lstat(base.runtime_dir)
     if info is None:
         return [base]
@@ -474,12 +474,12 @@ def all_server_paths(base: ServerPaths) -> list[ServerPaths]:
             raise CodexServerError("app-server runtime changed during inspection")
         with os.scandir(directory_fd) as entries:
             for entry in entries:
-                scanned += 1
-                if scanned > MAX_SERVER_DIRECTORY_ENTRIES:
-                    raise CodexServerError("too many app-server runtime entries")
                 try:
                     generation = validate_generation(entry.name)
                 except ValueError:
+                    scanned += 1
+                    if scanned > MAX_SERVER_DIRECTORY_ENTRIES:
+                        raise CodexServerError("too many app-server runtime entries")
                     continue
                 try:
                     entry_info = entry.stat(follow_symlinks=False)
@@ -497,6 +497,15 @@ def all_server_paths(base: ServerPaths) -> list[ServerPaths]:
                     raise CodexServerError(
                         f"app-server generation is owned by another user: {entry.name}"
                     )
+                paths = paths_for_generation(base, generation)
+                if (
+                    _lstat(paths.state_path) is None
+                    and _lstat(paths.socket_path) is None
+                ):
+                    continue
+                scanned += 1
+                if scanned > MAX_SERVER_DIRECTORY_ENTRIES:
+                    raise CodexServerError("too many app-server runtime entries")
                 generations.append(generation)
                 if len(generations) > MAX_SERVER_GENERATION_DIRECTORIES:
                     raise CodexServerError(
@@ -510,13 +519,10 @@ def all_server_paths(base: ServerPaths) -> list[ServerPaths]:
 def require_generation_capacity(base: ServerPaths, generation: str) -> None:
     """Bound retained servers before creating another generation."""
     target = paths_for_generation(base, generation)
-    if _lstat(target.runtime_dir) is not None:
+    retained = all_server_paths(base)[1:]
+    if any(paths.generation == target.generation for paths in retained):
         return
-    retained = sum(
-        _lstat(paths.state_path) is not None or _lstat(paths.socket_path) is not None
-        for paths in all_server_paths(base)[1:]
-    )
-    if retained >= MAX_SERVER_GENERATIONS:
+    if len(retained) >= MAX_SERVER_GENERATIONS:
         raise CodexServerError(
             "app-server generation limit reached; exit callback-ready sessions "
             "and run `codex-server stop --force` before launching another"

{claude_code_tools-1.16.1 → 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