claude-code-tools 0.1.13__tar.gz → 0.1.17__tar.gz

claude_code_tools-0.1.17/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Prasad Chalasani
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{claude_code_tools-0.1.13 → claude_code_tools-0.1.17}/PKG-INFO

@@ -1,7 +1,8 @@
 Metadata-Version: 2.4
 Name: claude-code-tools
-Version: 0.1.13
+Version: 0.1.17
 Summary: Collection of tools for working with Claude Code
+License-File: LICENSE
 Requires-Python: >=3.11
 Requires-Dist: click>=8.0.0
 Requires-Dist: fire>=0.5.0
@@ -62,6 +63,7 @@ This gives you:
 - `tmux-cli` - The interactive CLI controller we just covered
 - `find-claude-session` - Search and resume Claude Code sessions by keywords
 - `vault` - Encrypted backup for your .env files
+- `env-safe` - Safely inspect .env files without exposing values
 
 ## 🎮 tmux-cli Deep Dive
 
@@ -106,6 +108,12 @@ Example uses:
 - Launch web apps and test them with browser automation MCP tools like Puppeteer
 ```
 
+Incidentally, installing the Puppeteer MCP tool is easy:
+
+```bash
+claude mcp add puppeteer -- npx -y @modelcontextprotocol/server-puppeteer
+```
+
 For detailed instructions, see [docs/tmux-cli-instructions.md](docs/tmux-cli-instructions.md).
 
 ## 🔍 find-claude-session
@@ -182,6 +190,31 @@ vault status    # Check sync status for current project
 
 For detailed documentation, see [docs/vault-documentation.md](docs/vault-documentation.md).
 
+## 🔍 env-safe
+
+Safely inspect .env files without exposing sensitive values. Designed for Claude Code and other automated tools that need to work with environment files without accidentally leaking secrets.
+
+```bash
+env-safe list                    # List all environment variable keys
+env-safe list --status           # Show keys with defined/empty status  
+env-safe check API_KEY           # Check if a specific key exists
+env-safe count                   # Count total, defined, and empty variables
+env-safe validate                # Validate .env file syntax
+env-safe --help                  # See all options
+```
+
+### Key Features
+
+- **No Value Exposure** - Never displays actual environment values
+- **Safe Inspection** - Check which keys exist without security risks
+- **Syntax Validation** - Verify .env file format is correct
+- **Status Checking** - See which variables are defined vs empty
+- **Claude Code Integration** - Works with protection hooks to provide safe alternative
+
+### Why env-safe?
+
+When Claude Code attempts to read .env files directly (via cat, grep, etc.), safety hooks block the operation to prevent accidental exposure of API keys and secrets. The `env-safe` command provides a secure alternative that lets Claude Code inspect environment configuration without security risks.
+
 ## 🛡️ Claude Code Safety Hooks
 
 This repository includes a comprehensive set of safety hooks that enhance Claude
@@ -193,6 +226,8 @@ Code's behavior and prevent dangerous operations.
   pattern
 - **Git Safety** - Prevents dangerous `git add -A`, unsafe checkouts, and
   accidental data loss  
+- **Environment Security** - Blocks direct .env file access, suggests `env-safe`
+  command instead
 - **Context Management** - Blocks reading files >500 lines to prevent context
   bloat
 - **Command Enhancement** - Enforces ripgrep (`rg`) over grep for better

{claude_code_tools-0.1.13 → claude_code_tools-0.1.17}/README.md

@@ -50,6 +50,7 @@ This gives you:
 - `tmux-cli` - The interactive CLI controller we just covered
 - `find-claude-session` - Search and resume Claude Code sessions by keywords
 - `vault` - Encrypted backup for your .env files
+- `env-safe` - Safely inspect .env files without exposing values
 
 ## 🎮 tmux-cli Deep Dive
 
@@ -94,6 +95,12 @@ Example uses:
 - Launch web apps and test them with browser automation MCP tools like Puppeteer
 ```
 
+Incidentally, installing the Puppeteer MCP tool is easy:
+
+```bash
+claude mcp add puppeteer -- npx -y @modelcontextprotocol/server-puppeteer
+```
+
 For detailed instructions, see [docs/tmux-cli-instructions.md](docs/tmux-cli-instructions.md).
 
 ## 🔍 find-claude-session
@@ -170,6 +177,31 @@ vault status    # Check sync status for current project
 
 For detailed documentation, see [docs/vault-documentation.md](docs/vault-documentation.md).
 
+## 🔍 env-safe
+
+Safely inspect .env files without exposing sensitive values. Designed for Claude Code and other automated tools that need to work with environment files without accidentally leaking secrets.
+
+```bash
+env-safe list                    # List all environment variable keys
+env-safe list --status           # Show keys with defined/empty status  
+env-safe check API_KEY           # Check if a specific key exists
+env-safe count                   # Count total, defined, and empty variables
+env-safe validate                # Validate .env file syntax
+env-safe --help                  # See all options
+```
+
+### Key Features
+
+- **No Value Exposure** - Never displays actual environment values
+- **Safe Inspection** - Check which keys exist without security risks
+- **Syntax Validation** - Verify .env file format is correct
+- **Status Checking** - See which variables are defined vs empty
+- **Claude Code Integration** - Works with protection hooks to provide safe alternative
+
+### Why env-safe?
+
+When Claude Code attempts to read .env files directly (via cat, grep, etc.), safety hooks block the operation to prevent accidental exposure of API keys and secrets. The `env-safe` command provides a secure alternative that lets Claude Code inspect environment configuration without security risks.
+
 ## 🛡️ Claude Code Safety Hooks
 
 This repository includes a comprehensive set of safety hooks that enhance Claude
@@ -181,6 +213,8 @@ Code's behavior and prevent dangerous operations.
   pattern
 - **Git Safety** - Prevents dangerous `git add -A`, unsafe checkouts, and
   accidental data loss  
+- **Environment Security** - Blocks direct .env file access, suggests `env-safe`
+  command instead
 - **Context Management** - Blocks reading files >500 lines to prevent context
   bloat
 - **Command Enhancement** - Enforces ripgrep (`rg`) over grep for better

{claude_code_tools-0.1.13 → claude_code_tools-0.1.17}/claude_code_tools/__init__.py

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

claude_code_tools-0.1.17/claude_code_tools/env_safe.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+"""
+env-safe: A safe way to inspect .env files without exposing sensitive values.
+
+This tool allows Claude Code and other automated tools to:
+- List environment variable keys without showing values
+- Check if specific keys exist
+- Count the number of variables defined
+- Validate .env file syntax
+
+It specifically avoids displaying actual values to prevent accidental exposure
+of secrets, API keys, and other sensitive information.
+"""
+
+import os
+import sys
+import argparse
+from pathlib import Path
+from typing import List, Tuple, Optional
+import re
+
+
+def parse_env_file(filepath: Path) -> List[Tuple[str, bool]]:
+    """
+    Parse a .env file and extract variable names.
+    
+    Returns:
+        List of tuples: (variable_name, has_value)
+    """
+    if not filepath.exists():
+        raise FileNotFoundError(f"File not found: {filepath}")
+    
+    variables = []
+    
+    with open(filepath, 'r', encoding='utf-8') as f:
+        for line_num, line in enumerate(f, 1):
+            # Skip empty lines and comments
+            line = line.strip()
+            if not line or line.startswith('#'):
+                continue
+            
+            # Match KEY=value pattern
+            match = re.match(r'^([A-Za-z_][A-Za-z0-9_]*)\s*=(.*)$', line)
+            if match:
+                key = match.group(1)
+                value = match.group(2).strip()
+                has_value = bool(value and value != '""' and value != "''")
+                variables.append((key, has_value))
+            elif '=' in line:
+                # Malformed line - has = but doesn't match pattern
+                print(f"Warning: Line {line_num} appears malformed: {line[:50]}...", 
+                      file=sys.stderr)
+    
+    return variables
+
+
+def list_keys(filepath: Path, show_status: bool = False) -> None:
+    """List all environment variable keys in the file."""
+    try:
+        variables = parse_env_file(filepath)
+        
+        if not variables:
+            print("No environment variables found in file.")
+            return
+        
+        if show_status:
+            print(f"{'KEY':<30} {'STATUS':<10}")
+            print("-" * 40)
+            for key, has_value in sorted(variables):
+                status = "defined" if has_value else "empty"
+                print(f"{key:<30} {status:<10}")
+        else:
+            for key, _ in sorted(variables):
+                print(key)
+                
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error reading file: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def check_key(filepath: Path, key_name: str) -> None:
+    """Check if a specific key exists in the .env file."""
+    try:
+        variables = parse_env_file(filepath)
+        
+        for key, has_value in variables:
+            if key == key_name:
+                if has_value:
+                    print(f"✓ {key_name} is defined with a value")
+                else:
+                    print(f"⚠ {key_name} is defined but empty")
+                sys.exit(0)
+        
+        print(f"✗ {key_name} is not defined")
+        sys.exit(1)
+        
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error reading file: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def count_variables(filepath: Path) -> None:
+    """Count the number of variables defined."""
+    try:
+        variables = parse_env_file(filepath)
+        total = len(variables)
+        with_values = sum(1 for _, has_value in variables if has_value)
+        empty = total - with_values
+        
+        print(f"Total variables: {total}")
+        if total > 0:
+            print(f"  With values: {with_values}")
+            print(f"  Empty: {empty}")
+            
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error reading file: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def validate_syntax(filepath: Path) -> None:
+    """Validate the syntax of the .env file."""
+    try:
+        if not filepath.exists():
+            print(f"Error: File not found: {filepath}", file=sys.stderr)
+            sys.exit(1)
+            
+        issues = []
+        valid_lines = 0
+        
+        with open(filepath, 'r', encoding='utf-8') as f:
+            for line_num, line in enumerate(f, 1):
+                original_line = line
+                line = line.strip()
+                
+                # Skip empty lines and comments
+                if not line or line.startswith('#'):
+                    continue
+                
+                # Check for valid KEY=value pattern
+                if not re.match(r'^[A-Za-z_][A-Za-z0-9_]*\s*=.*$', line):
+                    if '=' in line:
+                        issues.append(f"Line {line_num}: Invalid key format")
+                    else:
+                        issues.append(f"Line {line_num}: Missing '=' separator")
+                else:
+                    valid_lines += 1
+        
+        if issues:
+            print(f"✗ Found {len(issues)} syntax issue(s):")
+            for issue in issues[:10]:  # Show first 10 issues
+                print(f"  {issue}")
+            if len(issues) > 10:
+                print(f"  ... and {len(issues) - 10} more")
+            sys.exit(1)
+        else:
+            print(f"✓ Syntax valid ({valid_lines} variables defined)")
+            
+    except Exception as e:
+        print(f"Error reading file: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Safely inspect .env files without exposing sensitive values",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  env-safe list                    # List all keys
+  env-safe list --status           # List keys with defined/empty status
+  env-safe check API_KEY           # Check if API_KEY exists
+  env-safe count                   # Count variables
+  env-safe validate                # Check syntax
+  env-safe list --file config.env  # Use different file
+
+This tool is designed to be safe for automated tools like Claude Code,
+preventing accidental exposure of sensitive environment values.
+        """
+    )
+    
+    parser.add_argument(
+        '--file', '-f',
+        default='.env',
+        help='Path to env file (default: .env)'
+    )
+    
+    subparsers = parser.add_subparsers(dest='command', help='Commands')
+    
+    # List command
+    list_parser = subparsers.add_parser('list', help='List all environment keys')
+    list_parser.add_argument(
+        '--status', '-s',
+        action='store_true',
+        help='Show whether each key has a value'
+    )
+    
+    # Check command
+    check_parser = subparsers.add_parser('check', help='Check if a key exists')
+    check_parser.add_argument('key', help='The key name to check')
+    
+    # Count command
+    count_parser = subparsers.add_parser('count', help='Count variables')
+    
+    # Validate command
+    validate_parser = subparsers.add_parser('validate', help='Validate syntax')
+    
+    args = parser.parse_args()
+    
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+    
+    filepath = Path(args.file)
+    
+    if args.command == 'list':
+        list_keys(filepath, args.status)
+    elif args.command == 'check':
+        check_key(filepath, args.key)
+    elif args.command == 'count':
+        count_variables(filepath)
+    elif args.command == 'validate':
+        validate_syntax(filepath)
+
+
+if __name__ == '__main__':
+    main()

{claude_code_tools-0.1.13 → claude_code_tools-0.1.17}/claude_code_tools/find_claude_session.py

@@ -121,39 +121,51 @@ def extract_project_name(original_path: str) -> str:
     return parts[-1] if parts else "unknown"
 
 
-def search_keywords_in_file(filepath: Path, keywords: List[str]) -> tuple[bool, int]:
+def search_keywords_in_file(filepath: Path, keywords: List[str]) -> tuple[bool, int, Optional[str]]:
     """
-    Check if all keywords are present in the JSONL file and count lines.
+    Check if all keywords are present in the JSONL file, count lines, and extract git branch.
     
     Args:
         filepath: Path to the JSONL file
         keywords: List of keywords to search for (case-insensitive)
         
     Returns:
-        Tuple of (matches: bool, line_count: int)
+        Tuple of (matches: bool, line_count: int, git_branch: Optional[str])
         - matches: True if ALL keywords are found in the file
         - line_count: Total number of lines in the file
+        - git_branch: Git branch name from the first message that has it, or None
     """
     # Convert keywords to lowercase for case-insensitive search
     keywords_lower = [k.lower() for k in keywords]
     found_keywords = set()
     line_count = 0
+    git_branch = None
     
     try:
         with open(filepath, 'r', encoding='utf-8') as f:
             for line in f:
                 line_count += 1
                 line_lower = line.lower()
+                
+                # Extract git branch from JSON if not already found
+                if git_branch is None:
+                    try:
+                        data = json.loads(line.strip())
+                        if 'gitBranch' in data and data['gitBranch']:
+                            git_branch = data['gitBranch']
+                    except (json.JSONDecodeError, KeyError):
+                        pass
+                
                 # Check which keywords are in this line
                 for keyword in keywords_lower:
                     if keyword in line_lower:
                         found_keywords.add(keyword)
     except Exception:
         # Skip files that can't be read
-        return False, 0
+        return False, 0, None
     
     matches = len(found_keywords) == len(keywords_lower)
-    return matches, line_count
+    return matches, line_count, git_branch
 
 
 def get_session_preview(filepath: Path) -> str:
@@ -187,7 +199,7 @@ def get_session_preview(filepath: Path) -> str:
     return "No preview available"
 
 
-def find_sessions(keywords: List[str], global_search: bool = False, claude_home: Optional[str] = None) -> List[Tuple[str, float, int, str, str, str]]:
+def find_sessions(keywords: List[str], global_search: bool = False, claude_home: Optional[str] = None) -> List[Tuple[str, float, int, str, str, str, Optional[str]]]:
     """
     Find all Claude Code sessions containing the specified keywords.
     
@@ -197,7 +209,7 @@ def find_sessions(keywords: List[str], global_search: bool = False, claude_home:
         claude_home: Optional custom Claude home directory (defaults to ~/.claude)
         
     Returns:
-        List of tuples (session_id, modification_time, line_count, project_name, preview, project_path) sorted by modification time
+        List of tuples (session_id, modification_time, line_count, project_name, preview, project_path, git_branch) sorted by modification time
     """
     matching_sessions = []
     
@@ -220,12 +232,12 @@ def find_sessions(keywords: List[str], global_search: bool = False, claude_home:
                     
                     # Search all JSONL files in this project directory
                     for jsonl_file in project_dir.glob("*.jsonl"):
-                        matches, line_count = search_keywords_in_file(jsonl_file, keywords)
+                        matches, line_count, git_branch = search_keywords_in_file(jsonl_file, keywords)
                         if matches:
                             session_id = jsonl_file.stem
                             mod_time = jsonl_file.stat().st_mtime
                             preview = get_session_preview(jsonl_file)
-                            matching_sessions.append((session_id, mod_time, line_count, project_name, preview, original_path))
+                            matching_sessions.append((session_id, mod_time, line_count, project_name, preview, original_path, git_branch))
                     
                     progress.advance(task)
         else:
@@ -234,12 +246,12 @@ def find_sessions(keywords: List[str], global_search: bool = False, claude_home:
                 project_name = extract_project_name(original_path)
                 
                 for jsonl_file in project_dir.glob("*.jsonl"):
-                    matches, line_count = search_keywords_in_file(jsonl_file, keywords)
+                    matches, line_count, git_branch = search_keywords_in_file(jsonl_file, keywords)
                     if matches:
                         session_id = jsonl_file.stem
                         mod_time = jsonl_file.stat().st_mtime
                         preview = get_session_preview(jsonl_file)
-                        matching_sessions.append((session_id, mod_time, line_count, project_name, preview, original_path))
+                        matching_sessions.append((session_id, mod_time, line_count, project_name, preview, original_path, git_branch))
     else:
         # Search current project only
         claude_dir = get_claude_project_dir(claude_home)
@@ -251,12 +263,12 @@ def find_sessions(keywords: List[str], global_search: bool = False, claude_home:
         
         # Search all JSONL files in the directory
         for jsonl_file in claude_dir.glob("*.jsonl"):
-            matches, line_count = search_keywords_in_file(jsonl_file, keywords)
+            matches, line_count, git_branch = search_keywords_in_file(jsonl_file, keywords)
             if matches:
                 session_id = jsonl_file.stem
                 mod_time = jsonl_file.stat().st_mtime
                 preview = get_session_preview(jsonl_file)
-                matching_sessions.append((session_id, mod_time, line_count, project_name, preview, os.getcwd()))
+                matching_sessions.append((session_id, mod_time, line_count, project_name, preview, os.getcwd(), git_branch))
     
     # Sort by modification time (newest first)
     matching_sessions.sort(key=lambda x: x[1], reverse=True)
@@ -264,7 +276,7 @@ def find_sessions(keywords: List[str], global_search: bool = False, claude_home:
     return matching_sessions
 
 
-def display_interactive_ui(sessions: List[Tuple[str, float, int, str, str, str]], keywords: List[str], stderr_mode: bool = False, num_matches: int = 10) -> Optional[Tuple[str, str]]:
+def display_interactive_ui(sessions: List[Tuple[str, float, int, str, str, str, Optional[str]]], keywords: List[str], stderr_mode: bool = False, num_matches: int = 10) -> Optional[Tuple[str, str]]:
     """Display interactive UI for session selection."""
     if not RICH_AVAILABLE:
         return None
@@ -292,16 +304,19 @@ def display_interactive_ui(sessions: List[Tuple[str, float, int, str, str, str]]
     table.add_column("#", style="bold yellow", width=3)
     table.add_column("Session ID", style="dim")
     table.add_column("Project", style="green")
+    table.add_column("Branch", style="magenta")
     table.add_column("Date", style="blue")
     table.add_column("Lines", style="cyan", justify="right")
     table.add_column("Preview", style="white", overflow="fold")
     
-    for idx, (session_id, mod_time, line_count, project_name, preview, _) in enumerate(display_sessions, 1):
+    for idx, (session_id, mod_time, line_count, project_name, preview, _, git_branch) in enumerate(display_sessions, 1):
         mod_date = datetime.fromtimestamp(mod_time).strftime('%Y-%m-%d %H:%M')
+        branch_display = git_branch if git_branch else "N/A"
         table.add_row(
             str(idx),
             session_id[:8] + "...",
             project_name,
+            branch_display,
             mod_date,
             str(line_count),
             preview
@@ -327,6 +342,11 @@ def display_interactive_ui(sessions: List[Tuple[str, float, int, str, str, str]]
                 console=ui_console
             )
             
+            # Handle empty input
+            if not choice or not choice.strip():
+                ui_console.print("[red]Invalid choice. Please try again.[/red]")
+                continue
+            
             # Restore stdout
             if stderr_mode:
                 sys.stdout.close()
@@ -340,7 +360,10 @@ def display_interactive_ui(sessions: List[Tuple[str, float, int, str, str, str]]
         except KeyboardInterrupt:
             ui_console.print("\n[yellow]Cancelled[/yellow]")
             return None
-        except (ValueError, EOFError):
+        except EOFError:
+            ui_console.print("\n[yellow]Cancelled (EOF)[/yellow]")
+            return None
+        except ValueError:
             ui_console.print("[red]Invalid choice. Please try again.[/red]")
 
 
@@ -496,12 +519,13 @@ To persist directory changes when resuming sessions:
         # Fallback: print session IDs as before
         if not args.shell:
             print("\nMatching sessions:")
-        for idx, (session_id, mod_time, line_count, project_name, preview, project_path) in enumerate(matching_sessions[:args.num_matches], 1):
+        for idx, (session_id, mod_time, line_count, project_name, preview, project_path, git_branch) in enumerate(matching_sessions[:args.num_matches], 1):
             mod_date = datetime.fromtimestamp(mod_time).strftime('%Y-%m-%d %H:%M:%S')
+            branch_display = git_branch if git_branch else "N/A"
             if getattr(args, 'global'):
-                print(f"{idx}. {session_id} | {project_name} | {mod_date} | {line_count} lines", file=sys.stderr if args.shell else sys.stdout)
+                print(f"{idx}. {session_id} | {project_name} | {branch_display} | {mod_date} | {line_count} lines", file=sys.stderr if args.shell else sys.stdout)
             else:
-                print(f"{idx}. {session_id} | {mod_date} | {line_count} lines", file=sys.stderr if args.shell else sys.stdout)
+                print(f"{idx}. {session_id} | {branch_display} | {mod_date} | {line_count} lines", file=sys.stderr if args.shell else sys.stdout)
         
         if len(matching_sessions) > args.num_matches:
             print(f"\n... and {len(matching_sessions) - args.num_matches} more sessions", file=sys.stderr if args.shell else sys.stdout)
@@ -510,7 +534,7 @@ To persist directory changes when resuming sessions:
         if len(matching_sessions) == 1:
             if not args.shell:
                 print("\nOnly one match found. Resuming automatically...")
-            session_id, _, _, _, _, project_path = matching_sessions[0]
+            session_id, _, _, _, _, project_path, _ = matching_sessions[0]
             resume_session(session_id, project_path, shell_mode=args.shell)
         else:
             try:
@@ -521,10 +545,15 @@ To persist directory changes when resuming sessions:
                     choice = sys.stdin.readline().strip()
                 else:
                     choice = input("\nEnter number to resume session (or Ctrl+C to cancel): ")
+                
+                # Handle empty input or EOF
+                if not choice:
+                    print("Cancelled (EOF)", file=sys.stderr)
+                    sys.exit(0)
                     
                 idx = int(choice) - 1
                 if 0 <= idx < min(args.num_matches, len(matching_sessions)):
-                    session_id, _, _, _, _, project_path = matching_sessions[idx]
+                    session_id, _, _, _, _, project_path, _ = matching_sessions[idx]
                     resume_session(session_id, project_path, shell_mode=args.shell)
                 else:
                     print("Invalid choice", file=sys.stderr)

{claude_code_tools-0.1.13 → claude_code_tools-0.1.17}/claude_code_tools/tmux_cli_controller.py

@@ -128,6 +128,19 @@ class TmuxCLIController:
         output, code = self._run_tmux_command(['display-message', '-p', '#{pane_id}'])
         return output if code == 0 else None
     
+    def get_current_window_id(self) -> Optional[str]:
+        """Get the ID of the current tmux window."""
+        # Use TMUX_PANE environment variable to get the pane we're running in
+        import os
+        current_pane = os.environ.get('TMUX_PANE')
+        if current_pane:
+            # Get the window ID for this specific pane
+            output, code = self._run_tmux_command(['display-message', '-t', current_pane, '-p', '#{window_id}'])
+            return output if code == 0 else None
+        # Fallback to current window
+        output, code = self._run_tmux_command(['display-message', '-p', '#{window_id}'])
+        return output if code == 0 else None
+    
     def list_panes(self) -> List[Dict[str, str]]:
         """
         List all panes in the current window.
@@ -175,8 +188,15 @@ class TmuxCLIController:
         Returns:
             Pane ID of the created pane
         """
+        # Get the current window ID to ensure pane is created in this window
+        current_window_id = self.get_current_window_id()
+        
         cmd = ['split-window']
         
+        # Target the specific window where tmux-cli was called from
+        if current_window_id:
+            cmd.extend(['-t', current_window_id])
+        
         if vertical:
             cmd.append('-h')
         else:

claude_code_tools-0.1.17/docs/dot-zshrc.md

@@ -0,0 +1,307 @@
+# Zsh Shell Setup Guide
+
+This guide covers the essential setup for a productive Zsh environment with
+Oh My Zsh, plugins, and Starship prompt.
+
+## Prerequisites
+
+1. **Install Homebrew** (macOS package manager)
+   ```bash
+   /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+   ```
+
+2. **Install Zsh** (usually pre-installed on macOS)
+   ```bash
+   brew install zsh
+   ```
+
+## Oh My Zsh Installation
+
+Install Oh My Zsh framework for managing Zsh configuration:
+
+```bash
+sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"
+```
+
+This creates `~/.oh-my-zsh` directory and a basic `~/.zshrc` file.
+
+## Essential Plugins
+
+### 1. Zsh Autosuggestions
+
+Suggests commands as you type based on history and completions:
+
+```bash
+git clone https://github.com/zsh-users/zsh-autosuggestions ~/.zsh/zsh-autosuggestions
+```
+
+### 2. Zsh Syntax Highlighting
+
+Provides syntax highlighting for the shell:
+
+```bash
+git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting
+```
+
+### 3. Configure Plugins in .zshrc
+
+Add to your `~/.zshrc`:
+
+```bash
+# Oh My Zsh path
+export ZSH="$HOME/.oh-my-zsh"
+
+# Plugins configuration
+plugins=(
+    git
+    zsh-autosuggestions
+    zsh-syntax-highlighting
+)
+
+# Source Oh My Zsh (commented out if using Starship)
+# source $ZSH/oh-my-zsh.sh
+
+# Source autosuggestions manually if needed
+source ~/.zsh/zsh-autosuggestions/zsh-autosuggestions.zsh
+```
+
+## Starship Prompt
+
+Starship is a minimal, blazing-fast, and customizable prompt for any shell.
+
+### Installation
+
+```bash
+curl -sS https://starship.rs/install.sh | sh
+```
+
+### Configuration
+
+Add to the end of your `~/.zshrc`:
+
+```bash
+eval "$(starship init zsh)"
+```
+
+### Starship Configuration File
+
+You can customize starship by creating/editing `~/.config/starship.toml`.
+
+I recommend this `catppuccin` preset:
+
+```bash
+starship preset catppuccin-powerline -o ~/.config/starship.toml
+```
+
+But if you want to tweak it, see the starship config docs.
+https://starship.rs/guide/
+
+## Enhanced Directory Listings with eza
+
+Eza is a modern replacement for `ls` with colors, icons, and Git integration.
+
+### Installation
+
+```bash
+brew install eza
+```
+
+### Configuration
+
+Add these aliases to your `~/.zshrc` to replace default `ls` commands:
+
+```bash
+# Replace ls with eza for beautiful directory listings
+alias ls='eza --icons --group-directories-first'
+alias ll='eza -l --icons --group-directories-first --header'
+alias la='eza -la --icons --group-directories-first --header'
+alias lt='eza --tree --icons --level=2'
+alias ltd='eza --tree --icons --level=2 --only-dirs'
+
+# Extended eza aliases
+alias l='eza -lbF --git --icons'                # list with git status
+alias llm='eza -lbGd --git --sort=modified'     # long list, modified date sort
+alias lls='eza -lbhHigmuSa --time-style=long-iso --git --color-scale'  # full details
+```
+
+### Features
+
+- **Icons**: Shows file type icons (requires a Nerd Font)
+- **Colors**: Color-codes files by type and permissions
+- **Git Integration**: Shows git status in listings
+- **Tree View**: Built-in tree view with `--tree` flag
+- **Sorting**: Groups directories first by default
+
+### Usage Examples
+
+```bash
+ls              # Basic listing with icons
+ll              # Long format with details
+la              # Show hidden files
+lt              # Tree view (2 levels)
+l               # List with git status indicators
+```
+
+## Terminal Title Management
+
+Add custom terminal title that shows current directory:
+
+```bash
+# Disable auto-setting terminal title
+DISABLE_AUTO_TITLE="true"
+
+# Set terminal title to current directory
+function precmd () {
+  echo -ne "\033]0;$(print -rD $PWD)\007"
+}
+precmd
+
+# Show command being executed in title with rocket emojis
+function preexec () {
+  print -Pn "\e]0;🚀 $(print -rD $PWD) $1 🚀\a"
+}
+```
+
+## History Search Enhancement
+
+### Option 1: Atuin (Modern Shell History)
+
+Install Atuin for enhanced history search:
+
+```bash
+brew install atuin
+```
+
+Configure in `~/.zshrc`:
+
+```bash
+export ATUIN_NOBIND="true"
+eval "$(atuin init zsh)"
+# Bind to up arrow keys (depends on terminal)
+bindkey '^[[A' _atuin_search_widget
+bindkey '^[OA' _atuin_search_widget
+```
+
+### Option 2: HSTR (Simple History Search)
+
+```bash
+brew install hstr
+```
+
+Configure in `~/.zshrc`:
+
+```bash
+alias hh=hstr
+setopt histignorespace           # skip cmds w/ leading space from history
+export HSTR_CONFIG=hicolor       # get more colors
+bindkey -s "\C-r" "\C-a hstr -- \C-j"  # bind hstr to Ctrl-r
+```
+
+## Useful Aliases
+
+Add these productivity aliases to your `~/.zshrc`:
+
+```bash
+# Git aliases
+alias gsuno="git status -uno"        # git status without untracked files
+alias gspu="git stash push -m"       # stash with message
+alias gspop="git stash pop"          # pop stash
+alias gsl="git stash list"           # list stashes
+
+# Quick git commit amend and push
+function gcpq() {
+  ga -u
+  git commit --amend --no-edit
+  git push origin main --force-with-lease
+}
+
+# Tmux aliases
+alias tmnew="tmux new -s "
+alias tmls="tmux ls"
+alias tma="tmux a -t "
+alias tmk="tmux kill-session -t "
+alias tmd="tmux detach"
+```
+
+## Completion System
+
+Enable advanced tab completion:
+
+```bash
+autoload -Uz compinit
+zstyle ':completion:*' menu select
+fpath+=~/.zfunc
+```
+
+## Environment Variables
+
+Set common environment variables:
+
+```bash
+export EDITOR="nano"  # or "vim", "code", etc.
+export TERM=xterm-256color
+```
+
+## Final .zshrc Structure
+
+Your `~/.zshrc` should follow this general structure:
+
+```bash
+# 1. Oh My Zsh configuration
+export ZSH="$HOME/.oh-my-zsh"
+plugins=(git zsh-autosuggestions zsh-syntax-highlighting)
+
+# 2. Source additional files
+source ~/.zsh/zsh-autosuggestions/zsh-autosuggestions.zsh
+
+# 3. Environment variables
+export EDITOR="nano"
+export TERM=xterm-256color
+
+# 4. Aliases and functions
+alias gsuno="git status -uno"
+# ... more aliases
+
+# 5. Terminal title customization
+DISABLE_AUTO_TITLE="true"
+function precmd () { ... }
+function preexec () { ... }
+
+# 6. History search tool (Atuin or HSTR)
+eval "$(atuin init zsh)"
+
+# 7. Completion system
+autoload -Uz compinit
+zstyle ':completion:*' menu select
+
+# 8. Starship prompt (at the very end)
+eval "$(starship init zsh)"
+```
+
+## Verification
+
+After setup, verify everything works:
+
+```bash
+# Reload shell configuration
+source ~/.zshrc
+
+# Test autosuggestions (type a partial command and see suggestions)
+# Test syntax highlighting (commands should be colored)
+# Test Starship prompt (should see a styled prompt)
+```
+
+## Troubleshooting
+
+1. **Slow shell startup**: Comment out unused plugins and features
+2. **Autosuggestions not working**: Ensure the plugin is properly cloned and
+   sourced
+3. **Starship not showing**: Make sure it's the last line in `.zshrc`
+4. **Terminal title not updating**: Check if `DISABLE_AUTO_TITLE="true"` is set
+
+## Additional Resources
+
+- [Oh My Zsh Documentation](https://github.com/ohmyzsh/ohmyzsh/wiki)
+- [Starship Documentation](https://starship.rs/config/)
+- [Zsh Autosuggestions](https://github.com/zsh-users/zsh-autosuggestions)
+- [Atuin Documentation](https://github.com/atuinsh/atuin)

{claude_code_tools-0.1.13 → claude_code_tools-0.1.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "claude-code-tools"
-version = "0.1.13"
+version = "0.1.17"
 description = "Collection of tools for working with Claude Code"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -17,6 +17,7 @@ dev = ["commitizen>=3.0.0"]
 find-claude-session = "claude_code_tools.find_claude_session:main"
 vault = "claude_code_tools.dotenv_vault:main"
 tmux-cli = "claude_code_tools.tmux_cli_controller:main"
+env-safe = "claude_code_tools.env_safe:main"
 
 [build-system]
 requires = ["hatchling"]
@@ -40,7 +41,7 @@ exclude = [
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "0.1.13"
+version = "0.1.17"
 tag_format = "v$version"
 version_files = [
     "pyproject.toml:version",