claude-code-tools 0.1.8__tar.gz → 0.1.10__tar.gz

{claude_code_tools-0.1.8 → claude_code_tools-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-tools
-Version: 0.1.8
+Version: 0.1.10
 Summary: Collection of tools for working with Claude Code
 Requires-Python: >=3.11
 Requires-Dist: click>=8.0.0

{claude_code_tools-0.1.8 → claude_code_tools-0.1.10}/claude_code_tools/__init__.py

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

{claude_code_tools-0.1.8 → claude_code_tools-0.1.10}/claude_code_tools/tmux_cli_controller.py

@@ -11,7 +11,74 @@ from typing import Optional, List, Dict, Tuple, Callable, Union
 import json
 import os
 import hashlib
-from pathlib import Path
+import importlib.resources
+
+
+def _load_help_text():
+    """Load help text from the package's docs directory."""
+    try:
+        # For development, try to load from the actual file system first
+        import pathlib
+        module_dir = pathlib.Path(__file__).parent
+        # Try looking in the parent directory (repo root) for docs
+        docs_file = module_dir.parent / 'docs' / 'tmux-cli-instructions.md'
+        if docs_file.exists():
+            return docs_file.read_text(encoding='utf-8')
+        
+        # For installed packages, use importlib.resources
+        if hasattr(importlib.resources, 'files'):
+            # Python 3.9+ style
+            import importlib.resources as resources
+            
+            # Try different possible locations for the docs
+            # 1. Try docs as a subdirectory within the package
+            try:
+                help_file = resources.files('claude_code_tools') / 'docs' / 'tmux-cli-instructions.md'
+                if help_file.is_file():
+                    return help_file.read_text(encoding='utf-8')
+            except:
+                pass
+            
+            # 2. Try accessing parent package to find docs at root level
+            try:
+                # This assumes docs/ is packaged at the same level as claude_code_tools/
+                package_root = resources.files('claude_code_tools').parent
+                help_file = package_root / 'docs' / 'tmux-cli-instructions.md'
+                if help_file.is_file():
+                    return help_file.read_text(encoding='utf-8')
+            except:
+                pass
+        
+        # Try pkg_resources as another fallback
+        try:
+            import pkg_resources
+            # Try different paths
+            for path in ['docs/tmux-cli-instructions.md', '../docs/tmux-cli-instructions.md']:
+                try:
+                    return pkg_resources.resource_string(
+                        'claude_code_tools', path
+                    ).decode('utf-8')
+                except:
+                    continue
+        except:
+            pass
+            
+    except Exception as e:
+        pass
+    
+    # If all else fails, return a basic help message
+    return """# tmux-cli Instructions
+
+Error: Could not load full documentation.
+
+Basic usage:
+- tmux-cli launch "command" - Launch a CLI application
+- tmux-cli send "text" --pane=PANE_ID - Send input to a pane
+- tmux-cli capture --pane=PANE_ID - Capture output from a pane
+- tmux-cli kill --pane=PANE_ID - Kill a pane
+- tmux-cli help - Display full help
+
+For full documentation, see docs/tmux-cli-instructions.md in the package repository."""
 
 
 class TmuxCLIController:
@@ -657,10 +724,6 @@ class CLI:
     
     def help(self):
         """Display tmux-cli usage instructions."""
-        # Find the instructions file relative to this module
-        module_dir = Path(__file__).parent.parent
-        instructions_file = module_dir / "docs" / "tmux-cli-instructions.md"
-        
         # Add mode-specific header
         mode_info = f"\n{'='*60}\n"
         if self.mode == 'local':
@@ -670,12 +733,7 @@ class CLI:
         mode_info += f"{'='*60}\n"
         
         print(mode_info)
-        
-        if instructions_file.exists():
-            print(instructions_file.read_text())
-        else:
-            print("Error: tmux-cli-instructions.md not found")
-            print(f"Expected location: {instructions_file}")
+        print(_load_help_text())
         
         if self.mode == 'remote':
             print("\n" + "="*60)

claude_code_tools-0.1.10/claude_code_tools/tmux_remote_controller.py

@@ -0,0 +1,69 @@
+#!/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.
+"""
+
+import subprocess
+from typing import Optional, List, Dict
+
+
+class RemoteTmuxController:
+    """Stub implementation of RemoteTmuxController to prevent import errors."""
+    
+    def __init__(self, session_name: str = "remote-cli-session"):
+        """Initialize with session name."""
+        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.")
+    
+    def list_panes(self) -> List[Dict[str, str]]:
+        """Return empty list."""
+        return []
+    
+    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.")
+    
+    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.")
+    
+    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.")
+    
+    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.")
+    
+    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.")
+    
+    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.")
+    
+    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.")
+    
+    def attach_session(self):
+        """Not implemented."""
+        raise NotImplementedError("Remote mode is not available. Please use tmux-cli from inside tmux.")
+    
+    def cleanup_session(self):
+        """Not implemented."""
+        raise NotImplementedError("Remote mode is not available. Please use tmux-cli from inside tmux.")
+    
+    def list_windows(self) -> List[Dict[str, str]]:
+        """Not implemented."""
+        raise NotImplementedError("Remote mode is not available. Please use tmux-cli from inside tmux.")
+    
+    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.")

{claude_code_tools-0.1.8 → claude_code_tools-0.1.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "claude-code-tools"
-version = "0.1.8"
+version = "0.1.10"
 description = "Collection of tools for working with Claude Code"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -23,6 +23,10 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [tool.hatch.build]
+include = [
+    "claude_code_tools/**/*.py",
+    "docs/*.md",
+]
 exclude = [
     "demos/",
     "*.mp4",
@@ -36,7 +40,7 @@ exclude = [
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "0.1.8"
+version = "0.1.10"
 tag_format = "v$version"
 version_files = [
     "pyproject.toml:version",

claude_code_tools-0.1.8/Makefile

@@ -1,36 +0,0 @@
-.PHONY: install release patch minor major dev-install help
-
-help:
-	@echo "Available commands:"
-	@echo "  make install      - Install in editable mode (for development)"
-	@echo "  make dev-install  - Install with dev dependencies (includes commitizen)"
-	@echo "  make release      - Bump patch version and install globally"
-	@echo "  make patch        - Bump patch version (0.0.X) and install"
-	@echo "  make minor        - Bump minor version (0.X.0) and install"
-	@echo "  make major        - Bump major version (X.0.0) and install"
-
-install:
-	uv tool install --force -e .
-
-dev-install:
-	uv pip install -e ".[dev]"
-
-release: patch
-
-patch:
-	@echo "Bumping patch version..."
-	uv run cz bump --increment PATCH --yes
-	uv tool install --force --reinstall .
-	@echo "Installation complete!"
-
-minor:
-	@echo "Bumping minor version..."
-	uv run cz bump --increment MINOR --yes
-	uv tool install --force --reinstall .
-	@echo "Installation complete!"
-
-major:
-	@echo "Bumping major version..."
-	uv run cz bump --increment MAJOR --yes
-	uv tool install --force --reinstall .
-	@echo "Installation complete!"

claude_code_tools-0.1.8/hooks/README.md

@@ -1,211 +0,0 @@
-# Claude Code Hooks
-
-This directory contains safety and utility hooks for Claude Code that enhance its
-behavior and prevent dangerous operations.
-
-## Overview
-
-Claude Code hooks are scripts that intercept tool operations to:
-- Prevent accidental data loss
-- Enforce best practices
-- Manage context size
-- Send notifications
-- Track operation state
-
-## Setup
-
-1. Copy `settings.sample.json` to `settings.json`:
-   ```bash
-   cp settings.sample.json settings.json
-   ```
-
-2. Set the `CLAUDE_CODE_TOOLS_PATH` environment variable:
-   ```bash
-   export CLAUDE_CODE_TOOLS_PATH=/path/to/claude-code-tools
-   ```
-
-3. Make hook scripts executable:
-   ```bash
-   chmod +x hooks/*.py hooks/*.sh
-   ```
-
-4. Place your `settings.json` at (or add contents to) your global claude location, e.g. `~/.claude/settings.json`` 
-
-## Hook Types
-
-### Notification Hooks
-
-Triggered for various events to send notifications.
-
-### PreToolUse Hooks
-
-Triggered before a tool executes. Can block operations by returning non-zero exit
-codes with error messages.
-
-### PostToolUse Hooks
-
-Triggered after a tool completes. Used for cleanup and state management.
-
-## Available Hooks
-
-### 1. notification_hook.sh
-
-**Type:** Notification  
-**Purpose:** Send notifications to ntfy.sh channel  
-**Behavior:**
-- Reads JSON input and extracts the 'message' field
-- Sends notification to ntfy.sh/cc-alerts channel
-- Never blocks operations
-
-**Configuration:** Update the ntfy.sh URL in the script if using a different
-channel.
-
-### 2. bash_hook.py
-
-**Type:** PreToolUse (Bash)  
-**Purpose:** Unified safety checks for bash commands  
-**Blocks:**
-- `rm` commands (enforces TRASH directory pattern)
-- Dangerous `git add` patterns (`-A`, `--all`, `.`, `*`)
-- Unsafe `git checkout` operations
-- Commands that could cause data loss
-
-**Features:**
-- Combines multiple safety checks
-- Provides helpful alternative suggestions
-- Prevents accidental file deletion and git mishaps
-
-### 3. file_size_conditional_hook.py
-
-**Type:** PreToolUse (Read)  
-**Purpose:** Prevent reading large files that bloat context  
-**Behavior:**
-- Main agent: Blocks files > 500 lines
-- Sub-agents: Blocks files > 10,000 lines
-- Binary files are always allowed
-- Considers offset/limit parameters
-
-**Suggestions:**
-- Use sub-agents for large file analysis
-- Use grep/search tools for specific content
-- Consider external tools for very large files
-
-### 4. pretask_subtask_flag.py & posttask_subtask_flag.py
-
-**Type:** PreToolUse/PostToolUse (Task)  
-**Purpose:** Track sub-agent execution state  
-**Behavior:**
-- Pre: Creates `.claude_in_subtask.flag` file
-- Post: Removes the flag file
-- Enables different behavior for sub-agents (like larger file limits)
-
-### 5. grep_block_hook.py
-
-**Type:** PreToolUse (Grep)  
-**Purpose:** Enforce use of ripgrep over grep  
-**Behavior:**
-- Always blocks grep commands
-- Suggests using `rg` (ripgrep) instead
-- Ensures better performance and features
-
-## Safety Features
-
-### Git Safety
-
-The bash hook includes comprehensive git safety:
-
-**Blocked Commands:**
-- `git add -A`, `git add --all`, `git add .`
-- `git commit -a` without message
-- `git checkout -f`, `git checkout .`
-- Operations that could lose uncommitted changes
-
-**Alternatives Suggested:**
-- `git add -u` for modified files
-- `git add <specific-files>` for targeted staging
-- `git stash` before dangerous operations
-- `git switch` for branch changes
-
-### File Deletion Safety
-
-**Instead of `rm`:**
-- Move files to `TRASH/` directory
-- Document in `TRASH-FILES.md` with reason
-- Preserves ability to recover files
-
-Example:
-```bash
-# Instead of: rm unwanted.txt
-mv unwanted.txt TRASH/
-echo "unwanted.txt - moved to TRASH/ - no longer needed" >> TRASH-FILES.md
-```
-
-### Context Management
-
-The file size hook prevents Claude from reading huge files that would:
-- Consume excessive context
-- Slow down processing
-- Potentially cause errors
-
-## Customization
-
-### Adding New Hooks
-
-1. Create your hook script in the `hooks/` directory
-2. Add it to your `settings.json`:
-   ```json
-   {
-     "matcher": "ToolName",
-     "hooks": [{
-       "type": "command",
-       "command": "$CLAUDE_CODE_TOOLS_PATH/hooks/your_hook.py"
-     }]
-   }
-   ```
-
-### Hook Return Codes
-
-- `0`: Allow operation to proceed
-- Non-zero: Block operation (error message goes to stderr)
-
-### Hook Input/Output
-
-Hooks receive:
-- Tool parameters as JSON on stdin
-- Environment variables with context
-
-Hooks output:
-- Approval/rejection via exit code
-- Error messages to stderr
-- Logs to stdout (not shown to user)
-
-## Best Practices
-
-1. **Make hooks fast** - They run synchronously before operations
-2. **Provide helpful errors** - Explain why operations are blocked
-3. **Suggest alternatives** - Help users accomplish their goals safely
-4. **Log for debugging** - Use stdout for diagnostic information
-5. **Test thoroughly** - Hooks can significantly impact Claude's behavior
-
-## Troubleshooting
-
-### Hooks not triggering
-
-- Verify `settings.json` is in the correct location
-- Check file permissions (`chmod +x`)
-- Ensure paths use `$CLAUDE_CODE_TOOLS_PATH`
-- Test with `echo` statements to debug
-
-### Operations being blocked unexpectedly
-
-- Check hook logic for edge cases
-- Review blocking conditions
-- Add logging to understand decisions
-- Consider making hooks more permissive for sub-agents
-
-### Performance issues
-
-- Hooks run synchronously - keep them fast
-- Avoid network calls in hooks
-- Cache results when possible
-- Consider async notifications post-operation

claude_code_tools-0.1.8/hooks/bash_hook.py

@@ -1,66 +0,0 @@
-#!/usr/bin/env python3
-"""
-Unified Bash hook that combines all bash command safety checks.
-This ensures that if ANY check wants to block, the command is blocked.
-"""
-import json
-import sys
-import os
-
-# Add hooks directory to Python path so we can import the other modules
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
-# Import check functions from other hooks
-from git_add_block_hook import check_git_add_command
-from git_checkout_safety_hook import check_git_checkout_command
-from rm_block_hook import check_rm_command
-
-
-def main():
-    data = json.load(sys.stdin)
-    
-    # Check if this is a Bash tool call
-    tool_name = data.get("tool_name")
-    if tool_name != "Bash":
-        print(json.dumps({"decision": "approve"}))
-        sys.exit(0)
-    
-    # Get the command being executed
-    command = data.get("tool_input", {}).get("command", "")
-    
-    # Run all checks - collect all blocking reasons
-    checks = [
-        check_rm_command,
-        check_git_add_command,
-        check_git_checkout_command,
-    ]
-    
-    blocking_reasons = []
-    
-    for check_func in checks:
-        should_block, reason = check_func(command)
-        if should_block:
-            blocking_reasons.append(reason)
-    
-    # If any check wants to block, block the command
-    if blocking_reasons:
-        # If multiple checks want to block, combine the reasons
-        if len(blocking_reasons) == 1:
-            combined_reason = blocking_reasons[0]
-        else:
-            combined_reason = "Multiple safety checks failed:\n\n"
-            for i, reason in enumerate(blocking_reasons, 1):
-                combined_reason += f"{i}. {reason}\n\n"
-        
-        print(json.dumps({
-            "decision": "block",
-            "reason": combined_reason
-        }, ensure_ascii=False))
-    else:
-        print(json.dumps({"decision": "approve"}))
-    
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

claude_code_tools-0.1.8/hooks/file_size_conditional_hook.py

@@ -1,96 +0,0 @@
-#!/usr/bin/env python3
-import os
-import json
-import sys
-import subprocess
-
-
-data = json.load(sys.stdin)
-
-# Check if we're in a subtask
-flag_file = '.claude_in_subtask.flag'
-is_main_agent = not os.path.exists(flag_file)
-# if os.path.exists(flag_file):
-#     print(json.dumps({"decision": "approve"}))
-#     sys.exit(0)
-
-# Check file size
-file_path = data.get("tool_input", {}).get("file_path")
-offset = data.get("tool_input", {}).get("offset",0)
-limit = data.get("tool_input", {}).get("limit",0) # 0 if absent
-
-if file_path and os.path.exists(file_path):
-    # Check if this is a binary file by examining its content
-    def is_binary_file(filepath):
-        """Check if a file is binary by looking for null bytes in first chunk"""
-        try:
-            with open(filepath, 'rb') as f:
-                # Read first 8192 bytes (or less if file is smaller)
-                chunk = f.read(8192)
-                if not chunk:  # Empty file
-                    return False
-                
-                # Files with null bytes are likely binary
-                if b'\x00' in chunk:
-                    return True
-                
-                # Try to decode as UTF-8
-                try:
-                    chunk.decode('utf-8')
-                    return False
-                except UnicodeDecodeError:
-                    return True
-        except Exception:
-            # If we can't read the file, assume it's binary to be safe
-            return True
-    
-    # Skip line count check for binary files
-    if is_binary_file(file_path):
-        print(json.dumps({"decision": "approve"}))
-        sys.exit(0)
-    
-    line_count = int(subprocess.check_output(['wc', '-l', file_path]).split()[0])
-    
-    # Compute effective number of lines to be read
-    if limit > 0:
-        # If limit is specified, we read from offset to offset+limit
-        effective_lines = min(limit, max(0, line_count - offset))
-    else:
-        # If no limit, we read from offset to end of file
-        effective_lines = max(0, line_count - offset)
-
-    if is_main_agent and line_count > 500:
-        print(json.dumps({
-            "decision": "block",
-            "reason": f"""
-                I see you are trying to read a file with {line_count} lines,
-                or a part of it. 
-                Please delegate the analysis to a SUB-AGENT using your Task tool,
-                so you don't bloat your context with the file content!
-                """,
-        }))
-        sys.exit(0)
-    elif (not is_main_agent) and line_count > 10_000:
-        # use gemini-cli to delegate the analysis
-        print(json.dumps({
-            "decision": "block",
-            "reason": f"""
-            File too large ({line_count} lines), please use the Gemini CLI
-            bash command to delegate the analysis to Gemini since it has
-            a 1M-token context window! This will help you avoid bloating 
-            your context.
-            
-            You can use Gemini CLI as in these EXAMPLES:
-            
-            `gemini -p "@src/somefile.py tell me at which line the definition of 
-                      the function 'my_function' is located"
-
-            `gemini -p "@package.json @src/index.js Analyze the dependencies used in the code"
-
-            See further guidelines in claude-mds/use-gemini-cli.md
-            """,
-        }))
-        sys.exit(0)
-
-print(json.dumps({"decision": "approve"}))
-sys.exit(0)

claude_code_tools-0.1.8/hooks/git_add_block_hook.py

@@ -1,73 +0,0 @@
-#!/usr/bin/env python3
-import re
-
-def check_git_add_command(command):
-    """
-    Check if a git add command contains dangerous patterns.
-    Returns tuple: (should_block: bool, reason: str or None)
-    """
-    # Normalize the command - handle multiple spaces, tabs, etc.
-    normalized_cmd = ' '.join(command.strip().split())
-    
-    # Pattern to match git add with problematic flags
-    # This catches: git add -A, git add --all, git add -a, git add ., and combined flags
-    git_add_pattern = re.compile(
-        r'^git\s+add\s+('
-        r'-[a-zA-Z]*[Aa][a-zA-Z]*|'  # Flags containing 'A' or 'a' (e.g., -A, -a, -fA, -Af)
-        r'--all|'                     # Long form --all
-        r'\.|'                        # git add . (adds everything in current dir)
-        r'\*'                         # git add * (shell expansion of all files)
-        r')', re.IGNORECASE
-    )
-    
-    if git_add_pattern.search(normalized_cmd):
-        reason = """DO NOT use 'git add -A', 'git add -a', 'git add --all', 'git add .' or 'git add *' as they add ALL files!
-        
-Instead, use one of these commands:
-- 'git add -u' to stage all modified and deleted files (but not untracked)
-- 'git add <specific-files>' to stage specific files you want
-- 'gsuno' (alias for 'git status -uno') to see modified files only
-- 'gcam "message"' to commit all modified files with a message
-
-This restriction prevents accidentally staging unwanted files."""
-        return True, reason
-    
-    # Also check for git commit -a without -m (which would open an editor)
-    # Check if command has -a flag but no -m flag
-    if re.search(r'^git\s+commit\s+', normalized_cmd):
-        has_a_flag = re.search(r'-[a-zA-Z]*a[a-zA-Z]*', normalized_cmd)
-        has_m_flag = re.search(r'-[a-zA-Z]*m[a-zA-Z]*', normalized_cmd)
-        if has_a_flag and not has_m_flag:
-            reason = """Avoid 'git commit -a' without a message flag. Use 'gcam "message"' instead, which is an alias for 'git commit -a -m'."""
-            return True, reason
-    
-    return False, None
-
-
-# If run as a standalone script
-if __name__ == "__main__":
-    import json
-    import sys
-    
-    data = json.load(sys.stdin)
-    
-    # Check if this is a Bash tool call
-    tool_name = data.get("tool_name")
-    if tool_name != "Bash":
-        print(json.dumps({"decision": "approve"}))
-        sys.exit(0)
-    
-    # Get the command being executed
-    command = data.get("tool_input", {}).get("command", "")
-    
-    should_block, reason = check_git_add_command(command)
-    
-    if should_block:
-        print(json.dumps({
-            "decision": "block",
-            "reason": reason
-        }))
-    else:
-        print(json.dumps({"decision": "approve"}))
-    
-    sys.exit(0)