bareagent-cli 0.1.0__py3-none-any.whl

bareagent/tracing/otel.py

@@ -0,0 +1,107 @@
+"""OpenTelemetry tracer backend (optional dependency).
+
+Requires the ``opentelemetry`` packages::
+
+    pip install opentelemetry-api opentelemetry-sdk opentelemetry-exporter-otlp-proto-http
+    # or: pip install bareagent-cli[otel]
+
+Activated automatically when ``OTEL_EXPORTER_OTLP_ENDPOINT`` is set, or when
+``[tracing] opentelemetry = true`` appears in the config file.
+"""
+
+from __future__ import annotations
+
+import contextlib
+from collections.abc import Iterator
+from typing import Any
+
+from bareagent.tracing._api import Span, Tracer
+
+
+class OTelSpan(Span):
+    """Span backed by an OpenTelemetry span."""
+
+    def __init__(self, otel_span: Any) -> None:
+        self._span = otel_span
+
+    def set_tag(self, key: str, value: Any) -> None:
+        self._span.set_attribute(key, _coerce(value))
+
+    def set_content_tag(self, key: str, value: Any) -> None:
+        self._span.set_attribute(f"content.{key}", _coerce(value))
+
+    def set_error(self, error: str) -> None:
+        from opentelemetry.trace import StatusCode
+
+        self._span.set_status(StatusCode.ERROR, error)
+
+    def end(self) -> None:
+        self._span.end()
+
+
+class OpenTelemetryTracer(Tracer):
+    """Tracer that emits standard OpenTelemetry spans.
+
+    Any OTel-compatible backend (Jaeger, Datadog, Langfuse via OTel, etc.)
+    can consume the spans.
+    """
+
+    def __init__(self, service_name: str = "bareagent") -> None:
+        from opentelemetry import trace
+        from opentelemetry.sdk.resources import SERVICE_NAME, Resource
+        from opentelemetry.sdk.trace import TracerProvider
+
+        resource = Resource.create({SERVICE_NAME: service_name})
+        provider = TracerProvider(resource=resource)
+        trace.set_tracer_provider(provider)
+        self._provider = provider
+        self._tracer = trace.get_tracer("bareagent")
+        self._current: OTelSpan | None = None
+
+    def add_exporter(self, exporter: Any, *, batch: bool = True) -> None:
+        """Attach a span exporter to the provider."""
+        from opentelemetry.sdk.trace.export import (
+            BatchSpanProcessor,
+            SimpleSpanProcessor,
+        )
+
+        processor = (
+            BatchSpanProcessor(exporter) if batch else SimpleSpanProcessor(exporter)
+        )
+        self._provider.add_span_processor(processor)
+
+    @contextlib.contextmanager
+    def trace(
+        self,
+        operation_name: str,
+        tags: dict[str, Any] | None = None,
+        *,
+        parent_span: Span | None = None,
+    ) -> Iterator[Span]:
+        with self._tracer.start_as_current_span(operation_name) as raw_span:
+            span = OTelSpan(raw_span)
+            if tags:
+                for k, v in tags.items():
+                    span.set_tag(k, v)
+            prev = self._current
+            self._current = span
+            try:
+                yield span
+            finally:
+                self._current = prev
+
+    def current_span(self) -> Span | None:
+        return self._current
+
+    def flush(self) -> None:
+        self._provider.force_flush()
+
+    def shutdown(self) -> None:
+        self._provider.shutdown()
+
+
+def _coerce(value: Any) -> str | int | float | bool:
+    """Coerce a value to an OTel-compatible attribute type."""
+    if isinstance(value, (str, int, float, bool)):
+        return value
+    return str(value)

bareagent/tracing/setup.py

@@ -0,0 +1,85 @@
+"""Configure tracing from config + environment (Haystack auto-detect pattern)."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from bareagent.tracing._api import Tracer
+from bareagent.tracing._proxy import enable_tracing
+
+
+def configure_tracing(
+    tracing_config: Any,
+    *,
+    session_id: str = "default",
+    interaction_logger: Any = None,
+) -> None:
+    """Read ``[tracing]`` config and wire up the global tracer.
+
+    Backends are activated by configuration or environment variables:
+
+    - **JsonFile**: always active when *interaction_logger* is provided
+      (backward compat with ``/log`` and the debug web viewer).
+    - **Langfuse**: ``LANGFUSE_PUBLIC_KEY`` env var, or
+      ``[tracing] langfuse = true``.
+    - **OpenTelemetry**: ``OTEL_EXPORTER_OTLP_ENDPOINT`` env var, or
+      ``[tracing] opentelemetry = true``.
+
+    When multiple backends are active a :class:`CompositeTracer` fans
+    out to all of them.
+    """
+
+    backends: list[Tracer] = []
+
+    # 1) JsonFile backend (always on if interaction_logger provided)
+    if interaction_logger is not None:
+        from bareagent.tracing.json_file import JsonFileTracer
+
+        backends.append(JsonFileTracer(interaction_logger))
+
+    # 2) Langfuse (config or env-var driven)
+    if _langfuse_enabled(tracing_config):
+        try:
+            from bareagent.tracing.langfuse import LangfuseTracer
+
+            backends.append(LangfuseTracer(session_id=session_id))
+        except ImportError:
+            pass  # langfuse not installed
+
+    # 3) OpenTelemetry (auto-detect: if OTEL_EXPORTER_OTLP_ENDPOINT is set)
+    if _otel_enabled(tracing_config):
+        try:
+            from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
+                OTLPSpanExporter,
+            )
+
+            from bareagent.tracing.otel import OpenTelemetryTracer
+
+            otel = OpenTelemetryTracer()
+            otel.add_exporter(OTLPSpanExporter())
+            backends.append(otel)
+        except ImportError:
+            pass  # opentelemetry not installed
+
+    if not backends:
+        return  # NullTracer remains active
+
+    if len(backends) == 1:
+        enable_tracing(backends[0])
+    else:
+        from bareagent.tracing.composite import CompositeTracer
+
+        enable_tracing(CompositeTracer(backends))
+
+
+def _langfuse_enabled(config: Any) -> bool:
+    if os.getenv("LANGFUSE_PUBLIC_KEY"):
+        return True
+    return bool(getattr(config, "langfuse", False))
+
+
+def _otel_enabled(config: Any) -> bool:
+    if os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT"):
+        return True
+    return bool(getattr(config, "opentelemetry", False))

bareagent/ui/__init__.py

@@ -0,0 +1,24 @@
+"""UI modules for BareAgent."""
+
+from bareagent.ui.console import AgentConsole
+from bareagent.ui.protocol import StreamProtocol, UIProtocol
+from bareagent.ui.stream import StreamPrinter
+from bareagent.ui.theme import (
+    ThemeManager,
+    format_theme_list,
+    format_unknown_theme,
+    get_theme,
+    init_theme,
+)
+
+__all__ = [
+    "AgentConsole",
+    "StreamPrinter",
+    "UIProtocol",
+    "StreamProtocol",
+    "ThemeManager",
+    "get_theme",
+    "init_theme",
+    "format_theme_list",
+    "format_unknown_theme",
+]

bareagent/ui/console.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any
+
+from rich import box
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.text import Text
+
+from bareagent.ui.theme import ThemeManager, get_theme
+
+if TYPE_CHECKING:
+    from bareagent.ui.stream import StreamPrinter
+
+MAX_TOOL_OUTPUT_CHARS = 2000
+MAX_PERMISSION_PREVIEW_CHARS = 500
+
+
+class AgentConsole:
+    def __init__(
+        self,
+        console: Console | None = None,
+        theme: ThemeManager | None = None,
+    ) -> None:
+        tm = theme or get_theme()
+        self.console = console or Console(
+            no_color=tm.no_color,
+        )
+        self._permission_choice: str | None = None
+        self._theme_pushed = False
+        self.set_theme(tm)
+
+    def set_theme(self, theme: ThemeManager | None = None) -> None:
+        tm = theme or get_theme()
+        if self._theme_pushed:
+            self.console.pop_theme()
+        self.console.push_theme(tm.rich_theme)
+        self._theme_pushed = True
+
+    def print_assistant(self, text: str) -> None:
+        if not text.strip():
+            return
+        self.console.print(Markdown(text))
+
+    def print_tool_call(self, name: str, input_data: Any) -> None:
+        icons = get_theme().icons
+        code, lexer = _render_payload(input_data)
+        self.console.print(
+            Panel(
+                Syntax(code, lexer, word_wrap=True),
+                title=f"[tool.name]{icons.tool} Tool Call[/] [muted]{name}[/]",
+                border_style="tool.border",
+                box=box.ROUNDED,
+                padding=(0, 1),
+            )
+        )
+
+    def print_tool_result(self, name: str, output: Any) -> None:
+        icons = get_theme().icons
+        code, lexer = _render_payload(output, max_chars=MAX_TOOL_OUTPUT_CHARS)
+        self.console.print(
+            Panel(
+                Syntax(code, lexer, word_wrap=True),
+                title=f"[success]{icons.success} Result[/] [muted]{name}[/]",
+                border_style="result.border",
+                box=box.ROUNDED,
+                padding=(0, 1),
+            )
+        )
+
+    def ask_permission(self, name: str, input_data: Any) -> bool:
+        theme = get_theme()
+        self._permission_choice = None
+        self.console.print(
+            Panel(
+                Syntax(
+                    _render_permission_payload(input_data),
+                    "json",
+                    word_wrap=True,
+                ),
+                title=(
+                    f"[warning]{theme.icons.warning} Permission Required: {name}[/]"
+                ),
+                subtitle=Text("[y] Allow  [n] Deny  [a] Always allow"),
+                border_style=theme.palette.warning,
+                box=box.ROUNDED,
+                padding=(0, 1),
+            )
+        )
+
+        while True:
+            try:
+                choice = input("> ").strip().lower()
+            except (EOFError, KeyboardInterrupt):
+                self._permission_choice = "deny"
+                return False
+
+            if choice == "y":
+                self._permission_choice = "allow"
+                return True
+            if choice == "n":
+                self._permission_choice = "deny"
+                return False
+            if choice == "a":
+                self._permission_choice = "always"
+                return True
+
+            self.console.print("Press y/n/a", style="permission.ask")
+
+    def consume_permission_choice(self) -> str | None:
+        choice = self._permission_choice
+        self._permission_choice = None
+        return choice
+
+    def print_error(self, msg: str) -> None:
+        icons = get_theme().icons
+        self.console.print(f"{icons.error} {msg}", style="error")
+
+    def print_status(self, msg: str) -> None:
+        self.console.print(msg, style="status")
+
+    def get_stream_printer(self) -> StreamPrinter:
+        from bareagent.ui.stream import StreamPrinter
+
+        return StreamPrinter(self.console)
+
+
+def _render_payload(payload: Any, *, max_chars: int | None = None) -> tuple[str, str]:
+    if isinstance(payload, (dict, list, tuple)):
+        text = json.dumps(payload, ensure_ascii=False, indent=2, default=str)
+        return _truncate(text, max_chars), "json"
+
+    if payload is None:
+        return "", "text"
+
+    text = str(payload)
+    parsed = _try_parse_json(text)
+    if parsed is not None:
+        # Re-format for consistent indentation.
+        formatted = json.dumps(parsed, ensure_ascii=False, indent=2, default=str)
+        return _truncate(formatted, max_chars), "json"
+    return _truncate(text, max_chars), "text"
+
+
+def _render_permission_payload(payload: Any) -> str:
+    text, _ = _render_payload(payload, max_chars=MAX_PERMISSION_PREVIEW_CHARS)
+    return text
+
+
+def _truncate(text: str, max_chars: int | None) -> str:
+    if max_chars is None or len(text) <= max_chars:
+        return text
+    return f"{text[:max_chars]}\n\n... [truncated]"
+
+
+def _try_parse_json(text: str) -> Any:
+    """Return parsed JSON object if *text* looks like JSON, else ``None``."""
+    stripped = text.strip()
+    if not stripped or stripped[0] not in "{[":
+        return None
+    try:
+        return json.loads(stripped)
+    except json.JSONDecodeError:
+        return None

bareagent/ui/prompt.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.completion import WordCompleter
+from prompt_toolkit.history import FileHistory, History, InMemoryHistory
+from prompt_toolkit.key_binding import KeyBindings
+
+
+class _ResilientFileHistory(FileHistory):
+    def store_string(self, string: str) -> None:
+        try:
+            super().store_string(string)
+        except OSError:
+            # Keep the current session usable even if history persistence fails.
+            pass
+
+
+class AgentPrompt:
+    def __init__(
+        self,
+        *,
+        commands: list[str],
+        history_file: Path,
+        get_mode_label: Callable[[], str],
+        cycle_mode: Callable[[], str] | None = None,
+    ) -> None:
+        self._get_mode_label = get_mode_label
+        self._cycle_mode = cycle_mode
+        self._session = PromptSession(
+            completer=WordCompleter(commands, sentence=True),
+            history=self._build_history(history_file),
+            key_bindings=self._build_bindings(cycle_mode),
+            complete_while_typing=True,
+            bottom_toolbar=self._toolbar,
+        )
+
+    def read_input(self) -> str:
+        return self._session.prompt(
+            lambda: f"[{self._get_mode_label()}] bareagent> ",
+        )
+
+    def _toolbar(self) -> str:
+        mode = self._get_mode_label()
+        if self._cycle_mode is None:
+            return f" Mode: {mode} | /help: commands"
+        return f" Mode: {mode} | Shift+Tab: cycle mode | /help: commands"
+
+    @staticmethod
+    def _build_history(history_file: Path) -> History:
+        try:
+            history_file.parent.mkdir(parents=True, exist_ok=True)
+            with history_file.open("ab"):
+                pass
+        except OSError:
+            return InMemoryHistory()
+        return _ResilientFileHistory(str(history_file))
+
+    @staticmethod
+    def _build_bindings(
+        cycle_mode: Callable[[], str] | None = None,
+    ) -> KeyBindings:
+        bindings = KeyBindings()
+
+        @bindings.add("c-j")
+        def _insert_newline(event) -> None:
+            event.current_buffer.insert_text("\n")
+
+        @bindings.add("s-tab")
+        def _on_cycle_mode(event) -> None:
+            if cycle_mode is None:
+                return
+            cycle_mode()
+            event.app.invalidate()
+
+        return bindings

bareagent/ui/protocol.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import Any, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class StreamProtocol(Protocol):
+    """Streaming output abstraction."""
+
+    def start(self) -> None: ...
+    def feed(self, token: str) -> None: ...
+    def finish(self) -> str: ...
+
+
+@runtime_checkable
+class UIProtocol(Protocol):
+    """UI abstraction consumed by the agent loop."""
+
+    def print_assistant(self, text: str) -> None: ...
+    def print_tool_call(self, name: str, input_data: Any) -> None: ...
+    def print_tool_result(self, name: str, output: Any) -> None: ...
+    def print_error(self, msg: str) -> None: ...
+    def print_status(self, msg: str) -> None: ...
+    def get_stream_printer(self) -> StreamProtocol: ...

bareagent/ui/stream.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import sys
+from typing import TextIO
+
+from rich.console import Console
+
+from bareagent.ui.theme import get_theme
+
+
+class StreamPrinter:
+    def __init__(
+        self,
+        console: Console | None = None,
+        *,
+        status_message: str = "Thinking...",
+        writer: TextIO | None = None,
+    ) -> None:
+        tm = get_theme()
+        self.console = console or Console(
+            no_color=tm.no_color,
+        )
+        self.status_message = status_message
+        console_writer = getattr(self.console, "file", None)
+        self.writer = writer or console_writer or sys.stdout
+        self._chunks: list[str] = []
+        self._active = False
+        self._printed_anything = False
+        self._theme_pushed = False
+
+    def start(self) -> None:
+        if self._active:
+            return
+        tm = get_theme()
+        if not self._theme_pushed:
+            self.console.push_theme(tm.rich_theme)
+            self._theme_pushed = True
+        if not self._chunks:
+            self.console.print(
+                f"{tm.icons.running} {self.status_message}",
+                style="status",
+            )
+        self._active = True
+
+    def feed(self, token: str) -> None:
+        if not token:
+            return
+        if not self._active:
+            self.start()
+        self._chunks.append(token)
+        self.writer.write(token)
+        self.writer.flush()
+        self._printed_anything = True
+
+    def finish(self) -> str:
+        if self._active and self._printed_anything:
+            self.writer.write("\n")
+            self.writer.flush()
+        self._active = False
+        if self._theme_pushed:
+            self.console.pop_theme()
+            self._theme_pushed = False
+        result = "".join(self._chunks)
+        self._chunks = []
+        self._printed_anything = False
+        return result