Add users/teams/tags commands, remove deprecated root commands

Implement basic users (list, get), teams (list, get), and tags (list,
get, create, delete) command groups with full API client modules. Remove
deprecated qualytics init and qualytics show-config forwarding commands
for V1 cleanup. Verify checks activate is properly visible.

Author: josecsotomorales

qualytics/api/tags.py

@@ -0,0 +1,56 @@
+"""Tag API operations using the centralized client."""
+
+from ..api.client import QualyticsClient
+
+
+def get_tag(client: QualyticsClient, tag_id: int) -> dict:
+    """Get a single tag by ID."""
+    response = client.get(f"tags/{tag_id}")
+    return response.json()
+
+
+def list_tags(
+    client: QualyticsClient,
+    *,
+    page: int = 1,
+    size: int = 100,
+) -> dict:
+    """List tags with pagination.
+
+    Returns the raw paginated response: {items, total, page, size}.
+    """
+    params: dict = {"page": page, "size": size}
+    response = client.get("tags", params=params)
+    return response.json()
+
+
+def list_all_tags(client: QualyticsClient) -> list[dict]:
+    """Fetch ALL tags across all pages."""
+    page = 1
+    size = 100
+    all_tags: list[dict] = []
+
+    while True:
+        data = list_tags(client, page=page, size=size)
+        items = data.get("items", [])
+        all_tags.extend(items)
+        total = data.get("total", 0)
+        if page * size >= total:
+            break
+        page += 1
+
+    return all_tags
+
+
+def create_tag(client: QualyticsClient, payload: dict) -> dict:
+    """Create a new tag. Returns the created tag with ID."""
+    response = client.post("tags", json=payload)
+    return response.json()
+
+
+def delete_tag(client: QualyticsClient, tag_id: int) -> dict:
+    """Delete a tag by ID."""
+    response = client.delete(f"tags/{tag_id}")
+    if not response.content or response.status_code == 204:
+        return {"success": True, "message": "Tag deleted successfully"}
+    return response.json()

qualytics/api/teams.py

@@ -0,0 +1,42 @@
+"""Team API operations using the centralized client."""
+
+from ..api.client import QualyticsClient
+
+
+def get_team(client: QualyticsClient, team_id: int) -> dict:
+    """Get a single team by ID."""
+    response = client.get(f"teams/{team_id}")
+    return response.json()
+
+
+def list_teams(
+    client: QualyticsClient,
+    *,
+    page: int = 1,
+    size: int = 100,
+) -> dict:
+    """List teams with pagination.
+
+    Returns the raw paginated response: {items, total, page, size}.
+    """
+    params: dict = {"page": page, "size": size}
+    response = client.get("teams", params=params)
+    return response.json()
+
+
+def list_all_teams(client: QualyticsClient) -> list[dict]:
+    """Fetch ALL teams across all pages."""
+    page = 1
+    size = 100
+    all_teams: list[dict] = []
+
+    while True:
+        data = list_teams(client, page=page, size=size)
+        items = data.get("items", [])
+        all_teams.extend(items)
+        total = data.get("total", 0)
+        if page * size >= total:
+            break
+        page += 1
+
+    return all_teams

qualytics/api/users.py

@@ -0,0 +1,42 @@
+"""User API operations using the centralized client."""
+
+from ..api.client import QualyticsClient
+
+
+def get_user(client: QualyticsClient, user_id: int) -> dict:
+    """Get a single user by ID."""
+    response = client.get(f"users/{user_id}")
+    return response.json()
+
+
+def list_users(
+    client: QualyticsClient,
+    *,
+    page: int = 1,
+    size: int = 100,
+) -> dict:
+    """List users with pagination.
+
+    Returns the raw paginated response: {items, total, page, size}.
+    """
+    params: dict = {"page": page, "size": size}
+    response = client.get("users", params=params)
+    return response.json()
+
+
+def list_all_users(client: QualyticsClient) -> list[dict]:
+    """Fetch ALL users across all pages."""
+    page = 1
+    size = 100
+    all_users: list[dict] = []
+
+    while True:
+        data = list_users(client, page=page, size=size)
+        items = data.get("items", [])
+        all_users.extend(items)
+        total = data.get("total", 0)
+        if page * size >= total:
+            break
+        page += 1
+
+    return all_users

qualytics/cli/main.py

@@ -45,37 +45,3 @@ def version_callback(
 
     print("\nRun [bold]'qualytics --help'[/bold] for more details.\n")
     raise typer.Exit()
-
-
-@app.command(hidden=True, deprecated=True)
-def show_config():
-    """[Deprecated] Use 'qualytics auth status' instead."""
-    print(
-        "[bold yellow]Warning: 'qualytics show-config' is deprecated. "
-        "Use 'qualytics auth status' instead.[/bold yellow]\n"
-    )
-    from .auth import auth_status
-
-    auth_status()
-
-
-@app.command(hidden=True, deprecated=True)
-def init(
-    url: str = typer.Option(
-        ..., help="The URL to be set. Example: https://your-qualytics.qualytics.io/"
-    ),
-    token: str = typer.Option(..., help="The token to be set."),
-    no_verify_ssl: bool = typer.Option(
-        False,
-        "--no-verify-ssl",
-        help="Disable SSL certificate verification for API requests.",
-    ),
-):
-    """[Deprecated] Use 'qualytics auth init' instead."""
-    print(
-        "[bold yellow]Warning: 'qualytics init' is deprecated. "
-        "Use 'qualytics auth init' instead.[/bold yellow]\n"
-    )
-    from .auth import auth_init
-
-    auth_init(url=url, token=token, no_verify_ssl=no_verify_ssl)

qualytics/cli/tags.py

@@ -0,0 +1,85 @@
+"""CLI commands for tag management."""
+
+import typer
+from rich import print
+
+from ..api.client import get_client, QualyticsAPIError
+from ..api.tags import create_tag, delete_tag, get_tag, list_all_tags
+from ..utils.serialization import OutputFormat, format_for_display
+
+from . import add_suggestion_callback
+from .progress import status
+
+tags_app = typer.Typer(
+    name="tags",
+    help="Manage tags",
+)
+add_suggestion_callback(tags_app, "tags")
+
+
+@tags_app.command("list")
+def tags_list(
+    fmt: OutputFormat = typer.Option(
+        OutputFormat.YAML, "--format", "-f", help="Output format: yaml or json"
+    ),
+):
+    """List all tags."""
+    client = get_client()
+
+    with status("[bold cyan]Fetching tags...[/bold cyan]"):
+        all_tags = list_all_tags(client)
+
+    if not all_tags:
+        print("[yellow]No tags found.[/yellow]")
+        raise typer.Exit()
+
+    print(f"[bold]Found {len(all_tags)} tag(s).[/bold]\n")
+    print(format_for_display(all_tags, fmt))
+
+
+@tags_app.command("get")
+def tags_get(
+    tag_id: int = typer.Option(..., "--id", help="Tag ID"),
+    fmt: OutputFormat = typer.Option(
+        OutputFormat.YAML, "--format", "-f", help="Output format: yaml or json"
+    ),
+):
+    """Get a single tag by ID."""
+    client = get_client()
+
+    with status("[bold cyan]Fetching tag...[/bold cyan]"):
+        result = get_tag(client, tag_id)
+
+    print(format_for_display(result, fmt))
+
+
+@tags_app.command("create")
+def tags_create(
+    name: str = typer.Option(..., "--name", "-n", help="Tag name"),
+    fmt: OutputFormat = typer.Option(
+        OutputFormat.YAML, "--format", "-f", help="Output format: yaml or json"
+    ),
+):
+    """Create a new tag."""
+    client = get_client()
+    payload = {"name": name}
+
+    result = create_tag(client, payload)
+    print(f"[green]Tag created successfully![/green]")
+    print(f"[green]Tag ID: {result.get('id')}[/green]\n")
+    print(format_for_display(result, fmt))
+
+
+@tags_app.command("delete")
+def tags_delete(
+    tag_id: int = typer.Option(..., "--id", help="Tag ID to delete"),
+):
+    """Delete a tag by ID."""
+    client = get_client()
+
+    try:
+        delete_tag(client, tag_id)
+        print(f"[green]Tag {tag_id} deleted successfully.[/green]")
+    except QualyticsAPIError as e:
+        print(f"[red]Failed to delete tag {tag_id}: {e.message}[/red]")
+        raise typer.Exit(code=1)

qualytics/cli/teams.py

@@ -0,0 +1,53 @@
+"""CLI commands for team management."""
+
+import typer
+from rich import print
+
+from ..api.client import get_client
+from ..api.teams import get_team, list_all_teams
+from ..utils.serialization import OutputFormat, format_for_display
+
+from . import add_suggestion_callback
+from .progress import status
+
+teams_app = typer.Typer(
+    name="teams",
+    help="List and view teams",
+)
+add_suggestion_callback(teams_app, "teams")
+
+
+@teams_app.command("list")
+def teams_list(
+    fmt: OutputFormat = typer.Option(
+        OutputFormat.YAML, "--format", "-f", help="Output format: yaml or json"
+    ),
+):
+    """List all teams."""
+    client = get_client()
+
+    with status("[bold cyan]Fetching teams...[/bold cyan]"):
+        all_teams = list_all_teams(client)
+
+    if not all_teams:
+        print("[yellow]No teams found.[/yellow]")
+        raise typer.Exit()
+
+    print(f"[bold]Found {len(all_teams)} team(s).[/bold]\n")
+    print(format_for_display(all_teams, fmt))
+
+
+@teams_app.command("get")
+def teams_get(
+    team_id: int = typer.Option(..., "--id", help="Team ID"),
+    fmt: OutputFormat = typer.Option(
+        OutputFormat.YAML, "--format", "-f", help="Output format: yaml or json"
+    ),
+):
+    """Get a single team by ID."""
+    client = get_client()
+
+    with status("[bold cyan]Fetching team...[/bold cyan]"):
+        result = get_team(client, team_id)
+
+    print(format_for_display(result, fmt))

qualytics/cli/users.py

@@ -0,0 +1,53 @@
+"""CLI commands for user management."""
+
+import typer
+from rich import print
+
+from ..api.client import get_client
+from ..api.users import get_user, list_all_users
+from ..utils.serialization import OutputFormat, format_for_display
+
+from . import add_suggestion_callback
+from .progress import status
+
+users_app = typer.Typer(
+    name="users",
+    help="List and view users",
+)
+add_suggestion_callback(users_app, "users")
+
+
+@users_app.command("list")
+def users_list(
+    fmt: OutputFormat = typer.Option(
+        OutputFormat.YAML, "--format", "-f", help="Output format: yaml or json"
+    ),
+):
+    """List all users."""
+    client = get_client()
+
+    with status("[bold cyan]Fetching users...[/bold cyan]"):
+        all_users = list_all_users(client)
+
+    if not all_users:
+        print("[yellow]No users found.[/yellow]")
+        raise typer.Exit()
+
+    print(f"[bold]Found {len(all_users)} user(s).[/bold]\n")
+    print(format_for_display(all_users, fmt))
+
+
+@users_app.command("get")
+def users_get(
+    user_id: int = typer.Option(..., "--id", help="User ID"),
+    fmt: OutputFormat = typer.Option(
+        OutputFormat.YAML, "--format", "-f", help="Output format: yaml or json"
+    ),
+):
+    """Get a single user by ID."""
+    client = get_client()
+
+    with status("[bold cyan]Fetching user...[/bold cyan]"):
+        result = get_user(client, user_id)
+
+    print(format_for_display(result, fmt))

qualytics/qualytics.py

@@ -19,6 +19,9 @@
 from .cli.export_import import export_import_app
 from .cli.mcp_cmd import mcp_app
 from .cli.doctor import doctor
+from .cli.users import users_app
+from .cli.teams import teams_app
+from .cli.tags import tags_app
 
 # Import config for environment setup
 from .config import DOTENV_PATH
@@ -39,6 +42,9 @@
 app.add_typer(auth_app, name="auth")
 app.add_typer(export_import_app, name="config")
 app.add_typer(mcp_app, name="mcp")
+app.add_typer(users_app, name="users")
+app.add_typer(teams_app, name="teams")
+app.add_typer(tags_app, name="tags")
 app.command("doctor", help="Check CLI health and connectivity")(doctor)