claudechic 0.2.2__py3-none-any.whl → 0.3.1__py3-none-any.whl

claudechic/commands.py

@@ -54,8 +54,22 @@ def handle_command(app: "ChatApp", prompt: str) -> bool:
         app._handle_usage_command()
         return True
 
-    if cmd == "/model":
-        app._handle_model_prompt()
+    if cmd == "/model" or cmd.startswith("/model "):
+        parts = cmd.split(maxsplit=1)
+        if len(parts) == 1:
+            # No argument - show prompt
+            app._handle_model_prompt()
+        else:
+            # Direct model selection: /model sonnet
+            model = parts[1].lower()
+            valid_models = {"opus", "sonnet", "haiku"}
+            if model not in valid_models:
+                app.notify(
+                    f"Invalid model '{model}'. Use: opus, sonnet, haiku",
+                    severity="error",
+                )
+            else:
+                app._set_agent_model(model)
         return True
 
     if cmd == "/exit":
@@ -65,6 +79,17 @@ def handle_command(app: "ChatApp", prompt: str) -> bool:
     if cmd == "/welcome":
         return _handle_welcome(app)
 
+    if cmd == "/help":
+        app.run_worker(_handle_help(app))
+        return True
+
+    if cmd == "/processes":
+        _handle_processes(app)
+        return True
+
+    if cmd.startswith("/analytics"):
+        return _handle_analytics(app, cmd)
+
     return False
 
 
@@ -91,7 +116,7 @@ def _handle_agent(app: "ChatApp", command: str) -> bool:
         # In narrow mode, open the sidebar overlay instead of listing
         width = app.size.width
         has_content = (
-            len(app.agents) > 1 or app.agent_sidebar._worktrees or app.todo_panel.todos
+            len(app.agents) > 1 or app.agent_section._worktrees or app.todo_panel.todos
         )
         if width < app.SIDEBAR_MIN_WIDTH and has_content:
             app._sidebar_overlay_open = True
@@ -123,10 +148,37 @@ def _handle_agent(app: "ChatApp", command: str) -> bool:
         app._close_agent(target)
         return True
 
-    # Create new agent
+    # Check if agent with this name exists - switch to it
     name = subcommand
-    path = Path(parts[2]) if len(parts) > 2 else Path.cwd()
-    app._create_new_agent(name, path)
+    existing = app.agent_mgr.find_by_name(name) if app.agent_mgr else None
+    if existing:
+        app._switch_to_agent(existing.id)
+        return True
+
+    # Create new agent - parse optional --model flag (supports --model=x or --model x)
+    cwd: Path | None = None
+    model = None
+    valid_models = {"opus", "sonnet", "haiku"}
+    args = parts[2:]
+    i = 0
+    while i < len(args):
+        part = args[i]
+        if part.startswith("--model="):
+            model = part[8:].lower()
+        elif part == "--model" and i + 1 < len(args):
+            model = args[i + 1].lower()
+            i += 1
+        elif not part.startswith("-") and cwd is None:
+            cwd = Path(part)
+        i += 1
+    if model and model not in valid_models:
+        app.notify(
+            f"Invalid model '{model}'. Use: opus, sonnet, haiku", severity="error"
+        )
+        return True
+    # Default to current agent's cwd, fallback to app's cwd
+    default_cwd = app._agent.cwd if app._agent else Path.cwd()
+    app._create_new_agent(name, cwd or default_cwd, model=model)
     return True
 
 
@@ -239,6 +291,11 @@ Claude Chic is open source and written in Python with Textual.  It's easy to ext
 
 **Example:** Use simple quality of life features like shell support with `!ls`. or `!git diff`.
 
+For more information, read
+[the docs](https://matthewrocklin.com/claudechic),
+[GitHub](https://github.com/mrocklin/claudechic),
+or this [introductory video](https://www.youtube.com/watch?v=2HcORToX5sU).
+
 Enjoy!
 
 ---
@@ -299,3 +356,60 @@ def _handle_compactish(app: "ChatApp", command: str) -> bool:
         app.notify("Session compacted", timeout=3)
 
     return True
+
+
+async def _handle_help(app: "ChatApp") -> None:
+    """Display help information."""
+    from claudechic.help_data import format_help
+    from claudechic.widgets import ChatMessage
+
+    agent = app._agent
+    help_text = await format_help(agent)
+
+    chat_view = app._chat_view
+    if chat_view:
+        msg = ChatMessage(help_text)
+        msg.add_class("system-message")
+        chat_view.mount(msg)
+        chat_view.scroll_if_tailing()
+
+
+def _handle_processes(app: "ChatApp") -> None:
+    """Show process modal with current background processes."""
+    from claudechic.widgets.modals.process_modal import ProcessModal
+
+    agent = app._agent
+    if agent:
+        processes = agent.get_background_processes()
+    else:
+        processes = []
+    app.push_screen(ProcessModal(processes))
+
+
+def _handle_analytics(app: "ChatApp", command: str) -> bool:
+    """Handle /analytics commands: opt-in, opt-out."""
+    from claudechic.config import (
+        get_analytics_enabled,
+        get_analytics_id,
+        set_analytics_enabled,
+    )
+
+    parts = command.split()
+    subcommand = parts[1] if len(parts) > 1 else ""
+
+    if subcommand == "opt-in":
+        set_analytics_enabled(True)
+        app.notify("Analytics enabled")
+        return True
+
+    if subcommand == "opt-out":
+        set_analytics_enabled(False)
+        app.notify("Analytics disabled")
+        return True
+
+    # Show current status
+    enabled = get_analytics_enabled()
+    user_id = get_analytics_id()
+    status = "enabled" if enabled else "disabled"
+    app.notify(f"Analytics {status}, ID: {user_id[:8]}...")
+    return True

claudechic/config.py

@@ -0,0 +1,80 @@
+"""Configuration management for claudechic via ~/.claude/claudechic.yaml."""
+
+import uuid
+from pathlib import Path
+
+import yaml
+
+CONFIG_PATH = Path.home() / ".claude" / "claudechic.yaml"
+
+_config: dict = {}
+_loaded: bool = False
+_new_install: bool = False  # True if analytics ID was just created
+
+
+def _load_config() -> dict:
+    """Load config from disk, creating with defaults if missing."""
+    global _config, _loaded, _new_install
+    if _loaded:
+        return _config
+
+    if CONFIG_PATH.exists():
+        with open(CONFIG_PATH) as f:
+            _config = yaml.safe_load(f) or {}
+    else:
+        _config = {}
+
+    # Ensure analytics section with defaults
+    if "analytics" not in _config:
+        _config["analytics"] = {}
+    if "enabled" not in _config["analytics"]:
+        _config["analytics"]["enabled"] = True
+    if "id" not in _config["analytics"]:
+        _config["analytics"]["id"] = str(uuid.uuid4())
+        _new_install = True
+        _save_config()
+
+    _loaded = True
+    return _config
+
+
+def _save_config() -> None:
+    """Write config to disk."""
+    if not _config:
+        return
+    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with open(CONFIG_PATH, "w") as f:
+        yaml.dump(_config, f, default_flow_style=False)
+
+
+def get_analytics_enabled() -> bool:
+    """Check if analytics collection is enabled."""
+    return _load_config()["analytics"]["enabled"]
+
+
+def get_analytics_id() -> str:
+    """Get the anonymous analytics ID, generating if needed."""
+    return _load_config()["analytics"]["id"]
+
+
+def set_analytics_enabled(enabled: bool) -> None:
+    """Enable or disable analytics collection."""
+    _load_config()["analytics"]["enabled"] = enabled
+    _save_config()
+
+
+def get_theme() -> str | None:
+    """Get saved theme preference, or None if not set."""
+    return _load_config().get("theme")
+
+
+def set_theme(theme: str) -> None:
+    """Save theme preference."""
+    _load_config()["theme"] = theme
+    _save_config()
+
+
+def is_new_install() -> bool:
+    """Check if this is a new install (analytics ID was just created)."""
+    _load_config()  # Ensure config is loaded
+    return _new_install

claudechic/features/worktree/commands.py

@@ -9,9 +9,11 @@ from textual.containers import Center
 from textual import work
 
 from claudechic.features.worktree.git import (
+    FinishInfo,
     FinishPhase,
     FinishState,
     ResolutionAction,
+    WorktreeInfo,
     WorktreeStatus,
     clean_gitignored_files,
     cleanup_worktrees,
@@ -27,7 +29,7 @@ from claudechic.features.worktree.git import (
     remove_worktree,
     start_worktree,
 )
-from claudechic.features.worktree.prompts import (
+from claudechic.widgets.prompts import (
     UncommittedChangesPrompt,
     WorktreePrompt,
 )
@@ -59,6 +61,8 @@ def handle_worktree_command(app: "ChatApp", command: str) -> None:
     elif subcommand == "cleanup":
         branches = parts[2].split() if len(parts) > 2 else None
         _handle_cleanup(app, branches)
+    elif subcommand == "discard":
+        _handle_discard(app)
     else:
         _switch_or_create_worktree(app, subcommand)
 
@@ -331,6 +335,71 @@ def _close_agents_for_branches(app: "ChatApp", branches: list[str]) -> None:
             app._do_close_agent(agent.id)
 
 
+def _handle_discard(app: "ChatApp") -> None:
+    """Handle /worktree discard command - discard current worktree entirely."""
+    success, message, info = get_finish_info(app.sdk_cwd)
+    if not success or info is None:
+        app.notify(message, severity="error")
+        return
+
+    status = diagnose_worktree(info)
+
+    # Check if there's anything to warn about
+    has_commits = status.commits_ahead > 0 and not status.is_merged
+    has_changes = status.has_uncommitted or status.untracked_other
+
+    if has_commits or has_changes:
+        _run_discard_prompt(app, info, status)
+    else:
+        _do_discard(app, info)
+
+
+def _do_discard(app: "ChatApp", info: FinishInfo) -> None:
+    """Force remove worktree and branch."""
+    wt = WorktreeInfo(path=info.worktree_dir, branch=info.branch_name, is_main=False)
+    success, msg = remove_worktree(wt, force=True)
+    if success:
+        app.notify(f"Discarded {info.branch_name}")
+        _close_agents_for_branches(app, [info.branch_name])
+    else:
+        app.notify(msg, severity="error")
+
+
+@work(group="discard_prompt", exclusive=True, exit_on_error=False)
+async def _run_discard_prompt(
+    app: "ChatApp", info: FinishInfo, status: WorktreeStatus
+) -> None:
+    """Prompt user to confirm discarding a worktree with commits/changes."""
+    from claudechic.widgets import SelectionPrompt, ChatInput
+
+    warnings = []
+    if status.commits_ahead > 0 and not status.is_merged:
+        warnings.append(f"{status.commits_ahead} unmerged commits")
+    if status.has_uncommitted:
+        warnings.append(f"{len(status.uncommitted_files)} uncommitted changes")
+    if status.untracked_other:
+        warnings.append(f"{len(status.untracked_other)} untracked files")
+
+    warning_text = ", ".join(warnings)
+    options = [
+        ("discard", f"Discard anyway ({warning_text})"),
+        ("cancel", "Cancel"),
+    ]
+
+    async with app._show_prompt(
+        SelectionPrompt(f"Discard {info.branch_name}?", options)
+    ) as prompt:
+        prompt.focus()
+        selected = await prompt.wait()
+
+    app.query_one("#input", ChatInput).focus()
+
+    if selected == "discard":
+        _do_discard(app, info)
+    else:
+        app.notify("Discard cancelled")
+
+
 def _handle_cleanup(app: "ChatApp", branches: list[str] | None) -> None:
     """Handle /worktree cleanup command."""
     results = cleanup_worktrees(branches)

claudechic/help_data.py

@@ -0,0 +1,200 @@
+"""Help data and formatting for /help command."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from claudechic.agent import Agent
+
+# Claudechic-specific commands
+CHIC_COMMANDS = [
+    ("/clear", "Clear chat and start new session"),
+    ("/resume [id]", "Resume a previous session"),
+    ("/agent [name] [path]", "Create or list agents"),
+    ("/shell <cmd>", "Run shell command (or -i for interactive)"),
+    ("/worktree <name>", "Create git worktree with agent"),
+    ("/compactish [-n]", "Compact session to reduce context"),
+    ("/usage", "Show API rate limit usage"),
+    ("/model", "Change model"),
+    ("/theme", "Search themes"),
+    ("/welcome", "Show welcome message"),
+    ("/help", "Show this help"),
+    ("/exit", "Quit"),
+    ("!<cmd>", "Shell command alias"),
+]
+
+# Keyboard shortcuts
+SHORTCUTS = [
+    ("Ctrl+C (x2)", "Quit"),
+    ("Ctrl+L", "Clear chat"),
+    ("Ctrl+S", "Screenshot"),
+    ("Shift+Tab", "Toggle auto-edit mode"),
+    ("Escape", "Cancel current action"),
+    ("Ctrl+N", "New agent hint"),
+    ("Ctrl+R", "History search"),
+    ("Ctrl+1-9", "Switch to agent by position"),
+    ("Enter", "Send message"),
+    ("Ctrl+J", "Insert newline"),
+    ("Up/Down", "Navigate input history"),
+]
+
+# MCP tools from claudechic (mcp.py)
+MCP_TOOLS = [
+    ("spawn_agent", "Create new Claude agent"),
+    ("spawn_worktree", "Create git worktree with agent"),
+    ("ask_agent", "Send question to another agent"),
+    ("tell_agent", "Send message without expecting reply"),
+    ("list_agents", "List all running agents"),
+    ("close_agent", "Close an agent by name"),
+]
+
+
+def _parse_skill_description(path: Path) -> str:
+    """Extract description from SKILL.md frontmatter."""
+    try:
+        content = path.read_text()
+        if content.startswith("---"):
+            end = content.find("---", 3)
+            if end > 0:
+                frontmatter = content[3:end]
+                for line in frontmatter.split("\n"):
+                    if line.startswith("description:"):
+                        return line.split(":", 1)[1].strip()
+    except Exception:
+        pass
+    return "No description"
+
+
+def discover_skills() -> list[tuple[str, str]]:
+    """Discover enabled skills from plugins."""
+    skills = []
+
+    # Read settings for enabled plugins
+    settings_path = Path.home() / ".claude" / "settings.json"
+    if not settings_path.exists():
+        return skills
+
+    try:
+        settings = json.loads(settings_path.read_text())
+    except Exception:
+        return skills
+
+    enabled = settings.get("enabledPlugins", {})
+
+    # Read installed plugins
+    installed_path = Path.home() / ".claude" / "plugins" / "installed_plugins.json"
+    if not installed_path.exists():
+        return skills
+
+    try:
+        installed = json.loads(installed_path.read_text())
+    except Exception:
+        return skills
+
+    for plugin_id, is_enabled in enabled.items():
+        if not is_enabled:
+            continue
+        if plugin_id not in installed.get("plugins", {}):
+            continue
+
+        installs = installed["plugins"][plugin_id]
+        if not installs:
+            continue
+
+        install_path = Path(installs[0]["installPath"])
+        skills_dir = install_path / "skills"
+        if not skills_dir.exists():
+            continue
+
+        for skill_dir in skills_dir.iterdir():
+            if not skill_dir.is_dir():
+                continue
+            skill_md = skill_dir / "SKILL.md"
+            if skill_md.exists():
+                desc = _parse_skill_description(skill_md)
+                # Format: plugin:skill or just skill if plugin matches
+                plugin_name = plugin_id.split("@")[0]
+                skill_name = skill_dir.name
+                if plugin_name == skill_name:
+                    skills.append((skill_name, desc))
+                else:
+                    skills.append((f"{plugin_name}:{skill_name}", desc))
+
+    return skills
+
+
+async def get_sdk_commands(agent: "Agent | None") -> list[tuple[str, str]]:
+    """Get commands from SDK server info."""
+    if not agent or not agent.client:
+        return []
+
+    try:
+        info = await agent.client.get_server_info()
+        if not info:
+            return []
+
+        return [
+            (f"/{cmd['name']}", cmd.get("description", ""))
+            for cmd in info.get("commands", [])
+        ]
+    except Exception:
+        return []
+
+
+async def format_help(agent: "Agent | None") -> str:
+    """Format complete help text as markdown."""
+    lines = ["# Help\n"]
+
+    # Discover skills first so we can filter them from SDK commands
+    skills = discover_skills()
+    skill_names = {name.split(":")[0] for name, _ in skills}  # e.g. "frontend-design"
+
+    # SDK commands (filter out skills which may appear here too)
+    sdk_cmds = await get_sdk_commands(agent)
+    sdk_cmds = [
+        (cmd, desc) for cmd, desc in sdk_cmds if cmd.lstrip("/") not in skill_names
+    ]
+    if sdk_cmds:
+        lines.append("## Claude Code Commands\n")
+        lines.append("| Command | Description |")
+        lines.append("|---------|-------------|")
+        for cmd, desc in sdk_cmds:
+            lines.append(f"| `{cmd}` | {desc} |")
+        lines.append("")
+
+    # Chic commands
+    lines.append("## Claudechic Commands\n")
+    lines.append("| Command | Description |")
+    lines.append("|---------|-------------|")
+    for cmd, desc in CHIC_COMMANDS:
+        lines.append(f"| `{cmd}` | {desc} |")
+    lines.append("")
+
+    # Skills (already discovered above for filtering)
+    if skills:
+        lines.append("## Skills\n")
+        lines.append("| Skill | Description |")
+        lines.append("|-------|-------------|")
+        for name, desc in skills:
+            lines.append(f"| `/{name}` | {desc} |")
+        lines.append("")
+
+    # MCP tools
+    lines.append("## MCP Tools (chic)\n")
+    lines.append("| Tool | Description |")
+    lines.append("|------|-------------|")
+    for name, desc in MCP_TOOLS:
+        lines.append(f"| `{name}` | {desc} |")
+    lines.append("")
+
+    # Shortcuts
+    lines.append("## Keyboard Shortcuts\n")
+    lines.append("| Key | Action |")
+    lines.append("|-----|--------|")
+    for key, action in SHORTCUTS:
+        lines.append(f"| `{key}` | {action} |")
+
+    return "\n".join(lines)

claudechic/messages.py

@@ -10,23 +10,6 @@ from claude_agent_sdk import (
 )
 
 
-class StreamChunk(Message):
-    """Message sent when a chunk of text is received from Claude."""
-
-    def __init__(
-        self,
-        text: str,
-        new_message: bool = False,
-        parent_tool_use_id: str | None = None,
-        agent_id: str | None = None,
-    ) -> None:
-        self.text = text
-        self.new_message = new_message  # Start a new ChatMessage widget
-        self.parent_tool_use_id = parent_tool_use_id  # If set, belongs to a Task
-        self.agent_id = agent_id  # Which agent this belongs to
-        super().__init__()
-
-
 class ResponseComplete(Message):
     """Message sent when Claude's response is complete."""
 

claudechic/processes.py

@@ -0,0 +1,120 @@
+"""Background process tracking and detection for Claude agents."""
+
+import re
+from dataclasses import dataclass
+from datetime import datetime
+
+import psutil
+
+
+@dataclass
+class BackgroundProcess:
+    """A background process being tracked."""
+
+    pid: int
+    command: str  # Short description of the command
+    start_time: datetime
+
+
+def _extract_command(cmdline: list[str]) -> str | None:
+    """Extract the user command from a shell cmdline.
+
+    Claude wraps commands like:
+      ['/bin/zsh', '-c', '-l', "source ... && eval 'sleep 30' ..."]
+
+    We want to extract just 'sleep 30'.
+    """
+    # Find the argument containing the actual command (after -c and optional -l)
+    cmd_arg = None
+    for i, arg in enumerate(cmdline):
+        if arg == "-c" and i + 1 < len(cmdline):
+            # Next non-flag arg is the command
+            for j in range(i + 1, len(cmdline)):
+                if not cmdline[j].startswith("-"):
+                    cmd_arg = cmdline[j]
+                    break
+            break
+
+    if not cmd_arg:
+        return None
+
+    # Try to extract from eval '...' pattern
+    match = re.search(r"eval ['\"](.+?)['\"] \\< /dev/null", cmd_arg)
+    if match:
+        return match.group(1)
+
+    # Try simpler eval pattern
+    match = re.search(r"eval ['\"](.+?)['\"]", cmd_arg)
+    if match:
+        return match.group(1)
+
+    # Fall back to full command (truncated)
+    return cmd_arg[:50] if len(cmd_arg) > 50 else cmd_arg
+
+
+def get_child_processes(claude_pid: int) -> list[BackgroundProcess]:
+    """Get background processes that are children of a claude process.
+
+    Args:
+        claude_pid: PID of the claude binary for an agent
+
+    Returns:
+        List of BackgroundProcess objects for active shell children
+    """
+    try:
+        claude_proc = psutil.Process(claude_pid)
+    except (psutil.NoSuchProcess, psutil.AccessDenied):
+        return []
+
+    processes = []
+    for child in claude_proc.children(recursive=True):
+        try:
+            name = child.name()
+            # Only track shell processes (where commands run)
+            if name not in ("zsh", "bash", "sh"):
+                continue
+
+            status = child.status()
+            if status == psutil.STATUS_ZOMBIE:
+                continue
+
+            # Extract the command being run
+            cmdline = child.cmdline()
+            command = _extract_command(cmdline)
+            if not command:
+                continue
+
+            # Filter out our own monitoring commands
+            if command.startswith("ps "):
+                continue
+
+            # Get start time
+            create_time = datetime.fromtimestamp(child.create_time())
+
+            processes.append(
+                BackgroundProcess(
+                    pid=child.pid, command=command, start_time=create_time
+                )
+            )
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            continue
+
+    return processes
+
+
+def get_claude_pid_from_client(client) -> int | None:
+    """Extract the claude process PID from an SDK client.
+
+    Args:
+        client: ClaudeSDKClient instance
+
+    Returns:
+        PID of the claude subprocess, or None if not available
+    """
+    try:
+        transport = client._transport
+        if transport and hasattr(transport, "_process") and transport._process:
+            return transport._process.pid
+    except Exception:
+        pass
+    return None