aru-code 0.57.0__tar.gz → 0.59.0__tar.gz

{aru_code-0.57.0/aru_code.egg-info → aru_code-0.59.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aru-code
-Version: 0.57.0
+Version: 0.59.0
 Summary: A Claude Code clone built with Agno agents
 Author-email: Estevao <estevaofon@gmail.com>
 License-Expression: MIT
@@ -116,16 +116,19 @@ Key bindings (TUI):
 Local slash commands inside the TUI: `/help`, `/clear`, `/quit`,
 `/plan`. Any other input is sent to the agent.
 
-### Classic REPL (opt-in)
+### Non-interactive (one-shot)
 
-Prefer the single-line prompt? Pass `--repl` to use the classic REPL:
+For scripting and pipes, pass a prompt directly instead of launching the
+TUI:
 
 ```bash
-aru --repl
+aru "fix the failing test in auth"   # one-shot, with tools
+aru --print "explain this module"    # text-only, no tools
+echo "summarize TODOs" | aru          # piped stdin
 ```
 
-Both modes share the same sessions, plugins, permissions, and tools —
-only presentation differs.
+One-shot mode shares the same sessions, plugins, permissions, and tools
+as the TUI — only presentation differs.
 
 ## Usage
 
@@ -706,7 +709,7 @@ Once a plan is stored, every following turn prepends a `<system-reminder>` listi
 ```
 aru-code/
 ├── aru/
-│   ├── cli.py              # Main REPL loop, argument parsing, and entry point
+│   ├── cli.py              # Argument parsing, one-shot execution, and entry point
 │   ├── agent_factory.py    # Single factory — builds Agno Agents from catalog specs
 │   ├── commands.py         # Slash commands, help display, shell execution
 │   ├── completers.py       # Input completions, paste detection, @file mentions

{aru_code-0.57.0 → aru_code-0.59.0}/README.md

@@ -68,16 +68,19 @@ Key bindings (TUI):
 Local slash commands inside the TUI: `/help`, `/clear`, `/quit`,
 `/plan`. Any other input is sent to the agent.
 
-### Classic REPL (opt-in)
+### Non-interactive (one-shot)
 
-Prefer the single-line prompt? Pass `--repl` to use the classic REPL:
+For scripting and pipes, pass a prompt directly instead of launching the
+TUI:
 
 ```bash
-aru --repl
+aru "fix the failing test in auth"   # one-shot, with tools
+aru --print "explain this module"    # text-only, no tools
+echo "summarize TODOs" | aru          # piped stdin
 ```
 
-Both modes share the same sessions, plugins, permissions, and tools —
-only presentation differs.
+One-shot mode shares the same sessions, plugins, permissions, and tools
+as the TUI — only presentation differs.
 
 ## Usage
 
@@ -658,7 +661,7 @@ Once a plan is stored, every following turn prepends a `<system-reminder>` listi
 ```
 aru-code/
 ├── aru/
-│   ├── cli.py              # Main REPL loop, argument parsing, and entry point
+│   ├── cli.py              # Argument parsing, one-shot execution, and entry point
 │   ├── agent_factory.py    # Single factory — builds Agno Agents from catalog specs
 │   ├── commands.py         # Slash commands, help display, shell execution
 │   ├── completers.py       # Input completions, paste detection, @file mentions

aru_code-0.59.0/aru/__init__.py

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

aru_code-0.59.0/aru/auth.py

@@ -0,0 +1,93 @@
+"""Credential store for provider API keys (OpenCode-parity ``auth.json``).
+
+``/connect`` writes here so users no longer have to hand-edit ``aru.json``
+to wire up a provider. Mirrors OpenCode's ``auth.json``: a flat
+``{ "<provider>": <info> }`` map persisted under the user's home, written
+with ``0600`` permissions so the key isn't world-readable.
+
+Schema (``info``) — a tagged union on ``type`` so future auth methods
+(OAuth, well-known) can slot in beside the current API-key path:
+
+    {"type": "api",   "key": "sk-...",            # built-in provider
+     "base_url": "...", "name": "...",            # extra fields for a
+     "provider_type": "openai", "default_model": "...",  # custom provider
+     "context_limit": 128000}
+    {"type": "local", "base_url": "http://..."}   # keyless (e.g. Ollama)
+
+Consumption lives in :func:`aru.providers.apply_stored_credentials`, which
+layers these onto the in-memory provider registry at startup (and again
+right after ``/connect``) so a stored key takes precedence over the
+provider's ``api_key_env``.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger("aru.auth")
+
+
+def auth_path() -> Path:
+    """Absolute path to the credential file (``~/.aru/auth.json``)."""
+    return Path.home() / ".aru" / "auth.json"
+
+
+def load_auth() -> dict[str, dict[str, Any]]:
+    """Return the full credential map, or ``{}`` when missing/unreadable."""
+    path = auth_path()
+    if not path.is_file():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as exc:
+        logger.warning("Failed to read %s: %s", path, exc)
+        return {}
+    if not isinstance(data, dict):
+        return {}
+    # Drop any malformed (non-dict) entries defensively.
+    return {k: v for k, v in data.items() if isinstance(v, dict)}
+
+
+def get_credential(provider_key: str) -> dict[str, Any] | None:
+    """Return the stored credential for ``provider_key`` or ``None``."""
+    return load_auth().get(provider_key)
+
+
+def _write_auth(data: dict[str, dict[str, Any]]) -> None:
+    """Write the credential map atomically-ish with ``0600`` perms."""
+    path = auth_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".json.tmp")
+    tmp.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    # Lock down before the rename so the secret is never briefly group/other
+    # readable. chmod is a partial no-op on Windows but harmless.
+    try:
+        os.chmod(tmp, 0o600)
+    except OSError:
+        pass
+    os.replace(tmp, path)
+    try:
+        os.chmod(path, 0o600)
+    except OSError:
+        pass
+
+
+def set_credential(provider_key: str, info: dict[str, Any]) -> None:
+    """Store (or replace) the credential for ``provider_key``."""
+    data = load_auth()
+    data[provider_key] = info
+    _write_auth(data)
+
+
+def remove_credential(provider_key: str) -> bool:
+    """Delete the credential for ``provider_key``. Returns ``True`` if removed."""
+    data = load_auth()
+    if provider_key not in data:
+        return False
+    del data[provider_key]
+    _write_auth(data)
+    return True

aru_code-0.59.0/aru/cli.py

@@ -0,0 +1,307 @@
+"""Non-interactive CLI for aru - a Claude Code clone.
+
+This module is the slim orchestrator: arg parsing, one-shot execution, and the
+entrypoint that launches the Textual TUI. All domain logic lives in dedicated
+modules; public names are re-exported here for backward compatibility.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import io as _io
+import logging as _logging
+import os
+import sys
+
+# ── Re-exports for backward compatibility ─────────────────────────────
+# Tests and external code import these from aru.cli; keep them accessible.
+
+from aru.session import (  # noqa: F401
+    DEFAULT_MODEL,
+    PlanStep,
+    Session,
+    SessionStore,
+    SESSIONS_DIR,
+    _generate_session_id,
+    parse_plan_steps,
+)
+
+from aru.display import (  # noqa: F401
+    StatusBar,
+    StreamingDisplay,
+    ToolTracker,
+    THINKING_PHRASES,
+    TOOL_DISPLAY_NAMES,
+    TOOL_PRIMARY_ARG,
+    _build_logo_with_shadow,
+    _format_tool_label,
+    aru_logo,
+    console,
+    format_duration,
+    neon_green,
+    shadow_green,
+)
+
+from aru.commands import (  # noqa: F401
+    SLASH_COMMANDS,
+    _show_help,
+    ask_yes_no,
+    run_shell,
+)
+
+from aru.runner import (  # noqa: F401
+    AgentRunResult,
+    _MUTATION_TOOLS,
+    build_env_context,
+    run_agent_capture,
+)
+
+from aru.agent_factory import (  # noqa: F401
+    create_custom_agent_instance,
+    create_general_agent,
+)
+
+# ── Platform setup ─────────────────────────────────────────────────────
+
+if sys.platform == "win32" and not hasattr(sys, "_called_from_test"):
+    sys.stdout = _io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8")
+    sys.stderr = _io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8")
+
+_logging.getLogger("agno").setLevel(_logging.WARNING)
+
+
+def _restore_worktree_from_session(session) -> str:
+    """Re-enter the worktree persisted on *session* (Tier 3 #2 R11).
+
+    Called at the top of ``run_tui`` right after the session is bound to
+    the runtime context. Three branches:
+
+    - ``worktree_path`` empty or missing → no-op, returns ``"none"``.
+    - ``worktree_path`` set AND directory exists on disk → ``enter_worktree``
+      is invoked so ``ctx.cwd`` matches the previous run. Returns
+      ``"entered"``.
+    - ``worktree_path`` set but directory is gone → warn, null the
+      session fields, return ``"stale"``.
+
+    Returns a short outcome label (``"none"``/``"entered"``/``"stale"``/
+    ``"error"``) so tests can pin the branch chosen without re-parsing
+    console output.
+    """
+    saved_wt = getattr(session, "worktree_path", None)
+    saved_branch = getattr(session, "worktree_branch", None)
+    if not saved_wt:
+        return "none"
+    if os.path.isdir(saved_wt):
+        from aru.runtime import enter_worktree as _re_enter
+        try:
+            _re_enter(saved_wt, saved_branch)
+            console.print(
+                f"[dim]Resumed inside worktree: {saved_branch} ({saved_wt})[/dim]"
+            )
+            return "entered"
+        except Exception as exc:
+            console.print(
+                f"[yellow]Could not re-enter worktree {saved_wt}: {exc}[/yellow]"
+            )
+            return "error"
+    console.print(
+        f"[yellow]Saved worktree path no longer exists: {saved_wt} — "
+        f"using project root[/yellow]"
+    )
+    session.worktree_path = None
+    session.worktree_branch = None
+    return "stale"
+
+
+def _configure_plugin_logger(verbose: bool = False) -> None:
+    """Attach a stderr handler to the ``aru.plugins`` logger.
+
+    Without this, ``logger.error(...)`` inside ``PluginManager`` (e.g. when a
+    subscriber raises) has no handler and disappears silently. Idempotent —
+    a marker attribute on the logger prevents double-registration when
+    ``run_oneshot`` is invoked multiple times in the same process (tests).
+    """
+    lg = _logging.getLogger("aru.plugins")
+    if getattr(lg, "_aru_handler_attached", False):
+        return
+    handler = _logging.StreamHandler(sys.stderr)
+    handler.setFormatter(
+        _logging.Formatter("[aru.plugins] %(levelname)s: %(message)s")
+    )
+    lg.addHandler(handler)
+    lg.setLevel(_logging.DEBUG if verbose else _logging.WARNING)
+    lg._aru_handler_attached = True  # type: ignore[attr-defined]
+
+
+# ── CLI entrypoint ─────────────────────────────────────────────────────
+
+def _list_sessions_and_exit():
+    """Print saved sessions and exit."""
+    store = SessionStore()
+    sessions = store.list_sessions()
+    if not sessions:
+        console.print("[dim]No saved sessions.[/dim]")
+        return
+    console.print("[bold]Recent sessions:[/bold]\n")
+    for s in sessions:
+        sid = s["session_id"]
+        title = s["title"][:50]
+        msgs = s["messages"]
+        updated = s["updated_at"]
+        model = s["model"]
+        console.print(f"  [bold cyan]{sid}[/bold cyan]  {title}  [dim]({msgs} msgs, {model}, {updated})[/dim]")
+    console.print(f"\n[dim]Resume with: aru --resume <id>[/dim]")
+
+
+async def run_oneshot(prompt: str, print_only: bool = False, skip_permissions: bool = False):
+    """Run a single prompt non-interactively and exit.
+
+    Args:
+        prompt: The user prompt to execute.
+        print_only: If True, run without tools (text-only response).
+        skip_permissions: If True, skip all permission checks.
+    """
+    from aru.runtime import init_ctx
+    from aru.config import load_config
+    from aru.cache_patch import apply_cache_patch
+
+    apply_cache_patch()
+    _configure_plugin_logger(verbose=bool(os.environ.get("ARU_VERBOSE")))
+    ctx = init_ctx(console=console, skip_permissions=skip_permissions)
+
+    # E6a: install REPL UI so migrated call sites work in one-shot mode.
+    from aru.ui import install_repl_ui_on_ctx
+    install_repl_ui_on_ctx(ctx)
+
+    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
+
+    ctx.session = session
+    ctx.model_id = session.model_id
+    small_ref = config.model_aliases.get("small") if config else None
+    if not small_ref:
+        from aru.providers import resolve_model_ref
+        provider_key, _ = resolve_model_ref(session.model_ref)
+        _small_defaults = {
+            "anthropic": "anthropic/claude-haiku-4-5",
+            "openai": "openai/gpt-4o-mini",
+            "groq": "groq/llama-3.1-8b-instant",
+            "deepseek": "deepseek/deepseek-chat",
+            "ollama": "ollama/llama3.1",
+        }
+        small_ref = _small_defaults.get(provider_key, session.model_ref)
+    ctx.small_model_ref = small_ref
+
+    extra_instructions = config.get_extra_instructions()
+
+    if print_only:
+        # Text-only mode: no tools, just a direct LLM call
+        from agno.agent import Agent
+        from aru.providers import create_model
+        from aru.agents.base import build_instructions
+
+        agent = Agent(
+            name="Aru",
+            model=create_model(session.model_ref, reasoning_override=session.reasoning_override),
+            tools=[],
+            instructions=build_instructions("general", extra_instructions),
+            markdown=True,
+        )
+        response = await agent.arun(prompt)
+        if response and response.content:
+            # Print raw text to stdout for piping
+            print(response.content)
+    else:
+        # Full mode with tools
+        from aru.runner import build_env_context
+        env_ctx = build_env_context(session)
+        agent = await create_general_agent(session, config, env_context=env_ctx)
+        session.add_message("user", prompt)
+        await run_agent_capture(agent, prompt, session)
+
+        if session.token_summary:
+            console.print(f"[dim]{session.token_summary}[/dim]")
+
+
+def main():
+    """Entry point for the aru CLI."""
+    from dotenv import load_dotenv
+
+    load_dotenv()
+    args = sys.argv[1:]
+    skip_permissions = "--dangerously-skip-permissions" in args
+    print_only = "--print" in args or "-p" in args
+
+    if "--list" in args:
+        _list_sessions_and_exit()
+        return
+
+    resume_id = None
+    if "--resume" in args:
+        idx = args.index("--resume")
+        if idx + 1 < len(args) and not args[idx + 1].startswith("--"):
+            resume_id = args[idx + 1]
+        else:
+            resume_id = "last"
+
+    # Collect positional arguments (non-flag, non-flag-value)
+    flags_with_value = {"--resume"}
+    positional = []
+    skip_next = False
+    for i, arg in enumerate(args):
+        if skip_next:
+            skip_next = False
+            continue
+        if arg.startswith("--") or arg.startswith("-"):
+            if arg in flags_with_value:
+                skip_next = True
+            continue
+        positional.append(arg)
+
+    # Piped stdin: echo "fix bug" | aru
+    if not sys.stdin.isatty() and not positional:
+        piped_input = sys.stdin.read().strip()
+        if piped_input:
+            positional = [piped_input]
+
+    # One-shot mode: aru "fix the bug" or aru --print "explain this"
+    if positional:
+        prompt = " ".join(positional)
+        try:
+            asyncio.run(run_oneshot(prompt, print_only=print_only, skip_permissions=skip_permissions))
+        except (KeyboardInterrupt, asyncio.CancelledError, SystemExit):
+            pass
+        except Exception as e:
+            from rich.markup import escape
+            console.print(f"\n[bold red]Fatal error: {escape(str(e))}[/bold red]")
+        return
+
+    # Interactive mode — the Textual TUI is the only interactive interface.
+    # `--repl` / `--tui` are still accepted as no-op flags for backwards compat.
+    from aru.tui import run_tui
+    try:
+        asyncio.run(run_tui(skip_permissions=skip_permissions, resume_id=resume_id))
+    except (KeyboardInterrupt, asyncio.CancelledError, SystemExit):
+        _graceful_exit()
+    except Exception as e:
+        from rich.markup import escape
+        console.print(f"\n[bold red]Fatal error: {escape(str(e))}[/bold red]")
+        _graceful_exit()
+
+
+def _graceful_exit():
+    """Save session and show resume hint on exit."""
+    try:
+        store = SessionStore()
+        last = store.load_last()
+        if last:
+            console.print(f"\n[dim]Session saved: {last.session_id}[/dim]")
+            console.print(f"[dim]Resume with:[/dim] [bold cyan]aru --resume {last.session_id}[/bold cyan]")
+    except Exception:
+        pass