erk 0.4.5__py3-none-any.whl

erk/cli/commands/branch/unassign_cmd.py

@@ -0,0 +1,197 @@
+"""Branch unassign command - remove a branch assignment from a pool slot."""
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import click
+
+from erk.cli.commands.slot.common import get_placeholder_branch_name
+from erk.cli.core import discover_repo_context
+from erk.core.context import ErkContext
+from erk.core.repo_discovery import RepoContext
+from erk.core.worktree_pool import (
+    PoolState,
+    SlotAssignment,
+    load_pool_state,
+    save_pool_state,
+)
+from erk_shared.output.output import user_output
+
+
+@dataclass(frozen=True)
+class UnassignResult:
+    """Result of an unassign operation."""
+
+    branch_name: str
+    slot_name: str
+    trunk_branch: str
+
+
+def execute_unassign(
+    ctx: ErkContext,
+    repo: RepoContext,
+    state: PoolState,
+    assignment: SlotAssignment,
+) -> UnassignResult:
+    """Execute the unassign operation for a pool slot.
+
+    This function handles:
+    - Checking for uncommitted changes
+    - Getting or creating placeholder branch
+    - Checking out placeholder branch
+    - Removing assignment from pool state
+
+    Args:
+        ctx: ErkContext with git operations
+        repo: Repository context
+        state: Current pool state
+        assignment: The assignment to remove
+
+    Returns:
+        UnassignResult with branch name, slot name, and trunk branch
+
+    Raises:
+        SystemExit: If worktree has uncommitted changes or placeholder branch cannot be determined
+    """
+    # Check for uncommitted changes before switching branches
+    if ctx.git.has_uncommitted_changes(assignment.worktree_path):
+        user_output(
+            f"Error: Worktree has uncommitted changes at {assignment.worktree_path}.\n"
+            "Commit or stash your changes before unassigning."
+        )
+        raise SystemExit(1) from None
+
+    # Get or create placeholder branch
+    placeholder_branch = get_placeholder_branch_name(assignment.slot_name)
+    if placeholder_branch is None:
+        user_output(
+            f"Error: Could not determine placeholder branch for slot {assignment.slot_name}."
+        )
+        raise SystemExit(1) from None
+
+    trunk_branch = ctx.git.detect_trunk_branch(repo.root)
+    local_branches = ctx.git.list_local_branches(repo.root)
+
+    if placeholder_branch not in local_branches:
+        ctx.git.create_branch(repo.root, placeholder_branch, trunk_branch)
+
+    # Checkout placeholder branch in the worktree
+    ctx.git.checkout_branch(assignment.worktree_path, placeholder_branch)
+
+    # Remove assignment from state (immutable update)
+    new_assignments = tuple(a for a in state.assignments if a.slot_name != assignment.slot_name)
+    new_state = PoolState(
+        version=state.version,
+        pool_size=state.pool_size,
+        slots=state.slots,
+        assignments=new_assignments,
+    )
+
+    # Save updated state (guard for dry-run mode)
+    if ctx.dry_run:
+        user_output("[DRY RUN] Would save pool state")
+    else:
+        save_pool_state(repo.pool_json_path, new_state)
+
+    return UnassignResult(
+        branch_name=assignment.branch_name,
+        slot_name=assignment.slot_name,
+        trunk_branch=trunk_branch,
+    )
+
+
+def _find_assignment_by_slot(state: PoolState, slot_name: str) -> SlotAssignment | None:
+    """Find an assignment by slot name.
+
+    Args:
+        state: Current pool state
+        slot_name: A slot name (e.g., "erk-managed-wt-01")
+
+    Returns:
+        SlotAssignment if found, None otherwise
+    """
+    for assignment in state.assignments:
+        if assignment.slot_name == slot_name:
+            return assignment
+    return None
+
+
+def _find_assignment_by_cwd(state: PoolState, cwd: Path) -> SlotAssignment | None:
+    """Find an assignment by checking if cwd is within a pool slot's worktree.
+
+    Args:
+        state: Current pool state
+        cwd: Current working directory
+
+    Returns:
+        SlotAssignment if cwd is within a pool slot, None otherwise
+    """
+    if not cwd.exists():
+        return None
+    resolved_cwd = cwd.resolve()
+    for assignment in state.assignments:
+        if not assignment.worktree_path.exists():
+            continue
+        wt_path = assignment.worktree_path.resolve()
+        if resolved_cwd == wt_path or wt_path in resolved_cwd.parents:
+            return assignment
+    return None
+
+
+@click.command("unassign")
+@click.argument("worktree", metavar="WORKTREE", required=False)
+@click.pass_obj
+def branch_unassign(ctx: ErkContext, worktree: str | None) -> None:
+    """Remove a branch assignment from a pool slot.
+
+    WORKTREE is the slot name (e.g., erk-managed-wt-01).
+
+    If no argument is provided, the current pool slot is detected from the
+    working directory.
+
+    The worktree directory is kept for reuse with future assignments.
+
+    Examples:
+        erk br unassign erk-managed-wt-01    # Unassign by worktree name
+        erk br unassign                      # Unassign current slot (from within pool worktree)
+    """
+    repo = discover_repo_context(ctx, ctx.cwd)
+
+    # Load pool state
+    state = load_pool_state(repo.pool_json_path)
+    if state is None:
+        user_output("Error: No pool configured. Run `erk br create` first.")
+        raise SystemExit(1) from None
+
+    # Find the assignment to remove
+    assignment: SlotAssignment | None = None
+
+    if worktree is not None:
+        # Find by slot name
+        assignment = _find_assignment_by_slot(state, worktree)
+        if assignment is None:
+            user_output(
+                f"Error: No worktree found for '{worktree}'.\n"
+                "Run `erk slot list` to see current assignments."
+            )
+            raise SystemExit(1) from None
+    else:
+        # Detect current slot from cwd
+        assignment = _find_assignment_by_cwd(state, ctx.cwd)
+        if assignment is None:
+            user_output(
+                "Error: Not inside a pool slot. Specify worktree name.\n"
+                "Usage: erk br unassign WORKTREE"
+            )
+            raise SystemExit(1) from None
+
+    # Execute the unassign operation
+    result = execute_unassign(ctx, repo, state, assignment)
+
+    user_output(
+        click.style("✓ ", fg="green")
+        + f"Unassigned {click.style(result.branch_name, fg='yellow')} "
+        + f"from {click.style(result.slot_name, fg='cyan')}"
+    )
+    user_output("  Switched to placeholder branch")
+    user_output("  Tip: Use 'erk wt co root' to return to root worktree")

erk/cli/commands/cc/__init__.py

@@ -0,0 +1,15 @@
+"""Claude Code session tools command group."""
+
+import click
+
+from erk.cli.commands.cc.jsonl_cmd import jsonl_viewer
+from erk.cli.commands.cc.session import session_group
+
+
+@click.group("cc")
+def cc_group() -> None:
+    """Claude Code session tools."""
+
+
+cc_group.add_command(session_group)
+cc_group.add_command(jsonl_viewer)

erk/cli/commands/cc/jsonl_cmd.py

@@ -0,0 +1,20 @@
+"""JSONL viewer CLI command."""
+
+from pathlib import Path
+
+import click
+
+from erk.tui.jsonl_viewer.app import JsonlViewerApp
+
+
+@click.command("jsonl")
+@click.argument("path", type=click.Path(exists=True, path_type=Path))
+def jsonl_viewer(path: Path) -> None:
+    """View a Claude Code session JSONL file in an interactive TUI.
+
+    PATH is the path to a .jsonl file to view.
+
+    Use Enter to expand/collapse entries, q or Esc to quit.
+    """
+    app = JsonlViewerApp(path)
+    app.run()

erk/cli/commands/cc/session/AGENTS.md

@@ -0,0 +1,30 @@
+# Claude Code Session Commands
+
+User-facing CLI commands for working with Claude Code sessions.
+
+## Related Documentation
+
+**Before modifying this code, read the session documentation:**
+
+@docs/learned/sessions/
+
+## Architecture
+
+These commands use the `ClaudeCodeSessionStore` abstraction from `erk_shared.extraction.claude_code_session_store`:
+
+- **ABC**: `ClaudeCodeSessionStore` - interface for session operations
+- **Real**: `RealClaudeCodeSessionStore` - reads from `~/.claude/projects/`
+- **Fake**: `FakeClaudeCodeSessionStore` - in-memory for testing
+
+## Commands
+
+### `erk cc session list`
+
+Lists sessions for the current worktree with session ID, time, size, and summary.
+
+**Key behaviors:**
+
+- By default, excludes agent sessions (files starting with `agent-`)
+- `--include-agents` flag includes agent sessions with parent linkage
+- Sessions sorted by modification time (newest first)
+- Summary extracted from first user message

erk/cli/commands/cc/session/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

erk/cli/commands/cc/session/__init__.py

@@ -0,0 +1,15 @@
+"""Session management command group for Claude Code."""
+
+import click
+
+from erk.cli.commands.cc.session.list_cmd import list_sessions
+from erk.cli.commands.cc.session.show_cmd import show_session
+
+
+@click.group("session")
+def session_group() -> None:
+    """Manage Claude Code sessions."""
+
+
+session_group.add_command(list_sessions)
+session_group.add_command(show_session)

erk/cli/commands/cc/session/list_cmd.py

@@ -0,0 +1,167 @@
+"""List Claude Code sessions for the current worktree."""
+
+import datetime
+import time
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from erk.core.context import ErkContext
+from erk_shared.extraction.claude_installation import ClaudeInstallation
+from erk_shared.extraction.session_schema import extract_first_user_message_text
+
+
+def format_relative_time(mtime: float) -> str:
+    """Format modification time as human-readable relative time.
+
+    Args:
+        mtime: Unix timestamp (seconds since epoch)
+
+    Returns:
+        Human-readable relative time string
+    """
+    now = time.time()
+    delta = now - mtime
+
+    if delta < 30:
+        return "just now"
+    if delta < 3600:  # < 1 hour
+        minutes = int(delta / 60)
+        return f"{minutes}m ago"
+    if delta < 86400:  # < 24 hours
+        hours = int(delta / 3600)
+        return f"{hours}h ago"
+    if delta < 604800:  # < 7 days
+        days = int(delta / 86400)
+        return f"{days}d ago"
+    # >= 7 days: show absolute date
+    return format_display_time(mtime)
+
+
+def format_display_time(mtime: float) -> str:
+    """Format modification time as display string.
+
+    Args:
+        mtime: Unix timestamp (seconds since epoch)
+
+    Returns:
+        Formatted date string like "Dec 3, 11:38 AM"
+    """
+    dt = datetime.datetime.fromtimestamp(mtime)
+    return dt.strftime("%b %-d, %-I:%M %p")
+
+
+def format_size(size_bytes: int) -> str:
+    """Format size in bytes as human-readable string.
+
+    Args:
+        size_bytes: Size in bytes
+
+    Returns:
+        Human-readable size string like "45KB"
+    """
+    if size_bytes < 1024:
+        return f"{size_bytes}B"
+    if size_bytes < 1024 * 1024:
+        return f"{size_bytes // 1024}KB"
+    return f"{size_bytes // (1024 * 1024)}MB"
+
+
+def _list_sessions_impl(
+    claude_installation: ClaudeInstallation,
+    cwd: Path,
+    limit: int,
+    include_agents: bool,
+) -> None:
+    """Implementation of session listing logic.
+
+    Args:
+        claude_installation: Claude installation to query
+        cwd: Current working directory (project identifier)
+        limit: Maximum number of sessions to show
+        include_agents: Whether to include agent sessions in the listing
+    """
+    # Check if project exists
+    if not claude_installation.has_project(cwd):
+        click.echo(f"No Claude Code sessions found for: {cwd}", err=True)
+        raise SystemExit(1)
+
+    # Get sessions
+    sessions = claude_installation.find_sessions(
+        cwd,
+        current_session_id=None,
+        min_size=0,
+        limit=limit,
+        include_agents=include_agents,
+    )
+
+    if not sessions:
+        click.echo("No sessions found.", err=True)
+        return
+
+    # Create Rich table
+    table = Table(show_header=True, header_style="bold", box=None)
+    table.add_column("id", style="cyan", no_wrap=True)
+    if include_agents:
+        table.add_column("parent", no_wrap=True)
+    table.add_column("time", no_wrap=True)
+    table.add_column("size", no_wrap=True, justify="right")
+    table.add_column("summary", no_wrap=False)
+
+    for session in sessions:
+        # Read session content for summary extraction
+        content = claude_installation.read_session(cwd, session.session_id, include_agents=False)
+        summary = ""
+        if content is not None:
+            summary = extract_first_user_message_text(content.main_content, max_length=50)
+
+        if include_agents:
+            # Show first 8 chars of parent_session_id for agents, empty for main sessions
+            parent_short = session.parent_session_id[:8] if session.parent_session_id else ""
+            table.add_row(
+                session.session_id,
+                parent_short,
+                format_relative_time(session.modified_at),
+                format_size(session.size_bytes),
+                summary,
+            )
+        else:
+            table.add_row(
+                session.session_id,
+                format_relative_time(session.modified_at),
+                format_size(session.size_bytes),
+                summary,
+            )
+
+    # Output table to stderr (consistent with user_output convention)
+    console = Console(stderr=True, force_terminal=True)
+    console.print(table)
+
+
+@click.command("list")
+@click.option(
+    "--limit",
+    default=10,
+    type=int,
+    help="Maximum number of sessions to list",
+)
+@click.option(
+    "--include-agents",
+    is_flag=True,
+    default=False,
+    help="Include agent sessions in the listing",
+)
+@click.pass_obj
+def list_sessions(ctx: ErkContext, limit: int, include_agents: bool) -> None:
+    """List Claude Code sessions for the current worktree.
+
+    Shows a table with session ID, time, size, and summary (first user message).
+    """
+    _list_sessions_impl(
+        ctx.claude_installation,
+        ctx.cwd,
+        limit,
+        include_agents,
+    )

erk/cli/commands/cc/session/show_cmd.py

@@ -0,0 +1,175 @@
+"""Show details for a specific Claude Code session."""
+
+from pathlib import Path
+
+import click
+from rich.console import Console
+
+from erk.cli.commands.cc.session.list_cmd import (
+    format_display_time,
+    format_size,
+)
+from erk.cli.ensure import Ensure
+from erk.core.context import ErkContext
+from erk_shared.extraction.claude_installation import ClaudeInstallation
+from erk_shared.extraction.session_schema import (
+    AgentInfo,
+    extract_agent_info_from_jsonl,
+    extract_first_user_message_text,
+)
+
+
+def format_duration(seconds: float) -> str:
+    """Format a duration in seconds to a human-readable string.
+
+    Args:
+        seconds: Duration in seconds
+
+    Returns:
+        Formatted string like "42s", "1m 30s", or "1h 15m"
+    """
+    if seconds < 60:
+        return f"{int(seconds)}s"
+    elif seconds < 3600:
+        minutes = int(seconds // 60)
+        secs = int(seconds % 60)
+        return f"{minutes}m {secs}s"
+    else:
+        hours = int(seconds // 3600)
+        minutes = int((seconds % 3600) // 60)
+        return f"{hours}h {minutes}m"
+
+
+def _show_session_impl(
+    claude_installation: ClaudeInstallation,
+    cwd: Path,
+    session_id: str | None,
+) -> None:
+    """Implementation of session show logic.
+
+    Args:
+        claude_installation: Claude installation to query
+        cwd: Current working directory (project identifier)
+        session_id: Session ID to show details for, or None to use most recent
+    """
+    console = Console(stderr=True, force_terminal=True)
+
+    # Check if project exists
+    Ensure.invariant(
+        claude_installation.has_project(cwd),
+        f"No Claude Code sessions found for: {cwd}",
+    )
+
+    # If no session_id provided, use the most recent session
+    inferred = False
+    if session_id is None:
+        sessions = claude_installation.find_sessions(
+            cwd,
+            current_session_id=None,
+            min_size=0,
+            include_agents=False,
+            limit=1,
+        )
+        Ensure.invariant(len(sessions) > 0, "No sessions found.")
+        session_id = sessions[0].session_id
+        inferred = True
+
+    # Get the session
+    session = Ensure.session(claude_installation.get_session(cwd, session_id))
+
+    # Check if this is an agent session - provide helpful error
+    parent_id = session.parent_session_id
+    Ensure.invariant(
+        parent_id is None,
+        f"Cannot show agent session directly. Use parent session instead: {parent_id}",
+    )
+
+    # Get the session path
+    session_path = claude_installation.get_session_path(cwd, session_id)
+
+    # Read session content for summary and agent info extraction
+    content = claude_installation.read_session(cwd, session_id, include_agents=False)
+    summary = ""
+    agent_infos: dict[str, AgentInfo] = {}
+    if content is not None:
+        summary = extract_first_user_message_text(content.main_content, max_length=100)
+        agent_infos = extract_agent_info_from_jsonl(content.main_content)
+
+    # Print inferred message if applicable
+    if inferred:
+        msg = f"Using most recent session for this worktree: {session.session_id}"
+        console.print(f"[dim]{msg}[/dim]")
+        console.print()
+
+    # Display metadata as key-value pairs
+    console.print(f"[bold]ID:[/bold] {session.session_id}")
+    console.print(f"[bold]Size:[/bold] {format_size(session.size_bytes)}")
+    console.print(f"[bold]Modified:[/bold] {format_display_time(session.modified_at)}")
+    if summary:
+        console.print(f"[bold]Summary:[/bold] {summary}")
+    if session_path is not None:
+        console.print(f"[bold]Path:[/bold] {session_path}")
+
+    # Find and display child agent sessions
+    all_sessions = claude_installation.find_sessions(
+        cwd,
+        current_session_id=None,
+        min_size=0,
+        include_agents=True,
+        limit=1000,
+    )
+
+    # Filter to only agent sessions with this parent
+    child_agents = [s for s in all_sessions if s.parent_session_id == session_id]
+
+    if child_agents:
+        console.print()
+        console.print("[bold]Agent Sessions:[/bold]")
+
+        for agent in child_agents:
+            info = agent_infos.get(agent.session_id)
+            agent_path = claude_installation.get_session_path(cwd, agent.session_id)
+
+            console.print()
+            # Format: type("prompt") or just session_id if no info
+            if info and info.agent_type:
+                # Clean up prompt: collapse whitespace, truncate
+                prompt_clean = " ".join(info.prompt.split())
+                if len(prompt_clean) > 80:
+                    prompt_preview = prompt_clean[:80] + "..."
+                else:
+                    prompt_preview = prompt_clean
+                console.print(f'  [cyan]{info.agent_type}[/cyan]("{prompt_preview}")')
+            else:
+                console.print(f"  [cyan]{agent.session_id}[/cyan]")
+            # Build metadata line: time, size, and optional duration
+            metadata_parts = [
+                format_display_time(agent.modified_at),
+                format_size(agent.size_bytes),
+            ]
+            if info and info.duration_secs is not None:
+                metadata_parts.append(format_duration(info.duration_secs))
+            console.print(f"    {'  '.join(metadata_parts)}")
+            if agent_path:
+                console.print(f"    {agent_path}")
+    else:
+        console.print()
+        console.print("[dim]No agent sessions[/dim]")
+
+
+@click.command("show")
+@click.argument("session_id", required=False, default=None)
+@click.pass_obj
+def show_session(ctx: ErkContext, session_id: str | None) -> None:
+    """Show details for a specific Claude Code session.
+
+    Displays session metadata (ID, size, modified time, path, summary)
+    and lists any child agent sessions.
+
+    If SESSION_ID is not provided, shows the most recent session.
+    """
+    _show_session_impl(
+        ctx.claude_installation,
+        ctx.cwd,
+        session_id,
+    )