claude-code-tools 0.1.12__py3-none-any.whl → 0.1.14__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.12"
+__version__ = "0.1.14"

claude_code_tools/find_claude_session.py

@@ -38,19 +38,31 @@ except ImportError:
 console = Console() if RICH_AVAILABLE else None
 
 
-def get_claude_project_dir() -> Path:
+def get_claude_project_dir(claude_home: Optional[str] = None) -> Path:
     """Convert current working directory to Claude project directory path."""
     cwd = os.getcwd()
+    
+    # Use provided claude_home or default to ~/.claude
+    if claude_home:
+        base_dir = Path(claude_home).expanduser()
+    else:
+        base_dir = Path.home() / ".claude"
 
     # Replace / with - to match Claude's directory naming convention
     project_path = cwd.replace("/", "-")
-    claude_dir = Path.home() / ".claude" / "projects" / project_path
+    claude_dir = base_dir / "projects" / project_path
     return claude_dir
 
 
-def get_all_claude_projects() -> List[Tuple[Path, str]]:
+def get_all_claude_projects(claude_home: Optional[str] = None) -> List[Tuple[Path, str]]:
     """Get all Claude project directories with their original paths."""
-    projects_dir = Path.home() / ".claude" / "projects"
+    # Use provided claude_home or default to ~/.claude
+    if claude_home:
+        base_dir = Path(claude_home).expanduser()
+    else:
+        base_dir = Path.home() / ".claude"
+    
+    projects_dir = base_dir / "projects"
     
     if not projects_dir.exists():
         return []
@@ -109,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:
@@ -175,22 +199,23 @@ def get_session_preview(filepath: Path) -> str:
     return "No preview available"
 
 
-def find_sessions(keywords: List[str], global_search: bool = False) -> 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.
     
     Args:
         keywords: List of keywords to search for
         global_search: If True, search all projects; if False, search current project only
+        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 = []
     
     if global_search:
         # Search all projects
-        projects = get_all_claude_projects()
+        projects = get_all_claude_projects(claude_home)
         
         if RICH_AVAILABLE and console:
             with Progress(
@@ -207,12 +232,12 @@ def find_sessions(keywords: List[str], global_search: bool = False) -> List[Tupl
                     
                     # 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:
@@ -221,15 +246,15 @@ def find_sessions(keywords: List[str], global_search: bool = False) -> List[Tupl
                 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_dir = get_claude_project_dir(claude_home)
         
         if not claude_dir.exists():
             return []
@@ -238,12 +263,12 @@ def find_sessions(keywords: List[str], global_search: bool = False) -> List[Tupl
         
         # 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)
@@ -251,7 +276,7 @@ def find_sessions(keywords: List[str], global_search: bool = False) -> List[Tupl
     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
@@ -279,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
@@ -314,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()
@@ -327,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]")
 
 
@@ -438,6 +474,11 @@ To persist directory changes when resuming sessions:
         action="store_true",
         help="Output shell commands for evaluation (for use with shell function)"
     )
+    parser.add_argument(
+        "--claude-home",
+        type=str,
+        help="Path to Claude home directory (default: ~/.claude)"
+    )
     
     args = parser.parse_args()
     
@@ -450,7 +491,7 @@ To persist directory changes when resuming sessions:
     
     # Check if searching current project only
     if not getattr(args, 'global'):
-        claude_dir = get_claude_project_dir()
+        claude_dir = get_claude_project_dir(args.claude_home)
         
         if not claude_dir.exists():
             print(f"No Claude project directory found for: {os.getcwd()}", file=sys.stderr)
@@ -458,7 +499,7 @@ To persist directory changes when resuming sessions:
             sys.exit(1)
     
     # Find matching sessions
-    matching_sessions = find_sessions(keywords, global_search=getattr(args, 'global'))
+    matching_sessions = find_sessions(keywords, global_search=getattr(args, 'global'), claude_home=args.claude_home)
     
     if not matching_sessions:
         scope = "all projects" if getattr(args, 'global') else "current project"
@@ -478,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)
@@ -492,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:
@@ -503,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.12.dist-info → claude_code_tools-0.1.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-tools
-Version: 0.1.12
+Version: 0.1.14
 Summary: Collection of tools for working with Claude Code
 Requires-Python: >=3.11
 Requires-Dist: click>=8.0.0
@@ -12,10 +12,13 @@ Description-Content-Type: text/markdown
 
 # claude-code-tools
 
-A collection of practical tools, hooks, and utilities for enhancing Claude Code.
+A collection of practical tools, hooks, and utilities for enhancing Claude Code
+and other CLI coding agents.
 
 ## 🎮 tmux-cli: Bridging Claude Code and Interactive CLIs
 
+> **Note**: While the description below focuses on Claude Code, tmux-cli works with any CLI coding agent.
+
  ![tmux-cli demo](demos/tmux-cli-demo-short.gif)
 
 Consider these scenarios:
@@ -25,8 +28,9 @@ for user input, but CC can't respond to prompts.
 
 You want Claude Code to debug using pdb, stepping through code line by line.
 
-You need CC to launch another Claude Code instance for code review - not as a 
-hidden sub-agent, but as a visible session you can monitor (as shown in gif above).
+You need your CLI code agent to launch another instance of the same OR different 
+CLI code agent, AND interact with it, not as a hidden sub-agent, 
+but as a visible session you can monitor (as shown in gif above).
 
 **tmux-cli enables these workflows** by giving Claude Code programmatic control 
 over terminal applications.
@@ -47,7 +51,10 @@ use tmux-cli behind the scenes.
 ## 🚀 Quick Start
 
 ```bash
-# Install all the command-line tools
+# Install from PyPI (recommended)
+uv tool install claude-code-tools
+
+# Or install the latest development version from GitHub
 uv tool install git+https://github.com/pchalasani/claude-code-tools
 ```
 
@@ -111,7 +118,15 @@ Add this function to your shell config (.bashrc/.zshrc) for persistent directory
 changes:
 
 ```bash
-fcs() { eval "$(find-claude-session --shell "$@" | sed '/^$/d')"; }
+fcs() {
+    # Check if user is asking for help
+    if [[ "$1" == "--help" ]] || [[ "$1" == "-h" ]]; then
+        find-claude-session --help
+        return
+    fi
+    # Run find-claude-session in shell mode and evaluate the output
+    eval "$(find-claude-session --shell "$@" | sed '/^$/d')"
+}
 ```
 
 Or source the provided function:
@@ -142,6 +157,10 @@ won't persist after exiting Claude Code.
 
 For detailed documentation, see [docs/find-claude-session.md](docs/find-claude-session.md).
 
+Looks like this -- 
+
+![fcs.png](docs/fcs.png)
+
 ## 🔐 vault
 
 Centralized encrypted backup for .env files across all your projects using SOPS.

{claude_code_tools-0.1.12.dist-info → claude_code_tools-0.1.14.dist-info}/RECORD

@@ -1,13 +1,15 @@
-claude_code_tools/__init__.py,sha256=5y73ossjGhW7mbIf6P5lH6vZCjSHBixWmUA09OTZUQI,90
+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=k7K-lwHY2aEWEgUw92T_NT3ds6cGql9eq1CKQikig68,21295
+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.12.dist-info/METADATA,sha256=OB9c9watxAHAekzai5JteE9epGn3NK1nI5S6aMmn8KA,9767
-claude_code_tools-0.1.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-claude_code_tools-0.1.12.dist-info/entry_points.txt,sha256=yUTZlZ2jteoUZ9bGPvZKI9tjmohPDhRk1fovu5pZACM,181
-claude_code_tools-0.1.12.dist-info/RECORD,,
+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,,

docs/claude-code-chutes.md

@@ -0,0 +1,138 @@
+Here’s what I found (forums + docs) and the cleanest ways to run **Claude Code** against **Chutes (OpenAI-compatible) instead of Anthropic models**—including whether you need an extra router.
+
+---
+
+## TL;DR
+
+* **You can’t point Claude Code directly at Chutes** because Claude Code speaks the **Anthropic `/v1/messages`** format, while Chutes exposes an **OpenAI-compatible `/v1/chat/completions`** API. You need a **translator/gateway** in the middle. ([Anthropic][1])
+* Two working choices seen in the community and in Anthropic’s docs:
+
+  1. **Claude Code Router (CCR)** — purpose-built local proxy that converts Claude Code → OpenAI format; works with OpenRouter, DeepSeek, Groq, etc., and also with custom OpenAI-compatible bases like **Chutes**. ([GitHub][2], [npm][3])
+  2. **LiteLLM “Anthropic unified endpoint”** — run LiteLLM as a gateway that **exposes an Anthropic-style endpoint** to Claude Code, while LiteLLM calls Chutes behind the scenes using its **OpenAI-compatible** route. ([Anthropic][1], [LiteLLM][4], [LiteLLM][5])
+
+Reddit users repeatedly report running **Claude Code + Chutes** successfully (often with GLM-4.5, DeepSeek, or Kimi K2) by using a router/gateway. ([Reddit][6], [Reddit][7], [Reddit][8])
+
+---
+
+## Option A — Claude Code Router (simplest)
+
+**When to choose:** quick setup focused on Claude Code; easy model switching with `/model`.
+
+1. **Install**
+
+```bash
+npm i -g @anthropic-ai/claude-code @musistudio/claude-code-router
+```
+
+CCR runs a local server and translates requests for you. ([GitHub][2])
+
+2. **Configure CCR for Chutes**
+   Create `~/.claude-code-router/config.json` like:
+
+```json
+{
+  "Providers": [
+    {
+      "name": "chutes",
+      "api_base_url": "https://llm.chutes.ai/v1/chat/completions",
+      "api_keys": ["YOUR_CHUTES_API_KEY"],
+      "models": ["deepseek-ai/DeepSeek-V3-0324"],
+      "transformer": { "use": ["openrouter"] }
+    }
+  ],
+  "Router": { "default": "chutes,deepseek-ai/DeepSeek-V3-0324" }
+}
+```
+
+Notes:
+
+* Chutes’ **base URL** is OpenAI-style: `https://llm.chutes.ai/v1/chat/completions`. ([Reddit][9])
+* Model IDs vary (e.g., `deepseek-ai/DeepSeek-V3-0324`, `Qwen/Qwen3-235B-A22B`, `ZhipuAI/glm-4.5`)—grab the exact string from Chutes’ model page. ([Reddit][9])
+
+3. **Start CCR and point Claude Code at it**
+
+```bash
+ccr start
+export ANTHROPIC_BASE_URL=http://127.0.0.1:3456
+claude
+```
+
+CCR exposes an Anthropic-compatible endpoint; setting `ANTHROPIC_BASE_URL` makes Claude Code use it. In the Claude Code REPL you can switch models with `/model provider,model`. ([npm][3])
+
+**Community confirmation:** multiple Reddit threads mention using Claude Code with GLM-4.5/DeepSeek **via Chutes** (often preferring CCR). ([Reddit][6], [Reddit][7])
+**Video walkthroughs:** several YouTube explainers demo **Claude Code Router**, setup, and model routing. ([YouTube][10], [YouTube][11])
+
+---
+
+## Option B — LiteLLM “Anthropic unified endpoint” (more general)
+
+**When to choose:** you want observability, spend controls, or to route many providers with one gateway.
+
+1. **Define a LiteLLM model that points to Chutes**
+   Create `litellm_config.yaml`:
+
+```yaml
+model_list:
+  - model_name: chutes-deepseek-v3
+    litellm_params:
+      model: openai/deepseek-ai/DeepSeek-V3-0324   # tell LiteLLM it's OpenAI-compatible
+      api_base: https://llm.chutes.ai/v1           # base should include /v1
+      api_key: YOUR_CHUTES_API_KEY
+```
+
+LiteLLM’s OpenAI-compatible docs show the `openai/` prefix and the need for `/v1` in `api_base`. ([LiteLLM][5])
+
+2. **Run LiteLLM and expose an Anthropic-style endpoint**
+
+```bash
+litellm --config /path/to/litellm_config.yaml
+export ANTHROPIC_BASE_URL=http://127.0.0.1:4000
+claude
+```
+
+Anthropic’s **LLM Gateway** guide explicitly supports setting `ANTHROPIC_BASE_URL` to a LiteLLM endpoint that speaks the **Anthropic messages** format. ([Anthropic][1], [LiteLLM][4])
+
+**Working example calling Chutes through LiteLLM (code snippet/gist):** shows `api_base="https://llm.chutes.ai/v1"` and an `openai/...` model. ([Gist][12])
+
+---
+
+## Do you need “Claude Code Router”?
+
+* **You need some router/gateway.** Claude Code won’t talk directly to Chutes’ OpenAI endpoint. You can use **CCR** (purpose-built) **or** **LiteLLM** (general gateway). Anthropic’s own docs describe the LiteLLM route with `ANTHROPIC_BASE_URL`, which is often the most “officially documented” path. ([Anthropic][1])
+* If you already run LiteLLM for other projects, use **Option B**. If you just want the fastest path specifically for Claude Code, **Option A (CCR)** is very popular on Reddit/YouTube. ([Reddit][7], [YouTube][10])
+
+---
+
+## Model tips & quirks from forums
+
+* **GLM-4.5** and **DeepSeek** models are frequently called out as working well with Claude Code via Chutes (router required). ([Reddit][6])
+* Some users report **tool-call robustness varies by model** (e.g., mixed results for Qwen Coder vs GLM-4.5). Test your target model for tool use. ([Reddit][13])
+* Chutes availability/rate-limit errors happen occasionally; regenerating keys or retrial often resolves. Base URL must be exact. ([Reddit][9])
+
+---
+
+### Sources
+
+* Anthropic docs — **LLM Gateway configuration** (LiteLLM, `ANTHROPIC_BASE_URL`, Anthropic-format endpoint). ([Anthropic][1])
+* LiteLLM docs — **Anthropic unified endpoint** and **OpenAI-compatible** config (`openai/` model prefix, `/v1` base). ([LiteLLM][4], [LiteLLM][5])
+* **Claude Code Router** repo/features and usage, plus fork with added key rotation & commands. ([GitHub][2], [npm][3])
+* Reddit confirmations & how-tos (Chutes base URL, examples, and user reports running Claude Code + Chutes): ([Reddit][9], [Reddit][6], [Reddit][7])
+* YouTube demos of **Claude Code Router** setup/routing. ([YouTube][10], [YouTube][11])
+
+---
+
+If you’d like, tell me your target model on Chutes (e.g., DeepSeek V3, GLM-4.5, Kimi K2), and I’ll hand you an exact `config.json` (CCR) or `litellm_config.yaml` that you can paste in and run.
+
+[1]: https://docs.anthropic.com/en/docs/claude-code/llm-gateway "LLM gateway configuration - Anthropic"
+[2]: https://github.com/musistudio/claude-code-router "GitHub - musistudio/claude-code-router: Use Claude Code as the foundation for coding infrastructure, allowing you to decide how to interact with the model while enjoying updates from Anthropic."
+[3]: https://www.npmjs.com/package/%40tellerlin/claude-code-router?activeTab=code "@tellerlin/claude-code-router - npm"
+[4]: https://docs.litellm.ai/docs/anthropic_unified?utm_source=chatgpt.com "v1/messages"
+[5]: https://docs.litellm.ai/docs/providers/openai_compatible?utm_source=chatgpt.com "OpenAI-Compatible Endpoints"
+[6]: https://www.reddit.com/r/ChatGPTCoding/comments/1mcgm9s/psa_zaiglm45_is_absolutely_crushing_it_for_coding/?utm_source=chatgpt.com "zai/glm-4.5 is absolutely crushing it for coding - way better ..."
+[7]: https://www.reddit.com/r/LocalLLaMA/comments/1mchsyd/tutorial_use_glm_45_or_any_llm_with_claude_code/?utm_source=chatgpt.com "[tutorial] Use GLM 4.5 (or any LLM) with Claude Code"
+[8]: https://www.reddit.com/r/ClaudeAI/comments/1m3nyrn/who_is_using_claude_code_with_kimi_k2_thoughts/?utm_source=chatgpt.com "Who is using Claude Code with kimi k2? Thoughts? Tips?"
+[9]: https://www.reddit.com/r/JanitorAI_Official/comments/1ju5vih/visual_guide_for_deepseek_users_via_chutesai_full/ "Visual Guide for DeepSeek Users (via Chutes.ai) – Full Credit to u/r3dux1337! : r/JanitorAI_Official"
+[10]: https://www.youtube.com/watch?pp=0gcJCfwAo7VqN5tD&v=sAuCUAZnXAE&utm_source=chatgpt.com "Claude Code Router + Gemini 2.5 Pro FREE API: RIP Gemini ..."
+[11]: https://www.youtube.com/watch?v=df-Fu2n7SLM&utm_source=chatgpt.com "The Claude Code HACK Anthropic Does Not Want You To Use"
+[12]: https://gist.github.com/aquan9/58f4a77414a74703157bf79ea1bf009f?utm_source=chatgpt.com "Using litellm with chutes.ai from the bit-tensor chutes subnet."
+[13]: https://www.reddit.com/r/LocalLLaMA/comments/1mf8la7/qwen3coder_is_bad_at_tool_call_while_glm45_is/?utm_source=chatgpt.com "Qwen3-Coder is bad at tool call while glm-4.5 is ..."

docs/reddit-post.md

@@ -0,0 +1,55 @@
+# Made a tool that lets Claude Code control terminal apps - thought some of you might find it useful
+
+Hey everyone! I've been using Claude Code a lot lately and kept running into the same frustration - it couldn't interact with CLI applications that need user input. So I built something to fix that.
+
+## What it does
+
+It's basically like Playwright/Puppeteer but for the terminal. Claude Code can now:
+- Run interactive scripts and respond to prompts
+- Use debuggers like pdb to step through code
+- Launch and control other CLI apps
+- Even spin up another Claude Code instance to have it work as a sub-agent -- 
+  and unlike the built-in sub-agents, you can clearly see what's going on.
+
+[GIF PLACEHOLDER - Shows tmux-cli in action]
+
+## How it works
+
+The magic happens through tmux (terminal multiplexer). I created a tool called `tmux-cli` that gives Claude Code the ability to:
+- Launch apps in separate tmux panes
+- Send keystrokes to them
+- Capture their output
+- Wait for them to idle
+
+You don't need to know tmux commands - Claude Code handles everything. Just tell it what you want and it figures out the tmux stuff.
+
+## Real use cases I've found helpful
+
+- **Debugging**: Claude can now use pdb to step through Python code, examine variables, and help me understand program flow
+- **Testing interactive scripts**: No more manually entering test inputs - Claude handles it
+- **Spawn other Claudes**: I can have Claude launch another Claude instance to work on
+  a task and interact with it. And unlike the built-in sub-agents, it's fully visible.
+
+## Getting it
+
+If you want to try it:
+
+```bash
+# Install from PyPI
+uv tool install claude-code-tools
+
+# Or get latest from GitHub
+uv tool install git+https://github.com/pchalasani/claude-code-tools
+```
+
+Then add a snippet to your `~/.claude/CLAUDE.md` to let Claude Code know about tmux-cli.
+
+The repo also includes some other tools like encrypted .env backup and a Claude session finder, but tmux-cli is the main thing I wanted to share.
+
+## Not trying to oversell
+
+This isn't revolutionary or anything - it's just a practical tool that solved a real problem I kept hitting. If you work with Claude Code and interactive CLIs, you might find it useful too.
+
+Happy to answer questions or hear if anyone has similar tools they've built!
+
+Repo: https://github.com/pchalasani/claude-code-tools