ensemble-claude 0.3.1__py3-none-any.whl → 0.4.1__py3-none-any.whl

ensemble/__init__.py

@@ -1,5 +1,5 @@
 """Ensemble AI Orchestration - Multi-agent orchestration for Claude Code."""
 
-__version__ = "0.3.1"
+__version__ = "0.4.1"
 __author__ = "Ensemble Team"
 

ensemble/cli.py

@@ -4,6 +4,7 @@ import click
 
 from ensemble import __version__
 from ensemble.commands.init import init
+from ensemble.commands.issue import issue
 from ensemble.commands.launch import launch
 
 
@@ -19,6 +20,7 @@ def cli() -> None:
 
 
 cli.add_command(init)
+cli.add_command(issue)
 cli.add_command(launch)
 
 

ensemble/commands/_issue_impl.py

@@ -0,0 +1,150 @@
+"""Implementation of the ensemble issue command."""
+
+import click
+
+from ensemble.issue_provider import Issue, IssueProvider
+from ensemble.providers.github import GitHubProvider
+
+
+def get_provider(provider_name: str) -> IssueProvider:
+    """Get the issue provider by name.
+
+    Args:
+        provider_name: Name of the provider ('github', 'gitlab').
+
+    Returns:
+        IssueProvider instance.
+
+    Raises:
+        click.ClickException: If provider is not available.
+    """
+    if provider_name == "github":
+        provider = GitHubProvider()
+        if not provider.is_available():
+            raise click.ClickException(
+                "GitHub CLI (gh) is not installed. "
+                "Install it from: https://cli.github.com/"
+            )
+        return provider
+    elif provider_name == "gitlab":
+        raise click.ClickException(
+            "GitLab provider is not yet implemented. Coming soon!"
+        )
+    else:
+        raise click.ClickException(f"Unknown provider: {provider_name}")
+
+
+def run_issue(
+    identifier: str | None,
+    state: str,
+    provider: str,
+) -> None:
+    """Run the issue command implementation.
+
+    Args:
+        identifier: Issue number or URL (None to list issues).
+        state: Filter state for listing ('open', 'closed', 'all').
+        provider: Provider name ('github', 'gitlab').
+    """
+    issue_provider = get_provider(provider)
+
+    if identifier:
+        # View specific issue
+        _view_issue(issue_provider, identifier)
+    else:
+        # List issues
+        _list_issues(issue_provider, state)
+
+
+def _view_issue(provider: IssueProvider, identifier: str) -> None:
+    """View a specific issue.
+
+    Args:
+        provider: Issue provider instance.
+        identifier: Issue number or URL.
+    """
+    try:
+        issue = provider.get_issue(identifier)
+        _print_issue_detail(issue)
+    except ValueError as e:
+        raise click.ClickException(str(e))
+    except RuntimeError as e:
+        raise click.ClickException(str(e))
+
+
+def _list_issues(provider: IssueProvider, state: str) -> None:
+    """List issues.
+
+    Args:
+        provider: Issue provider instance.
+        state: Filter state.
+    """
+    try:
+        issues = provider.list_issues(state=state)
+
+        if not issues:
+            click.echo(f"No {state} issues found.")
+            return
+
+        click.echo(f"\n{click.style(f'{len(issues)} {state} issue(s):', bold=True)}\n")
+
+        for issue in issues:
+            _print_issue_summary(issue)
+
+        click.echo("")
+
+    except RuntimeError as e:
+        raise click.ClickException(str(e))
+
+
+def _print_issue_summary(issue: Issue) -> None:
+    """Print a one-line summary of an issue.
+
+    Args:
+        issue: Issue to print.
+    """
+    # Format: #123 [bug, urgent] Issue title
+    number = click.style(f"#{issue.number}", fg="cyan", bold=True)
+    labels = ""
+    if issue.labels:
+        label_str = ", ".join(issue.labels[:3])  # Max 3 labels
+        if len(issue.labels) > 3:
+            label_str += ", ..."
+        labels = click.style(f" [{label_str}]", fg="yellow")
+
+    # Truncate title if too long
+    title = issue.title
+    if len(title) > 60:
+        title = title[:57] + "..."
+
+    click.echo(f"  {number}{labels} {title}")
+
+
+def _print_issue_detail(issue: Issue) -> None:
+    """Print detailed view of an issue.
+
+    Args:
+        issue: Issue to print.
+    """
+    click.echo("")
+    click.echo(click.style(f"Issue #{issue.number}", fg="cyan", bold=True))
+    click.echo(click.style("=" * 60, dim=True))
+    click.echo("")
+    click.echo(f"{click.style('Title:', bold=True)} {issue.title}")
+    click.echo(f"{click.style('State:', bold=True)} {issue.state}")
+
+    if issue.labels:
+        labels = ", ".join(issue.labels)
+        click.echo(f"{click.style('Labels:', bold=True)} {labels}")
+
+    click.echo(f"{click.style('URL:', bold=True)} {issue.url}")
+    click.echo("")
+
+    if issue.body:
+        click.echo(click.style("Description:", bold=True))
+        click.echo(click.style("-" * 40, dim=True))
+        click.echo(issue.body)
+    else:
+        click.echo(click.style("(No description)", dim=True))
+
+    click.echo("")

ensemble/commands/_launch_impl.py

@@ -4,6 +4,7 @@ import os
 import shutil
 import subprocess
 import sys
+import time
 from pathlib import Path
 from typing import Optional
 
@@ -16,7 +17,7 @@ def run_launch(session: str = "ensemble", attach: bool = True) -> None:
     """Run the launch command implementation.
 
     Args:
-        session: Name of the tmux session.
+        session: Base name for the tmux sessions (will create {session}-conductor and {session}-workers).
         attach: Whether to attach to the session after creation.
     """
     # Check prerequisites
@@ -29,12 +30,24 @@ def run_launch(session: str = "ensemble", attach: bool = True) -> None:
         click.echo("Install Claude Code from: https://claude.ai/code")
         sys.exit(1)
 
-    # Check if session already exists
-    if _session_exists(session):
-        click.echo(f"Session '{session}' already exists.")
-        if attach:
-            click.echo(f"Attaching to existing session...")
-            _attach_session(session)
+    # Session names
+    conductor_session = f"{session}-conductor"
+    workers_session = f"{session}-workers"
+
+    # Check if sessions already exist
+    conductor_exists = _session_exists(conductor_session)
+    workers_exists = _session_exists(workers_session)
+
+    if conductor_exists or workers_exists:
+        click.echo("Existing Ensemble sessions found:")
+        if conductor_exists:
+            click.echo(f"  - {conductor_session}")
+        if workers_exists:
+            click.echo(f"  - {workers_session}")
+        click.echo("")
+        click.echo("To attach, open two terminal windows and run:")
+        click.echo(f"  Terminal 1: tmux attach -t {conductor_session}")
+        click.echo(f"  Terminal 2: tmux attach -t {workers_session}")
         return
 
     project_root = Path.cwd()
@@ -46,21 +59,58 @@ def run_launch(session: str = "ensemble", attach: bool = True) -> None:
         click.echo("Run 'ensemble init' first")
         sys.exit(1)
 
-    click.echo(f"Launching Ensemble session '{session}'...")
+    click.echo(f"Launching Ensemble sessions '{session}-*'...")
+
+    # Clean up queue directories
+    queue_dir = project_root / "queue"
+    if queue_dir.exists():
+        for subdir in ["tasks", "processing", "reports", "ack"]:
+            subdir_path = queue_dir / subdir
+            if subdir_path.exists():
+                for f in subdir_path.glob("*.yaml"):
+                    f.unlink()
+                for f in subdir_path.glob("*.ack"):
+                    f.unlink()
+
+    # Ensure queue directories exist
+    for subdir in ["tasks", "processing", "reports", "ack", "conductor"]:
+        (queue_dir / subdir).mkdir(parents=True, exist_ok=True)
 
     # Get agent paths
     agents = _resolve_agent_paths(project_root)
 
-    # Create tmux session with layout
-    _create_session(session, project_root, agents)
+    # Create tmux sessions (2 separate sessions)
+    _create_sessions(session, project_root, agents)
 
     # Save pane IDs
     _save_pane_ids(session, ensemble_dir)
 
-    click.echo(click.style("Ensemble session started!", fg="green"))
+    click.echo(click.style("Ensemble sessions started!", fg="green"))
+    click.echo("")
+    click.echo("==========================================")
+    click.echo("  Two separate tmux sessions created!")
+    click.echo("==========================================")
+    click.echo("")
+    click.echo(f"Session 1: {conductor_session}")
+    click.echo("  +------------------+------------------+")
+    click.echo("  |   Conductor      |   dashboard      |")
+    click.echo("  +------------------+------------------+")
+    click.echo("")
+    click.echo(f"Session 2: {workers_session}")
+    click.echo("  +------------------+------------------+")
+    click.echo("  |   dispatch       |   worker-area    |")
+    click.echo("  +------------------+------------------+")
+    click.echo("")
+    click.echo("To view both simultaneously, open two terminal windows:")
+    click.echo(f"  Terminal 1: tmux attach -t {conductor_session}")
+    click.echo(f"  Terminal 2: tmux attach -t {workers_session}")
+    click.echo("")
 
     if attach:
-        _attach_session(session)
+        click.echo(f"Attaching to {conductor_session}...")
+        click.echo(f"(Open another terminal and run: tmux attach -t {workers_session})")
+        click.echo("")
+        _attach_session(conductor_session)
 
 
 def _check_tmux() -> bool:
@@ -125,93 +175,168 @@ def _resolve_agent_paths(project_root: Path) -> dict[str, Path]:
     return agents
 
 
-def _create_session(session: str, project_root: Path, agents: dict[str, Path]) -> None:
-    """Create the tmux session with Ensemble layout."""
-    # Create new session (detached)
+def _create_sessions(session: str, project_root: Path, agents: dict[str, Path]) -> None:
+    """Create two separate tmux sessions for Ensemble.
+
+    Session 1 ({session}-conductor): Conductor (left 60%) + Dashboard (right 40%)
+    Session 2 ({session}-workers): Dispatch (left 60%) + Worker area (right 40%)
+
+    This allows viewing both sessions simultaneously in separate terminal windows.
+    """
+    conductor_session = f"{session}-conductor"
+    workers_session = f"{session}-workers"
+
+    # === Session 1: Conductor ===
     subprocess.run(
         [
             "tmux", "new-session",
             "-d",
-            "-s", session,
+            "-s", conductor_session,
             "-c", str(project_root),
             "-n", "main",
         ],
         check=True,
     )
 
-    # Split into 3 panes: Conductor (left), Dashboard (top-right), Dispatch (bottom-right)
-    # First split vertically (creates pane 1 on right)
+    # Split conductor window: left/right (60/40)
     subprocess.run(
-        ["tmux", "split-window", "-t", f"{session}:main", "-h", "-c", str(project_root)],
-        check=True,
-    )
-
-    # Split the right pane horizontally (creates pane 2 at bottom-right)
-    subprocess.run(
-        ["tmux", "split-window", "-t", f"{session}:main.1", "-v", "-c", str(project_root)],
+        ["tmux", "split-window", "-t", f"{conductor_session}:main", "-h", "-l", "40%", "-c", str(project_root)],
         check=True,
     )
 
     # Set pane titles
-    subprocess.run(["tmux", "select-pane", "-t", f"{session}:main.0", "-T", "conductor"], check=True)
-    subprocess.run(["tmux", "select-pane", "-t", f"{session}:main.1", "-T", "dashboard"], check=True)
-    subprocess.run(["tmux", "select-pane", "-t", f"{session}:main.2", "-T", "dispatch"], check=True)
+    subprocess.run(["tmux", "select-pane", "-t", f"{conductor_session}:main.0", "-T", "conductor"], check=True)
+    subprocess.run(["tmux", "select-pane", "-t", f"{conductor_session}:main.1", "-T", "dashboard"], check=True)
 
-    # Start Claude in Conductor pane (pane 0)
+    # Start Claude in Conductor pane (left)
     conductor_agent = agents.get("conductor")
     if conductor_agent:
-        cmd = f"claude --agent {conductor_agent}"
+        cmd = f"MAX_THINKING_TOKENS=0 claude --agent {conductor_agent} --model opus --dangerously-skip-permissions"
     else:
-        cmd = "claude"
+        cmd = "MAX_THINKING_TOKENS=0 claude --model opus --dangerously-skip-permissions"
+    subprocess.run(
+        ["tmux", "send-keys", "-t", f"{conductor_session}:main.0", cmd],
+        check=True,
+    )
+    time.sleep(1)
     subprocess.run(
-        ["tmux", "send-keys", "-t", f"{session}:main.0", cmd, "Enter"],
+        ["tmux", "send-keys", "-t", f"{conductor_session}:main.0", "Enter"],
         check=True,
     )
 
-    # Start dashboard watch in Dashboard pane (pane 1)
+    # Start dashboard watch in Dashboard pane (right)
     dashboard_path = project_root / ".ensemble" / "status" / "dashboard.md"
     subprocess.run(
-        ["tmux", "send-keys", "-t", f"{session}:main.1", f"watch -n 2 cat {dashboard_path}", "Enter"],
+        ["tmux", "send-keys", "-t", f"{conductor_session}:main.1", f"watch -n 5 cat {dashboard_path}"],
         check=True,
     )
+    time.sleep(1)
+    subprocess.run(
+        ["tmux", "send-keys", "-t", f"{conductor_session}:main.1", "Enter"],
+        check=True,
+    )
+
+    # フレンドリーファイア防止: Conductorが起動完了するまで待機
+    time.sleep(3)
 
-    # Start Claude in Dispatch pane (pane 2)
+    # === Session 2: Workers ===
+    subprocess.run(
+        [
+            "tmux", "new-session",
+            "-d",
+            "-s", workers_session,
+            "-c", str(project_root),
+            "-n", "main",
+        ],
+        check=True,
+    )
+
+    # Split workers window: left/right (60/40)
+    subprocess.run(
+        ["tmux", "split-window", "-t", f"{workers_session}:main", "-h", "-l", "40%", "-c", str(project_root)],
+        check=True,
+    )
+
+    # Set pane titles
+    subprocess.run(["tmux", "select-pane", "-t", f"{workers_session}:main.0", "-T", "dispatch"], check=True)
+    subprocess.run(["tmux", "select-pane", "-t", f"{workers_session}:main.1", "-T", "worker-area"], check=True)
+
+    # Start Claude in Dispatch pane (left)
     dispatch_agent = agents.get("dispatch")
     if dispatch_agent:
-        cmd = f"claude --agent {dispatch_agent}"
+        cmd = f"claude --agent {dispatch_agent} --model sonnet --dangerously-skip-permissions"
     else:
-        cmd = "claude"
+        cmd = "claude --model sonnet --dangerously-skip-permissions"
     subprocess.run(
-        ["tmux", "send-keys", "-t", f"{session}:main.2", cmd, "Enter"],
+        ["tmux", "send-keys", "-t", f"{workers_session}:main.0", cmd],
+        check=True,
+    )
+    time.sleep(1)
+    subprocess.run(
+        ["tmux", "send-keys", "-t", f"{workers_session}:main.0", "Enter"],
         check=True,
     )
 
-    # Select Conductor pane
-    subprocess.run(["tmux", "select-pane", "-t", f"{session}:main.0"], check=True)
+    # Show placeholder message in worker area (right)
+    subprocess.run(
+        ["tmux", "send-keys", "-t", f"{workers_session}:main.1", "echo '=== Worker Area ===' && echo 'Workers will be started here.'", "Enter"],
+        check=True,
+    )
+
+    # Select dispatch pane in workers session
+    subprocess.run(["tmux", "select-pane", "-t", f"{workers_session}:main.0"], check=True)
 
 
 def _save_pane_ids(session: str, ensemble_dir: Path) -> None:
     """Save pane IDs to panes.env file."""
-    # Get pane IDs
+    conductor_session = f"{session}-conductor"
+    workers_session = f"{session}-workers"
+
+    # Get conductor session pane IDs
+    result = subprocess.run(
+        ["tmux", "list-panes", "-t", f"{conductor_session}:main", "-F", "#{pane_index}:#{pane_id}"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+
+    conductor_pane_map = {}
+    for line in result.stdout.strip().split("\n"):
+        if ":" in line:
+            idx, pane_id = line.split(":", 1)
+            conductor_pane_map[int(idx)] = pane_id
+
+    # Get workers session pane IDs
     result = subprocess.run(
-        ["tmux", "list-panes", "-t", f"{session}:main", "-F", "#{pane_index}:#{pane_id}"],
+        ["tmux", "list-panes", "-t", f"{workers_session}:main", "-F", "#{pane_index}:#{pane_id}"],
         capture_output=True,
         text=True,
         check=True,
     )
 
-    pane_map = {}
+    workers_pane_map = {}
     for line in result.stdout.strip().split("\n"):
         if ":" in line:
             idx, pane_id = line.split(":", 1)
-            pane_map[int(idx)] = pane_id
+            workers_pane_map[int(idx)] = pane_id
 
     # Write panes.env
     panes_env = ensemble_dir / "panes.env"
     with open(panes_env, "w") as f:
         f.write("# Ensemble pane IDs (auto-generated)\n")
-        f.write(f"CONDUCTOR_PANE={pane_map.get(0, '%0')}\n")
-        f.write(f"DASHBOARD_PANE={pane_map.get(1, '%1')}\n")
-        f.write(f"DISPATCH_PANE={pane_map.get(2, '%2')}\n")
+        f.write("# Session names\n")
+        f.write(f"CONDUCTOR_SESSION={conductor_session}\n")
+        f.write(f"WORKERS_SESSION={workers_session}\n")
+        f.write("\n")
+        f.write("# Pane IDs (use these with tmux send-keys -t)\n")
+        f.write(f"CONDUCTOR_PANE={conductor_pane_map.get(0, '%0')}\n")
+        f.write(f"DASHBOARD_PANE={conductor_pane_map.get(1, '%1')}\n")
+        f.write(f"DISPATCH_PANE={workers_pane_map.get(0, '%0')}\n")
+        f.write(f"WORKER_AREA_PANE={workers_pane_map.get(1, '%1')}\n")
+        f.write("\n")
+        f.write("# Usage examples:\n")
+        f.write("# source .ensemble/panes.env\n")
+        f.write("# tmux send-keys -t \"$CONDUCTOR_PANE\" 'message' Enter\n")
+        f.write("# tmux send-keys -t \"$DISPATCH_PANE\" 'message' Enter\n")
 
     click.echo(f"  Saved pane IDs to {panes_env.relative_to(ensemble_dir.parent)}")

ensemble/commands/issue.py

@@ -0,0 +1,36 @@
+"""Issue command for listing and viewing issues."""
+
+import click
+
+
+@click.command()
+@click.argument("identifier", required=False)
+@click.option(
+    "--state",
+    type=click.Choice(["open", "closed", "all"]),
+    default="open",
+    help="Filter issues by state.",
+)
+@click.option(
+    "--provider",
+    type=click.Choice(["github", "gitlab"]),
+    default="github",
+    help="Issue provider to use.",
+)
+def issue(identifier: str | None, state: str, provider: str) -> None:
+    """List issues or view a specific issue.
+
+    Without IDENTIFIER, lists all issues.
+    With IDENTIFIER, shows details of that issue (number or URL).
+
+    Examples:
+
+        ensemble issue              # List open issues
+
+        ensemble issue 123          # View issue #123
+
+        ensemble issue --state all  # List all issues
+    """
+    from ensemble.commands._issue_impl import run_issue
+
+    run_issue(identifier=identifier, state=state, provider=provider)

ensemble/git_utils.py

@@ -0,0 +1,157 @@
+"""Git utilities for branch and PR management."""
+
+import re
+import subprocess
+
+
+def get_current_branch() -> str:
+    """Get the name of the current git branch.
+
+    Returns:
+        Current branch name.
+    """
+    result = subprocess.run(
+        ["git", "branch", "--show-current"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    return result.stdout.strip()
+
+
+def is_working_tree_clean() -> bool:
+    """Check if the git working tree is clean.
+
+    Returns:
+        True if there are no uncommitted changes.
+    """
+    result = subprocess.run(
+        ["git", "status", "--porcelain"],
+        capture_output=True,
+        text=True,
+    )
+    return result.stdout.strip() == ""
+
+
+def ensure_main_updated(base_branch: str = "main") -> None:
+    """Checkout the main branch and pull latest changes.
+
+    Args:
+        base_branch: Name of the base branch (default: main).
+
+    Raises:
+        RuntimeError: If checkout or pull fails.
+    """
+    # Checkout base branch
+    result = subprocess.run(
+        ["git", "checkout", base_branch],
+        capture_output=True,
+        text=True,
+    )
+
+    if result.returncode != 0:
+        raise RuntimeError(f"Failed to checkout {base_branch}: {result.stderr}")
+
+    # Pull latest
+    result = subprocess.run(
+        ["git", "pull", "origin", base_branch],
+        capture_output=True,
+        text=True,
+    )
+
+    if result.returncode != 0:
+        # Pull might fail if remote doesn't exist, which is OK for local repos
+        pass
+
+
+def create_issue_branch(issue_number: int, title: str) -> str:
+    """Create a new branch for working on an issue.
+
+    Format: issue/<number>-<slugified-title>
+
+    Args:
+        issue_number: Issue number.
+        title: Issue title (will be slugified).
+
+    Returns:
+        Name of the created branch.
+
+    Raises:
+        RuntimeError: If branch creation fails.
+    """
+    # Slugify title
+    slug = title.lower()
+    slug = re.sub(r"[^a-z0-9\s-]", "", slug)
+    slug = re.sub(r"\s+", "-", slug)
+    slug = re.sub(r"-+", "-", slug)
+    slug = slug.strip("-")
+
+    # Truncate if too long
+    if len(slug) > 40:
+        slug = slug[:40].rsplit("-", 1)[0]
+
+    branch_name = f"issue/{issue_number}-{slug}"
+
+    # Try to create new branch
+    result = subprocess.run(
+        ["git", "checkout", "-b", branch_name],
+        capture_output=True,
+        text=True,
+    )
+
+    if result.returncode != 0:
+        # Branch might already exist, try to checkout
+        if "already exists" in result.stderr:
+            result = subprocess.run(
+                ["git", "checkout", branch_name],
+                capture_output=True,
+                text=True,
+            )
+            if result.returncode != 0:
+                raise RuntimeError(f"Failed to checkout branch {branch_name}: {result.stderr}")
+        else:
+            raise RuntimeError(f"Failed to create branch {branch_name}: {result.stderr}")
+
+    return branch_name
+
+
+def create_pull_request(
+    title: str,
+    body: str,
+    issue_number: int | None = None,
+) -> str:
+    """Create a pull request using gh CLI.
+
+    Args:
+        title: PR title.
+        body: PR body/description.
+        issue_number: Optional issue number to link.
+
+    Returns:
+        URL of the created PR.
+
+    Raises:
+        RuntimeError: If PR creation fails.
+    """
+    # Build body with issue reference if provided
+    full_body = body
+    if issue_number:
+        if f"#{issue_number}" not in body and f"Closes #{issue_number}" not in body:
+            full_body = f"{body}\n\nCloses #{issue_number}"
+
+    cmd = [
+        "gh", "pr", "create",
+        "--title", title,
+        "--body", full_body,
+    ]
+
+    result = subprocess.run(
+        cmd,
+        capture_output=True,
+        text=True,
+    )
+
+    if result.returncode != 0:
+        raise RuntimeError(f"Failed to create pull request: {result.stderr}")
+
+    return result.stdout.strip()