devmux 0.2.0__py3-none-any.whl

devmux/__init__.py

@@ -0,0 +1,3 @@
+"""devmux - A tmux session manager for AI agent CLIs."""
+
+__version__ = "0.2.0"

devmux/cli/main.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""devmux - A tmux session manager for AI agent CLIs."""
+
+from __future__ import annotations
+
+from pathlib import Path
+import sys
+
+import click
+
+from devmux import __version__
+from devmux.core.manager import SessionManager, SessionManagerError
+from devmux.utils.config import Config, ConfigError, VALID_ROLES, render_preset
+
+
+def _load_config(config_path: str) -> Config:
+    path = Path(config_path)
+    if not path.exists():
+        raise ConfigError(f"Config file '{config_path}' not found.")
+    return Config.load(path)
+
+
+def _fail(exc: Exception) -> None:
+    click.echo(f"Error: {exc}", err=True)
+    raise SystemExit(1) from exc
+
+
+@click.group()
+@click.version_option(version=__version__)
+def cli() -> None:
+    """Launch reproducible tmux workspaces for AI-heavy CLI development."""
+
+
+@cli.command()
+@click.option(
+    "--preset",
+    type=click.Choice(["minimal", "backend", "full-stack"]),
+    default="backend",
+    show_default=True,
+    help="Starter workspace template to scaffold.",
+)
+@click.option(
+    "--config",
+    "-c",
+    default="devmux.yaml",
+    show_default=True,
+    help="Path to write the generated config file.",
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    help="Overwrite the target config file if it already exists.",
+)
+def init(preset: str, config: str, force: bool) -> None:
+    """Create a starter devmux config."""
+    try:
+        config_path = Path(config)
+        if config_path.exists() and not force:
+            raise ConfigError(
+                f"Config file '{config}' already exists. Pass --force to overwrite it."
+            )
+
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        config_path.write_text(render_preset(preset), encoding="utf-8")
+        click.echo(f"Wrote {preset} preset to '{config}'.")
+    except Exception as exc:
+        _fail(exc)
+
+
+@cli.command()
+@click.argument("workspace_name")
+@click.option(
+    "--config",
+    "-c",
+    default="devmux.yaml",
+    show_default=True,
+    help="Path to config file.",
+)
+@click.option(
+    "--detach",
+    is_flag=True,
+    help="Create or reuse the session without attaching to it.",
+)
+@click.option(
+    "--recreate",
+    is_flag=True,
+    help="Kill any existing session with the same name before creating it again.",
+)
+def start(workspace_name: str, config: str, detach: bool, recreate: bool) -> None:
+    """Create or resume a named workspace."""
+    try:
+        cfg = _load_config(config)
+        manager = SessionManager()
+        result = manager.start_workspace(workspace_name, cfg, recreate=recreate)
+
+        if detach:
+            verb = "Created" if result.created else "Reusing"
+            click.echo(f"{verb} detached session '{workspace_name}'.")
+            return
+
+        click.echo(f"Attaching to session '{workspace_name}'.")
+        manager.attach_session(workspace_name)
+    except Exception as exc:
+        _fail(exc)
+
+
+@cli.command(name="attach")
+@click.argument("workspace_name")
+def attach(workspace_name: str) -> None:
+    """Attach to an existing session."""
+    try:
+        manager = SessionManager()
+        manager.attach_session(workspace_name)
+    except Exception as exc:
+        _fail(exc)
+
+
+@cli.command(name="resume")
+@click.argument("workspace_name")
+def resume(workspace_name: str) -> None:
+    """Resume an existing session by name."""
+    try:
+        manager = SessionManager()
+        manager.attach_session(workspace_name)
+    except Exception as exc:
+        _fail(exc)
+
+
+@cli.command(name="ls")
+def list_sessions() -> None:
+    """List active tmux sessions."""
+    try:
+        manager = SessionManager()
+        sessions = manager.list_sessions()
+        if sessions:
+            click.echo("Active sessions:")
+            for session in sessions:
+                click.echo(f"  - {session}")
+        else:
+            click.echo("No active sessions.")
+    except Exception as exc:
+        _fail(exc)
+
+
+@cli.command()
+@click.argument("workspace_name")
+def kill(workspace_name: str) -> None:
+    """Kill a named session."""
+    try:
+        manager = SessionManager()
+        manager.kill_session(workspace_name)
+        click.echo(f"Killed session '{workspace_name}'.")
+    except Exception as exc:
+        _fail(exc)
+
+
+@cli.command()
+@click.argument("prompt")
+@click.option(
+    "--session",
+    "-s",
+    help="Target session name. Defaults to the current tmux session.",
+)
+@click.option(
+    "--all",
+    "send_all",
+    is_flag=True,
+    help="Send to every pane in the target session.",
+)
+@click.option(
+    "--role",
+    type=click.Choice(sorted(VALID_ROLES)),
+    help="Send only to panes with the selected role.",
+)
+@click.option(
+    "--pane",
+    "pane_names",
+    multiple=True,
+    help="Send only to the named pane. Repeat to target multiple panes.",
+)
+def send(
+    prompt: str,
+    session: str | None,
+    send_all: bool,
+    role: str | None,
+    pane_names: tuple[str, ...],
+) -> None:
+    """Send a prompt to selected panes."""
+    try:
+        if send_all and (role or pane_names):
+            raise click.ClickException(
+                "--all cannot be combined with --role or --pane."
+            )
+        if role and pane_names:
+            raise click.ClickException("--role cannot be combined with --pane.")
+
+        manager = SessionManager()
+        delivered_to = manager.broadcast_prompt(
+            prompt,
+            session_name=session,
+            send_all=send_all,
+            role=role,
+            pane_names=pane_names,
+        )
+        click.echo(f"Delivered prompt to: {', '.join(delivered_to)}")
+    except Exception as exc:
+        _fail(exc)
+
+
+def main() -> int:
+    cli()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

devmux/core/__init__.py

@@ -0,0 +1 @@
+

devmux/core/manager.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import os
+import shutil
+from typing import Iterable
+
+import libtmux
+from libtmux.constants import OptionScope, PaneDirection
+from libtmux.pane import Pane
+from libtmux.session import Session
+from libtmux.window import Window
+
+from devmux.utils.config import Config, ConfigError, PaneConfig, WorkspaceConfig
+
+
+class SessionManagerError(RuntimeError):
+    """Raised when tmux session management fails."""
+
+
+@dataclass(frozen=True)
+class StartResult:
+    session_name: str
+    created: bool
+
+
+class SessionManager:
+    def __init__(self, socket_name: str | None = None, tmux_bin: str | None = None):
+        self.tmux_bin = tmux_bin or shutil.which("tmux")
+        self.server = libtmux.Server(socket_name=socket_name, tmux_bin=self.tmux_bin)
+
+    def ensure_tmux_available(self) -> None:
+        if not self.tmux_bin:
+            raise SessionManagerError(
+                "tmux is not installed or not available on PATH. Install tmux first."
+            )
+        try:
+            self.server.cmd("list-sessions")
+        except Exception as exc:  # pragma: no cover - libtmux exception surface varies
+            raise SessionManagerError(f"Unable to reach tmux: {exc}") from exc
+
+    def start_workspace(
+        self,
+        workspace_name: str,
+        config: Config,
+        *,
+        recreate: bool = False,
+    ) -> StartResult:
+        self.ensure_tmux_available()
+        workspace = self._get_workspace(config, workspace_name)
+
+        if recreate and self.server.has_session(workspace_name):
+            self.kill_session(workspace_name)
+
+        if self.server.has_session(workspace_name):
+            return StartResult(session_name=workspace_name, created=False)
+
+        session = self._create_session(workspace_name, workspace)
+        self._configure_session(session, workspace)
+        return StartResult(session_name=workspace_name, created=True)
+
+    def attach_session(self, workspace_name: str) -> None:
+        self.ensure_tmux_available()
+        session = self._find_session(workspace_name)
+        if session is None:
+            raise SessionManagerError(f"Session '{workspace_name}' does not exist.")
+        self.server.attach_session(target_session=workspace_name)
+
+    def list_sessions(self) -> list[str]:
+        self.ensure_tmux_available()
+        return [session.session_name for session in self.server.sessions]
+
+    def kill_session(self, workspace_name: str) -> None:
+        self.ensure_tmux_available()
+        session = self._find_session(workspace_name)
+        if session is None:
+            raise SessionManagerError(f"Session '{workspace_name}' does not exist.")
+        session.kill()
+
+    def broadcast_prompt(
+        self,
+        prompt: str,
+        *,
+        session_name: str | None = None,
+        send_all: bool = False,
+        role: str | None = None,
+        pane_names: Iterable[str] | None = None,
+    ) -> list[str]:
+        self.ensure_tmux_available()
+        session = self._resolve_session_for_send(session_name)
+        panes = self._resolve_target_panes(
+            session,
+            send_all=send_all,
+            role=role,
+            pane_names=list(pane_names or []),
+        )
+        if not panes:
+            raise SessionManagerError(
+                f"No panes matched in session '{session.session_name}'."
+            )
+
+        delivered_to: list[str] = []
+        for pane in panes:
+            pane.send_keys(prompt, enter=True)
+            delivered_to.append(self._pane_name(pane))
+        return delivered_to
+
+    def _create_session(self, workspace_name: str, workspace: WorkspaceConfig) -> Session:
+        start_directory = None
+        if workspace.cwd:
+            start_directory = str(
+                PaneConfig(
+                    name="_workspace",
+                    role="shell",
+                    command="true",
+                    cwd=workspace.cwd,
+                ).resolved_cwd(base_dir=workspace.base_dir)
+            )
+        return self.server.new_session(
+            session_name=workspace_name,
+            attach=False,
+            start_directory=start_directory,
+        )
+
+    def _configure_session(self, session: Session, workspace: WorkspaceConfig) -> None:
+        window = session.active_window
+        panes = self._build_layout(window, workspace)
+        for pane, pane_config in zip(panes, workspace.panes, strict=True):
+            self._configure_pane(pane, pane_config, workspace)
+
+    def _build_layout(self, window: Window, workspace: WorkspaceConfig) -> list[Pane]:
+        base_pane = window.active_pane
+        panes = [base_pane]
+
+        if workspace.layout == "duo":
+            panes.append(base_pane.split(direction=PaneDirection.Right, size="50%"))
+            return panes
+
+        if workspace.layout == "trio":
+            side_pane = base_pane.split(direction=PaneDirection.Right, size="50%")
+            panes.append(side_pane)
+            panes.append(side_pane.split(direction=PaneDirection.Below, size="50%"))
+            return panes
+
+        if workspace.layout == "quad":
+            right_pane = base_pane.split(direction=PaneDirection.Right, size="50%")
+            panes.append(right_pane)
+            panes.append(base_pane.split(direction=PaneDirection.Below, size="50%"))
+            panes.append(right_pane.split(direction=PaneDirection.Below, size="50%"))
+            return panes
+
+        if workspace.layout == "focus":
+            side_seed = base_pane.split(direction=PaneDirection.Right, size="30%")
+            panes.append(side_seed)
+            for _ in range(len(workspace.panes) - 2):
+                panes.append(side_seed.split(direction=PaneDirection.Below))
+            window.select_layout("main-vertical")
+            window.set_option("main-pane-width", "70%", scope=OptionScope.Window)
+            return panes
+
+        raise SessionManagerError(f"Unsupported layout '{workspace.layout}'.")
+
+    def _configure_pane(
+        self, pane: Pane, pane_config: PaneConfig, workspace: WorkspaceConfig
+    ) -> None:
+        pane_path = pane_config.resolved_cwd(workspace.cwd, workspace.base_dir)
+        pane.set_title(pane_config.name)
+        pane.set_option("@devmux_name", pane_config.name, scope=OptionScope.Pane)
+        pane.set_option("@devmux_role", pane_config.role, scope=OptionScope.Pane)
+        pane.send_keys(f"cd {self._shell_quote(str(pane_path))}", enter=True)
+        pane.send_keys(pane_config.command, enter=True)
+
+    def _resolve_session_for_send(self, session_name: str | None) -> Session:
+        target_session = session_name or self._current_session_name()
+        if not target_session:
+            raise SessionManagerError(
+                "Not inside a tmux session and no session specified. Pass --session NAME."
+            )
+        session = self._find_session(target_session)
+        if session is None:
+            raise SessionManagerError(f"Session '{target_session}' does not exist.")
+        return session
+
+    def _resolve_target_panes(
+        self,
+        session: Session,
+        *,
+        send_all: bool,
+        role: str | None,
+        pane_names: list[str],
+    ) -> list[Pane]:
+        panes = list(session.active_window.panes)
+        if send_all:
+            return panes
+
+        if pane_names:
+            matched = [pane for pane in panes if self._pane_name(pane) in set(pane_names)]
+            missing = sorted(set(pane_names) - {self._pane_name(pane) for pane in matched})
+            if missing:
+                raise SessionManagerError(
+                    f"Unknown pane names for session '{session.session_name}': {', '.join(missing)}."
+                )
+            return matched
+
+        target_role = role or "agent"
+        return [pane for pane in panes if self._pane_role(pane) == target_role]
+
+    def _get_workspace(self, config: Config, workspace_name: str) -> WorkspaceConfig:
+        workspace = config.workspaces.get(workspace_name)
+        if workspace is None:
+            raise ConfigError(f"Workspace '{workspace_name}' not found in config.")
+        return workspace
+
+    def _find_session(self, workspace_name: str) -> Session | None:
+        return self.server.sessions.get(session_name=workspace_name)
+
+    def _current_session_name(self) -> str | None:
+        pane_id = os.environ.get("TMUX_PANE")
+        if not pane_id:
+            return None
+        output = self.server.cmd("display-message", "-p", "-t", pane_id, "#{session_name}")
+        if output.returncode != 0 or not output.stdout:
+            return None
+        return output.stdout[0].strip()
+
+    @staticmethod
+    def _pane_name(pane: Pane) -> str:
+        return str(pane.show_option("@devmux_name", scope=OptionScope.Pane) or pane.pane_title)
+
+    @staticmethod
+    def _pane_role(pane: Pane) -> str:
+        return str(pane.show_option("@devmux_role", scope=OptionScope.Pane) or "agent")
+
+    @staticmethod
+    def _shell_quote(value: str) -> str:
+        return "'" + value.replace("'", "'\"'\"'") + "'"

devmux/utils/__init__.py

@@ -0,0 +1 @@
+

devmux/utils/config.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+import os
+from typing import Any
+
+import yaml
+
+
+VALID_LAYOUTS = {"duo", "trio", "quad", "focus"}
+VALID_ROLES = {"agent", "logs", "tests", "shell"}
+
+
+class ConfigError(ValueError):
+    """Raised when devmux configuration is invalid."""
+
+
+@dataclass(frozen=True)
+class PaneConfig:
+    name: str
+    role: str
+    command: str
+    cwd: str | None = None
+
+    def resolved_cwd(
+        self, workspace_cwd: str | None = None, base_dir: Path | None = None
+    ) -> Path:
+        cwd = Path(os.path.expanduser(self.cwd or workspace_cwd or "."))
+        if cwd.is_absolute():
+            return cwd.resolve()
+        anchor = base_dir or Path.cwd()
+        return (anchor / cwd).resolve()
+
+
+@dataclass(frozen=True)
+class WorkspaceConfig:
+    layout: str
+    cwd: str | None = None
+    panes: list[PaneConfig] = field(default_factory=list)
+    base_dir: Path = field(default_factory=Path.cwd)
+
+    def validate(self, name: str) -> None:
+        if self.layout not in VALID_LAYOUTS:
+            raise ConfigError(
+                f"Workspace '{name}' uses unsupported layout '{self.layout}'. "
+                f"Choose one of: {', '.join(sorted(VALID_LAYOUTS))}."
+            )
+
+        pane_count = len(self.panes)
+        if pane_count == 0:
+            raise ConfigError(f"Workspace '{name}' must define at least one pane.")
+
+        layout_bounds = {
+            "duo": {2},
+            "trio": {3},
+            "quad": {4},
+            "focus": {2, 3, 4, 5},
+        }
+        if pane_count not in layout_bounds[self.layout]:
+            allowed = ", ".join(str(count) for count in sorted(layout_bounds[self.layout]))
+            raise ConfigError(
+                f"Workspace '{name}' layout '{self.layout}' supports pane counts: {allowed}. "
+                f"Found {pane_count}."
+            )
+
+        seen_names: set[str] = set()
+        for pane in self.panes:
+            if not pane.name.strip():
+                raise ConfigError(f"Workspace '{name}' contains a pane with an empty name.")
+            if pane.name in seen_names:
+                raise ConfigError(
+                    f"Workspace '{name}' defines duplicate pane name '{pane.name}'."
+                )
+            seen_names.add(pane.name)
+
+            if pane.role not in VALID_ROLES:
+                raise ConfigError(
+                    f"Pane '{pane.name}' in workspace '{name}' uses unsupported role "
+                    f"'{pane.role}'. Choose one of: {', '.join(sorted(VALID_ROLES))}."
+                )
+            if not pane.command.strip():
+                raise ConfigError(
+                    f"Pane '{pane.name}' in workspace '{name}' must define a non-empty command."
+                )
+            resolved_cwd = pane.resolved_cwd(self.cwd, self.base_dir)
+            if not resolved_cwd.exists():
+                raise ConfigError(
+                    f"Pane '{pane.name}' in workspace '{name}' references missing cwd "
+                    f"'{resolved_cwd}'."
+                )
+
+
+@dataclass(frozen=True)
+class Config:
+    workspaces: dict[str, WorkspaceConfig] = field(default_factory=dict)
+
+    @classmethod
+    def load(cls, path: Path) -> "Config":
+        with path.open("r", encoding="utf-8") as handle:
+            data = yaml.safe_load(handle) or {}
+
+        if not isinstance(data, dict):
+            raise ConfigError("The config file must contain a top-level mapping.")
+
+        workspaces_data = data.get("workspaces", {})
+        if not isinstance(workspaces_data, dict):
+            raise ConfigError("'workspaces' must be a mapping.")
+
+        workspaces: dict[str, WorkspaceConfig] = {}
+        for workspace_name, raw_workspace in workspaces_data.items():
+            if not isinstance(raw_workspace, dict):
+                raise ConfigError(
+                    f"Workspace '{workspace_name}' must be defined as a mapping."
+                )
+
+            layout = str(raw_workspace.get("layout", "")).strip()
+            workspace_cwd = raw_workspace.get("cwd")
+
+            panes = cls._parse_panes(raw_workspace)
+            workspace = WorkspaceConfig(
+                layout=layout,
+                cwd=workspace_cwd,
+                panes=panes,
+                base_dir=path.parent.resolve(),
+            )
+            workspace.validate(workspace_name)
+            workspaces[workspace_name] = workspace
+
+        return cls(workspaces=workspaces)
+
+    @staticmethod
+    def _parse_panes(raw_workspace: dict[str, Any]) -> list[PaneConfig]:
+        if "panes" in raw_workspace:
+            raw_panes = raw_workspace["panes"]
+        else:
+            raw_agents = raw_workspace.get("agents", [])
+            raw_panes = [
+                {
+                    "name": agent.get("name", ""),
+                    "role": "agent",
+                    "command": Config._legacy_agent_command(agent),
+                    "cwd": agent.get("cwd"),
+                }
+                for agent in raw_agents
+            ]
+
+        if not isinstance(raw_panes, list):
+            raise ConfigError("'panes' must be a list.")
+
+        panes: list[PaneConfig] = []
+        for raw_pane in raw_panes:
+            if not isinstance(raw_pane, dict):
+                raise ConfigError("Each pane definition must be a mapping.")
+
+            name = str(raw_pane.get("name", "")).strip()
+            role = str(raw_pane.get("role", "agent")).strip()
+            command = str(raw_pane.get("command", "")).strip()
+            cwd = raw_pane.get("cwd")
+
+            panes.append(PaneConfig(name=name, role=role, command=command, cwd=cwd))
+
+        return panes
+
+    @staticmethod
+    def _legacy_agent_command(agent: dict[str, Any]) -> str:
+        cmd = str(agent.get("cmd", "")).strip()
+        flags = str(agent.get("flags", "")).strip()
+        return " ".join(part for part in [cmd, flags] if part)
+
+
+def render_preset(preset: str) -> str:
+    presets = {
+        "minimal": """# devmux v0.2 example config
+# Replace the example commands below with the agent CLIs you use daily.
+workspaces:
+  minimal:
+    layout: duo
+    cwd: .
+    panes:
+      - name: claude
+        role: agent
+        command: "claude"
+      - name: codex
+        role: agent
+        command: "codex --approval auto"
+""",
+        "backend": """# devmux v0.2 example config
+# The commands are generic examples. Swap in Claude, Codex, Gemini, Aider, tests, or logs as needed.
+workspaces:
+  backend:
+    layout: trio
+    cwd: .
+    panes:
+      - name: planner
+        role: agent
+        command: "claude"
+      - name: builder
+        role: agent
+        command: "codex --approval auto"
+      - name: logs
+        role: logs
+        command: "docker compose logs -f"
+""",
+        "full-stack": """# devmux v0.2 example config
+# The layout is tuned for two agents plus live tests and logs.
+workspaces:
+  full-stack:
+    layout: quad
+    cwd: .
+    panes:
+      - name: frontend
+        role: agent
+        command: "claude"
+      - name: backend
+        role: agent
+        command: "codex --approval auto"
+      - name: tests
+        role: tests
+        command: "npm test"
+      - name: logs
+        role: logs
+        command: "docker compose logs -f"
+""",
+    }
+    if preset not in presets:
+        raise ConfigError(
+            f"Unknown preset '{preset}'. Choose one of: minimal, backend, full-stack."
+        )
+    return presets[preset]

devmux-0.2.0.dist-info/METADATA

@@ -0,0 +1,288 @@
+Metadata-Version: 2.4
+Name: devmux
+Version: 0.2.0
+Summary: A tmux session manager purpose-built for AI agent CLIs
+Author-email: Ollayor <ollayor@example.com>
+Project-URL: Homepage, https://github.com/olllayor/devmux
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: libtmux>=0.8.2
+Requires-Dist: PyYAML>=5.4
+Requires-Dist: click>=8.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Dynamic: license-file
+
+# devmux
+
+`devmux` is a tmux launcher for developers who use multiple AI agents in the CLI.
+
+It gives you one command to open a repeatable coding cockpit with agent panes, tests, logs, and shell helpers in the right layout and working directories.
+
+## Why it exists
+
+If you already work with tools like Claude Code, Codex, Gemini CLI, Aider, test watchers, and logs, your terminal usually turns into a mess:
+
+- too many panes to rebuild by hand
+- prompts sent to the wrong place
+- different repos and directories across panes
+- no shared setup you can reuse every day
+
+`devmux` fixes that by making your workflow reproducible.
+
+## What it does
+
+- Launch named workspaces from `devmux.yaml`
+- Create real tmux layouts: `duo`, `trio`, `quad`, `focus`
+- Route prompts safely by pane role or pane name
+- Reuse existing sessions with idempotent `start`
+- Rebuild a workspace with `--recreate`
+- Scaffold starter configs with `devmux init`
+- Keep runtime behavior generic while still supporting AI-heavy workflows
+
+## Who it is for
+
+`devmux` is best for developers who:
+
+- already use tmux
+- run 2 to 5 CLI agents or helper panes at once
+- want one command to restore a known working setup
+- want a simple, scriptable alternative to a full TUI dashboard
+
+## Requirements
+
+- macOS or Linux
+- `tmux` installed and available on `PATH`
+- Python 3.8+
+
+Check tmux:
+
+```bash
+tmux -V
+```
+
+## Install
+
+### Option 1: Install from PyPI
+
+Use this after you publish `devmux` to PyPI:
+
+```bash
+python3 -m pip install devmux
+```
+
+### Option 2: Install from GitHub right now
+
+If you want people to try it before a PyPI release:
+
+```bash
+python3 -m pip install "git+https://github.com/olllayor/devmux.git"
+```
+
+### Option 3: Install locally for development
+
+```bash
+git clone https://github.com/olllayor/devmux.git
+cd devmux
+python3 -m pip install -e ".[dev]"
+```
+
+## Quick start
+
+Generate a starter config:
+
+```bash
+devmux init --preset backend
+```
+
+Start the workspace:
+
+```bash
+devmux start backend
+```
+
+Create or reuse a session without attaching:
+
+```bash
+devmux start backend --detach
+```
+
+Resume the same workspace later:
+
+```bash
+devmux resume backend
+```
+
+Send a prompt to all agent panes in the current session:
+
+```bash
+devmux send "review the auth flow"
+```
+
+Target a specific role or pane:
+
+```bash
+devmux send "show me errors" --role logs
+devmux send "run tests" --pane tests
+devmux send "status" --all
+```
+
+List or kill sessions:
+
+```bash
+devmux ls
+devmux kill backend
+```
+
+## Config
+
+Example `devmux.yaml`:
+
+```yaml
+workspaces:
+  backend:
+    layout: trio
+    cwd: ~/projects/tapi
+    panes:
+      - name: planner
+        role: agent
+        command: "claude"
+      - name: builder
+        role: agent
+        command: "codex --approval auto"
+      - name: logs
+        role: logs
+        command: "docker compose logs -f"
+```
+
+Accepted layouts:
+
+- `duo`
+- `trio`
+- `quad`
+- `focus`
+
+Accepted roles:
+
+- `agent`
+- `logs`
+- `tests`
+- `shell`
+
+Legacy `agents` configs are still accepted and mapped to `role: agent`.
+
+## Commands
+
+```bash
+devmux init [--preset minimal|backend|full-stack] [--config PATH] [--force]
+devmux start <workspace> [--config PATH] [--detach] [--recreate]
+devmux attach <workspace>
+devmux resume <workspace>
+devmux ls
+devmux kill <workspace>
+devmux send "<prompt>" [--session NAME] [--all | --role ROLE | --pane NAME ...]
+```
+
+## Typical workflows
+
+### Two-agent coding setup
+
+```yaml
+workspaces:
+  minimal:
+    layout: duo
+    cwd: .
+    panes:
+      - name: claude
+        role: agent
+        command: "claude"
+      - name: codex
+        role: agent
+        command: "codex --approval auto"
+```
+
+### Backend setup with logs
+
+```yaml
+workspaces:
+  backend:
+    layout: trio
+    cwd: .
+    panes:
+      - name: planner
+        role: agent
+        command: "claude"
+      - name: builder
+        role: agent
+        command: "codex --approval auto"
+      - name: logs
+        role: logs
+        command: "docker compose logs -f"
+```
+
+### Full-stack setup with tests and logs
+
+```yaml
+workspaces:
+  full-stack:
+    layout: quad
+    cwd: .
+    panes:
+      - name: frontend
+        role: agent
+        command: "claude"
+      - name: backend
+        role: agent
+        command: "codex --approval auto"
+      - name: tests
+        role: tests
+        command: "npm test"
+      - name: logs
+        role: logs
+        command: "docker compose logs -f"
+```
+
+## How to release it to the world
+
+Use two distribution paths:
+
+1. GitHub for discovery, source, issues, releases, and docs.
+2. PyPI for the simplest install command: `python3 -m pip install devmux`.
+
+Recommended rollout order:
+
+1. Push this repo to GitHub with a clean README, license, and tagged release.
+2. Publish version `0.2.0` to PyPI.
+3. Share a short demo GIF/video showing `devmux init`, `devmux start`, and `devmux send`.
+4. Post it in places where AI-heavy CLI devs already are: X, Reddit, Hacker News, tmux/devtools communities, Discord/Slack groups, and your own network.
+
+The detailed publishing checklist is in [RELEASING.md](/Users/ollayor/Code/Projects/agenix/RELEASING.md).
+
+## Development
+
+Install dev dependencies:
+
+```bash
+python3 -m pip install -e ".[dev]"
+```
+
+Run tests:
+
+```bash
+python3 -m pytest
+```
+
+## Scope
+
+`devmux` v0.2 is intentionally focused:
+
+- no TUI yet
+- no status bar or health dashboard
+- no deep agent-specific integrations
+- no full pane history or recovery system
+
+The goal is to be a reliable painkiller for launching and routing multi-agent CLI sessions.

devmux-0.2.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+devmux/__init__.py,sha256=Wy4CaBWIov4M_oNoBrzzzWN0Imijce7eQKfmNDAMDuo,80
+devmux/cli/main.py,sha256=ROh1PyO8AV-FawspsYIPhqLZLi9NHNM6CijVdN6gKhk,5695
+devmux/core/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+devmux/core/manager.py,sha256=BSUplGPyBaeLs-3d6hOQfUQq1zV21jHSFln4zv_O2h8,9015
+devmux/utils/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+devmux/utils/config.py,sha256=QkWq3n05eaIdxF5p5fdzshETU6NyxRR8OmEBOcdLvz0,7416
+devmux-0.2.0.dist-info/licenses/LICENSE,sha256=m4iEyn9xE5zQzQFhPHGjlmEqA-TjObpB_gVBbpDW56I,1064
+devmux-0.2.0.dist-info/METADATA,sha256=09ScZAVV4k_P_RIsJ-GssUOJ5DYeZAg0WqtUdMm3uso,6084
+devmux-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+devmux-0.2.0.dist-info/entry_points.txt,sha256=NHZ13BwV2-vDZSE_Ca50RWCNYq1AP2t1xOT6Nvh4X4w,48
+devmux-0.2.0.dist-info/top_level.txt,sha256=bgCMo4cQWJs2H9MTXe-WJL9HMboStS61r10A5v11YMg,7
+devmux-0.2.0.dist-info/RECORD,,

devmux-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

devmux-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+devmux = devmux.cli.main:main

devmux-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ollayor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

devmux-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+devmux