claude-code-tools 0.1.14__py3-none-any.whl → 0.1.18__py3-none-any.whl

claude_code_tools/__init__.py

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

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/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/tmux_remote_controller.py

@@ -1,69 +1,229 @@
 #!/usr/bin/env python3
 """
-Remote Tmux Controller - Stub implementation
-This is a minimal stub to prevent import errors when tmux-cli is used outside tmux.
+Remote Tmux Controller
+
+Enables tmux-cli to work when run outside of tmux by:
+- Auto-creating a detached tmux session on first use
+- Managing commands in separate tmux windows (not panes)
+- Providing an API compatible with the local (pane) controller
 """
 
 import subprocess
-from typing import Optional, List, Dict
+import time
+import hashlib
+from typing import Optional, List, Dict, Tuple, Union
 
 
 class RemoteTmuxController:
-    """Stub implementation of RemoteTmuxController to prevent import errors."""
+    """Remote controller that manages a dedicated tmux session and windows."""
     
     def __init__(self, session_name: str = "remote-cli-session"):
-        """Initialize with session name."""
+        """Initialize with session name and ensure the session exists."""
         self.session_name = session_name
-        print(f"Warning: RemoteTmuxController is not fully implemented.")
-        print(f"Remote mode functionality is currently unavailable.")
-        print(f"Please use tmux-cli from inside a tmux session for full functionality.")
+        self.target_window: Optional[str] = None  # e.g., "session:0" (active pane in that window)
+        print(f"Note: tmux-cli is running outside tmux. Managing windows in session '{session_name}'.")
+        print("For better integration, consider running from inside a tmux session.")
+        print("Use 'tmux-cli attach' to view the remote session.")
+        self._ensure_session()
+    
+    # ----------------------------
+    # Internal utilities
+    # ----------------------------
+    def _run_tmux(self, args: List[str]) -> Tuple[str, int]:
+        result = subprocess.run(
+            ['tmux'] + args,
+            capture_output=True,
+            text=True
+        )
+        return result.stdout.strip(), result.returncode
+    
+    def _ensure_session(self) -> None:
+        """Create the session if it doesn't exist (detached)."""
+        _, code = self._run_tmux(['has-session', '-t', self.session_name])
+        if code != 0:
+            # Create a detached session using user's default shell
+            # Return the session name just to force creation
+            self._run_tmux([
+                'new-session', '-d', '-s', self.session_name, '-P', '-F', '#{session_name}'
+            ])
+            # Remember first window as default target
+            self.target_window = f"{self.session_name}:0"
+        else:
+            # If already exists and we don't have a target, set to active window
+            if not self.target_window:
+                win, code2 = self._run_tmux(['display-message', '-p', '-t', self.session_name, '#{session_name}:#{window_index}'])
+                if code2 == 0 and win:
+                    self.target_window = win
+    
+    def _window_target(self, pane: Optional[str]) -> str:
+        """Resolve user-provided pane/window hint to a tmux target.
+        Accepts:
+        - None -> use last target window if set else active window in session
+        - digits (e.g., "1") -> session:index
+        - full tmux target (e.g., "name:1" or "name:1.0" or "%12") -> pass-through
+        """
+        self._ensure_session()
+        if pane is None:
+            if self.target_window:
+                return self.target_window
+            # Fallback to active window in session
+            win, code = self._run_tmux(['display-message', '-p', '-t', self.session_name, '#{session_name}:#{window_index}'])
+            if code == 0 and win:
+                self.target_window = win
+                return win
+            # Final fallback: session:0
+            return f"{self.session_name}:0"
+        # If user supplied a simple index
+        if isinstance(pane, str) and pane.isdigit():
+            return f"{self.session_name}:{pane}"
+        # Otherwise assume user provided a pane/window target or pane id
+        return pane
+    
+    def _active_pane_in_window(self, window_target: str) -> str:
+        """Return a target that tmux can use to address the active pane of a window.
+        For tmux commands that accept pane targets, a window target resolves to its
+        active pane, so we can pass the window target directly.
+        Still, normalize to make intent clear.
+        """
+        return window_target
     
     def list_panes(self) -> List[Dict[str, str]]:
-        """Return empty list."""
-        return []
+        """In remote mode, list windows in the managed session.
+        Returns a list shaped similarly to local list_panes, with keys:
+        id (window target), index, title (window name), active (bool), size (N/A)
+        """
+        self._ensure_session()
+        out, code = self._run_tmux([
+            'list-windows', '-t', self.session_name,
+            '-F', '#{window_index}|#{window_name}|#{window_active}|#{window_width}x#{window_height}'
+        ])
+        if code != 0 or not out:
+            return []
+        windows: List[Dict[str, str]] = []
+        for line in out.split('\n'):
+            if not line:
+                continue
+            idx, name, active, size = line.split('|')
+            windows.append({
+                'id': f"{self.session_name}:{idx}",
+                'index': idx,
+                'title': name,
+                'active': active == '1',
+                'size': size
+            })
+        return windows
     
     def launch_cli(self, command: str, name: Optional[str] = None) -> Optional[str]:
-        """Not implemented."""
-        raise NotImplementedError("Remote mode is not available. Please use tmux-cli from inside tmux.")
+        """Launch a command in a new window within the managed session.
+        Returns the window target (e.g., "session:1").
+        """
+        self._ensure_session()
+        args = ['new-window', '-t', self.session_name, '-P', '-F', '#{session_name}:#{window_index}']
+        if name:
+            args.extend(['-n', name])
+        if command:
+            args.append(command)
+        out, code = self._run_tmux(args)
+        if code == 0 and out:
+            self.target_window = out
+            return out
+        return None
     
     def send_keys(self, text: str, pane_id: Optional[str] = None, enter: bool = True,
-                  delay_enter: bool = True):
-        """Not implemented."""
-        raise NotImplementedError("Remote mode is not available. Please use tmux-cli from inside tmux.")
+                  delay_enter: Union[bool, float] = True):
+        """Send keys to the active pane of a given window (or last target)."""
+        if not text:
+            return
+        target = self._active_pane_in_window(self._window_target(pane_id))
+        if enter and delay_enter:
+            # First send text (no Enter)
+            self._run_tmux(['send-keys', '-t', target, text])
+            # Delay
+            delay = 1.0 if isinstance(delay_enter, bool) else float(delay_enter)
+            time.sleep(delay)
+            # Then Enter
+            self._run_tmux(['send-keys', '-t', target, 'Enter'])
+        else:
+            args = ['send-keys', '-t', target, text]
+            if enter:
+                args.append('Enter')
+            self._run_tmux(args)
     
     def capture_pane(self, pane_id: Optional[str] = None, lines: Optional[int] = None) -> str:
-        """Not implemented."""
-        raise NotImplementedError("Remote mode is not available. Please use tmux-cli from inside tmux.")
+        """Capture output from the active pane of a window."""
+        target = self._active_pane_in_window(self._window_target(pane_id))
+        args = ['capture-pane', '-t', target, '-p']
+        if lines:
+            args.extend(['-S', f'-{lines}'])
+        out, _ = self._run_tmux(args)
+        return out
     
     def wait_for_idle(self, pane_id: Optional[str] = None, idle_time: float = 2.0,
                      check_interval: float = 0.5, timeout: Optional[int] = None) -> bool:
-        """Not implemented."""
-        raise NotImplementedError("Remote mode is not available. Please use tmux-cli from inside tmux.")
+        """Wait until captured output is unchanged for idle_time seconds."""
+        target = self._active_pane_in_window(self._window_target(pane_id))
+        start_time = time.time()
+        last_change = time.time()
+        last_hash = ""
+        while True:
+            if timeout is not None and (time.time() - start_time) > timeout:
+                return False
+            content, _ = self._run_tmux(['capture-pane', '-t', target, '-p'])
+            h = hashlib.md5(content.encode()).hexdigest()
+            if h != last_hash:
+                last_hash = h
+                last_change = time.time()
+            else:
+                if (time.time() - last_change) >= idle_time:
+                    return True
+            time.sleep(check_interval)
     
     def send_interrupt(self, pane_id: Optional[str] = None):
-        """Not implemented."""
-        raise NotImplementedError("Remote mode is not available. Please use tmux-cli from inside tmux.")
+        target = self._active_pane_in_window(self._window_target(pane_id))
+        self._run_tmux(['send-keys', '-t', target, 'C-c'])
     
     def send_escape(self, pane_id: Optional[str] = None):
-        """Not implemented."""
-        raise NotImplementedError("Remote mode is not available. Please use tmux-cli from inside tmux.")
+        target = self._active_pane_in_window(self._window_target(pane_id))
+        self._run_tmux(['send-keys', '-t', target, 'Escape'])
     
     def kill_window(self, window_id: Optional[str] = None):
-        """Not implemented."""
-        raise NotImplementedError("Remote mode is not available. Please use tmux-cli from inside tmux.")
+        target = self._window_target(window_id)
+        # Ensure the target refers to a window (not a %pane id)
+        # If user passed a pane id like %12, tmux can still resolve to its window
+        self._run_tmux(['kill-window', '-t', target])
+        if self.target_window == target:
+            self.target_window = None
     
     def attach_session(self):
-        """Not implemented."""
-        raise NotImplementedError("Remote mode is not available. Please use tmux-cli from inside tmux.")
+        self._ensure_session()
+        # Attach will replace the current terminal view until the user detaches
+        subprocess.run(['tmux', 'attach-session', '-t', self.session_name])
     
     def cleanup_session(self):
-        """Not implemented."""
-        raise NotImplementedError("Remote mode is not available. Please use tmux-cli from inside tmux.")
+        self._run_tmux(['kill-session', '-t', self.session_name])
+        self.target_window = None
     
     def list_windows(self) -> List[Dict[str, str]]:
-        """Not implemented."""
-        raise NotImplementedError("Remote mode is not available. Please use tmux-cli from inside tmux.")
+        """List all windows in the managed session with basic info."""
+        self._ensure_session()
+        out, code = self._run_tmux(['list-windows', '-t', self.session_name, '-F', '#{window_index}|#{window_name}|#{window_active}'])
+        if code != 0 or not out:
+            return []
+        windows: List[Dict[str, str]] = []
+        for line in out.split('\n'):
+            if not line:
+                continue
+            idx, name, active = line.split('|')
+            # Try to get active pane id for each window (best effort)
+            pane_out, _ = self._run_tmux(['display-message', '-p', '-t', f'{self.session_name}:{idx}', '#{pane_id}'])
+            windows.append({
+                'index': idx,
+                'name': name,
+                'active': active == '1',
+                'pane_id': pane_out or ''
+            })
+        return windows
     
     def _resolve_pane_id(self, pane: Optional[str]) -> Optional[str]:
-        """Not implemented."""
-        raise NotImplementedError("Remote mode is not available. Please use tmux-cli from inside tmux.")
+        """Resolve user-provided identifier to a tmux target string for remote ops."""
+        return self._window_target(pane)

{claude_code_tools-0.1.14.dist-info → claude_code_tools-0.1.18.dist-info}/METADATA

@@ -1,7 +1,8 @@
 Metadata-Version: 2.4
 Name: claude-code-tools
-Version: 0.1.14
+Version: 0.1.18
 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?
+
+Claude Code is completely blocked from directly accessing .env files - no reading, writing, or editing allowed. This prevents both accidental exposure of API keys and unintended modifications. The `env-safe` command provides the only approved way for Claude Code to inspect environment configuration safely, while any modifications must be done manually outside of Claude Code.
+
 ## 🛡️ 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 all .env file operations (read/write/edit),
+  suggests `env-safe` command for safe inspection
 - **Context Management** - Blocks reading files >500 lines to prevent context
   bloat
 - **Command Enhancement** - Enforces ripgrep (`rg`) over grep for better
@@ -200,20 +235,26 @@ Code's behavior and prevent dangerous operations.
 
 ### Quick Setup
 
-1. Copy the sample hooks configuration:
-   ```bash
-   cp hooks/settings.sample.json hooks/settings.json
-   export CLAUDE_CODE_TOOLS_PATH=/path/to/claude-code-tools
-   ```
-
-2. Reference in your Claude Code settings or use `--hooks` flag:
-   ```bash
-   claude --hooks /path/to/hooks/settings.json
+1. Copy the hooks configuration from `hooks/settings.sample.json` 
+
+2. Add the hooks to your global Claude settings at `~/.claude/settings.json`:
+   - If the file doesn't exist, create it
+   - Copy the "hooks" section from settings.sample.json
+   - Replace `/path/to/claude-code-tools` with your actual path to this repository
+   
+   Example ~/.claude/settings.json:
+   ```json
+   {
+     "hooks": {
+       // ... hooks configuration from settings.sample.json ...
+     }
+   }
    ```
 
 ### Available Hooks
 
 - `bash_hook.py` - Comprehensive bash command safety checks
+- `env_file_protection_hook.py` - Blocks all .env file operations
 - `file_size_conditional_hook.py` - Prevents reading huge files
 - `grep_block_hook.py` - Enforces ripgrep usage
 - `notification_hook.sh` - Sends ntfy.sh notifications

claude_code_tools-0.1.18.dist-info/RECORD

@@ -0,0 +1,18 @@
+claude_code_tools/__init__.py,sha256=l3LA3WuWQ4uiYiBmrFu5kJhLChWwGUFgAm6V_K3XBhU,90
+claude_code_tools/dotenv_vault.py,sha256=KPI9NDFu5HE6FfhQUYw6RhdR-miN0ScJHsBg0OVG61k,9617
+claude_code_tools/env_safe.py,sha256=TSSkOjEpzBwNgbeSR-0tR1-pAW_qmbZNmn3fiAsHJ4w,7659
+claude_code_tools/find_claude_session.py,sha256=TfQWW2zMDJAnfLREt_P23BB6e9Qb-XS22SSEU80K-4Y,23524
+claude_code_tools/tmux_cli_controller.py,sha256=Af9XPPfKxB8FsT-wIxJBzhUUqTo2IpnCH6XzJDTnRo0,28454
+claude_code_tools/tmux_remote_controller.py,sha256=eY1ouLtUzJ40Ik4nqUBvc3Gl1Rx0_L4TFW4j708lgvI,9942
+docs/claude-code-chutes.md,sha256=jCnYAAHZm32NGHE0CzGGl3vpO_zlF_xdmr23YxuCjPg,8098
+docs/claude-code-tmux-tutorials.md,sha256=S-9U3a1AaPEBPo3oKpWuyOfKK7yPFOIu21P_LDfGUJk,7558
+docs/dot-zshrc.md,sha256=DC2fOiGrUlIzol6N_47CW53a4BsnMEvCnhlRRVxFCTc,7160
+docs/find-claude-session.md,sha256=fACbQP0Bj5jqIpNWk0lGDOQQaji-K9Va3gUv2RA47VQ,4284
+docs/reddit-post.md,sha256=ZA7kPoJNi06t6F9JQMBiIOv039ADC9lM8YXFt8UA_Jg,2345
+docs/tmux-cli-instructions.md,sha256=lQqKTI-uhH-EdU9P4To4GC10WJjj3VllAW4cxd8jfj8,4167
+docs/vault-documentation.md,sha256=5XzNpHyhGU38JU2hKEWEL1gdPq3rC2zBg8yotK4eNF4,3600
+claude_code_tools-0.1.18.dist-info/METADATA,sha256=NLlm1gDQL74h7IXXtvBqVX8TC6GBuTL4wydxt8SKsO4,12310
+claude_code_tools-0.1.18.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+claude_code_tools-0.1.18.dist-info/entry_points.txt,sha256=AdJXTNrrAbUp0EhSRQuA0IBjFLBUXdqh7nuBYVFEAig,224
+claude_code_tools-0.1.18.dist-info/licenses/LICENSE,sha256=BBQdOBLdFB3CEPmb3pqxeOThaFCIdsiLzmDANsCHhoM,1073
+claude_code_tools-0.1.18.dist-info/RECORD,,

{claude_code_tools-0.1.14.dist-info → claude_code_tools-0.1.18.dist-info}/entry_points.txt

@@ -1,4 +1,5 @@
 [console_scripts]
+env-safe = claude_code_tools.env_safe:main
 find-claude-session = claude_code_tools.find_claude_session:main
 tmux-cli = claude_code_tools.tmux_cli_controller:main
 vault = claude_code_tools.dotenv_vault:main

claude_code_tools-0.1.18.dist-info/licenses/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.

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.14.dist-info/RECORD

@@ -1,15 +0,0 @@
-claude_code_tools/__init__.py,sha256=_-QQFZ18-bFEW2GEAgme8FhI4Ejyk7Fxq8o0zPNtT9U,90
-claude_code_tools/dotenv_vault.py,sha256=KPI9NDFu5HE6FfhQUYw6RhdR-miN0ScJHsBg0OVG61k,9617
-claude_code_tools/find_claude_session.py,sha256=TfQWW2zMDJAnfLREt_P23BB6e9Qb-XS22SSEU80K-4Y,23524
-claude_code_tools/tmux_cli_controller.py,sha256=0PqWBhITw74TtOKAfiUJMyHEFVOlLp4sEYmSlDHyznc,27482
-claude_code_tools/tmux_remote_controller.py,sha256=uK9lJKrNz7_NeV1_V3BM-q0r6sRVmYfOR8H3zo5hfH8,3220
-docs/claude-code-chutes.md,sha256=jCnYAAHZm32NGHE0CzGGl3vpO_zlF_xdmr23YxuCjPg,8098
-docs/claude-code-tmux-tutorials.md,sha256=S-9U3a1AaPEBPo3oKpWuyOfKK7yPFOIu21P_LDfGUJk,7558
-docs/find-claude-session.md,sha256=fACbQP0Bj5jqIpNWk0lGDOQQaji-K9Va3gUv2RA47VQ,4284
-docs/reddit-post.md,sha256=ZA7kPoJNi06t6F9JQMBiIOv039ADC9lM8YXFt8UA_Jg,2345
-docs/tmux-cli-instructions.md,sha256=lQqKTI-uhH-EdU9P4To4GC10WJjj3VllAW4cxd8jfj8,4167
-docs/vault-documentation.md,sha256=5XzNpHyhGU38JU2hKEWEL1gdPq3rC2zBg8yotK4eNF4,3600
-claude_code_tools-0.1.14.dist-info/METADATA,sha256=mkXcHoHrAhUHp-4rYvAKD9qDA94C5hsPj9OSs1j2i9I,10313
-claude_code_tools-0.1.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-claude_code_tools-0.1.14.dist-info/entry_points.txt,sha256=yUTZlZ2jteoUZ9bGPvZKI9tjmohPDhRk1fovu5pZACM,181
-claude_code_tools-0.1.14.dist-info/RECORD,,