acra-cli 0.1.2__tar.gz → 0.1.4__tar.gz

{acra_cli-0.1.2/acra_cli.egg-info → acra_cli-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: acra-cli
-Version: 0.1.2
+Version: 0.1.4
 Summary: Agentic CLI for LLM task execution, research, and workflow automation.
 Author: Raj Tembe
 License: GNU Affero General Public License v3

{acra_cli-0.1.2 → acra_cli-0.1.4}/acra/__init__.py

@@ -1,6 +1,6 @@
 """acra package root."""
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"
 
 from .cli import main
 

{acra_cli-0.1.2 → acra_cli-0.1.4}/acra/cli.py

@@ -2,11 +2,17 @@
 
 import typer
 
+import acra
+from acra.commands.ask import ask, build, explain, fix, review, run
+from acra.commands.research import research
 from acra.commands import (
     serve_app,
     config_app,
     keys_app,
-    research_app,
+    brain_app,
+    context_app,
+    logs_app,
+    plugin_app,
     memory_app,
     session_app,
     graph_app,
@@ -19,11 +25,28 @@ app = typer.Typer(add_completion=True)
 app.add_typer(serve_app, name="serve")
 app.add_typer(config_app, name="config")
 app.add_typer(keys_app, name="keys")
-app.add_typer(research_app, name="research")
 app.add_typer(memory_app, name="memory")
 app.add_typer(session_app, name="session")
 app.add_typer(graph_app, name="graph")
 app.add_typer(utils_app, name="workspace")
+app.add_typer(brain_app, name="brain", help="Brain management commands for acra.")
+app.add_typer(context_app, name="context", help="Context management commands for acra.")
+app.add_typer(logs_app, name="logs", help="Logging commands for acra.")
+app.add_typer(plugin_app, name="plugin", help="Plugin commands for acra.")
+
+app.command("ask")(ask)
+app.command("build")(build)
+app.command("fix")(fix)
+app.command("review")(review)
+app.command("explain")(explain)
+app.command("run")(run)
+app.command("research")(research)
+
+
+def _version_callback(value: bool):
+    if value:
+        typer.echo(acra.__version__)
+        raise typer.Exit()
 
 
 def app_main() -> None:
@@ -34,19 +57,32 @@ def app_main() -> None:
 @app.callback(invoke_without_command=True)
 def main(
     ctx: typer.Context,
+    version: bool = typer.Option(
+        False,
+        "--version",
+        callback=_version_callback,
+        is_eager=True,
+        help="Show the installed acra version and exit.",
+    ),
     profile: str = typer.Option(None, "--profile", help="Profile to use."),
     workspace: str = typer.Option(None, "--workspace", help="Override workspace path."),
-    no_memory: bool = typer.Option(False, "--no-memory", help="Run without memory."),
+    use_memory: bool = typer.Option(True, "--memory/--no-memory", help="Use memory."),
     dry_run: bool = typer.Option(False, "--dry-run", help="Display planned actions without executing."),
     json_output: bool = typer.Option(False, "--json", help="Output JSON-formatted results."),
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging."),
     quiet: bool = typer.Option(False, "--quiet", "-q", help="Suppress output."),
     timeout: int = typer.Option(0, "--timeout", help="Override execution timeout in seconds."),
+    party: bool = typer.Option(
+        False,
+        "--party",
+        "--easter-egg",
+        help="Show the rainbow party-mode startup banner.",
+    ),
 ):
     """acra: Agentic CLI for LLM powered task execution and research workflows."""
     if ctx.invoked_subcommand is None:
-        launch_shell(profile=profile, workspace=workspace)
+        launch_shell(profile=profile, workspace=workspace, party=party)
 
 
 if __name__ == "__main__":
-    app_main()
+    app_main()

{acra_cli-0.1.2 → acra_cli-0.1.4}/acra/commands/__init__.py

@@ -1,6 +1,7 @@
 """acra command modules."""
 
 from .serve import app as serve_app
+from .ask import app as ask_app
 from .config import app as config_app
 from .brain import app as brain_app
 from .research import app as research_app
@@ -15,6 +16,7 @@ from .utils import app as utils_app
 
 __all__ = [
     "serve_app",
+    "ask_app",
     "config_app",
     "brain_app",
     "research_app",

acra_cli-0.1.4/acra/commands/ask.py

@@ -0,0 +1,106 @@
+"""Agent task commands for acra."""
+
+import uuid
+from typing import Optional
+
+import typer
+
+from acra.graph.workflow import OmniAgentCallbacks, omniagent_graph
+from acra.ui.components import render_panel
+
+app = typer.Typer(help="Agent task commands for acra.")
+
+
+def _run_task(
+    task: str,
+    task_label: str,
+    profile: Optional[str] = None,
+    use_memory: bool = True,
+    interactive: bool = False,
+):
+    state = {
+        "user_request": task,
+        "task_label": task_label,
+        "no_memory": not use_memory,
+        "profile": profile,
+        "interactive": interactive,
+    }
+    # The compiled graph always carries a checkpointer, which requires a
+    # thread_id on every invoke call regardless of whether the caller wants
+    # persistence. A fresh id is generated per invocation; when --no-memory
+    # is set, nothing is done with it beyond satisfying the checkpointer, so
+    # no state is meaningfully persisted or reused across runs.
+    thread_id = str(uuid.uuid4())
+    config = {
+        "callbacks": [OmniAgentCallbacks()],
+        "configurable": {"thread_id": thread_id},
+    }
+    result = omniagent_graph.invoke(state, config=config)
+    render_panel(result, title=task_label)
+    return result
+
+
+@app.command()
+def ask(
+    task: str = typer.Argument(..., help="Task or question for the agent."),
+    profile: Optional[str] = typer.Option(None, help="Profile to use."),
+    use_memory: bool = typer.Option(True, "--memory/--no-memory", help="Use memory for this task."),
+    interactive: bool = typer.Option(False, "--interactive", help="Route agent approval requests to the human node."),
+):
+    """Ask the assistant a question."""
+    return _run_task(task, "ask", profile, use_memory, interactive)
+
+
+@app.command()
+def build(
+    task: str = typer.Argument(..., help="Build task for the agent."),
+    profile: Optional[str] = typer.Option(None, help="Profile to use."),
+    use_memory: bool = typer.Option(True, "--memory/--no-memory", help="Use memory for this task."),
+    interactive: bool = typer.Option(False, "--interactive", help="Route agent approval requests to the human node."),
+):
+    """Run a build workflow for a project task."""
+    return _run_task(task, "build", profile, use_memory, interactive)
+
+
+@app.command()
+def fix(
+    task: str = typer.Argument(..., help="Code issue or bug for the agent to fix."),
+    profile: Optional[str] = typer.Option(None, help="Profile to use."),
+    use_memory: bool = typer.Option(True, "--memory/--no-memory", help="Use memory for this task."),
+    interactive: bool = typer.Option(False, "--interactive", help="Route agent approval requests to the human node."),
+):
+    """Run a fix workflow for a code issue."""
+    return _run_task(task, "fix", profile, use_memory, interactive)
+
+
+@app.command()
+def review(
+    task: str = typer.Argument(..., help="Code, design, or task to review."),
+    profile: Optional[str] = typer.Option(None, help="Profile to use."),
+    use_memory: bool = typer.Option(True, "--memory/--no-memory", help="Use memory for this task."),
+    interactive: bool = typer.Option(False, "--interactive", help="Route agent approval requests to the human node."),
+):
+    """Review code or design with the critic pipeline."""
+    return _run_task(task, "review", profile, use_memory, interactive)
+
+
+@app.command()
+def explain(
+    task: str = typer.Argument(..., help="Concept or code path to explain."),
+    profile: Optional[str] = typer.Option(None, help="Profile to use."),
+    use_memory: bool = typer.Option(True, "--memory/--no-memory", help="Use memory for this task."),
+    interactive: bool = typer.Option(False, "--interactive", help="Route agent approval requests to the human node."),
+):
+    """Explain a technical concept or code path."""
+    return _run_task(task, "explain", profile, use_memory, interactive)
+
+
+@app.command()
+def run(
+    task: str = typer.Argument(..., help="Task for the agent to execute."),
+    profile: Optional[str] = typer.Option(None, help="Profile to use."),
+    use_memory: bool = typer.Option(True, "--memory/--no-memory", help="Use memory for this task."),
+    interactive: bool = typer.Option(False, "--interactive", help="Route agent approval requests to the human node."),
+):
+    """Execute a task using the executor agent."""
+    return _run_task(task, "run", profile, use_memory, interactive)

{acra_cli-0.1.2 → acra_cli-0.1.4}/acra/commands/research.py

@@ -1,6 +1,7 @@
 """Research command module for acra."""
 
 import json
+import uuid
 import typer
 from typing import List, Optional
 
@@ -27,7 +28,11 @@ def research(
     output: Optional[str] = typer.Option(None, help="Write research output to a file."),
     save: bool = typer.Option(False, help="Persist research output into memory."),
     follow_up: bool = typer.Option(False, help="Keep the session open for follow-up questions."),
-    no_memory: bool = typer.Option(False, help="Skip memory persistence for this research."),
+    use_memory: bool = typer.Option(
+        True,
+        "--memory/--no-memory",
+        help="Use memory persistence for this research.",
+    ),
     profile: Optional[str] = typer.Option(None, help="Profile to use."),
     json_output: bool = typer.Option(False, "--json", help="Output JSON instead of rich text."),
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Show detailed debug output."),
@@ -45,11 +50,18 @@ def research(
         "research_depth": depth,
         "research_sources": source_list,
         "follow_up": follow_up,
-        "save_to_memory": save and not no_memory,
+        "save_to_memory": save and use_memory,
         "profile": profile,
     }
 
-    result = workflow.invoke(state, config={"callbacks": [OmniAgentCallbacks()]})
+    thread_id = str(uuid.uuid4())
+    result = workflow.invoke(
+        state,
+        config={
+            "callbacks": [OmniAgentCallbacks()],
+            "configurable": {"thread_id": thread_id},
+        },
+    )
 
     report = format_research_report(result, output_format=format)
 
@@ -62,4 +74,4 @@ def research(
 
     render_panel(report, title="Research Results")
     if json_output:
-        typer.echo(json.dumps(report, indent=2))
+        typer.echo(json.dumps(report, indent=2))

{acra_cli-0.1.2 → acra_cli-0.1.4}/acra/commands/serve.py

@@ -7,7 +7,15 @@ app = typer.Typer(help="Interactive shell for acra.", invoke_without_command=Tru
 
 
 @app.callback()
-def serve(ctx: typer.Context):
+def serve(
+    ctx: typer.Context,
+    party: bool = typer.Option(
+        False,
+        "--party",
+        "--easter-egg",
+        help="Show the rainbow party-mode startup banner.",
+    ),
+):
     """Launch the interactive acra shell."""
     if ctx.invoked_subcommand is None:
-        launch_shell()
+        launch_shell(party=party)

acra_cli-0.1.4/acra/ui/animated_banner.py

@@ -0,0 +1,287 @@
+"""Animated startup banner and easter eggs for acra.
+
+This module owns the ANSI-driven intro sequence shown when the interactive
+shell starts (`acra` with no subcommand, or `acra serve`):
+
+    1. The "ACRA" wordmark is revealed with a left-to-right glitch/scan
+       animation (or, in --party mode, a rainbow cycle with an emoji burst).
+    2. A subtitle is typed out character by character.
+    3. A tagline fades in (swapped for a holiday-specific line on a handful
+       of dates).
+    4. The version number is shown with a short spinner that resolves to a
+       "ready" checkmark, similar to Copilot CLI's startup indicator.
+
+Everything here is pure ANSI escape codes + stdlib (no extra dependencies).
+
+Two independent accessibility/scripting gates, matching conventions used
+across the CLI ecosystem (see https://no-color.org, https://force-color.org,
+and GitHub's writeup on building the Copilot CLI banner: fast-changing
+terminal output is a real screen-reader and low-vision concern, not just a
+cosmetic one):
+
+  * Color (`_supports_color`) is disabled by NO_COLOR or TERM=dumb, and can
+    be forced back on with FORCE_COLOR even when piped.
+  * Timed motion (`_animations_enabled`) is disabled whenever stdout isn't a
+    real interactive terminal, in CI, or when ACRA_NO_ANIMATION is set -
+    falling back to an instant, fully-resolved static print so scripting,
+    piping, and tests stay fast and deterministic.
+
+These are independent: a NO_COLOR user on a real terminal still gets the
+scan/typing motion, just monochrome; a CI run gets neither, instantly.
+"""
+
+from __future__ import annotations
+
+import os
+import random
+import sys
+import time
+from datetime import date
+from typing import Iterable, List, Optional
+
+from acra import __version__
+from acra.ui.banner import WELCOME_TEXT
+
+RESET = "\033[0m"
+BOLD = "\033[1m"
+DIM = "\033[2m"
+
+COLORS = {
+    "black": "\033[30m",
+    "red": "\033[31m",
+    "green": "\033[32m",
+    "yellow": "\033[33m",
+    "blue": "\033[34m",
+    "magenta": "\033[35m",
+    "cyan": "\033[36m",
+    "white": "\033[37m",
+    "bright_red": "\033[91m",
+    "bright_green": "\033[92m",
+    "bright_yellow": "\033[93m",
+    "bright_blue": "\033[94m",
+    "bright_magenta": "\033[95m",
+    "bright_cyan": "\033[96m",
+    "bright_white": "\033[97m",
+}
+
+# ANSI-Shadow-style block glyphs. Only the letters ACRA needs are defined;
+# each glyph is a fixed 6-row x 8-column block so rows line up cleanly
+# whichever letters are combined.
+_GLYPHS = {
+    "A": [
+        " █████╗ ",
+        "██╔══██╗",
+        "███████║",
+        "██╔══██║",
+        "██║  ██║",
+        "╚═╝  ╚═╝",
+    ],
+    "C": [
+        " ██████╗",
+        "██╔════╝",
+        "██║     ",
+        "██║     ",
+        "╚██████╗",
+        " ╚═════╝",
+    ],
+    "R": [
+        "██████╗ ",
+        "██╔══██╗",
+        "██████╔╝",
+        "██╔══██╗",
+        "██║  ██║",
+        "╚═╝  ╚═╝",
+    ],
+}
+
+WORDMARK = "ACRA"
+_GLYPH_HEIGHT = 6
+
+# Vertical gradient applied to the wordmark, top row to bottom row.
+_GRADIENT = ["bright_cyan", "bright_cyan", "cyan", "bright_magenta", "magenta", "bright_yellow"]
+
+_RAINBOW_CYCLE = [
+    "bright_red",
+    "bright_yellow",
+    "bright_green",
+    "bright_cyan",
+    "bright_blue",
+    "bright_magenta",
+]
+
+_GLITCH_CHARS = "@#$%&*+=-/\\|<>?░▒▓"
+_PARTY_EMOJIS = ["🎉", "✨", "🎊", "🚀", "🔥", "🥳", "⭐", "💥"]
+
+# Same frame set as the "dots" spinner in the widely-used cli-spinners
+# package (npm), the de facto standard braille spinner recognized across
+# npm/yarn/ora-based tools.
+_SPINNER_FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+
+_HOLIDAY_TAGLINES = {
+    (1, 1): "New year, new agent runs. Let's build.",
+    (4, 1): "ACRA: (mostly) not lying to you today.",
+    (10, 31): "ACRA: coding like it's Halloween.",
+    (12, 25): "Shipping code, not presents, today.",
+}
+
+
+def _supports_color() -> bool:
+    """https://no-color.org / https://force-color.org, checked in that order."""
+    if os.environ.get("FORCE_COLOR", "") != "":
+        return True
+    if os.environ.get("NO_COLOR", "") != "":
+        return False
+    if os.environ.get("TERM") == "dumb":
+        return False
+    return True
+
+
+def _animations_enabled() -> bool:
+    """Whether to run the timed ANSI animations, or fall back to a static print."""
+    if os.environ.get("ACRA_NO_ANIMATION"):
+        return False
+    if os.environ.get("CI"):
+        return False
+    return sys.stdout.isatty()
+
+
+def _style(text: str, color: Optional[str] = None, bold: bool = False, dim: bool = False) -> str:
+    """Wrap text in ANSI codes, or return it unchanged when color is disabled."""
+    if not _supports_color():
+        return text
+    codes = ""
+    if bold:
+        codes += BOLD
+    if dim:
+        codes += DIM
+    if color:
+        codes += COLORS.get(color, "")
+    return f"{codes}{text}{RESET}" if codes else text
+
+
+def _build_art(word: str = WORDMARK, spacing: str = " ") -> List[str]:
+    return [spacing.join(_GLYPHS[letter][row] for letter in word) for row in range(_GLYPH_HEIGHT)]
+
+
+def _print_art_static(art_lines: Iterable[str], gradient: List[str]) -> None:
+    for row_idx, line in enumerate(art_lines):
+        print(_style(line, color=gradient[row_idx % len(gradient)], bold=True))
+
+
+def _glitch_scan_reveal(art_lines: List[str], gradient: List[str], steps: int = 10, delay: float = 0.025) -> None:
+    """Reveal the wordmark left-to-right, resolving glitch characters into the real ones."""
+    if not _animations_enabled():
+        _print_art_static(art_lines, gradient)
+        return
+
+    width = max(len(line) for line in art_lines)
+    height = len(art_lines)
+
+    sys.stdout.write("\n" * height)
+    for step in range(1, steps + 1):
+        threshold = int(width * step / steps)
+        sys.stdout.write(f"\033[{height}A")
+        for row_idx, line in enumerate(art_lines):
+            rendered = [
+                " " if ch == " " else (ch if col < threshold else random.choice(_GLITCH_CHARS))
+                for col, ch in enumerate(line)
+            ]
+            styled = _style("".join(rendered), color=gradient[row_idx % len(gradient)], bold=True)
+            sys.stdout.write(f"\033[K{styled}\n")
+        sys.stdout.flush()
+        time.sleep(delay)
+
+
+def _party_reveal(art_lines: List[str], frames: int = 10, delay: float = 0.09) -> None:
+    """Rainbow-cycling wordmark with a burst of flying emojis, for --party / --easter-egg."""
+    if not _animations_enabled():
+        print(_style("PARTY MODE \U0001f389", color="bright_magenta", bold=True))
+        _print_art_static(art_lines, _RAINBOW_CYCLE)
+        return
+
+    width = max(len(line) for line in art_lines)
+    height = len(art_lines)
+
+    sys.stdout.write("\n" * (height + 1))
+    for frame in range(frames):
+        sys.stdout.write(f"\033[{height + 1}A")
+        for row_idx, line in enumerate(art_lines):
+            color = _RAINBOW_CYCLE[(row_idx + frame) % len(_RAINBOW_CYCLE)]
+            sys.stdout.write(f"\033[K{_style(line, color=color, bold=True)}\n")
+        emoji_row = "".join(
+            random.choice(_PARTY_EMOJIS) if random.random() < 0.3 else " " for _ in range(width // 2)
+        )
+        sys.stdout.write(f"\033[K{emoji_row}\n")
+        sys.stdout.flush()
+        time.sleep(delay)
+
+    print(_style("\U0001f389 PARTY MODE ACTIVATED \U0001f389", color="bright_magenta", bold=True))
+
+
+def _type_line(text: str, color: Optional[str] = None, delay: float = 0.012) -> None:
+    if not _animations_enabled():
+        print(_style(text, color=color))
+        return
+    for ch in text:
+        sys.stdout.write(_style(ch, color=color))
+        sys.stdout.flush()
+        time.sleep(delay)
+    sys.stdout.write("\n")
+
+
+def _fade_in_lines(lines: Iterable[str], dim: bool = False, delay: float = 0.12) -> None:
+    for line in lines:
+        if _animations_enabled():
+            time.sleep(delay)
+        print(_style(line, dim=dim))
+
+
+def _spinner_version_line(accent: str, frames: int = 14, delay: float = 0.035) -> None:
+    """Show 'acra vX.Y.Z' with a small spinner that resolves into a ready check."""
+    label = _style(f"acra v{__version__}", color=accent, bold=True)
+    ready = _style("\u2713 ready", color="bright_green")
+
+    if not _animations_enabled():
+        print(f"{label}  {ready}")
+        return
+
+    for i in range(frames):
+        frame = _SPINNER_FRAMES[i % len(_SPINNER_FRAMES)]
+        status = _style(f"{frame} initializing\u2026", dim=True)
+        sys.stdout.write(f"\r{label}  {status}\033[K")
+        sys.stdout.flush()
+        time.sleep(delay)
+    sys.stdout.write(f"\r{label}  {ready}\033[K\n")
+    sys.stdout.flush()
+
+
+def _holiday_tagline(today: Optional[date] = None) -> Optional[str]:
+    today = today or date.today()
+    return _HOLIDAY_TAGLINES.get((today.month, today.day))
+
+
+def render_intro(theme: Optional[dict] = None, party: bool = False) -> None:
+    """Print the full animated acra startup banner.
+
+    `theme` is one of the dicts from acra.ui.theme (must contain "accent").
+    `party` triggers the rainbow/emoji easter egg instead of the normal
+    glitch-scan reveal; wired up to `acra --party` / `acra --easter-egg`.
+    """
+    theme = theme or {}
+    accent = theme.get("accent", "bright_cyan")
+    if accent not in COLORS:
+        accent = "bright_cyan"
+
+    art = _build_art()
+
+    if party:
+        _party_reveal(art)
+    else:
+        _glitch_scan_reveal(art, _GRADIENT)
+
+    _type_line("Autonomous Coding & Research Agent", color=accent)
+
+    tagline = _holiday_tagline() or WELCOME_TEXT
+    _fade_in_lines([tagline], dim=True)
+
+    _spinner_version_line(accent)

{acra_cli-0.1.2 → acra_cli-0.1.4}/acra/ui/banner.py

@@ -3,14 +3,7 @@
 from rich.panel import Panel
 from rich.console import Console
 
-MASCOT = r"""
-  ____   ____  ____
- / __ \ / __ \/ __ \
-| |  | | |  | | |  | |
-| |  | | |  | | |  | |
-| |__| | |__| | |__| |
- \____/ \____/ \____/
-"""
+from acra import __version__
 
 WELCOME_TEXT = "acra: agentic CLI for LLM task workflows"
 
@@ -18,12 +11,11 @@ WELCOME_TEXT = "acra: agentic CLI for LLM task workflows"
 def render_banner(provider: str, model: str, profile: str, workspace: str, theme: dict) -> Panel:
     console = Console()
     lines = [
-        f"[bold {theme['accent']}]acra v0.1.2[/bold {theme['accent']}]",
         f"Provider: {provider} · Model: {model}",
         f"Profile: {profile} · Workspace: {workspace}",
     ]
     content = "\n".join(lines)
-    return Panel(content, title=WELCOME_TEXT, subtitle=MASCOT, style=theme["border"], border_style=theme["border"])
+    return Panel(content, title="Session", style=theme["border"], border_style=theme["border"])
 
 
 def render_tips(theme: dict) -> Panel:
@@ -37,4 +29,4 @@ def render_tips(theme: dict) -> Panel:
 
 
 # Compatibility alias for older imports and public package API.
-welcome_banner = render_banner
+welcome_banner = render_banner

{acra_cli-0.1.2 → acra_cli-0.1.4}/acra/ui/shell.py

@@ -9,6 +9,7 @@ from prompt_toolkit import PromptSession
 from prompt_toolkit.completion import Completer, Completion
 from prompt_toolkit.shortcuts import CompleteStyle
 from acra.ui.banner import render_banner, render_tips
+from acra.ui.animated_banner import render_intro
 from acra.ui.theme import get_theme
 from acra.config.profile_manager import ProfileManager
 from rich.console import Console
@@ -31,9 +32,10 @@ class SlashCompleter(Completer):
                 yield completion
 
 
-def launch_shell(profile: str = None, workspace: str = None):
+def launch_shell(profile: str = None, workspace: str = None, party: bool = False):
     config = ProfileManager().load_profile(profile)
     theme = get_theme(config.get("theme", "dark-orange"))
+    render_intro(theme, party=party)
     banner = render_banner(
         config.get("provider", "gemini"),
         config.get("model", "gemini-2.5-flash"),
@@ -88,4 +90,4 @@ def launch_shell(profile: str = None, workspace: str = None):
         except EOFError:
             break
 
-    console.print(Panel("Goodbye", title="acra"))
+    console.print(Panel("Goodbye", title="acra"))

{acra_cli-0.1.2 → acra_cli-0.1.4/acra_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: acra-cli
-Version: 0.1.2
+Version: 0.1.4
 Summary: Agentic CLI for LLM task execution, research, and workflow automation.
 Author: Raj Tembe
 License: GNU Affero General Public License v3

{acra_cli-0.1.2 → acra_cli-0.1.4}/acra_cli.egg-info/SOURCES.txt

@@ -154,11 +154,13 @@ acra/tools/web_tools/arxiv_search.py
 acra/tools/web_tools/serpapi_search.py
 acra/tools/web_tools/tavily_search.py
 acra/ui/__init__.py
+acra/ui/animated_banner.py
 acra/ui/banner.py
 acra/ui/components.py
 acra/ui/shell.py
 acra/ui/theme.py
 acra/ui/__pycache__/__init__.cpython-312.pyc
+acra/ui/__pycache__/animated_banner.cpython-312.pyc
 acra/ui/__pycache__/banner.cpython-312.pyc
 acra/ui/__pycache__/components.cpython-312.pyc
 acra/ui/__pycache__/shell.cpython-312.pyc
@@ -174,4 +176,5 @@ acra_cli.egg-info/dependency_links.txt
 acra_cli.egg-info/entry_points.txt
 acra_cli.egg-info/requires.txt
 acra_cli.egg-info/top_level.txt
-tests/test_cli.py
+tests/test_cli.py
+tests/test_interactive_routing.py