overcode 0.1.5__tar.gz → 0.1.6__tar.gz

{overcode-0.1.5/src/overcode.egg-info → overcode-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: overcode
-Version: 0.1.5
+Version: 0.1.6
 Summary: A supervisor for managing multiple Claude Code instances in tmux
 Author: Mike Bond
 Project-URL: Homepage, https://github.com/mkb23/overcode

{overcode-0.1.5 → overcode-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "overcode"
-version = "0.1.5"
+version = "0.1.6"
 description = "A supervisor for managing multiple Claude Code instances in tmux"
 authors = [
     {name = "Mike Bond"}

overcode-0.1.6/src/overcode/__init__.py

@@ -0,0 +1,14 @@
+"""
+Overcode - A supervisor for managing multiple Claude Code instances.
+"""
+
+from pathlib import Path
+
+_toml = Path(__file__).resolve().parent.parent.parent / "pyproject.toml"
+if _toml.is_file():
+    import tomllib
+    with open(_toml, "rb") as _f:
+        __version__ = tomllib.load(_f)["project"]["version"]
+else:
+    from importlib.metadata import version as _version
+    __version__ = _version("overcode")

overcode-0.1.6/src/overcode/claude_config.py

@@ -0,0 +1,90 @@
+"""Read and write Claude Code settings.json files.
+
+Provides a reusable editor for Claude Code's JSON settings, with
+convenience methods for managing hooks.
+"""
+
+from __future__ import annotations
+
+import copy
+import json
+from pathlib import Path
+
+
+class ClaudeConfigEditor:
+    """Read and write Claude Code settings.json files."""
+
+    def __init__(self, path: Path):
+        self.path = Path(path)
+
+    @classmethod
+    def user_level(cls) -> ClaudeConfigEditor:
+        """Editor for user-level settings (~/.claude/settings.json)."""
+        return cls(Path.home() / ".claude" / "settings.json")
+
+    @classmethod
+    def project_level(cls, project_dir: Path | None = None) -> ClaudeConfigEditor:
+        """Editor for project-level settings (.claude/settings.json).
+
+        Args:
+            project_dir: Project root. Defaults to cwd.
+        """
+        base = Path(project_dir) if project_dir else Path.cwd()
+        return cls(base / ".claude" / "settings.json")
+
+    def load(self) -> dict:
+        """Load settings from file.
+
+        Returns empty dict if file doesn't exist.
+        Raises ValueError on invalid JSON or non-object content.
+        """
+        if not self.path.exists():
+            return {}
+        text = self.path.read_text()
+        try:
+            data = json.loads(text)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Invalid JSON in {self.path}: {e}") from e
+        if not isinstance(data, dict):
+            raise ValueError(f"{self.path} contains non-object JSON")
+        return data
+
+    def save(self, settings: dict) -> None:
+        """Write settings to file. Creates parent dirs as needed."""
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.path.write_text(json.dumps(settings, indent=2) + "\n")
+
+    def has_hook(self, event: str, command: str) -> bool:
+        """Check if a command hook exists for the given event."""
+        settings = self.load()
+        for entry in settings.get("hooks", {}).get(event, []):
+            for hook in entry.get("hooks", []):
+                if hook.get("command") == command:
+                    return True
+        return False
+
+    def add_hook(self, event: str, command: str, matcher: str = "") -> bool:
+        """Add a command hook for an event.
+
+        Returns True if the hook was added, False if it already exists.
+        """
+        settings = self.load()
+        # Check existing
+        for entry in settings.get("hooks", {}).get(event, []):
+            for hook in entry.get("hooks", []):
+                if hook.get("command") == command:
+                    return False
+
+        updated = copy.deepcopy(settings)
+        if "hooks" not in updated:
+            updated["hooks"] = {}
+        if event not in updated["hooks"]:
+            updated["hooks"][event] = []
+
+        updated["hooks"][event].append({
+            "matcher": matcher,
+            "hooks": [{"type": "command", "command": command}],
+        })
+
+        self.save(updated)
+        return True

{overcode-0.1.5 → overcode-0.1.6}/src/overcode/cli.py

@@ -16,7 +16,8 @@ from .launcher import ClaudeLauncher
 app = typer.Typer(
     name="overcode",
     help="Manage and supervise Claude Code agents",
-    no_args_is_help=True,
+    no_args_is_help=False,
+    invoke_without_command=True,
     rich_markup_mode="rich",
 )
 
@@ -62,6 +63,15 @@ SessionOption = Annotated[
 ]
 
 
+@app.callback(invoke_without_command=True)
+def main_callback(ctx: typer.Context):
+    """Launch the TUI monitor when no command is given."""
+    if ctx.invoked_subcommand is None:
+        from .tui import run_tui
+
+        run_tui("agents")
+
+
 # =============================================================================
 # Agent Commands
 # =============================================================================
@@ -235,6 +245,40 @@ def set_value(
     rprint(f"[green]✓ Set {name} value to {value}[/green]")
 
 
+@app.command(name="set-budget")
+def set_budget(
+    name: Annotated[str, typer.Argument(help="Name of agent")],
+    budget: Annotated[float, typer.Argument(help="Budget in USD (0 to clear)")],
+    session: SessionOption = "agents",
+):
+    """Set cost budget for an agent (#173).
+
+    When an agent's estimated cost reaches the budget, heartbeats are
+    disabled and supervision is skipped.
+
+    Examples:
+        overcode set-budget my-agent 5.00    # $5 budget
+        overcode set-budget my-agent 0       # Clear budget
+    """
+    from .session_manager import SessionManager
+
+    manager = SessionManager()
+    agent = manager.get_session_by_name(name)
+    if not agent:
+        rprint(f"[red]Error: Agent '{name}' not found[/red]")
+        raise typer.Exit(code=1)
+
+    if budget < 0:
+        rprint("[red]Error: Budget cannot be negative[/red]")
+        raise typer.Exit(code=1)
+
+    manager.set_cost_budget(agent.id, budget)
+    if budget > 0:
+        rprint(f"[green]✓ Set {name} budget to ${budget:.2f}[/green]")
+    else:
+        rprint(f"[green]✓ Cleared budget for {name}[/green]")
+
+
 @app.command()
 def send(
     name: Annotated[str, typer.Argument(help="Name of agent")],
@@ -283,20 +327,235 @@ def show(
     lines: Annotated[
         int, typer.Option("--lines", "-n", help="Number of lines to show")
     ] = 50,
+    no_stats: Annotated[
+        bool, typer.Option("--no-stats", help="Skip stats, show only pane output")
+    ] = False,
+    stats_only: Annotated[
+        bool, typer.Option("--stats-only", "-s", help="Show only stats, no pane output")
+    ] = False,
     session: SessionOption = "agents",
 ):
-    """Show recent output from an agent."""
+    """Show agent details and recent output."""
+    from .status_detector import StatusDetector
+    from .history_reader import get_session_stats
+    from .status_patterns import extract_background_bash_count, extract_live_subagent_count, strip_ansi
+    from .tui_helpers import (
+        calculate_uptime, format_duration, format_tokens, format_cost,
+        format_line_count, get_current_state_times, get_status_symbol,
+        get_git_diff_stats,
+    )
+    from .monitor_daemon_state import get_monitor_daemon_state
+
     launcher = ClaudeLauncher(session)
 
-    output = launcher.get_session_output(name, lines=lines)
-    if output is not None:
-        print(f"=== {name} (last {lines} lines) ===")
-        print(output)
-        print(f"=== end {name} ===")
+    # Get the Session object
+    sess = launcher.sessions.get_session_by_name(name)
+    if sess is None:
+        rprint(f"[red]✗[/red] Agent '[bold]{name}[/bold]' not found")
+        raise typer.Exit(1)
+
+    # Detect live status (gets status + pane content with ANSI for bash count)
+    pane_content_raw = ""
+    if sess.status == "terminated":
+        status = "terminated"
+        activity = "(tmux window no longer exists)"
+    else:
+        status_detector = StatusDetector(session)
+        status, activity, pane_content_raw = status_detector.detect_status(sess)
+
+    if sess.is_asleep:
+        status = "asleep"
+
+    if not no_stats:
+        # Gather all stats
+        bg_bash_count = extract_background_bash_count(pane_content_raw) if pane_content_raw else 0
+        live_sub_count = extract_live_subagent_count(pane_content_raw) if pane_content_raw else 0
+
+        claude_stats = None
+        try:
+            claude_stats = get_session_stats(sess)
+        except Exception:
+            pass
+
+        git_diff = None
+        try:
+            if sess.start_directory:
+                git_diff = get_git_diff_stats(sess.start_directory)
+        except Exception:
+            pass
+
+        uptime = calculate_uptime(sess.start_time) if sess.start_time else "-"
+        green_time, non_green_time, sleep_time = get_current_state_times(
+            sess.stats, is_asleep=sess.is_asleep
+        )
+        active_time = green_time + non_green_time
+        active_pct = (green_time / active_time * 100) if active_time > 0 else 0
+
+        ai_short = ""
+        ai_context = ""
+        try:
+            daemon_state = get_monitor_daemon_state(session)
+            if daemon_state:
+                ds = daemon_state.get_session_by_name(name)
+                if ds:
+                    ai_short = ds.activity_summary or ""
+                    ai_context = ds.activity_summary_context or ""
+        except Exception:
+            pass
+
+        # Status line
+        symbol, _ = get_status_symbol(status)
+        time_in_state = ""
+        if sess.stats.state_since:
+            try:
+                from datetime import datetime
+                elapsed = (datetime.now() - datetime.fromisoformat(sess.stats.state_since)).total_seconds()
+                time_in_state = f" ({format_duration(elapsed)})"
+            except (ValueError, TypeError):
+                pass
+
+        # Permissiveness emoji
+        perm_map = {"bypass": "🔥 bypass", "permissive": "🏃 permissive", "normal": "👮 normal"}
+        perm_display = perm_map.get(sess.permissiveness_mode, sess.permissiveness_mode)
+
+        # Render stats
+        print(f"=== {name} ===")
+        print(f"Status:    {symbol} {status}{time_in_state:<16} Uptime:  {uptime}")
+        repo_info = f"{sess.repo_name or '-'}:{sess.branch or '-'}"
+        tc_display = "🕐 enabled" if sess.time_context_enabled else "disabled"
+        print(f"Repo:      {repo_info:<28} Mode:    {perm_display}")
+        print(f"Time ctx:  {tc_display}")
+
+        # Time
+        time_str = f"▶ {format_duration(green_time):>5} active  ⏸ {format_duration(non_green_time):>5} stalled  💤 {format_duration(sleep_time):>5} sleep  ({active_pct:.0f}%)"
+        print(f"Time:      {time_str}")
+
+        # Tokens & cost
+        if claude_stats:
+            token_str = f"Σ {format_tokens(claude_stats.total_tokens)}"
+            if claude_stats.current_context_tokens > 0:
+                ctx_pct = min(100, claude_stats.current_context_tokens / 200_000 * 100)
+                token_str += f" (context {ctx_pct:.0f}%)"
+            cost = sess.stats.estimated_cost_usd
+            budget = sess.cost_budget_usd
+            if budget > 0:
+                cost_display = f"{format_cost(cost)}/{format_cost(budget)}"
+            else:
+                cost_display = format_cost(cost)
+            print(f"Tokens:    {token_str:<28} Cost:    {cost_display}")
+
+            # Work & interactions
+            median_work = claude_stats.median_work_time
+            work_str = format_duration(median_work) if median_work > 0 else "-"
+            human_count = max(0, claude_stats.interaction_count - sess.stats.steers_count)
+            print(f"Work:      ⏱ {work_str} median{'':<18} Interactions: 👤 {human_count} human 🤖 {sess.stats.steers_count} robot")
+        else:
+            print(f"Tokens:    -")
+
+        # Git
+        if git_diff:
+            files, ins, dels = git_diff
+            print(f"Git:       Δ{files} files +{format_line_count(ins)} -{format_line_count(dels)}")
+
+        # Subagents & background bashes (live counts from status bar)
+        print(f"Agents:    🤿 {live_sub_count} subagents  🐚 {bg_bash_count} background bashes")
+
+        # Standing orders
+        if sess.standing_instructions:
+            prefix = "✓ " if sess.standing_orders_complete else ""
+            instr = sess.standing_instructions[:80]
+            print(f"Orders:    📋 {prefix}{instr}")
+
+        # AI summaries
+        if ai_short:
+            print(f"AI:        {ai_short}")
+        if ai_context:
+            print(f"Context:   {ai_context}")
+
+        # Activity from status detector
+        if activity:
+            print(f"Activity:  {activity[:100]}")
+
+        print()
+
+    # Pane output section (skip if --stats-only or --lines 0)
+    if not stats_only and lines > 0:
+        if pane_content_raw:
+            clean_content = strip_ansi(pane_content_raw)
+            content_lines = clean_content.rstrip().split('\n')
+            display_lines = content_lines[-lines:]
+            print(f"=== {name} (last {lines} lines) ===")
+            print('\n'.join(display_lines))
+            print(f"=== end {name} ===")
+        else:
+            # Fallback for terminated sessions
+            output = launcher.get_session_output(name, lines=lines)
+            if output is not None:
+                print(f"=== {name} (last {lines} lines) ===")
+                print(output)
+                print(f"=== end {name} ===")
+            else:
+                rprint(f"[dim]No pane output available[/dim]")
+
+
+@app.command("time-context")
+def time_context():
+    """Output a compact time-awareness line for Claude Code hooks.
+
+    Called by a UserPromptSubmit hook on every prompt. Outputs a single
+    line with clock, presence, office hours, uptime, and heartbeat info.
+    Silently exits when not in an overcode-managed session (env vars missing).
+    """
+    from .time_context import get_agent_identity, generate_time_context
+
+    name, tmux = get_agent_identity()
+    if not name or not tmux:
+        raise typer.Exit(0)
+
+    line = generate_time_context(tmux, name)
+    if not line:
+        raise typer.Exit(0)
+    print(line)
+
+
+@app.command("install-hook")
+def install_hook(
+    project: Annotated[
+        bool,
+        typer.Option("--project", "-p", help="Install to project-level .claude/settings.json instead of user-level"),
+    ] = False,
+):
+    """Install the time-context hook into Claude Code settings.
+
+    By default installs to user-level settings (~/.claude/settings.json).
+    Use --project to install to the current project's .claude/settings.json.
+
+    The hook runs 'overcode time-context' on every prompt, giving Claude
+    continuous awareness of clock, presence, office hours, and uptime.
+    """
+    from .claude_config import ClaudeConfigEditor
+
+    if project:
+        editor = ClaudeConfigEditor.project_level()
+        level = "project"
     else:
-        rprint(f"[red]✗[/red] Could not get output from '[bold]{name}[/bold]'")
+        editor = ClaudeConfigEditor.user_level()
+        level = "user"
+
+    try:
+        added = editor.add_hook("UserPromptSubmit", "overcode time-context")
+    except ValueError as e:
+        rprint(f"[red]Error:[/red] {e}")
         raise typer.Exit(1)
 
+    if added:
+        rprint(f"[green]\u2713[/green] Installed time-context hook in {level} settings")
+        rprint(f"  [dim]{editor.path}[/dim]")
+        rprint(f"\n  [dim]The hook runs 'overcode time-context' on every prompt.[/dim]")
+        rprint(f"  [dim]Toggle per-agent with F in the TUI.[/dim]")
+    else:
+        rprint(f"[green]\u2713[/green] Hook already installed in {level} settings ({editor.path})")
+
 
 @app.command()
 def instruct(
@@ -375,6 +634,154 @@ def instruct(
             rprint(f"[dim]Tip: Use 'overcode presets' to see available presets[/dim]")
 
 
+@app.command()
+def heartbeat(
+    name: Annotated[str, typer.Argument(help="Name of agent")],
+    enable: Annotated[
+        bool, typer.Option("--enable", "-e", help="Enable heartbeat")
+    ] = False,
+    disable: Annotated[
+        bool, typer.Option("--disable", "-d", help="Disable heartbeat")
+    ] = False,
+    pause: Annotated[
+        bool, typer.Option("--pause", help="Pause heartbeat (keep config)")
+    ] = False,
+    resume: Annotated[
+        bool, typer.Option("--resume", help="Resume paused heartbeat")
+    ] = False,
+    frequency: Annotated[
+        Optional[str], typer.Option("--frequency", "-f", help="Interval (e.g., 300, 5m, 1h)")
+    ] = None,
+    instruction: Annotated[
+        Optional[str], typer.Option("--instruction", "-i", help="Instruction to send")
+    ] = None,
+    show: Annotated[
+        bool, typer.Option("--show", "-s", help="Show current heartbeat config")
+    ] = False,
+    session: SessionOption = "agents",
+):
+    """Configure heartbeat for an agent (#171).
+
+    Heartbeat sends a periodic instruction to keep agents active or provide
+    regular status updates. The instruction is sent at the configured frequency.
+
+    Examples:
+        overcode heartbeat my-agent --show              # Show current config
+        overcode heartbeat my-agent -e -f 5m -i "Status check"  # Enable
+        overcode heartbeat my-agent --pause             # Temporarily pause
+        overcode heartbeat my-agent --resume            # Resume
+        overcode heartbeat my-agent --disable           # Disable completely
+    """
+    from .session_manager import SessionManager
+    from .tui_helpers import format_duration
+
+    manager = SessionManager()
+    agent = manager.get_session_by_name(name)
+    if not agent:
+        rprint(f"[red]Error: Agent '{name}' not found[/red]")
+        raise typer.Exit(code=1)
+
+    # Parse frequency if provided
+    freq_seconds = None
+    if frequency:
+        freq = frequency.strip().lower()
+        try:
+            if freq.endswith('s'):
+                freq_seconds = int(freq[:-1])
+            elif freq.endswith('m'):
+                freq_seconds = int(freq[:-1]) * 60
+            elif freq.endswith('h'):
+                freq_seconds = int(freq[:-1]) * 3600
+            else:
+                freq_seconds = int(freq)
+        except ValueError:
+            rprint(f"[red]Error: Invalid frequency format '{frequency}'[/red]")
+            rprint("[dim]Use: 300, 5m, or 1h[/dim]")
+            raise typer.Exit(code=1)
+
+        if freq_seconds < 30:
+            rprint("[red]Error: Minimum heartbeat interval is 30 seconds[/red]")
+            raise typer.Exit(code=1)
+
+    # Show current config
+    if show or (not enable and not disable and not pause and not resume
+                and not frequency and not instruction):
+        if agent.heartbeat_enabled:
+            freq_str = format_duration(agent.heartbeat_frequency_seconds)
+            status = "[yellow]paused[/yellow]" if agent.heartbeat_paused else "[green]enabled[/green]"
+            rprint(f"Heartbeat for '[bold]{name}[/bold]': {status}")
+            rprint(f"  Frequency: {freq_str}")
+            rprint(f"  Instruction: {agent.heartbeat_instruction or '(none)'}")
+            if agent.last_heartbeat_time:
+                rprint(f"  Last sent: {agent.last_heartbeat_time}")
+        else:
+            rprint(f"Heartbeat for '[bold]{name}[/bold]': [dim]disabled[/dim]")
+        return
+
+    # Disable
+    if disable:
+        manager.update_session(
+            agent.id,
+            heartbeat_enabled=False,
+            heartbeat_paused=False,
+            heartbeat_instruction="",
+        )
+        rprint(f"[green]✓ Heartbeat disabled for {name}[/green]")
+        return
+
+    # Pause
+    if pause:
+        if not agent.heartbeat_enabled:
+            rprint(f"[yellow]Heartbeat is not enabled for {name}[/yellow]")
+            return
+        manager.update_session(agent.id, heartbeat_paused=True)
+        rprint(f"[green]✓ Heartbeat paused for {name}[/green]")
+        return
+
+    # Resume
+    if resume:
+        if not agent.heartbeat_enabled:
+            rprint(f"[yellow]Heartbeat is not enabled for {name}[/yellow]")
+            return
+        manager.update_session(agent.id, heartbeat_paused=False)
+        rprint(f"[green]✓ Heartbeat resumed for {name}[/green]")
+        return
+
+    # Enable with frequency and instruction
+    if enable:
+        if not instruction:
+            rprint("[red]Error: --instruction required when enabling heartbeat[/red]")
+            raise typer.Exit(code=1)
+
+        final_freq = freq_seconds or 300  # Default 5 minutes
+        manager.update_session(
+            agent.id,
+            heartbeat_enabled=True,
+            heartbeat_paused=False,
+            heartbeat_frequency_seconds=final_freq,
+            heartbeat_instruction=instruction,
+        )
+        rprint(f"[green]✓ Heartbeat enabled for {name}[/green]")
+        rprint(f"  Frequency: {format_duration(final_freq)}")
+        rprint(f"  Instruction: {instruction}")
+        return
+
+    # Update frequency or instruction without full enable
+    updates = {}
+    if freq_seconds:
+        updates['heartbeat_frequency_seconds'] = freq_seconds
+    if instruction:
+        updates['heartbeat_instruction'] = instruction
+
+    if updates:
+        manager.update_session(agent.id, **updates)
+        rprint(f"[green]✓ Heartbeat config updated for {name}[/green]")
+        if freq_seconds:
+            rprint(f"  Frequency: {format_duration(freq_seconds)}")
+        if instruction:
+            rprint(f"  Instruction: {instruction}")
+
+
 # =============================================================================
 # Monitoring Commands
 # =============================================================================
@@ -383,11 +790,25 @@ def instruct(
 @app.command()
 def monitor(
     session: SessionOption = "agents",
+    restart: Annotated[
+        bool, typer.Option("--restart", help="Restart the monitor daemon before launching")
+    ] = False,
     diagnostics: Annotated[
         bool, typer.Option("--diagnostics", help="Diagnostic mode: disable all auto-refresh timers")
     ] = False,
 ):
     """Launch the standalone TUI monitor."""
+    if restart:
+        from .monitor_daemon import stop_monitor_daemon, is_monitor_daemon_running, get_monitor_daemon_pid
+
+        if is_monitor_daemon_running(session):
+            pid = get_monitor_daemon_pid(session)
+            if stop_monitor_daemon(session):
+                rprint(f"[green]✓[/green] Monitor daemon stopped (was PID {pid})")
+            else:
+                rprint("[red]Failed to stop monitor daemon[/red]")
+                raise typer.Exit(1)
+
     from .tui import run_tui
 
     run_tui(session, diagnostics=diagnostics)
@@ -844,6 +1265,12 @@ CONFIG_TEMPLATE = """\
 #     - name: "Full Day"
 #       start: "09:00"
 #       end: "17:00"
+
+# Time context hook settings (for 'overcode time-context')
+# time_context:
+#   office_start: 9
+#   office_end: 17
+#   heartbeat_interval_minutes: 15  # omit to disable
 """
 
 

{overcode-0.1.5 → overcode-0.1.6}/src/overcode/config.py

@@ -185,3 +185,26 @@ def get_web_time_presets() -> list:
         {"name": "Evening", "start": "18:00", "end": "22:00"},
         {"name": "All Time", "start": None, "end": None},
     ]
+
+
+def get_time_context_config() -> dict:
+    """Get time context configuration for the time-context hook.
+
+    Config format in ~/.overcode/config.yaml:
+        time_context:
+          office_start: 9
+          office_end: 17
+          heartbeat_interval_minutes: 15  # omit to disable
+
+    Returns:
+        Dict with office_start (int), office_end (int),
+        heartbeat_interval_minutes (Optional[int])
+    """
+    config = load_config()
+    tc = config.get("time_context", {})
+
+    return {
+        "office_start": tc.get("office_start", 9),
+        "office_end": tc.get("office_end", 17),
+        "heartbeat_interval_minutes": tc.get("heartbeat_interval_minutes"),
+    }

{overcode-0.1.5 → overcode-0.1.6}/src/overcode/daemon_utils.py

@@ -7,6 +7,7 @@ avoiding code duplication between monitor_daemon and supervisor_daemon.
 
 import os
 import signal
+import time
 from pathlib import Path
 from typing import Callable, Optional, Tuple
 
@@ -75,6 +76,14 @@ def create_daemon_helpers(
 
         try:
             os.kill(pid, signal.SIGTERM)
+            # Wait for process to actually terminate before removing PID file
+            start = time.time()
+            while time.time() - start < 5.0:
+                try:
+                    os.kill(pid, 0)
+                    time.sleep(0.1)
+                except (OSError, ProcessLookupError):
+                    break
             remove_pid_file(pid_path)
             return True
         except (OSError, ProcessLookupError):