redis-flags 0.1.0__py3-none-any.whl

redis_flags/commands/__init__.py

@@ -0,0 +1 @@
+from . import flag, user, cohort, history

redis_flags/commands/cohort.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from ..config import get_env, get_redis_url
+from ..connection import get_client
+from ..output import (
+    print_cohorts_table, print_cohort_panel,
+    print_success, print_error
+)
+from redis_feature_flags import FeatureFlags
+from redis_feature_flags.exceptions import FlagNotFoundError
+
+app = typer.Typer()
+
+
+def get_flags(env: Optional[str], redis_url: Optional[str]) -> FeatureFlags:
+    resolved_env = get_env(env)
+    resolved_url = get_redis_url(redis_url)
+    client = get_client(resolved_url)
+    return FeatureFlags(client, env=resolved_env)
+
+
+@app.command("create-cohort")
+def create_cohort(
+    cohort_name: str = typer.Argument(..., help="Cohort name"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Create a new cohort.
+
+    Example:
+        redis-flags create-cohort beta-testers
+    """
+    flags = get_flags(env, redis_url)
+    flags.create_cohort(cohort_name)
+    print_success(f"Created cohort [bold]{cohort_name}[/bold]")
+
+
+@app.command("delete-cohort")
+def delete_cohort(
+    cohort_name: str = typer.Argument(..., help="Cohort name"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+    confirm: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
+):
+    """
+    Delete a cohort and clean up all member reverse index entries.
+
+    Example:
+        redis-flags delete-cohort beta-testers
+        redis-flags delete-cohort beta-testers --yes
+    """
+    if not confirm:
+        typer.confirm(
+            f"Delete cohort '{cohort_name}'? This cannot be undone.",
+            abort=True,
+        )
+    flags = get_flags(env, redis_url)
+    flags._cohorts.delete(cohort_name)
+    print_success(f"Deleted cohort [bold]{cohort_name}[/bold]")
+
+
+@app.command("add-to-cohort")
+def add_to_cohort(
+    cohort_name: str = typer.Argument(..., help="Cohort name"),
+    user_id: str = typer.Argument(..., help="User ID to add"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Add a user to a cohort.
+
+    Example:
+        redis-flags add-to-cohort beta-testers alice
+    """
+    flags = get_flags(env, redis_url)
+    flags.add_to_cohort(cohort_name, user_id)
+    print_success(f"Added [bold]{user_id}[/bold] to cohort [bold]{cohort_name}[/bold]")
+
+
+@app.command("remove-from-cohort")
+def remove_from_cohort(
+    cohort_name: str = typer.Argument(..., help="Cohort name"),
+    user_id: str = typer.Argument(..., help="User ID to remove"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Remove a user from a cohort.
+
+    Example:
+        redis-flags remove-from-cohort beta-testers alice
+    """
+    flags = get_flags(env, redis_url)
+    flags.remove_from_cohort(cohort_name, user_id)
+    print_success(f"Removed [bold]{user_id}[/bold] from cohort [bold]{cohort_name}[/bold]")
+
+
+@app.command("list-cohorts")
+def list_cohorts(
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    List all cohorts.
+
+    Example:
+        redis-flags list-cohorts
+    """
+    flags = get_flags(env, redis_url)
+    cohorts = flags._cohorts.list_cohorts()
+    print_cohorts_table(cohorts)
+
+
+@app.command("inspect-cohort")
+def inspect_cohort(
+    cohort_name: str = typer.Argument(..., help="Cohort name"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Show all members of a cohort.
+
+    Example:
+        redis-flags inspect-cohort beta-testers
+    """
+    flags = get_flags(env, redis_url)
+    members = flags._cohorts.get_members(cohort_name)
+    print_cohort_panel(cohort_name, list(members))

redis_flags/commands/flag.py

@@ -0,0 +1,213 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from ..config import get_env, get_redis_url
+from ..connection import get_client
+from ..output import (
+    print_flags_table, print_flag_panel,
+    print_success, print_error
+)
+from redis_feature_flags import FeatureFlags
+from redis_feature_flags.exceptions import (
+    FlagNotFoundError, InvalidRolloutError
+)
+
+import getpass
+
+app = typer.Typer()
+console = Console()
+
+
+def get_flags(env: Optional[str], redis_url: Optional[str]) -> FeatureFlags:
+    """Build FeatureFlags instance from CLI options."""
+    resolved_env = get_env(env)
+    resolved_url = get_redis_url(redis_url)
+    client = get_client(resolved_url)
+    return FeatureFlags(client, env=resolved_env)
+
+
+@app.command("create")
+def create(
+    flag_name: str = typer.Argument(..., help="Flag name"),
+    rollout: int = typer.Option(0, "--rollout", "-r", help="Rollout percentage 0-100"),
+    created_by: str = typer.Option(getpass.getuser(), "--created-by", help="Who is creating this flag"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Create a new feature flag.
+
+    Example:
+        redis-flags create dark_mode
+        redis-flags create dark_mode --rollout 10
+        redis-flags create dark_mode --rollout 10 --created-by alice
+    """
+    try:
+        flags = get_flags(env, redis_url)
+        flags.create(flag_name, rollout=rollout, created_by=created_by)
+        print_success(f"Created flag [bold]{flag_name}[/bold] (rollout: {rollout}%)")
+    except InvalidRolloutError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command("enable")
+def enable(
+    flag_name: str = typer.Argument(..., help="Flag name"),
+    updated_by: str = typer.Option(getpass.getuser(), "--updated-by", help="Who is enabling this flag"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Enable a feature flag.
+
+    Example:
+        redis-flags enable dark_mode
+        redis-flags enable dark_mode --updated-by alice
+    """
+    try:
+        flags = get_flags(env, redis_url)
+        flags.enable(flag_name, updated_by=updated_by)
+        print_success(f"Enabled [bold]{flag_name}[/bold]")
+    except FlagNotFoundError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command("disable")
+def disable(
+    flag_name: str = typer.Argument(..., help="Flag name"),
+    updated_by: str = typer.Option(getpass.getuser(), "--updated-by", help="Who is disabling this flag"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Disable a feature flag — instant kill switch.
+
+    Example:
+        redis-flags disable dark_mode
+        redis-flags disable dark_mode --updated-by alice
+    """
+    try:
+        flags = get_flags(env, redis_url)
+        flags.disable(flag_name, updated_by=updated_by)
+        print_success(f"Disabled [bold]{flag_name}[/bold]")
+    except FlagNotFoundError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command("set-rollout")
+def set_rollout(
+    flag_name: str = typer.Argument(..., help="Flag name"),
+    percent: int = typer.Argument(..., help="Rollout percentage 0-100"),
+    updated_by: str = typer.Option(getpass.getuser(), "--updated-by", help="Who is updating this flag"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Set the rollout percentage for a flag.
+
+    Example:
+        redis-flags set-rollout dark_mode 50
+        redis-flags set-rollout dark_mode 100
+    """
+    try:
+        flags = get_flags(env, redis_url)
+        flags.set_rollout(flag_name, percent, updated_by=updated_by)
+        print_success(f"Rollout for [bold]{flag_name}[/bold] set to {percent}%")
+    except (FlagNotFoundError, InvalidRolloutError) as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command("delete")
+def delete(
+    flag_name: str = typer.Argument(..., help="Flag name"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+    confirm: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
+):
+    """
+    Delete a feature flag permanently.
+
+    Example:
+        redis-flags delete dark_mode
+        redis-flags delete dark_mode --yes
+    """
+    if not confirm:
+        typer.confirm(
+            f"Delete flag '{flag_name}'? This cannot be undone.",
+            abort=True,
+        )
+    try:
+        flags = get_flags(env, redis_url)
+        flags.delete(flag_name)
+        print_success(f"Deleted flag [bold]{flag_name}[/bold]")
+    except FlagNotFoundError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command("list")
+def list_flags(
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    List all feature flags.
+
+    Example:
+        redis-flags list
+        redis-flags --env prod list
+    """
+    flags = get_flags(env, redis_url)
+    flag_names = flags.list_flags()
+    flag_data = []
+    for name in flag_names:
+        data = flags.get(name)
+        data["name"] = name
+        flag_data.append(data)
+    print_flags_table(flag_data)
+
+
+@app.command("inspect")
+def inspect(
+    flag_name: str = typer.Argument(..., help="Flag name"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Show detailed information about a flag including users and cohorts.
+
+    Example:
+        redis-flags inspect dark_mode
+    """
+    try:
+        flags = get_flags(env, redis_url)
+        resolved_env = get_env(env)
+        resolved_url = get_redis_url(redis_url)
+        client = get_client(resolved_url)
+
+        from redis_feature_flags.schema import SchemaKeys
+        schema = SchemaKeys(env=resolved_env)
+
+        data = flags.get(flag_name)
+        data["name"] = flag_name
+
+        users = [
+            u.decode() for u in
+            client.smembers(schema.flag_users(flag_name))
+        ]
+        cohorts = [
+            c.decode() for c in
+            client.smembers(schema.flag_cohorts(flag_name))
+        ]
+        print_flag_panel(data, users, cohorts)
+    except FlagNotFoundError as e:
+        print_error(str(e))
+        raise typer.Exit(1)

redis_flags/commands/history.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+app = typer.Typer()
+console = Console()
+
+
+@app.command("history")
+def history(
+    flag_name: str = typer.Argument(..., help="Flag name"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Show version history for a flag.
+
+    Example:
+        redis-flags history dark_mode
+    """
+    console.print("[yellow]History coming in v1.1[/yellow]")
+
+
+@app.command("rollback")
+def rollback(
+    flag_name: str = typer.Argument(..., help="Flag name"),
+    version: int = typer.Option(..., "--version", "-v", help="Version to roll back to"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Roll back a flag to a previous version.
+
+    Example:
+        redis-flags rollback dark_mode --version 2
+    """
+    console.print("[yellow]Rollback coming in v1.1[/yellow]")

redis_flags/commands/user.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from ..config import get_env, get_redis_url
+from ..connection import get_client
+from ..output import print_success, print_error
+from redis_feature_flags import FeatureFlags
+from redis_feature_flags.exceptions import FlagNotFoundError
+
+app = typer.Typer()
+
+
+def get_flags(env: Optional[str], redis_url: Optional[str]) -> FeatureFlags:
+    resolved_env = get_env(env)
+    resolved_url = get_redis_url(redis_url)
+    client = get_client(resolved_url)
+    return FeatureFlags(client, env=resolved_env)
+
+
+@app.command("add-user")
+def add_user(
+    flag_name: str = typer.Argument(..., help="Flag name"),
+    user_id: str = typer.Argument(..., help="User ID to add"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Add a user to a flag's allowlist.
+
+    Example:
+        redis-flags add-user dark_mode alice
+    """
+    try:
+        flags = get_flags(env, redis_url)
+        flags.add_user(flag_name, user_id)
+        print_success(f"Added [bold]{user_id}[/bold] to flag [bold]{flag_name}[/bold]")
+    except FlagNotFoundError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command("remove-user")
+def remove_user(
+    flag_name: str = typer.Argument(..., help="Flag name"),
+    user_id: str = typer.Argument(..., help="User ID to remove"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Remove a user from a flag's allowlist.
+
+    Example:
+        redis-flags remove-user dark_mode alice
+    """
+    flags = get_flags(env, redis_url)
+    flags.remove_user(flag_name, user_id)
+    print_success(f"Removed [bold]{user_id}[/bold] from flag [bold]{flag_name}[/bold]")

redis_flags/config.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Optional
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+import tomli_w
+
+CONFIG_PATH = Path.home() / ".redis-flags.toml"
+
+
+def read_config() -> dict:
+    """
+    Read config from ~/.redis-flags.toml.
+    Returns empty dict if file does not exist.
+    """
+    if not CONFIG_PATH.exists():
+        return {}
+    with open(CONFIG_PATH, "rb") as f:
+        return tomllib.load(f)
+
+
+def write_config(data: dict) -> None:
+    """
+    Write config to ~/.redis-flags.toml.
+    Creates the file if it does not exist.
+    """
+    with open(CONFIG_PATH, "wb") as f:
+        tomli_w.dump(data, f)
+
+
+def get_env(env_override: Optional[str] = None) -> str:
+    """
+    Resolve the active environment.
+
+    Priority:
+        1. --env flag passed directly to command
+        2. env saved in ~/.redis-flags.toml
+        3. Neither set → raise error with helpful message
+
+    Args:
+        env_override: value from --env flag. None if not passed.
+
+    Returns:
+        The active environment string e.g. "prod", "staging", "dev"
+
+    Raises:
+        SystemExit: if no environment is set anywhere.
+    """
+    if env_override:
+        return env_override
+
+    config = read_config()
+    env = config.get("env")
+
+    if not env:
+        from rich.console import Console
+        console = Console()
+        console.print("\n[red]Error:[/red] No environment set.\n")
+        console.print("  Set a default environment:")
+        console.print("    [cyan]redis-flags use prod[/cyan]")
+        console.print("    [cyan]redis-flags use staging[/cyan]")
+        console.print("    [cyan]redis-flags use dev[/cyan]\n")
+        console.print("  Or specify for this command:")
+        console.print("    [cyan]redis-flags --env prod list[/cyan]\n")
+        raise SystemExit(1)
+
+    return env
+
+
+def get_redis_url(url_override: Optional[str] = None) -> str:
+    """
+    Resolve the Redis URL.
+
+    Priority:
+        1. --redis-url flag passed directly to command
+        2. redis_url saved in ~/.redis-flags.toml
+        3. Default: redis://localhost:6379
+
+    Args:
+        url_override: value from --redis-url flag. None if not passed.
+
+    Returns:
+        Redis URL string.
+    """
+    if url_override:
+        return url_override
+
+    config = read_config()
+    return config.get("redis_url", "redis://localhost:6379")

redis_flags/connection.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import redis
+from rich.console import Console
+
+console = Console()
+
+
+def get_client(redis_url: str) -> redis.Redis:
+    """
+    Create and verify a Redis client connection.
+
+    Args:
+        redis_url: Full Redis URL e.g. redis://localhost:6379
+                   Supports auth: redis://:password@host:6379
+
+    Returns:
+        Connected Redis client.
+
+    Raises:
+        SystemExit: if Redis is unreachable.
+    """
+    try:
+        client = redis.Redis.from_url(redis_url, decode_responses=False)
+        client.ping()
+        return client
+    except redis.ConnectionError:
+        console.print(f"\n[red]Error:[/red] Cannot connect to Redis at {redis_url}\n")
+        console.print("  Start Redis locally:")
+        console.print("    [cyan]brew services start redis[/cyan]       (macOS)")
+        console.print("    [cyan]sudo systemctl start redis[/cyan]      (Linux)")
+        console.print("    [cyan]docker run -p 6379:6379 redis[/cyan]   (Docker)\n")
+        console.print("  Or set a custom Redis URL:")
+        console.print("    [cyan]redis-flags --redis-url redis://your-host:6379 list[/cyan]\n")
+        raise SystemExit(1)
+    except redis.AuthenticationError:
+        console.print(f"\n[red]Error:[/red] Redis authentication failed.\n")
+        console.print("  Provide credentials in the URL:")
+        console.print("    [cyan]redis-flags --redis-url redis://:password@host:6379 list[/cyan]\n")
+        raise SystemExit(1)

redis_flags/main.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from .config import read_config, write_config, get_env, get_redis_url
+from .connection import get_client
+from .commands import flag, user, cohort, history
+
+app = typer.Typer(
+    name="redis-flags",
+    help="Manage Redis feature flags from your terminal.",
+    no_args_is_help=True,
+)
+
+app.add_typer(flag.app,    name="", help="")
+app.add_typer(user.app,    name="", help="")
+app.add_typer(cohort.app,  name="", help="")
+app.add_typer(history.app, name="", help="")
+
+console = Console()
+
+
+@app.command("use")
+def use_env(
+    env: str = typer.Argument(..., help="Environment to use e.g. prod staging dev"),
+):
+    """
+    Set the active environment for all subsequent commands.
+
+    Example:
+        redis-flags use prod
+        redis-flags use staging
+        redis-flags use dev
+    """
+    config = read_config()
+    config["env"] = env
+    write_config(config)
+    console.print(f"[green]✓[/green] Environment set to [bold]{env}[/bold]")
+
+
+@app.command("status")
+def status(
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL"),
+):
+    """
+    Show current context — environment and Redis connection.
+
+    Example:
+        redis-flags status
+    """
+    config = read_config()
+    env = config.get("env", "[red]not set[/red]")
+    url = get_redis_url(redis_url)
+
+    connected = False
+    try:
+        client = get_client(url)
+        connected = True
+    except SystemExit:
+        pass
+
+    connection_status = "[green]connected ✓[/green]" if connected else "[red]unreachable ✗[/red]"
+
+    lines = [
+        f"[bold]Environment[/bold]   {env}",
+        f"[bold]Redis URL[/bold]     {url}",
+        f"[bold]Redis[/bold]         {connection_status}",
+    ]
+
+    console.print(Panel(
+        "\n".join(lines),
+        title="[bold cyan]Current context[/bold cyan]",
+        expand=False,
+    ))

redis_flags/output.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Dict, List
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich import box
+from datetime import datetime, timezone
+
+console = Console()
+
+
+def format_enabled(value: str) -> str:
+    """Format enabled field as colored yes/no."""
+    if value == "1":
+        return "[green]yes[/green]"
+    return "[red]no[/red]"
+
+
+def format_rollout(value: str) -> str:
+    """Format rollout as percentage string."""
+    return f"{value}%"
+
+def format_timestamp(value: str) -> str:
+    if not value or value == "0":
+        return "never"
+    try:
+        dt = datetime.fromtimestamp(int(value), tz=timezone.utc)
+        return dt.strftime("%Y-%m-%d %H:%M UTC")
+    except (ValueError, OSError):
+        return value
+
+
+def print_flags_table(flags: List[Dict[str, Any]]) -> None:
+    """
+    Print a list of flags as a rich table.
+    Used by: redis-flags list
+    """
+    if not flags:
+        console.print("[yellow]No flags found.[/yellow]")
+        return
+
+    table = Table(box=box.ROUNDED, show_header=True, header_style="bold cyan")
+    table.add_column("Flag", style="bold")
+    table.add_column("Enabled")
+    table.add_column("Rollout")
+    table.add_column("Updated by")
+    table.add_column("Updated at")
+
+    for flag in flags:
+        table.add_row(
+            flag.get("name", ""),
+            format_enabled(flag.get("enabled", "0")),
+            format_rollout(flag.get("rollout", "0")),
+            flag.get("updated_by", ""),
+            format_timestamp(flag.get("updated_at", "0")),
+        )
+
+    console.print(table)
+
+
+def print_flag_panel(
+    flag: Dict[str, Any],
+    users: List[str],
+    cohorts: List[str],
+) -> None:
+    """
+    Print detailed flag info as a rich panel.
+    Used by: redis-flags inspect {flag_name}
+    """
+    lines = []
+    lines.append(f"[bold]Enabled[/bold]      {format_enabled(flag.get('enabled', '0'))}")
+    lines.append(f"[bold]Rollout[/bold]      {format_rollout(flag.get('rollout', '0'))}")
+    lines.append(f"[bold]Version[/bold]      {flag.get('flag_version', '1')}")
+    lines.append(f"[bold]Expires[/bold]      {format_timestamp(flag.get('expires_at', '0'))}")
+    lines.append(f"[bold]Created by[/bold]   {flag.get('created_by', '')}")
+    lines.append(f"[bold]Created at[/bold]   {format_timestamp(flag.get('created_at', '0'))}")
+    lines.append(f"[bold]Updated by[/bold]   {flag.get('updated_by', '')}")
+    lines.append(f"[bold]Updated at[/bold]   {format_timestamp(flag.get('updated_at', '0'))}")
+
+    if users:
+        lines.append("")
+        lines.append("[bold]Users[/bold]")
+        for user in sorted(users):
+            lines.append(f"  {user}")
+    else:
+        lines.append("")
+        lines.append("[bold]Users[/bold]      [dim]none[/dim]")
+
+    if cohorts:
+        lines.append("")
+        lines.append("[bold]Cohorts[/bold]")
+        for cohort in sorted(cohorts):
+            lines.append(f"  {cohort}")
+    else:
+        lines.append("")
+        lines.append("[bold]Cohorts[/bold]    [dim]none[/dim]")
+
+    console.print(Panel(
+        "\n".join(lines),
+        title=f"[bold cyan]{flag.get('name', '')}[/bold cyan]",
+        expand=False,
+    ))
+
+
+def print_cohorts_table(cohorts: List[str]) -> None:
+    """
+    Print a list of cohorts as a rich table.
+    Used by: redis-flags list-cohorts
+    """
+    if not cohorts:
+        console.print("[yellow]No cohorts found.[/yellow]")
+        return
+
+    table = Table(box=box.ROUNDED, show_header=True, header_style="bold cyan")
+    table.add_column("Cohort", style="bold")
+
+    for cohort in sorted(cohorts):
+        table.add_row(cohort)
+
+    console.print(table)
+
+
+def print_cohort_panel(cohort_name: str, members: List[str]) -> None:
+    """
+    Print detailed cohort info as a rich panel.
+    Used by: redis-flags inspect-cohort {cohort_name}
+    """
+    lines = []
+    lines.append(f"[bold]Members[/bold]   {len(members)}")
+
+    if members:
+        lines.append("")
+        for member in sorted(members):
+            lines.append(f"  {member}")
+    else:
+        lines.append("")
+        lines.append("  [dim]no members[/dim]")
+
+    console.print(Panel(
+        "\n".join(lines),
+        title=f"[bold cyan]{cohort_name}[/bold cyan]",
+        expand=False,
+    ))
+
+
+def print_success(message: str) -> None:
+    """Print a green success message."""
+    console.print(f"[green]✓[/green] {message}")
+
+
+def print_error(message: str) -> None:
+    """Print a red error message."""
+    console.print(f"[red]Error:[/red] {message}")
+
+
+def print_warning(message: str) -> None:
+    """Print a yellow warning message."""
+    console.print(f"[yellow]Warning:[/yellow] {message}")

redis_flags-0.1.0.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: redis-flags
+Version: 0.1.0
+Summary: CLI for redis-feature-flags — manage feature flags from your terminal.
+License: MIT
+Keywords: cli,feature-flags,redis
+Requires-Python: >=3.9
+Requires-Dist: redis-feature-flags>=0.1.0
+Requires-Dist: redis>=4.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: tomli-w
+Requires-Dist: tomli>=2.0.0; python_version < '3.11'
+Requires-Dist: typer>=0.9.0
+Provides-Extra: dev
+Requires-Dist: fakeredis>=2.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: typer[testing]>=0.9.0; extra == 'dev'

redis_flags-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+redis_flags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+redis_flags/config.py,sha256=1gutwKeCsjlI_BERyGwrUSRX4vJ54DurAWoCASfRoMo,2425
+redis_flags/connection.py,sha256=umOTKosJPWuM6jzw3EBaQo0U6Uh2rxRqUNsf4KXGd7Q,1480
+redis_flags/main.py,sha256=xnOLeR3ZSNK9g6Y4DX9-Wfn0anzso_n3n_DGUD7mN-o,1977
+redis_flags/output.py,sha256=OmUpuBKQRpyo8FjuDjaIdBT8hWE1ukjWjFdyXyixIJY,4726
+redis_flags/commands/__init__.py,sha256=fRdr-VtmLBr_rfT8F2gpvOPSasPTZ2Db-Z1nu-ijHrQ,41
+redis_flags/commands/cohort.py,sha256=HXQGwhp6jKbXhppgww50TBnGIWp1CIFbKut40zyH9co,4323
+redis_flags/commands/flag.py,sha256=mCUDvjm-hErQrWKZgra_cgfSdSBvvPa9mJbbc5kWUsI,6941
+redis_flags/commands/history.py,sha256=Qe-5gRlkcvzPGbkGJ6n79M0zD5bIOS8DY2NJnWNfz4M,1151
+redis_flags/commands/user.py,sha256=gnu-d9LcJatPwg9HbQ40o0ITt_GysWED2QrdglAUoDw,1946
+redis_flags-0.1.0.dist-info/METADATA,sha256=reUUbmOZ0TYki4Bsj0z1HAP2FOBQp67NHNvqRzfpafg,618
+redis_flags-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+redis_flags-0.1.0.dist-info/entry_points.txt,sha256=OCUxGN3dw1t9WpYdXVffvHsuJ8GDfBBbzfgC2Cone-4,53
+redis_flags-0.1.0.dist-info/RECORD,,

redis_flags-0.1.0.dist-info/WHEEL

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

redis_flags-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+redis-flags = redis_flags.main:app