hire-ai 0.1.0__py3-none-any.whl

hire/__init__.py

@@ -0,0 +1,3 @@
+"""hire - CLI to orchestrate AI agents (Claude, Codex, Gemini)."""
+
+__version__ = "0.1.0"

hire/adapters/__init__.py

@@ -0,0 +1,21 @@
+"""Agent adapters."""
+
+from .base import AgentAdapter
+from .claude import ClaudeAdapter
+from .codex import CodexAdapter
+from .gemini import GeminiAdapter
+
+
+def get_adapter(agent: str) -> AgentAdapter:
+    """Get an adapter for the specified agent."""
+    adapters = {
+        "claude": ClaudeAdapter,
+        "codex": CodexAdapter,
+        "gemini": GeminiAdapter,
+    }
+    if agent not in adapters:
+        raise ValueError(f"Unknown agent: {agent}. Available: {list(adapters.keys())}")
+    return adapters[agent]()
+
+
+__all__ = ["AgentAdapter", "ClaudeAdapter", "CodexAdapter", "GeminiAdapter", "get_adapter"]

hire/adapters/base.py

@@ -0,0 +1,42 @@
+"""Base adapter class."""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class AgentAdapter(ABC):
+    """Abstract base class for agent adapters."""
+
+    name: str = "base"
+
+    @abstractmethod
+    def ask(
+        self,
+        message: str,
+        session_id: str | None = None,
+        model: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Send a message to the agent and get a response.
+
+        Args:
+            message: The message to send
+            session_id: Optional CLI session ID for continuation
+            model: Optional model to use
+
+        Returns:
+            dict with keys:
+                - response: The agent's response text
+                - session_id: The CLI session ID for future continuation
+                - raw: The raw output from the CLI (for debugging)
+        """
+        pass
+
+    def build_command(
+        self,
+        message: str,
+        session_id: str | None = None,
+        model: str | None = None,
+    ) -> list[str]:
+        """Build the command to execute. Override in subclasses."""
+        raise NotImplementedError

hire/adapters/claude.py

@@ -0,0 +1,74 @@
+"""Claude CLI adapter."""
+
+import json
+import subprocess
+from typing import Any
+
+from ..config import get_adapter_config
+from .base import AgentAdapter
+
+
+class ClaudeAdapter(AgentAdapter):
+    """Adapter for Claude CLI."""
+
+    name = "claude"
+
+    def build_command(
+        self,
+        message: str,
+        session_id: str | None = None,
+        model: str | None = None,
+    ) -> list[str]:
+        """Build the claude command."""
+        config = get_adapter_config("claude")
+        command = config.get("command", "claude")
+        args = config.get("args", [])
+
+        cmd = [command, "-p", message, "--output-format", "json"]
+        cmd.extend(args)
+
+        if session_id:
+            cmd.extend(["--resume", session_id])
+
+        if model:
+            cmd.extend(["--model", model])
+
+        return cmd
+
+    def ask(
+        self,
+        message: str,
+        session_id: str | None = None,
+        model: str | None = None,
+    ) -> dict[str, Any]:
+        """Send a message to Claude and get a response."""
+        cmd = self.build_command(message, session_id, model)
+
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+        )
+
+        if result.returncode != 0:
+            return {
+                "response": None,
+                "session_id": session_id,
+                "error": result.stderr or "Command failed",
+                "raw": result.stdout,
+            }
+
+        try:
+            data = json.loads(result.stdout)
+            return {
+                "response": data.get("result", ""),
+                "session_id": data.get("session_id", session_id),
+                "raw": data,
+            }
+        except json.JSONDecodeError:
+            # If not JSON, return raw output
+            return {
+                "response": result.stdout,
+                "session_id": session_id,
+                "raw": result.stdout,
+            }

hire/adapters/codex.py

@@ -0,0 +1,98 @@
+"""Codex CLI adapter."""
+
+import json
+import subprocess
+from typing import Any
+
+from ..config import get_adapter_config
+from .base import AgentAdapter
+
+
+class CodexAdapter(AgentAdapter):
+    """Adapter for Codex CLI."""
+
+    name = "codex"
+
+    def build_command(
+        self,
+        message: str,
+        session_id: str | None = None,
+        model: str | None = None,
+    ) -> list[str]:
+        """Build the codex command."""
+        config = get_adapter_config("codex")
+        command = config.get("command", "codex")
+        args = config.get("args", [])
+
+        if session_id:
+            # Resume session: codex exec resume <SESSION_ID> "message"
+            cmd = [command, "exec", "resume", session_id, message, "--json", "--skip-git-repo-check"]
+        else:
+            # New session: codex exec "message"
+            cmd = [command, "exec", message, "--json", "--skip-git-repo-check"]
+
+        cmd.extend(args)
+
+        if model:
+            cmd.extend(["--model", model])
+
+        return cmd
+
+    def ask(
+        self,
+        message: str,
+        session_id: str | None = None,
+        model: str | None = None,
+    ) -> dict[str, Any]:
+        """Send a message to Codex and get a response."""
+        cmd = self.build_command(message, session_id, model)
+
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+        )
+
+        if result.returncode != 0:
+            return {
+                "response": None,
+                "session_id": session_id,
+                "error": result.stderr or "Command failed",
+                "raw": result.stdout,
+            }
+
+        # Codex outputs JSONL (one JSON object per line)
+        # Parse all lines and extract the final response
+        lines = result.stdout.strip().split("\n")
+        response_text = ""
+        new_session_id = session_id
+
+        for line in lines:
+            if not line.strip():
+                continue
+            try:
+                event = json.loads(line)
+                event_type = event.get("type", "")
+
+                # Get thread_id from thread.started event
+                if event_type == "thread.started":
+                    new_session_id = event.get("thread_id", new_session_id)
+
+                # Get response text from item.completed with agent_message
+                if event_type == "item.completed":
+                    item = event.get("item", {})
+                    if item.get("type") == "agent_message":
+                        response_text = item.get("text", "")
+
+            except json.JSONDecodeError:
+                continue
+
+        # If no structured response found, use raw output
+        if not response_text:
+            response_text = result.stdout.strip()
+
+        return {
+            "response": response_text,
+            "session_id": new_session_id,
+            "raw": result.stdout,
+        }

hire/adapters/gemini.py

@@ -0,0 +1,91 @@
+"""Gemini CLI adapter."""
+
+import json
+import subprocess
+from typing import Any
+
+from ..config import get_adapter_config
+from .base import AgentAdapter
+
+
+class GeminiAdapter(AgentAdapter):
+    """Adapter for Gemini CLI."""
+
+    name = "gemini"
+
+    def build_command(
+        self,
+        message: str,
+        session_id: str | None = None,
+        model: str | None = None,
+    ) -> list[str]:
+        """Build the gemini command."""
+        config = get_adapter_config("gemini")
+        command = config.get("command", "gemini")
+        args = config.get("args", [])
+
+        # gemini -p "message" -o json -y
+        cmd = [command, "-p", message, "-o", "json"]
+        cmd.extend(args)
+
+        # Resume uses "latest" or index number, not session ID
+        if session_id:
+            cmd.extend(["-r", session_id])
+
+        if model:
+            cmd.extend(["-m", model])
+
+        return cmd
+
+    def ask(
+        self,
+        message: str,
+        session_id: str | None = None,
+        model: str | None = None,
+    ) -> dict[str, Any]:
+        """Send a message to Gemini and get a response."""
+        cmd = self.build_command(message, session_id, model)
+
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+        )
+
+        if result.returncode != 0:
+            return {
+                "response": None,
+                "session_id": session_id,
+                "error": result.stderr or "Command failed",
+                "raw": result.stdout,
+            }
+
+        # Try to parse JSON output
+        try:
+            data = json.loads(result.stdout)
+            # Extract response - structure may vary
+            response_text = ""
+            new_session_id = session_id
+
+            if isinstance(data, dict):
+                response_text = data.get("result", data.get("response", data.get("text", "")))
+                new_session_id = data.get("session_id", data.get("sessionId", session_id))
+            elif isinstance(data, str):
+                response_text = data
+
+            # For continuation, use "latest" as session identifier
+            if not new_session_id:
+                new_session_id = "latest"
+
+            return {
+                "response": response_text,
+                "session_id": new_session_id,
+                "raw": data,
+            }
+        except json.JSONDecodeError:
+            # Plain text output
+            return {
+                "response": result.stdout.strip(),
+                "session_id": "latest",  # Use "latest" for continuation
+                "raw": result.stdout,
+            }

hire/cli.py

@@ -0,0 +1,164 @@
+"""CLI entry point."""
+
+import argparse
+import sys
+
+from . import __version__
+from .commands import run_ask, run_delete, run_sessions, run_show
+
+
+SUBCOMMANDS = {"sessions", "show", "delete", "help", "--help", "-h", "--version"}
+
+
+def main() -> int:
+    """Main entry point."""
+    # Check if first arg is a subcommand, if not, treat as default (hire) action
+    if len(sys.argv) > 1 and sys.argv[1] not in SUBCOMMANDS:
+        # Default action: hire an agent
+        return run_default()
+
+    # Subcommand mode
+    parser = argparse.ArgumentParser(
+        prog="hire",
+        description="Hire AI agents to do tasks (Claude, Codex, Gemini)",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # sessions command
+    sessions_parser = subparsers.add_parser("sessions", help="List sessions")
+    sessions_parser.add_argument(
+        "target",
+        nargs="?",
+        choices=["claude", "codex", "gemini"],
+        help="Filter by agent",
+    )
+    sessions_parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output in JSON format",
+    )
+
+    # show command
+    show_parser = subparsers.add_parser("show", help="Show session details")
+    show_parser.add_argument(
+        "name_or_id",
+        help="Session name or ID",
+    )
+    show_parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output in JSON format",
+    )
+
+    # delete command
+    delete_parser = subparsers.add_parser("delete", help="Delete a session")
+    delete_parser.add_argument(
+        "name_or_id",
+        help="Session name or ID",
+    )
+    delete_parser.add_argument(
+        "-f", "--force",
+        action="store_true",
+        help="Delete without confirmation",
+    )
+
+    args = parser.parse_args()
+
+    if args.command is None:
+        print_usage()
+        return 0
+
+    # Dispatch to command handlers
+    if args.command == "sessions":
+        return run_sessions(args)
+    elif args.command == "show":
+        return run_show(args)
+    elif args.command == "delete":
+        return run_delete(args)
+    else:
+        print_usage()
+        return 1
+
+
+def run_default() -> int:
+    """Run the default hire action."""
+    parser = argparse.ArgumentParser(
+        prog="hire",
+        description="Hire AI agents to do tasks",
+        usage="hire [options] <target> <message>\n       hire <subcommand> [args]",
+    )
+    parser.add_argument(
+        "target",
+        nargs="?",
+        help="Target agent: claude, codex, or gemini",
+    )
+    parser.add_argument(
+        "message",
+        nargs="?",
+        help="Message to send",
+    )
+    parser.add_argument(
+        "-c", "--continue",
+        dest="continue_session",
+        action="store_true",
+        help="Continue the latest session",
+    )
+    parser.add_argument(
+        "-s", "--session",
+        help="Continue a specific session (by name or ID)",
+    )
+    parser.add_argument(
+        "-n", "--name",
+        help="Name for the session",
+    )
+    parser.add_argument(
+        "-m", "--model",
+        help="Model to use",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output in JSON format",
+    )
+
+    args = parser.parse_args()
+    return run_ask(args)
+
+
+def print_usage():
+    """Print usage information."""
+    print("""hire - Hire AI agents to do tasks (Claude, Codex, Gemini)
+
+Usage:
+  hire <target> <message>      Hire an agent to do a task
+  hire -s <session> <message>  Continue a specific session
+  hire sessions [target]       List sessions
+  hire show <name-or-id>       Show session details
+  hire delete <name-or-id>     Delete a session
+
+Targets:
+  claude, codex, gemini
+
+Options:
+  -c, --continue     Continue the latest session
+  -s, --session ID   Continue a specific session
+  -n, --name NAME    Name the session
+  -m, --model MODEL  Specify model
+  --json             Output in JSON format
+
+Examples:
+  hire codex "Design a REST API"
+  hire gemini "Research React 19 features" --json
+  hire -s abc123 "Tell me more"
+  hire sessions codex
+""")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

hire/commands/__init__.py

@@ -0,0 +1,8 @@
+"""CLI commands."""
+
+from .ask import run_ask
+from .sessions import run_sessions
+from .show import run_show
+from .delete import run_delete
+
+__all__ = ["run_ask", "run_sessions", "run_show", "run_delete"]

hire/commands/ask.py

@@ -0,0 +1,143 @@
+"""Ask command implementation."""
+
+import json
+import sys
+from argparse import Namespace
+
+from ..adapters import get_adapter
+from ..session import (
+    create_session,
+    find_session,
+    get_latest_session,
+    list_sessions,
+    save_session,
+)
+
+
+VALID_TARGETS = {"claude", "codex", "gemini"}
+
+
+def run_ask(args: Namespace) -> int:
+    """Run the ask command."""
+    target = args.target
+    message = args.message
+    continue_session = getattr(args, "continue_session", False)
+    session_id = args.session
+    name = args.name
+    model = args.model
+    output_json = args.json
+
+    # Handle case where target is actually the message (when target is omitted)
+    # e.g., "delegate 'message'" -> target='message', message=None
+    if target and target not in VALID_TARGETS and message is None:
+        message = target
+        target = None
+
+    # Load config for defaults
+    from ..config import load_config
+    config = load_config()
+
+    if not target:
+        target = config.get("defaults", {}).get("agent")
+
+    # Determine which session to use
+    cli_session_id = None
+    existing_session = None
+
+    if session_id:
+        # Use specified session
+        existing_session = find_session(session_id)
+        if existing_session:
+            cli_session_id = existing_session.get("cli_session_id")
+            # If target not specified, get it from session
+            if not target:
+                target = existing_session.get("agent")
+        else:
+            print(f"Error: Session not found: {session_id}", file=sys.stderr)
+            return 1
+    elif name:
+        # Check if named session exists
+        existing_session = find_session(name)
+        if existing_session:
+            if continue_session:
+                cli_session_id = existing_session.get("cli_session_id")
+            # If target not specified, get it from session
+            if not target:
+                target = existing_session.get("agent")
+            # else: create new session with this name (will replace)
+    elif continue_session:
+        # Continue latest session
+        if not target:
+            # Try to find latest session across all agents
+            sessions = list_sessions()
+            if sessions:
+                existing_session = sessions[0]
+                target = existing_session.get("agent")
+        else:
+            existing_session = get_latest_session(target)
+        
+        if existing_session:
+            cli_session_id = existing_session.get("cli_session_id")
+        else:
+            print(f"Warning: No previous session found{' for ' + target if target else ''}, starting new session", file=sys.stderr)
+
+    # Validate target
+    if not target:
+        print("Error: Target agent is required (claude, codex, or gemini)", file=sys.stderr)
+        return 1
+
+    # Validate message
+    if not message:
+        print("Error: Message is required", file=sys.stderr)
+        print("Usage: hire <target> <message>", file=sys.stderr)
+        return 1
+
+    # Get the adapter for the target agent
+    try:
+        adapter = get_adapter(target)
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+    # Call the agent
+    result = adapter.ask(message, session_id=cli_session_id, model=model)
+
+    if result.get("error"):
+        print(f"Error: {result['error']}", file=sys.stderr)
+        if result.get("raw"):
+            print(f"Raw output: {result['raw']}", file=sys.stderr)
+        return 1
+
+    # Get the new session ID from the response
+    new_cli_session_id = result.get("session_id")
+
+    # Save or update session
+    if existing_session and cli_session_id:
+        # Update existing session
+        existing_session["cli_session_id"] = new_cli_session_id or cli_session_id
+        if name:
+            existing_session["name"] = name
+        save_session(existing_session)
+        session = existing_session
+    else:
+        # Create new session
+        session = create_session(
+            agent=target,
+            cli_session_id=new_cli_session_id or "unknown",
+            name=name,
+        )
+
+    # Output
+    if output_json:
+        output = {
+            "response": result.get("response"),
+            "session_id": session["id"],
+            "cli_session_id": session["cli_session_id"],
+            "agent": target,
+            "name": session.get("name"),
+        }
+        print(json.dumps(output, indent=2, ensure_ascii=False))
+    else:
+        print(result.get("response", ""))
+
+    return 0

hire/commands/delete.py

@@ -0,0 +1,35 @@
+"""Delete command implementation."""
+
+import sys
+from argparse import Namespace
+
+from ..session import delete_session, find_session
+
+
+def run_delete(args: Namespace) -> int:
+    """Run the delete command."""
+    name_or_id = args.name_or_id
+    force = getattr(args, "force", False)
+
+    session = find_session(name_or_id)
+
+    if not session:
+        print(f"Error: Session not found: {name_or_id}", file=sys.stderr)
+        return 1
+
+    # Confirm deletion unless --force
+    if not force:
+        agent = session.get("agent", "")
+        name = session.get("name", "-")
+        print(f"Delete session {session['id'][:8]} ({agent}, name={name})?")
+        response = input("Type 'yes' to confirm: ")
+        if response.lower() != "yes":
+            print("Cancelled")
+            return 0
+
+    if delete_session(session):
+        print(f"Deleted session: {session['id'][:8]}")
+        return 0
+    else:
+        print(f"Error: Failed to delete session", file=sys.stderr)
+        return 1

hire/commands/sessions.py

@@ -0,0 +1,38 @@
+"""Sessions command implementation."""
+
+import json
+from argparse import Namespace
+
+from ..session import list_sessions
+
+
+def run_sessions(args: Namespace) -> int:
+    """Run the sessions command."""
+    target = args.target
+    output_json = getattr(args, "json", False)
+
+    sessions = list_sessions(agent=target)
+
+    if output_json:
+        print(json.dumps(sessions, indent=2, ensure_ascii=False))
+    else:
+        if not sessions:
+            if target:
+                print(f"No sessions found for {target}")
+            else:
+                print("No sessions found")
+            return 0
+
+        # Print table header
+        print(f"{'AGENT':<10} {'NAME':<20} {'ID':<10} {'UPDATED':<20}")
+        print("-" * 62)
+
+        for session in sessions:
+            agent = session.get("agent", "")
+            name = session.get("name", "-") or "-"
+            session_id = session.get("id", "")[:8]
+            updated = session.get("updated_at", "")[:19].replace("T", " ")
+
+            print(f"{agent:<10} {name:<20} {session_id:<10} {updated:<20}")
+
+    return 0

hire/commands/show.py

@@ -0,0 +1,31 @@
+"""Show command implementation."""
+
+import json
+import sys
+from argparse import Namespace
+
+from ..session import find_session
+
+
+def run_show(args: Namespace) -> int:
+    """Run the show command."""
+    name_or_id = args.name_or_id
+    output_json = getattr(args, "json", False)
+
+    session = find_session(name_or_id)
+
+    if not session:
+        print(f"Error: Session not found: {name_or_id}", file=sys.stderr)
+        return 1
+
+    if output_json:
+        print(json.dumps(session, indent=2, ensure_ascii=False))
+    else:
+        print(f"Session: {session.get('id')}")
+        print(f"Agent:   {session.get('agent')}")
+        print(f"Name:    {session.get('name', '-')}")
+        print(f"CLI ID:  {session.get('cli_session_id')}")
+        print(f"Created: {session.get('created_at')}")
+        print(f"Updated: {session.get('updated_at')}")
+
+    return 0

hire/config.py

@@ -0,0 +1,48 @@
+"""Configuration management."""
+
+import json
+from typing import Any
+
+from .paths import get_config_path
+
+DEFAULT_CONFIG = {
+    "adapters": {
+        "claude": {
+            "command": "claude",
+            "args": ["--dangerously-skip-permissions"]
+        },
+        "codex": {
+            "command": "codex",
+            "args": ["--full-auto"]
+        },
+        "gemini": {
+            "command": "gemini",
+            "args": ["-y"]
+        }
+    },
+    "defaults": {
+        "agent": "claude"
+    }
+}
+
+
+def load_config() -> dict[str, Any]:
+    """Load configuration from file, or return defaults."""
+    config_path = get_config_path()
+    if config_path.exists():
+        with open(config_path) as f:
+            return json.load(f)
+    return DEFAULT_CONFIG.copy()
+
+
+def save_config(config: dict[str, Any]) -> None:
+    """Save configuration to file."""
+    config_path = get_config_path()
+    with open(config_path, "w") as f:
+        json.dump(config, f, indent=2)
+
+
+def get_adapter_config(agent: str) -> dict[str, Any]:
+    """Get configuration for a specific adapter."""
+    config = load_config()
+    return config.get("adapters", {}).get(agent, {})

hire/paths.py

@@ -0,0 +1,53 @@
+"""XDG-compliant path management for hire CLI."""
+
+import os
+from pathlib import Path
+
+APP_NAME = "hire"
+
+
+def get_config_dir() -> Path:
+    """Get XDG config directory (~/.config/hire/)."""
+    xdg_config = os.environ.get("XDG_CONFIG_HOME", "")
+    if xdg_config:
+        base = Path(xdg_config)
+    else:
+        base = Path.home() / ".config"
+
+    config_dir = base / APP_NAME
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir
+
+
+def get_data_dir() -> Path:
+    """Get XDG data directory (~/.local/share/hire/)."""
+    xdg_data = os.environ.get("XDG_DATA_HOME", "")
+    if xdg_data:
+        base = Path(xdg_data)
+    else:
+        base = Path.home() / ".local" / "share"
+
+    data_dir = base / APP_NAME
+    data_dir.mkdir(parents=True, exist_ok=True)
+    return data_dir
+
+
+def get_config_path() -> Path:
+    """Get config file path (~/.config/hire/config.json)."""
+    return get_config_dir() / "config.json"
+
+
+def get_sessions_dir(agent: str | None = None) -> Path:
+    """Get sessions directory for an agent.
+
+    Args:
+        agent: Agent name (claude, codex, gemini). If None, returns base sessions dir.
+
+    Returns:
+        Path to sessions directory.
+    """
+    sessions_dir = get_data_dir() / "sessions"
+    if agent:
+        sessions_dir = sessions_dir / agent
+    sessions_dir.mkdir(parents=True, exist_ok=True)
+    return sessions_dir

hire/session.py

@@ -0,0 +1,163 @@
+"""Session management."""
+
+import json
+import uuid
+from datetime import datetime
+from typing import Any
+
+from .paths import get_data_dir, get_sessions_dir
+
+
+def create_session(agent: str, cli_session_id: str, name: str | None = None) -> dict[str, Any]:
+    """Create a new session."""
+    session = {
+        "id": str(uuid.uuid4()),
+        "cli_session_id": cli_session_id,
+        "agent": agent,
+        "name": name,
+        "created_at": datetime.now().isoformat(),
+        "updated_at": datetime.now().isoformat(),
+    }
+    save_session(session)
+    return session
+
+
+def save_session(session: dict[str, Any]) -> None:
+    """Save a session to file."""
+    session["updated_at"] = datetime.now().isoformat()
+    sessions_dir = get_sessions_dir(session["agent"])
+
+    # Use session ID as filename (1 file per session)
+    filename = f"{session['id']}.json"
+    filepath = sessions_dir / filename
+
+    with open(filepath, "w") as f:
+        json.dump(session, f, indent=2)
+
+    # Update latest pointer
+    latest_path = sessions_dir / "latest.json"
+    with open(latest_path, "w") as f:
+        json.dump({"session_id": session["id"], "filename": filename}, f)
+
+
+def get_latest_session(agent: str) -> dict[str, Any] | None:
+    """Get the latest session for an agent."""
+    sessions_dir = get_sessions_dir(agent)
+    latest_path = sessions_dir / "latest.json"
+
+    if not latest_path.exists():
+        return None
+
+    with open(latest_path) as f:
+        latest = json.load(f)
+
+    filepath = sessions_dir / latest["filename"]
+    if not filepath.exists():
+        return None
+
+    with open(filepath) as f:
+        return json.load(f)
+
+
+def get_session_by_id(session_id: str) -> dict[str, Any] | None:
+    """Get a session by its ID (searches all agents)."""
+    sessions_base = get_sessions_dir()
+
+    if not sessions_base.exists():
+        return None
+
+    for agent_dir in sessions_base.iterdir():
+        if not agent_dir.is_dir():
+            continue
+        for session_file in agent_dir.glob("*.json"):
+            if session_file.name == "latest.json":
+                continue
+            with open(session_file) as f:
+                session = json.load(f)
+                if session["id"] == session_id or session["id"].startswith(session_id):
+                    return session
+    return None
+
+
+def get_session_by_name(name: str) -> dict[str, Any] | None:
+    """Get a session by its name (searches all agents)."""
+    sessions_base = get_sessions_dir()
+
+    if not sessions_base.exists():
+        return None
+
+    for agent_dir in sessions_base.iterdir():
+        if not agent_dir.is_dir():
+            continue
+        for session_file in agent_dir.glob("*.json"):
+            if session_file.name == "latest.json":
+                continue
+            with open(session_file) as f:
+                session = json.load(f)
+                if session.get("name") == name:
+                    return session
+    return None
+
+
+def find_session(name_or_id: str) -> dict[str, Any] | None:
+    """Find a session by name or ID."""
+    # Try by name first
+    session = get_session_by_name(name_or_id)
+    if session:
+        return session
+
+    # Then try by ID
+    return get_session_by_id(name_or_id)
+
+
+def list_sessions(agent: str | None = None) -> list[dict[str, Any]]:
+    """List all sessions, optionally filtered by agent."""
+    sessions_base = get_sessions_dir()
+
+    if not sessions_base.exists():
+        return []
+
+    sessions = []
+
+    if agent:
+        agent_dirs = [sessions_base / agent]
+    else:
+        agent_dirs = [d for d in sessions_base.iterdir() if d.is_dir()]
+
+    for agent_dir in agent_dirs:
+        if not agent_dir.exists():
+            continue
+        for session_file in agent_dir.glob("*.json"):
+            if session_file.name == "latest.json":
+                continue
+            with open(session_file) as f:
+                sessions.append(json.load(f))
+
+    # Sort by updated_at descending
+    sessions.sort(key=lambda s: s.get("updated_at", ""), reverse=True)
+    return sessions
+
+
+def delete_session(session: dict[str, Any]) -> bool:
+    """Delete a session."""
+    sessions_dir = get_sessions_dir(session["agent"])
+
+    # Find and delete the session file
+    for session_file in sessions_dir.glob("*.json"):
+        if session_file.name == "latest.json":
+            continue
+        with open(session_file) as f:
+            s = json.load(f)
+            if s["id"] == session["id"]:
+                session_file.unlink()
+
+                # Update latest if needed
+                latest_path = sessions_dir / "latest.json"
+                if latest_path.exists():
+                    with open(latest_path) as f:
+                        latest = json.load(f)
+                    if latest["session_id"] == session["id"]:
+                        latest_path.unlink()
+
+                return True
+    return False

hire_ai-0.1.0.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: hire-ai
+Version: 0.1.0
+Summary: CLI to orchestrate AI agents (Claude, Codex, Gemini)
+Project-URL: Homepage, https://github.com/nichiki/hire
+Project-URL: Repository, https://github.com/nichiki/hire
+Project-URL: Issues, https://github.com/nichiki/hire/issues
+Author: nichiki
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent,ai,claude,cli,codex,gemini,llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Requires-Dist: twine>=5.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# hire
+
+CLI to orchestrate AI agents (Claude, Codex, Gemini).
+
+## Installation
+
+```bash
+# Using pipx (recommended)
+pipx install hire
+
+# Using pip
+pip install hire
+
+# Using Homebrew
+brew install nichiki/tap/hire
+```
+
+## Prerequisites
+
+You need at least one of the following CLI tools installed:
+
+- [Claude CLI](https://docs.anthropic.com/claude-code)
+- [Codex CLI](https://github.com/openai/codex)
+- [Gemini CLI](https://github.com/google-gemini/gemini-cli)
+
+## Usage
+
+```bash
+# Basic usage - hire an agent
+hire codex "Design a REST API for a todo app"
+hire gemini "Research the latest React 19 features"
+hire claude "Review this code for security issues"
+
+# Continue a session
+hire -c codex "Tell me more about the authentication"
+hire -s SESSION_ID "Follow up question"
+
+# Name a session for later
+hire -n my-project codex "Start designing the architecture"
+hire -s my-project "What about the database schema?"
+
+# Output as JSON
+hire gemini "Summarize this" --json
+
+# Session management
+hire sessions              # List all sessions
+hire sessions codex        # List Codex sessions only
+hire show SESSION_ID       # Show session details
+hire delete SESSION_ID     # Delete a session
+```
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| `-c, --continue` | Continue the latest session |
+| `-s, --session ID` | Continue a specific session |
+| `-n, --name NAME` | Name the session |
+| `-m, --model MODEL` | Specify model to use |
+| `--json` | Output in JSON format |
+
+## Configuration
+
+Config is stored at `~/.config/hire/config.json`:
+
+```json
+{
+  "adapters": {
+    "claude": {
+      "command": "claude",
+      "args": ["--dangerously-skip-permissions"]
+    },
+    "codex": {
+      "command": "codex",
+      "args": ["--full-auto"]
+    },
+    "gemini": {
+      "command": "gemini",
+      "args": ["-y"]
+    }
+  },
+  "defaults": {
+    "agent": "claude"
+  }
+}
+```
+
+## Data Storage
+
+Sessions are stored at `~/.local/share/hire/sessions/`.
+
+## License
+
+MIT

hire_ai-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+hire/__init__.py,sha256=-V9lKavG7egEg5jYKkWGmwMTdpZzvGX_Tkl5sM9U6l0,90
+hire/cli.py,sha256=jGCt6rAKTy_Ydk4sorBAzJ6uSfuuJDeAEVgxyZ14pqg,4244
+hire/config.py,sha256=s058dSnojmIdT1KRULWXchdMv6WM9aZ8CKgCqMGdVvA,1164
+hire/paths.py,sha256=PMLwEil1qRmW-9fJ-nTnvWZOUuJvMc-N54xrPp2NHfA,1372
+hire/session.py,sha256=Y-A2zCqiVshEOkBTNTAgaYu_FtCy1JBp4R91NMs5ffY,4874
+hire/adapters/__init__.py,sha256=Hl3ZpDFaWQL0RSKT_XaNTWHwMP6VQMorq7Ce_pn3qpU,612
+hire/adapters/base.py,sha256=rubjoIXu7S8nIhBhksejR_Pb5YG4kwTZUj3dAMff_l4,1105
+hire/adapters/claude.py,sha256=tM7G25jGqinjK_7QjtF_N0E089V9p1dzNReXJnq0VO4,1929
+hire/adapters/codex.py,sha256=_4MXGTz-0YujuutDVCliaj9P94bm-Z1yNEElRtN3wzA,2895
+hire/adapters/gemini.py,sha256=Qm_e1zzhxu2ooXANfFvVCwzxteVatlbDnBZeuf-jHNw,2613
+hire/commands/__init__.py,sha256=sp3kdLPcKmqqgh_PyiOyDxJeHhnCHw0GIaoHWccgSCk,204
+hire/commands/ask.py,sha256=tsM3VK3i06zTQgb0iEAXX97_13b9bHVyX8Ju7dV369g,4490
+hire/commands/delete.py,sha256=1fLZ64xmyIzR5s7i7lsNe-WornsD_qsOAe1cCdOodDU,991
+hire/commands/sessions.py,sha256=aIsh8oC4N3KtMeUdIrCvU3hONMxAfV_Z4qnprBiP62k,1073
+hire/commands/show.py,sha256=gztFedJ553fvru0dPbHyperOMXDew-Yri3E3APu9d3c,860
+hire_ai-0.1.0.dist-info/METADATA,sha256=FCFDGQIV4XBQ7ZhLCHq9hlJ6HRP2nahzJw3ievV3y9s,3151
+hire_ai-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+hire_ai-0.1.0.dist-info/entry_points.txt,sha256=oq7wq8Ju9C2Lw79ljxSkQIaeKOHA_aIN9JKQAaDbz_Q,39
+hire_ai-0.1.0.dist-info/licenses/LICENSE,sha256=Hj8NYmaOGk4xCcCYqD_5U91CVJwcJXEFSMWS965dUI0,1064
+hire_ai-0.1.0.dist-info/RECORD,,

hire_ai-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

hire_ai-0.1.0.dist-info/entry_points.txt

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

hire_ai-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 nichiki
+
+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.