qbraid-cli 0.14.0__tar.gz → 0.15.1__tar.gz

{qbraid_cli-0.14.0/qbraid_cli.egg-info → qbraid_cli-0.15.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qbraid-cli
-Version: 0.14.0
+Version: 0.15.1
 Summary: Command Line Interface for interacting with all parts of the qBraid platform.
 Author-email: qBraid Development Team <contact@qbraid.com>
 License-Expression: LicenseRef-Proprietary

{qbraid_cli-0.14.0 → qbraid_cli-0.15.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qbraid-cli"
-version = "0.14.0"
+version = "0.15.1"
 description = "Command Line Interface for interacting with all parts of the qBraid platform."
 readme = "README.md"
 authors = [{ name = "qBraid Development Team", email = "contact@qbraid.com" }]

{qbraid_cli-0.14.0 → qbraid_cli-0.15.1}/qbraid_cli/agents/app.py

@@ -3,13 +3,15 @@
 
 """Agents CLI - Monitor and manage AI coding agent sessions."""
 
+import inspect
 import os
 import re
 import signal
 import time
 from datetime import datetime
+from enum import Enum
 from pathlib import Path
-from typing import List, Optional
+from typing import Any, Callable, Dict, List, Optional
 
 import click
 import typer
@@ -1096,10 +1098,59 @@ def _interactive_attach(console_: Console) -> str:
     return selected
 
 
+class ApprovalMode(str, Enum):
+    """How much the agent asks before acting.
+
+    A launched agent is detached, so a confirmation prompt has nobody to
+    answer it — ``auto`` is the mode for anything you intend to leave running.
+    """
+
+    ASK = "ask"
+    AUTO = "auto"
+
+
+def _approval_kwargs(method: Callable[..., Any], approval: Optional[str]) -> Dict[str, Any]:
+    """Forward ``approval`` only to a qbraid-core new enough to accept it.
+
+    The CLI's floor is qbraid-core>=0.5.0, which predates the parameter. Passing
+    it unconditionally would raise TypeError on EVERY launch there, not only
+    when --approval was used — so detect support and, when the user actually
+    asked for a mode we cannot honour, say so plainly instead of forwarding it.
+
+    A Mock reports ``(*args, **kwargs)``; VAR_KEYWORD therefore counts as
+    support, which is both correct in general and keeps test doubles working.
+    """
+    try:
+        params = inspect.signature(method).parameters
+        supported = "approval" in params or any(
+            param.kind is inspect.Parameter.VAR_KEYWORD for param in params.values()
+        )
+    except (TypeError, ValueError):  # pragma: no cover - non-introspectable callable
+        supported = True
+
+    if supported:
+        return {"approval": approval}
+
+    if approval is not None:
+        try:
+            from qbraid_core import __version__ as core_version
+        except ImportError:  # pragma: no cover
+            core_version = "unknown"
+        handle_error(
+            error_type="UnsupportedOptionError",
+            message=(
+                f"--approval requires a newer qbraid-core (installed: {core_version}). "
+                "Upgrade with: pip install -U qbraid-core"
+            ),
+            include_traceback=False,
+        )
+    return {}
+
+
 @agents_app.command("launch")
 def agents_launch(
     tool: Optional[str] = typer.Option(
-        None, "--tool", "-t", help="Agent tool (claude, claude-auto, codeq, codex)"
+        None, "--tool", "-t", help="Agent tool (claude, codeq, codex; claude-auto = claude --approval auto)"
     ),
     cwd: Optional[str] = typer.Option(None, "--cwd", help="Working directory"),
     name: Optional[str] = typer.Option(None, "--name", "-n", help="Agent name"),
@@ -1116,10 +1167,21 @@ def agents_launch(
     compute: Optional[str] = typer.Option(
         None, "--compute", "-c", help="SSH alias for remote compute server"
     ),
+    approval: Optional[ApprovalMode] = typer.Option(
+        None,
+        "--approval",
+        help="ask: the agent confirms before acting. auto: it acts without asking.",
+    ),
 ):
     """Launch an AI coding agent.
 
     Starts the agent in a managed tmux session.
+
+    The agent runs detached, so nothing is watching its confirmation prompts.
+    Pass --approval auto for an agent you intend to leave running: it starts
+    the tool in its own non-interactive mode instead of parking on a prompt
+    until you come back. Approval mode is remembered, so `qbraid agents
+    resume` restores it.
     """
     try:
         from qbraid_core.services.agents import AgentLauncher, AgentLauncherError
@@ -1148,6 +1210,7 @@ def agents_launch(
                 instructions=instructions,
                 agent_type=agent_type,
                 tags=tag,
+                **_approval_kwargs(launcher.remote_launch, approval.value if approval else None),
             )
         else:
 
@@ -1164,6 +1227,7 @@ def agents_launch(
                 parent_session_id=parent,
                 team_id=team,
                 tags=tag,
+                **_approval_kwargs(launcher.launch, approval.value if approval else None),
                 progress_callback=_clone_progress if repo else None,
             )
 
@@ -1334,12 +1398,15 @@ def agents_resume(
                     if original:
                         tool_value = original.tool.value if original.tool else "claude"
                         fork_name = name or f"{tmux_win}-fork"
-                        # Launch fresh with same tool and cwd
+                        # Launch fresh with same tool and cwd.
                         session = launcher.launch(
                             tool=tool_value,
                             cwd=original.cwd,
                             name=fork_name,
                             instructions=None,
+                            # A fork of a detached agent must not quietly
+                            # become one that waits for a human.
+                            **_approval_kwargs(launcher.launch, getattr(original, "approval", None)),
                         )
                     else:
                         console.print("[red]Could not find original session to fork.[/red]")

{qbraid_cli-0.14.0 → qbraid_cli-0.15.1}/qbraid_cli/skills/app.py

@@ -40,11 +40,21 @@ class SkillTargetOption(str, Enum):
 
     CLAUDE_CODE = "claude-code"
     CODEX = "codex"
+    PI = "pi"
     CURSOR = "cursor"
     COPILOT = "copilot"
     ALL = "all"
 
 
+_ACTION_STYLE = {
+    "installed": "[green]installed[/green]",
+    "updated": "[green]updated[/green]",
+    "unchanged": "[dim]unchanged[/dim]",
+    "failed": "[red]failed[/red]",
+    "unknown": "[dim]done (older qbraid-core)[/dim]",
+}
+
+
 class VisibilityOption(str, Enum):
     """Skill visibility level."""
 
@@ -213,39 +223,106 @@ def skills_install(
         "-t",
         help="Target AI coding tool(s) to install for",
     ),
+    path: Optional[str] = typer.Option(
+        None,
+        "--path",
+        "-p",
+        help="Install into this directory instead of a tool's skills directory",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Replace the installed copy even if it is unchanged or was not installed by qbraid",
+    ),
 ) -> None:
     """Install a skill for AI coding tools.
 
-    By default, installs to Claude Code (~/.claude/skills/).
-    Use --target all to install to all supported tools.
+    By default, installs to Claude Code (~/.claude/skills/). Use --target all
+    for every supported tool; --target codex or --target pi both land in
+    ~/.agents/skills/, which Codex and CodeQ (pi) read.
+
+    In a tool's skills directory the skill is placed under its own name (not
+    its slug); with --path it is placed under its slug at that path. The
+    download is checked against the registry's checksum, and installing an
+    unchanged skill again is a no-op.
     """
+    from pathlib import Path
+
+    install_path = Path(path).expanduser() if path else None
+    console = Console()
+    legacy_core = False
 
     def install_skill():
+        nonlocal legacy_core
         from qbraid_core.services.skills import SkillsClient
 
         client = SkillsClient()
-        return client.install_skill(slug, target=target.value)
-
-    console = Console()
+        if hasattr(client, "install_skill_ex"):
+            return client.install_skill_ex(slug, target=target.value, install_path=install_path, force=force)
+        # older qbraid-core: slug-named directories, no checksum or manifest, no --force
+        legacy_core = True
+        return {
+            name: _LegacyInstall(slug, installed_path)
+            for name, installed_path in client.install_skill(
+                slug, target=target.value, install_path=install_path
+            ).items()
+        }
 
     try:
         console.print(f"[dim]Installing skill '{slug}'...[/dim]")
-        installed_paths = run_progress_task(install_skill)
+        results = run_progress_task(install_skill)
 
-        console.print(f"\n[green]✓[/green] Skill '{slug}' installed successfully!\n")
+        if legacy_core and force:
+            console.print(
+                "[yellow]Note:[/yellow] the installed qbraid-core does not support --force; "
+                "the flag was ignored. Upgrade qbraid-core for --force, checksum "
+                "verification and name-based skill directories."
+            )
 
-        for target_name, path in installed_paths.items():
-            console.print(f"  [cyan]{target_name}[/cyan]: {path}")
+        failed = [name for name, result in results.items() if result.action == "failed"]
+        mark = "[yellow]![/yellow]" if failed else "[green]✓[/green]"
+        console.print(f"\n{mark} Skill '{slug}':\n")
+        for target_name, result in results.items():
+            version = f" v{result.version}" if result.version else ""
+            line = (
+                f"  [cyan]{target_name}[/cyan]: "
+                f"{_ACTION_STYLE.get(result.action, result.action)} "
+                f"[bold]{result.name}[/bold]{version} → {result.path}"
+            )
+            if result.action == "failed" and getattr(result, "error", None):
+                line += f"\n      [red]{result.error}[/red]"
+            console.print(line)
 
+        if failed:
+            handle_error(message=f"Skill '{slug}' failed for: {', '.join(failed)}")
         console.print("\n[dim]The skill is now available in your AI coding tool(s).[/dim]")
 
+    except typer.Exit:
+        raise
     except Exception as err:  # pylint: disable=broad-exception-caught
         handle_error(message=f"Failed to install skill: {err}")
 
 
+class _LegacyInstall:  # pylint: disable=too-few-public-methods
+    """Install result shape for a qbraid-core without install_skill_ex.
+
+    That core cannot tell whether anything changed, so the action is reported
+    as ``unknown`` rather than claiming ``installed``.
+    """
+
+    def __init__(self, slug: str, path) -> None:
+        self.slug = slug
+        self.name = slug
+        self.path = path
+        self.version = None
+        self.action = "unknown"
+        self.error = None
+
+
 @skills_app.command(name="uninstall")
 def skills_uninstall(
-    slug: str = typer.Argument(..., help="The skill slug to uninstall"),
+    slug: str = typer.Argument(..., help="The skill slug (or installed name) to uninstall"),
     target: SkillTargetOption = typer.Option(
         SkillTargetOption.ALL,
         "--target",
@@ -255,7 +332,8 @@ def skills_uninstall(
 ) -> None:
     """Uninstall a skill from AI coding tools.
 
-    By default, uninstalls from all supported tools.
+    By default, uninstalls from all supported tools. Accepts the registry slug
+    or the installed directory name.
     """
 
     def uninstall_skill():
@@ -294,15 +372,28 @@ def skills_installed(
         help="Show skills for specific tool only",
     ),
 ) -> None:
-    """List locally installed skills."""
+    """List locally installed skills.
+
+    Shows each skill's name, registry slug and version per tool.
+    """
 
     def list_installed():
         from qbraid_core.services.skills import SkillsClient
 
         client = SkillsClient()
+        if hasattr(client, "list_all_installed_skills_detailed"):
+            if target:
+                return {target.value: client.list_installed_skills_detailed(target=target.value)}
+            return client.list_all_installed_skills_detailed()
+        # older qbraid-core: directory names only
         if target:
-            return {target.value: client.list_installed_skills(target=target.value)}
-        return client.list_all_installed_skills()
+            listed = {target.value: client.list_installed_skills(target=target.value)}
+        else:
+            listed = client.list_all_installed_skills()
+        return {
+            name: [{"name": skill, "slug": skill, "version": None} for skill in skills]
+            for name, skills in listed.items()
+        }
 
     console = Console()
 
@@ -320,8 +411,14 @@ def skills_installed(
         for target_name, skills in results.items():
             if skills:
                 console.print(f"[cyan]{target_name}[/cyan]:")
-                for skill_slug in skills:
-                    console.print(f"  • {skill_slug}")
+                for entry in skills:
+                    slug_note = (
+                        f" [dim]({entry['slug']})[/dim]"
+                        if entry.get("slug") and entry["slug"] != entry["name"]
+                        else ""
+                    )
+                    version = f" v{entry['version']}" if entry.get("version") else ""
+                    console.print(f"  • {entry['name']}{slug_note}{version}")
             else:
                 console.print(f"[dim]{target_name}: (none)[/dim]")
 

{qbraid_cli-0.14.0 → qbraid_cli-0.15.1/qbraid_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qbraid-cli
-Version: 0.14.0
+Version: 0.15.1
 Summary: Command Line Interface for interacting with all parts of the qBraid platform.
 Author-email: qBraid Development Team <contact@qbraid.com>
 License-Expression: LicenseRef-Proprietary