dacli-tui 0.4.0__tar.gz

dacli_tui-0.4.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: dacli-tui
+Version: 0.4.0
+Summary: Rich + prompt-toolkit REPL, themes, and widgets for dacli
+Author-email: Mouad Jaouhari <github@mj-dev.net>
+Project-URL: Homepage, https://github.com/mouadja02/dacli
+Keywords: tui,repl,rich,prompt-toolkit
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: dacli-core==0.4.0
+Requires-Dist: rich<16,>=13
+Requires-Dist: prompt-toolkit<4,>=3
+Provides-Extra: textual
+Requires-Dist: textual<2,>=0.50; extra == "textual"
+
+# dacli-tui
+
+The Rich + prompt-toolkit REPL for [dacli](https://github.com/mouadja02/dacli):
+theme engine, widgets, transcript viewer — editable by prompt. Depends on
+`dacli-core`.

dacli_tui-0.4.0/README.md

@@ -0,0 +1,5 @@
+# dacli-tui
+
+The Rich + prompt-toolkit REPL for [dacli](https://github.com/mouadja02/dacli):
+theme engine, widgets, transcript viewer — editable by prompt. Depends on
+`dacli-core`.

dacli_tui-0.4.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dacli-tui"
+dynamic = ["version"]
+description = "Rich + prompt-toolkit REPL, themes, and widgets for dacli"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "Mouad Jaouhari", email = "github@mj-dev.net" }]
+keywords = ["tui", "repl", "rich", "prompt-toolkit"]
+dependencies = [
+    "dacli-core==0.4.0",
+    "rich>=13,<16",
+    "prompt-toolkit>=3,<4",
+]
+
+[project.optional-dependencies]
+# Full-screen transcript viewer (tui/transcript_app.py). Rich is the default UI;
+# textual is lazy-imported, so a default install never loads it.
+textual = ["textual>=0.50,<2"]
+
+[project.urls]
+Homepage = "https://github.com/mouadja02/dacli"
+
+[tool.setuptools.dynamic]
+version = { attr = "dacli.tui.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["dacli*"]
+namespaces = true

dacli_tui-0.4.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dacli_tui-0.4.0/src/dacli/tui/__init__.py

@@ -0,0 +1,23 @@
+"""DACLI terminal UI package (Rich-based)."""
+
+from .design import ASCII, SPACING, TIER_STYLE, UNICODE, Glyphs, gauge, resolve_glyphs
+from .ui import DacliUI, StreamView
+from .theme import THEMES, DEFAULT_THEME, get_theme, ThemeSpec
+
+__all__ = [
+    "ASCII",
+    "DEFAULT_THEME",
+    "SPACING",
+    "THEMES",
+    "TIER_STYLE",
+    "UNICODE",
+    "DacliUI",
+    "Glyphs",
+    "StreamView",
+    "ThemeSpec",
+    "gauge",
+    "get_theme",
+    "resolve_glyphs",
+]
+
+__version__ = "0.4.0"

dacli_tui-0.4.0/src/dacli/tui/chat_session.py

@@ -0,0 +1,357 @@
+"""Interactive chat REPL.
+
+Builds the agent/memory/UI, runs first-run bootstrap, then loops on input —
+delegating ``/commands`` to :func:`dacli.tui.slash.dispatch` and everything else
+to the agent. Extracted from ``scripts/cli.py`` so the Click surface stays thin.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+from prompt_toolkit.history import FileHistory
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+
+from dacli.config import CLI_COMMANDS
+from dacli.config.settings import (
+    invalidate_config_cache,
+    is_llm_configured,
+    load_config,
+)
+from dacli.connectors.registry import CONNECTORS_CONFIG_PATH
+from dacli.core import __author__, __version__, paths
+from dacli.core.host import DacliHost
+from dacli.core.logging_setup import get_logger
+from dacli.core.memory import AgentMemory
+from dacli.core.onboarding import collect_llm_credentials, run_first_connection
+from dacli.core.store import DacliStore
+from dacli.governance.permissions import EscalationChoice, EscalationRequest
+import dacli.tui.reports as reports
+import dacli.tui.slash as slash
+from dacli.tui import DacliUI
+
+log = get_logger(__name__)
+
+
+def _enabled_connector_names(registry, ext_registry=None) -> list:
+    # Short connector names for the welcome card / status bar.
+    # Old-path connectors (system/sandbox — internal, skip them in display).
+    catalog = registry.get_catalog()
+    names = [
+        cid for cid in catalog
+        if registry.is_connector_enabled(cid) and cid not in ("system", "sandbox")
+    ]
+    # New-path extensions (seeds + user-generated).
+    if ext_registry is not None:
+        names.extend(ext_registry.extension_ids())
+    return names
+
+
+def _ctx_pct(memory, agent=None) -> int:
+    # Context fill for the toolbar (0-100). Prefer the assembler's real budget
+    # snapshot (cached once per turn by the context pipeline) so the number
+    # reflects true token pressure; before the first turn assembles anything,
+    # fall back to the rolling message-window proxy.
+    try:
+        last = agent._context["last_context"]() if agent is not None else None
+        budget = getattr(last, "budget", None)
+        if budget:
+            used = sum(v.get("used", 0) for v in budget.values())
+            cap = sum(v.get("cap", 0) for v in budget.values())
+            if cap > 0:
+                return min(100, max(0, round(used / cap * 100)))
+    except Exception:
+        # a toolbar glitch must never break the input loop
+        log.debug(
+            "context-percent toolbar calc failed; falling back to window", exc_info=True
+        )
+    window = max(getattr(memory, "memory_window", 0) or 1, 1)
+    used = min(len(memory.get_full_history()), window)
+    return round(used / window * 100)
+
+
+async def run_chat(
+    config_path: str | None, session_id: str | None, force_setup: bool = False
+):
+    # Run the interactive chat session.
+    # Load configuration first so the UI is themed from the user's settings.
+    settings = load_config(config_path)
+    chat_ui = DacliUI(settings=settings, version=__version__, author=__author__)
+    con = chat_ui.console
+
+    chat_ui.banner()
+    chat_ui.status("Loading configuration…")
+
+    # First-run LLM bootstrap: with no usable provider/model/key, collect them
+    # interactively (key -> encrypted store, rest -> config.yaml) before any
+    # connector setup. Must run before the agent is built.
+    if not is_llm_configured(settings):
+        settings = collect_llm_credentials(
+            con, settings, store_base_dir=str(Path(settings.agent.state_path).parent)
+        )
+
+    # Persistent project store (.dacli/dacli.json): startups, config snapshot, usage/cost
+    store = DacliStore(base_dir=str(Path(settings.agent.state_path).parent))
+    # Onboarding is conversational now (M12): no connector wizard. Offer a first
+    # connection once, after the host is built — it needs the live extension
+    # registry and secret store. ``--setup`` forces the offer on any run.
+    want_onboarding = force_setup or store.is_first_run()
+
+    # Initialize memory
+    memory = AgentMemory(
+        state_path=settings.agent.state_path,
+        history_path=settings.agent.history_path,
+        memory_window=settings.agent.memory_window,
+    )
+
+    # Load session if specified
+    if session_id:
+        if memory.load_session(session_id):
+            chat_ui.notice(f"Loaded session: {session_id}", style="success")
+        else:
+            chat_ui.error(f"Session not found: {session_id}")
+            return
+
+    def on_user_input_needed(question: str) -> str:
+        # Asked mid-loop (system connector); the stream is already torn down.
+        con.print(
+            Panel(
+                question,
+                title="[warning]input needed[/warning]",
+                border_style="warning",
+                padding=(1, 2),
+            )
+        )
+        return Prompt.ask("[prompt]your response[/prompt]", console=con)
+
+    def on_approval(request) -> bool:
+        # Governance: a risky/irreversible action wants sign-off. Show
+        # the blast radius, the classifier's reasoning, the rollback plan and any
+        # dry-run / shadow diff, then ask. Default is NO (fail-safe).
+        chat_ui.approval_panel(request)
+        return Confirm.ask(
+            "[prompt]Proceed with this action?[/prompt]", console=con, default=False
+        )
+
+    def on_escalation(request: EscalationRequest) -> EscalationChoice:
+        # Scope escalation: the action exceeds the connector's granted scope.
+        # Show a panel with current/needed scope and 3 choices.
+        chat_ui.escalation_panel(request)
+        answer = Prompt.ask(
+            "[prompt]Choice[/prompt]",
+            choices=["1", "2", "3"],
+            default="3",
+            console=con,
+        )
+        return {
+            "1": EscalationChoice.ALLOW_ONCE,
+            "2": EscalationChoice.ALLOW_PERMANENTLY,
+            "3": EscalationChoice.DECLINE,
+        }.get(answer, EscalationChoice.DECLINE)
+
+    # Initialize the host (M09) — UI methods wired directly as kernel callbacks.
+    # Wrapped in a factory so a `/workspace` switch can rebuild the host for the
+    # newly active workspace without restarting the process (M15). Passing
+    # memory/store=None lets the host derive workspace-scoped ones.
+    def make_host(settings, memory=None, store=None):
+        return DacliHost(
+            settings=settings,
+            memory=memory,
+            on_status_update=chat_ui.status,
+            on_tool_start=chat_ui.tool_start,
+            on_tool_end=chat_ui.tool_end,
+            on_tool_progress=chat_ui.tool_progress,
+            on_user_input_needed=on_user_input_needed,
+            on_approval=on_approval,
+            on_escalation=on_escalation,
+            on_stream_start=chat_ui.on_stream_start,
+            on_text=chat_ui.on_text,
+            on_stream_end=chat_ui.on_stream_end,
+            connectors_config_path=CONNECTORS_CONFIG_PATH,
+            store=store,
+        )
+
+    agent = make_host(settings, memory, store)
+
+    # Initialize connections (the agent emits its own progress via on_status).
+    con.print()
+    try:
+        if not await agent.initialize():
+            chat_ui.error("Failed to initialize agent. Check your configuration.")
+            return
+    except Exception as e:
+        chat_ui.error(f"Initialization error: {e}")
+        chat_ui.notice(
+            "Check your config.yaml and ensure credentials are set.", style="muted"
+        )
+        return
+
+    # Point the transcript log at the session spill store so /expand can fetch
+    # an elided result back off-context instead of re-running the tool (P11).
+    spill_store = getattr(agent, "_context", {}).get("store")
+    if spill_store is not None:
+        chat_ui.bind_result_store(spill_store)
+
+    # Persist startup + a secret-redacted snapshot of the effective config.
+    store.record_startup()
+    store.snapshot_config(settings)
+    store.save()
+
+    # Conversational first-connection onboarding (M12). Skippable; declining
+    # leaves an empty ~/.dacli untouched.
+    if want_onboarding:
+        con.print()
+        run_first_connection(chat_ui, con, agent._ext_registry, agent.secrets)
+        invalidate_config_cache()
+        settings = load_config(config_path)
+
+    con.print()
+    resolved_config = paths.resolve_config_path(config_path)
+    chat_ui.welcome(
+        model=settings.llm.model,
+        provider=settings.llm.provider,
+        connectors=_enabled_connector_names(agent.registry, agent._ext_registry),
+        cwd=str(Path.cwd()),
+        config=str(resolved_config) if resolved_config else None,
+        state=str(paths.state_dir().resolve()),
+    )
+
+    # Surface any connectors the registry had to skip (bad manifest / import
+    # error / failing operations()) so a broken — often freshly generated —
+    # connector is visible instead of silently missing.
+    failed = agent.registry.failed_connectors()
+    if failed:
+        for cid, reason in failed.items():
+            chat_ui.notice(f"Connector '{cid}' was skipped: {reason}", style="warning")
+        chat_ui.notice(
+            "Fix it with /debug-connector, then /import-connector to re-enable.",
+            style="muted",
+        )
+
+    # Mutable session state the slash handlers read and (for reloads) write.
+    ctx = slash.ChatContext(
+        ui=chat_ui,
+        console=con,
+        memory=memory,
+        agent=agent,
+        store=store,
+        settings=settings,
+        config_path=config_path,
+        make_host=make_host,
+    )
+
+    # Set up prompt toolkit for better input.
+    # Resolve to absolute so prompt_toolkit can always find the file on exit,
+    # even if something shifts cwd mid-session.
+    history_file = (Path(settings.agent.history_path) / "input_history.txt").resolve()
+    history_file.parent.mkdir(parents=True, exist_ok=True)
+
+    # The toolbar reads ctx.* (not the construction-time locals) so a `/workspace`
+    # switch, which swaps ctx.agent/memory/store, is reflected without a restart.
+    def _session_cost() -> str:
+        # Live per-session $cost for the bottom bar; blank on any hiccup.
+        # O(1) lookup — the toolbar recomputes this on every keystroke.
+        try:
+            return reports.fmt_cost(ctx.store.session_cost_usd(ctx.memory.session_id))
+        except Exception:
+            return ""
+
+    def _warehouse_cost() -> str:
+        # Live per-session warehouse $spend (P14), shown next to the LLM cost.
+        # Blank until a governed warehouse action records an estimate.
+        try:
+            usd = ctx.store.session_warehouse_usd(ctx.memory.session_id)
+            return reports.fmt_cost(usd) if usd else ""
+        except Exception:
+            return ""
+
+    def bottom_toolbar():
+        from dacli.core.test_mode import test_mode as _tm
+
+        return chat_ui.bottom_toolbar(
+            provider=ctx.settings.llm.provider,
+            model=ctx.settings.llm.model,
+            connectors=_enabled_connector_names(
+                ctx.agent.registry, ctx.agent._ext_registry
+            ),
+            ctx_pct=_ctx_pct(ctx.memory, ctx.agent),
+            session=ctx.memory.session_id,
+            test_mode=_tm.toolbar_text(),
+            cost=_session_cost(),
+            wh_cost=_warehouse_cost(),
+        )
+
+    pt_session = PromptSession(
+        history=FileHistory(str(history_file)),
+        auto_suggest=AutoSuggestFromHistory(),
+        completer=slash.SlashCommandCompleter(CLI_COMMANDS),
+        complete_while_typing=True,
+        key_bindings=slash.build_completion_keybindings(),
+        bottom_toolbar=bottom_toolbar,
+    )
+
+    try:
+        while True:
+            try:
+                user_input = await asyncio.to_thread(
+                    pt_session.prompt,
+                    chat_ui.prompt_html(),
+                )
+
+                if not user_input.strip():
+                    continue
+
+                # Slash commands run through the registry; everything else is a
+                # message for the agent.
+                if user_input.startswith("/"):
+                    await slash.dispatch(ctx, user_input)
+                    if ctx.should_exit:
+                        break
+                    continue
+
+                # Process the message with the agent. The kernel streams text +
+                # tool calls to the UI as it runs, so there is nothing to print
+                # here on success — only errors / hand-offs need a notice.
+                # (prompt_toolkit already leaves the typed "❯ …" line in the
+                # scrollback, so we don't re-echo it.)
+                con.print()
+                if getattr(ctx.settings.ui, "show_header", False):
+                    chat_ui.turn_header(
+                        model=ctx.settings.llm.model, session=ctx.memory.session_id
+                    )
+
+                try:
+                    response = await ctx.agent.process_message(user_input)
+                except KeyboardInterrupt:
+                    chat_ui.stream.abort()
+                    chat_ui.notice("Interrupted.", style="warning")
+                    continue
+
+                if response.error:
+                    chat_ui.error(f"Error: {response.error}")
+
+                if response.needs_user_input:
+                    chat_ui.notice(
+                        "⏳ Agent is waiting for your input to continue.",
+                        style="warning",
+                    )
+
+                con.print()
+
+            except KeyboardInterrupt:
+                chat_ui.stream.abort()
+                con.print("\n[muted]Use /exit to quit[/muted]")
+                continue
+
+            except EOFError:
+                break
+
+    finally:
+        chat_ui.stream.abort()
+        con.print("\n[muted]Cleaning up…[/muted]")
+        await ctx.agent.shutdown()
+        chat_ui.notice("Goodbye 👋", style="success")

dacli_tui-0.4.0/src/dacli/tui/design.py

@@ -0,0 +1,168 @@
+"""Design tokens for the DACLI terminal UI.
+
+Single source of truth for **spacing, glyphs, box styles and semantic color
+maps** so every renderer in ``tui/ui.py`` makes the same choices. Two glyph
+sets exist: ``UNICODE`` for capable terminals and ``ASCII`` for everything
+else (non-UTF-8 encodings, ``TERM=dumb``, ``NO_COLOR`` environments, or an
+explicit ``ui.glyphs: ascii`` setting). :func:`resolve_glyphs` picks one.
+
+Reliability note: this module is presentation-only and import-safe — it never
+touches config, credentials or the control loop. Capability detection is
+best-effort and degrades to ASCII on any doubt.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Any
+
+from rich import box
+from rich.text import Text
+
+
+@dataclass(frozen=True)
+class Glyphs:
+    """One coherent glyph set; every UI marker comes from here."""
+
+    # Transcript gutter markers.
+    agent: str
+    tool: str
+    result: str
+    user_caret: str
+    # Status icons (always paired with color, never color-only).
+    ok: str
+    warn: str
+    err: str
+    info: str
+    pending: str
+    running: str
+    paused: str
+    # Connector enablement dots.
+    enabled: str
+    disabled: str
+    # Misc affordances.
+    caret: str          # streaming tail caret
+    hint: str           # remediation-hint arrow
+    gauge_on: str       # filled cell of the context gauge
+    gauge_off: str      # empty cell of the context gauge
+    ellipsis: str
+    dot: str            # separator dot in summaries ("· 340ms")
+    dash: str           # placeholder dash in empty table cells
+    arrows: str         # history-keys hint in the welcome tips
+    delta: str          # change marker in diff/plan tables ("Δ rows")
+    mult: str           # breadth-first multiplier ("×3")
+    # Bottom-bar segment icons (empty in ASCII mode; labels carry meaning).
+    bar_conn: str
+    bar_ctx: str
+    bar_session: str
+    bar_sep: str
+    # Spinner animation frames (one frame per char/element).
+    spinner_frames: str
+    # Box style for panels/tables.
+    box: box.Box
+
+
+UNICODE = Glyphs(
+    agent="⏺", tool="⏺", result="⎿", user_caret="❯",
+    ok="✓", warn="⚠", err="✗", info="ℹ", pending="○", running="◐", paused="⏸",
+    enabled="●", disabled="○",
+    caret="▌", hint="↳", gauge_on="▰", gauge_off="▱", ellipsis="…",
+    dot="·", dash="—", arrows="↑↓", delta="Δ", mult="×",
+    bar_conn="⛁ ", bar_ctx="◴ ", bar_session="⎇ ", bar_sep="│",
+    spinner_frames="⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏",
+    box=box.ROUNDED,
+)
+
+ASCII = Glyphs(
+    agent="*", tool="*", result=">", user_caret=">",
+    ok="+", warn="!", err="x", info="i", pending="o", running="~", paused="=",
+    enabled="*", disabled="o",
+    caret="|", hint="->", gauge_on="#", gauge_off="-", ellipsis="...",
+    dot=".", dash="-", arrows="Up/Down", delta="d", mult="x",
+    bar_conn="", bar_ctx="", bar_session="", bar_sep="|",
+    spinner_frames="|/-\\",
+    box=box.ASCII,
+)
+
+# One spacing system: gutter width, body indent, panel padding, section gap.
+SPACING: dict[str, Any] = {
+    "gutter_w": 1,
+    "indent": 2,
+    "panel_pad": (1, 2),
+    "section_gap": 1,
+}
+
+# Blast-radius tier → semantic style. Shared by the audit view, the plan
+# preview and the approval panel so "risky" reads the same color everywhere.
+TIER_STYLE = {
+    "safe": "success",
+    "write": "info",
+    "risky": "warning",
+    "irreversible": "error",
+}
+
+
+def tier_legend(dot: str = "·") -> Text:
+    """A one-line ``safe · write · risky · irreversible`` key in tier colors.
+
+    Shared under the dense governance panels (plan, audit, approval) so the
+    blast-radius colors are decodable without memorizing them.
+    """
+    legend = Text()
+    for i, (name, style) in enumerate(TIER_STYLE.items()):
+        if i:
+            legend.append(f"  {dot}  ", style="muted")
+        legend.append(name, style=style)
+    return legend
+
+
+def gauge(pct: Any, glyphs: Glyphs, cells: int = 5) -> str:
+    """Render a percentage as a tiny bar gauge, e.g. ``▰▰▰▱▱ 58%``.
+
+    Defensive: a non-numeric ``pct`` renders as an empty gauge rather than
+    raising (the status bar must never crash the input loop).
+    """
+    try:
+        clamped = min(100, max(0, int(pct)))
+    except Exception:
+        clamped = 0
+    filled = round(cells * clamped / 100)
+    return glyphs.gauge_on * filled + glyphs.gauge_off * (cells - filled) + f" {clamped}%"
+
+
+def _console_can_encode(console: Any, probe: str = "⏺⎿✓▰") -> bool:
+    """Best-effort: can this console's encoding represent our glyphs?"""
+    try:
+        encoding = getattr(console.options, "encoding", "") or "ascii"
+        probe.encode(encoding)
+    except Exception:
+        return False
+    return True
+
+
+def resolve_glyphs(console: Any, settings: Any = None) -> Glyphs:
+    """Pick the glyph set for this console + settings.
+
+    ASCII when: ``ui.glyphs == "ascii"``, the console can't encode Unicode,
+    ``NO_COLOR`` is set, or the terminal is dumb. Unicode otherwise. An
+    explicit ``ui.glyphs == "unicode"`` wins over the heuristics.
+    """
+    try:
+        preference = str(
+            getattr(getattr(settings, "ui", None), "glyphs", "auto") or "auto"
+        ).strip().lower()
+    except Exception:
+        preference = "auto"
+    if preference == "ascii":
+        return ASCII
+    if preference == "unicode":
+        return UNICODE
+    # auto: degrade on any capability doubt.
+    if os.environ.get("NO_COLOR"):
+        return ASCII
+    if os.environ.get("TERM", "").lower() == "dumb":
+        return ASCII
+    if not _console_can_encode(console):
+        return ASCII
+    return UNICODE