aru-code 0.27.0__tar.gz → 0.28.0__tar.gz

{aru_code-0.27.0/aru_code.egg-info → aru_code-0.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aru-code
-Version: 0.27.0
+Version: 0.28.0
 Summary: A Claude Code clone built with Agno agents
 Author-email: Estevao <estevaofon@gmail.com>
 License-Expression: MIT

aru_code-0.28.0/aru/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.28.0"

{aru_code-0.27.0 → aru_code-0.28.0}/aru/cli.py

@@ -136,6 +136,11 @@ async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
 
     # Load project configuration
     config = load_config()
+    ctx.config = config
+    # Populate invoke_skill's dynamic docstring so the LLM-facing schema lists
+    # the skills actually available on this machine.
+    from aru.tools.skill import _update_invoke_skill_docstring
+    _update_invoke_skill_docstring(config.skills)
     if config.agents_md:
         console.print("[dim]Loaded AGENTS.md[/dim]")
     if config.commands:
@@ -546,6 +551,12 @@ async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
                     console.print(f"  [bold cyan]{entry.name}[/bold cyan]  [dim]{entry.description}[/dim]")
             continue
 
+        if user_input.lower() == "/plugin" or user_input.lower().startswith("/plugin "):
+            from aru.commands import handle_plugin_command
+            rest = user_input[len("/plugin"):].strip()
+            handle_plugin_command(rest)
+            continue
+
         if user_input.lower() == "/help":
             _show_help(config)
             continue
@@ -746,6 +757,10 @@ async def run_oneshot(prompt: str, print_only: bool = False, skip_permissions: b
     ctx = init_ctx(console=console, skip_permissions=skip_permissions)
 
     config = load_config()
+    ctx.config = config
+    # Populate invoke_skill's dynamic docstring (same as interactive path)
+    from aru.tools.skill import _update_invoke_skill_docstring
+    _update_invoke_skill_docstring(config.skills)
     session = Session()
     if config.default_model:
         session.model_ref = config.default_model

aru_code-0.28.0/aru/commands.py

@@ -0,0 +1,244 @@
+"""Slash command definitions, help display, shell execution, and user prompts."""
+
+from __future__ import annotations
+
+import subprocess
+import os
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.text import Text
+
+from aru.display import console
+
+SLASH_COMMANDS = [
+    ("/help", "Show help and available commands", "/help"),
+    ("/plan", "Create an implementation plan", "/plan <task>"),
+    ("/model", "Switch model/provider", "/model [provider/model]"),
+    ("/sessions", "List recent sessions", "/sessions"),
+    ("/commands", "List custom commands", "/commands"),
+    ("/skills", "List available skills", "/skills"),
+    ("/agents", "List custom agents", "/agents"),
+    ("/mcp", "List loaded MCP tools", "/mcp"),
+    ("/plugin", "Manage cached plugins (install/list/remove/update)", "/plugin <subcommand>"),
+    ("/undo", "Undo last turn — restore files and/or conversation", "/undo"),
+    ("/cost", "Show detailed token usage and cost", "/cost"),
+    ("/quit", "Exit aru", "/quit"),
+]
+
+
+def run_shell(command: str):
+    """Run a shell command directly, streaming output to the terminal."""
+    console.print()
+    console.print(Panel(
+        Syntax(command, "bash", theme="monokai"),
+        title="[bold]Shell[/bold]",
+        border_style="dim",
+        expand=False,
+    ))
+    try:
+        process = subprocess.Popen(
+            command,
+            shell=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            cwd=os.getcwd(),
+            bufsize=1,
+        )
+        for line in process.stdout:
+            console.print(Text(line.rstrip()))
+        process.wait()
+        if process.returncode != 0:
+            console.print(f"[red]Exit code: {process.returncode}[/red]")
+    except KeyboardInterrupt:
+        process.kill()
+        console.print("\n[yellow]Interrupted.[/yellow]")
+    except Exception as e:
+        from rich.markup import escape
+        console.print(f"[red]Error: {escape(str(e))}[/red]")
+    console.print()
+
+
+def ask_yes_no(prompt: str) -> bool:
+    """Ask the user a yes/no question."""
+    try:
+        answer = console.input(f"[bold yellow]{prompt} (y/n):[/bold yellow] ").strip().lower()
+        return answer in ("y", "yes", "s", "sim")
+    except (EOFError, KeyboardInterrupt):
+        return False
+
+
+def handle_plugin_command(args: str) -> None:
+    """Handle /plugin <subcommand> [args] — install/list/remove/update/info."""
+    from rich.table import Table
+    from rich.markup import escape
+
+    parts = args.strip().split(None, 2)
+    if not parts:
+        _show_plugin_help()
+        return
+
+    subcmd = parts[0].lower()
+
+    if subcmd == "list":
+        from aru.plugin_cache import list_installed
+        entries = list_installed()
+        if not entries:
+            console.print("[dim]No plugins installed. Use /plugin install <spec> to add one.[/dim]")
+            return
+        table = Table(show_header=True, header_style="bold", box=None, padding=(0, 2))
+        table.add_column("Name", style="cyan")
+        table.add_column("Version", style="green")
+        table.add_column("Source")
+        table.add_column("Spec", style="dim")
+        for e in entries:
+            table.add_row(e.id, e.version or "-", e.source, e.spec)
+        console.print(table)
+        return
+
+    if subcmd == "install":
+        if len(parts) < 2:
+            console.print("[yellow]Usage: /plugin install <spec> [name][/yellow]")
+            return
+        spec = parts[1]
+        name = parts[2] if len(parts) >= 3 else None
+        from aru.plugin_cache import install
+        console.print(f"[dim]Installing {escape(spec)}...[/dim]")
+        result = install(spec, name=name)
+        if not result.ok:
+            console.print(f"[red]Install failed: {escape(result.error or 'unknown error')}[/red]")
+            return
+        provides = result.provides
+        provides_str = ", ".join(f"{c} {k}" for k, c in provides.items()) or "no resources"
+        console.print(
+            f"[green]Installed {escape(result.name or '')}"
+            f"{f'@{result.version}' if result.version else ''}[/green] "
+            f"([dim]{result.state}[/dim]) -> {escape(str(result.target))}"
+        )
+        console.print(f"[dim]Provides: {provides_str}[/dim]")
+        console.print(
+            "[dim]Discovery refreshes on next aru restart. "
+            "Skills/agents/tools from the plugin will then be available.[/dim]"
+        )
+        return
+
+    if subcmd == "remove":
+        if len(parts) < 2:
+            console.print("[yellow]Usage: /plugin remove <name>[/yellow]")
+            return
+        name = parts[1]
+        from aru.plugin_cache import remove
+        if remove(name):
+            console.print(f"[green]Removed plugin: {escape(name)}[/green]")
+        else:
+            console.print(f"[yellow]Plugin not found: {escape(name)}[/yellow]")
+        return
+
+    if subcmd == "update":
+        if len(parts) < 2:
+            console.print("[yellow]Usage: /plugin update <name>[/yellow]")
+            return
+        name = parts[1]
+        from aru.plugin_cache import update
+        console.print(f"[dim]Updating {escape(name)}...[/dim]")
+        result = update(name)
+        if not result.ok:
+            console.print(f"[red]Update failed: {escape(result.error or 'unknown error')}[/red]")
+            return
+        console.print(
+            f"[green]Updated {escape(result.name or '')}"
+            f"{f'@{result.version}' if result.version else ''}[/green] "
+            f"([dim]{result.state}[/dim])"
+        )
+        return
+
+    if subcmd == "info":
+        if len(parts) < 2:
+            console.print("[yellow]Usage: /plugin info <name>[/yellow]")
+            return
+        name = parts[1]
+        from aru.plugin_cache import list_installed, read_manifest
+        from pathlib import Path
+        entries = {e.id: e for e in list_installed()}
+        entry = entries.get(name)
+        if entry is None:
+            console.print(f"[yellow]Plugin not found: {escape(name)}[/yellow]")
+            return
+        manifest = read_manifest(Path(entry.target))
+        console.print(f"[bold cyan]{escape(entry.id)}[/bold cyan]")
+        console.print(f"  [dim]version:[/dim]     {entry.version or '-'}")
+        console.print(f"  [dim]source:[/dim]      {entry.source}")
+        console.print(f"  [dim]spec:[/dim]        {escape(entry.spec)}")
+        console.print(f"  [dim]target:[/dim]      {escape(entry.target)}")
+        console.print(f"  [dim]fingerprint:[/dim] {entry.fingerprint}")
+        console.print(f"  [dim]first_time:[/dim]  {entry.first_time}")
+        console.print(f"  [dim]last_time:[/dim]   {entry.last_time}")
+        if manifest:
+            desc = manifest.get("description")
+            if desc:
+                console.print(f"  [dim]description:[/dim] {escape(str(desc))}")
+            engines = manifest.get("engines") or {}
+            if isinstance(engines, dict) and engines.get("aru"):
+                console.print(f"  [dim]engines.aru:[/dim] {escape(str(engines['aru']))}")
+        return
+
+    _show_plugin_help()
+
+
+def _show_plugin_help() -> None:
+    """Print /plugin command usage."""
+    from rich.table import Table
+    table = Table(show_header=True, header_style="bold", box=None, padding=(0, 2))
+    table.add_column("Subcommand", style="cyan")
+    table.add_column("Description", style="dim")
+    table.add_row("/plugin install <spec> [name]", "Install a plugin from git or local path")
+    table.add_row("/plugin list", "List installed plugins")
+    table.add_row("/plugin remove <name>", "Uninstall a plugin")
+    table.add_row("/plugin update <name>", "Update a plugin (git pull)")
+    table.add_row("/plugin info <name>", "Show plugin metadata")
+    console.print(table)
+    console.print()
+    console.print("[dim]Spec formats:[/dim]")
+    console.print("[dim]  github:user/repo            — shorthand for GitHub[/dim]")
+    console.print("[dim]  github:user/repo@v1.0.0     — pin to tag/branch[/dim]")
+    console.print("[dim]  git+https://host/path.git   — any git URL[/dim]")
+    console.print("[dim]  file:///abs/path  or ./rel  — local directory[/dim]")
+
+
+def _show_help(config) -> None:
+    """Display help with available commands."""
+    from rich.table import Table
+
+    table = Table(show_header=True, header_style="bold", box=None, padding=(0, 2))
+    table.add_column("Command", style="cyan")
+    table.add_column("Description", style="dim")
+
+    table.add_row("/plan <task>", "Create detailed implementation plan")
+    table.add_row("/model [provider/model]", "Switch models (e.g., ollama/llama3.1, openai/gpt-4o)")
+    table.add_row("/sessions", "List recent sessions")
+    table.add_row("/commands", "List custom commands")
+    table.add_row("/skills", "List available skills")
+    table.add_row("/agents", "List custom agents")
+    table.add_row("/mcp", "List loaded MCP tools")
+    table.add_row("/plugin <subcmd>", "Manage plugins (install/list/remove/update/info)")
+    table.add_row("/undo", "Undo last turn (restore files and/or conversation)")
+    table.add_row("/help", "Show this help")
+    table.add_row("/quit", "Exit aru")
+    table.add_row("! <cmd>", "Run shell command")
+
+    if config and config.commands:
+        table.add_row("", "")
+        for name, cmd_def in config.commands.items():
+            table.add_row(f"/{name}", cmd_def.description)
+
+    if config and config.custom_agents:
+        primary = {k: v for k, v in config.custom_agents.items() if v.mode == "primary"}
+        if primary:
+            table.add_row("", "")
+            for name, agent_def in primary.items():
+                table.add_row(f"/{name}", f"[agent] {agent_def.description}")
+
+    console.print(table)
+    console.print()

{aru_code-0.27.0 → aru_code-0.28.0}/aru/config.py

@@ -535,9 +535,15 @@ def load_config(cwd: str | None = None) -> AgentConfig:
         config.commands = _load_commands(agents_dir)
 
     # Discover skills from multiple roots (agentskills.io convention)
-    # Order: global paths first, project-local last (local overrides global)
+    # Order: cached plugins first (lowest priority), then global, then project-local
+    # (local overrides global overrides cache — lets users shadow plugin skills).
     home = Path.home()
     skill_roots: list[Path] = []
+    try:
+        from aru.plugin_cache import get_cached_plugin_roots
+        skill_roots.extend(get_cached_plugin_roots())
+    except Exception as exc:  # defensive: never fail config load over cache
+        logger.warning("Failed to load cached plugin roots: %s", exc)
     for dirname in (".agents", ".claude"):
         global_dir = home / dirname
         if global_dir.is_dir():