dataface 0.1.2__py3-none-any.whl

dataface/cli/_json_output.py

@@ -0,0 +1,8 @@
+"""Shared JSON output helper for dft verbs."""
+
+from pydantic import BaseModel
+
+
+def print_json_result(result: BaseModel) -> None:
+    """Write result as JSON to stdout — stable wire contract for all dft verbs."""
+    print(result.model_dump_json(exclude_none=True, indent=2))

dataface/cli/_parsing.py

@@ -0,0 +1,17 @@
+"""Parse repeatable `--flag key=value` options into a dict."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+import typer
+
+
+def parse_kv_pairs(items: Iterable[str], flag: str) -> dict[str, str]:
+    out: dict[str, str] = {}
+    for item in items:
+        if "=" not in item:
+            raise typer.BadParameter(f"{flag} expects key=value, got: {item!r}")
+        k, v = item.split("=", 1)
+        out[k] = v
+    return out

dataface/cli/_version_info.py

@@ -0,0 +1,56 @@
+"""Compose the `dft --version` line: version, install path, Python, editable flag."""
+
+from __future__ import annotations
+
+import json
+import platform
+import sys
+from dataclasses import dataclass
+from importlib import metadata
+from pathlib import Path
+
+import dataface
+
+
+@dataclass(frozen=True)
+class VersionInfo:
+    version: str
+    package_dir: Path
+    python_version: str
+    python_executable: str
+    editable: bool
+
+    def render(self) -> str:
+        editable = " (editable)" if self.editable else ""
+        return (
+            f"dft {self.version} from {self.package_dir}{editable} "
+            f"(Python {self.python_version}, {self.python_executable})"
+        )
+
+
+def _read_direct_url_json() -> str | None:
+    try:
+        return metadata.distribution("dataface").read_text("direct_url.json")
+    except metadata.PackageNotFoundError:
+        return None
+
+
+def _is_editable() -> bool:
+    raw = _read_direct_url_json()
+    if not raw:
+        return False
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError:
+        return False
+    return bool(data.get("dir_info", {}).get("editable"))
+
+
+def collect() -> VersionInfo:
+    return VersionInfo(
+        version=dataface.__version__,
+        package_dir=Path(dataface.__file__).parent,
+        python_version=platform.python_version(),
+        python_executable=sys.executable,
+        editable=_is_editable(),
+    )

dataface/cli/commands/__init__.py

@@ -0,0 +1,3 @@
+"""CLI command implementations."""
+
+__all__ = []

dataface/cli/commands/_agent_input.py

@@ -0,0 +1,205 @@
+"""Input layer abstraction for dft chat.
+
+Two concrete implementations:
+- PromptToolkitInput: pinned prompt bar, multi-line edit, autocompletion,
+  arrow-key history. Used when stdin is a real TTY and TERM is not dumb.
+- StdlibInput: wraps typer.prompt + readline history. Fallback for piped
+  stdin, dumb terminals, and environments where prompt_toolkit is unavailable.
+
+select_input_layer() picks the right layer at runtime.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+from typing import Any, Protocol, runtime_checkable
+
+import typer
+
+
+@runtime_checkable
+class InputLayer(Protocol):
+    """One method: read a prompt, return a string. EOFError on Ctrl+D."""
+
+    def read(self, prompt: str) -> str:
+        """Read one user turn.
+
+        Args:
+            prompt: The prompt string to display.
+
+        Returns:
+            The user's input as a string.
+
+        Raises:
+            EOFError: When the user presses Ctrl+D (end of input).
+        """
+        ...
+
+
+class StdlibInput:
+    """Stdlib input: typer.prompt + readline history file."""
+
+    def __init__(self, hist_path: Path) -> None:
+        self._hist_path = hist_path
+        self._setup_readline()
+
+    def _setup_readline(self) -> None:
+        try:
+            import readline  # noqa: PLC0415  # type: ignore[import]
+
+            self._hist_path.parent.mkdir(parents=True, exist_ok=True)
+            if self._hist_path.exists():
+                readline.read_history_file(str(self._hist_path))
+            readline.set_history_length(1000)
+            import atexit  # noqa: PLC0415
+
+            atexit.register(readline.write_history_file, str(self._hist_path))
+        except (ImportError, OSError):
+            pass
+
+    def read(self, prompt: str) -> str:
+        return typer.prompt(prompt.rstrip(": "))
+
+
+class DftCompleter:
+    """Completer for dft chat: slash commands and @-path completions."""
+
+    def __init__(self, slash_commands: set[str]) -> None:
+        self._slash_commands = sorted(slash_commands)
+
+    def get_completions(self, document: Any, complete_event: Any) -> list[Any]:
+        from prompt_toolkit.completion import Completion  # noqa: PLC0415
+
+        # document is a prompt_toolkit Document
+        text: str = document.text_before_cursor
+
+        # Slash-command completions: only when buffer starts with /
+        if text.startswith("/"):
+            typed_cmd = text[1:]  # strip leading /
+            completions = []
+            for cmd in self._slash_commands:
+                if cmd.startswith(typed_cmd):
+                    # Completion.text is what gets appended to the buffer
+                    completions.append(
+                        Completion(cmd[len(typed_cmd) :], display=f"/{cmd}")
+                    )
+            return completions
+
+        # @-path completions: delegate to PathCompleter when buffer contains @
+        if "@" in text:
+            at_pos = text.rfind("@")
+            before_at = text[:at_pos]
+            # Only trigger if @ is at word boundary (not inside a word like email)
+            if before_at and before_at[-1].isalnum():
+                return []
+            partial_path = text[at_pos + 1 :]
+            from prompt_toolkit.completion import PathCompleter  # noqa: PLC0415
+            from prompt_toolkit.document import Document  # noqa: PLC0415
+
+            # Build a sub-document for PathCompleter using just the path portion
+            sub_doc = Document(partial_path, len(partial_path))
+            path_completions = []
+            pc = PathCompleter(min_input_len=0)
+            for c in pc.get_completions(
+                sub_doc, complete_event
+            ):  # complete_event is CompleteEvent from prompt_toolkit
+                path_completions.append(
+                    Completion(
+                        c.text, start_position=c.start_position, display=c.display
+                    )
+                )
+            return path_completions
+
+        return []
+
+
+class PromptToolkitInput:
+    """prompt_toolkit input: pinned prompt, multi-line, history, completions.
+
+    Enter submits; Escape+Enter (Meta+Enter) inserts a newline.
+    The default for multiline=True is the opposite, so we override with
+    explicit KeyBindings — matching Claude Code / ChatGPT / Slack behavior.
+    """
+
+    def __init__(self, hist_path: Path, slash_commands: set[str]) -> None:
+        from prompt_toolkit import PromptSession  # noqa: PLC0415
+        from prompt_toolkit.history import FileHistory  # noqa: PLC0415
+        from prompt_toolkit.key_binding import KeyBindings  # noqa: PLC0415
+
+        hist_path.parent.mkdir(parents=True, exist_ok=True)
+
+        kb = KeyBindings()
+
+        @kb.add("enter")
+        def _submit(event: Any) -> None:
+            event.current_buffer.validate_and_handle()
+
+        @kb.add("escape", "enter")
+        def _newline_meta(event: Any) -> None:
+            event.current_buffer.insert_text("\n")
+
+        self._session: PromptSession = PromptSession(
+            history=FileHistory(str(hist_path)),
+            # DftCompleter is duck-typed against the Completer protocol; we
+            # don't inherit because prompt_toolkit imports are deferred to
+            # keep it an optional dep.
+            completer=DftCompleter(slash_commands),  # type: ignore[arg-type]
+            multiline=True,
+            key_bindings=kb,
+        )
+        # Single-slot timestamp store for double-tap-exit. prompt_toolkit
+        # intercepts SIGINT and raises KeyboardInterrupt in the read thread,
+        # so the chat loop's signal handler never fires while we own the
+        # prompt. We track Ctrl+C state here instead.
+        self._last_sigint_ts: list[float] = []
+
+    def read(self, prompt: str) -> str:
+        try:
+            return self._session.prompt(prompt)
+        except KeyboardInterrupt:
+            import time  # noqa: PLC0415
+
+            now = time.monotonic()
+            if self._last_sigint_ts and (now - self._last_sigint_ts[0]) < 1.0:
+                # Double-tap within 1s — end the session.
+                raise EOFError from None
+            if self._last_sigint_ts:
+                self._last_sigint_ts[0] = now
+            else:
+                self._last_sigint_ts.append(now)
+            print(
+                "(Press Ctrl+C again within 1s to exit, or Ctrl+D)",
+                file=sys.stderr,
+            )
+            return ""
+
+
+def select_input_layer(
+    hist_path: Path, slash_commands: set[str] | None = None
+) -> InputLayer:
+    """Select the right input layer for the current environment.
+
+    Returns PromptToolkitInput when:
+    - stdin is a TTY
+    - TERM is not "dumb"
+    - prompt_toolkit can be imported
+
+    Otherwise returns StdlibInput.
+    """
+    if slash_commands is None:
+        slash_commands = set()
+
+    if not sys.stdin.isatty():
+        return StdlibInput(hist_path)
+
+    if os.environ.get("TERM") == "dumb":
+        return StdlibInput(hist_path)
+
+    try:
+        import prompt_toolkit  # noqa: PLC0415, F401
+    except ImportError:
+        return StdlibInput(hist_path)
+
+    return PromptToolkitInput(hist_path, slash_commands)

dataface/cli/commands/_agent_server.py

@@ -0,0 +1,115 @@
+"""Embedded HTTP server lifecycle for `dft chat`.
+
+`dft chat` runs the same FastAPI app that `dft mcp serve` exposes alongside
+its stdio MCP transport, so that URLs the model emits via `render_dashboard`
+(e.g. `http://localhost:<port>/<face>`) actually open a live preview. Without
+this, those URLs 404.
+
+The agent's chat loop is sync; uvicorn needs asyncio. We host the server on a
+dedicated background thread + asyncio loop owned by these helpers — separate
+from the external-MCP manager's loop so neither lifecycle blocks the other.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import threading
+from concurrent.futures import Future
+from dataclasses import dataclass
+
+import uvicorn
+
+from dataface.core.serve.embedded import build_embedded_server
+
+
+@dataclass
+class EmbeddedServerHandle:
+    """Handle for the agent's embedded preview HTTP server."""
+
+    server: uvicorn.Server
+    port: int
+    loop: asyncio.AbstractEventLoop
+    thread: threading.Thread
+    serve_future: Future[None]
+
+
+def start_http_server(*, port_hint: int = 8765) -> EmbeddedServerHandle:
+    """Start the dataface FastAPI server on a background thread.
+
+    Resolves a free port starting at *port_hint* via `find_available_port` so
+    the agent doesn't collide with a `dft mcp serve` already on 8765.
+
+    Returns a handle the caller hands to `stop_http_server` for teardown.
+    Surfaces `ImportError` (uvicorn missing — install `dataface[mcp]`) and
+    `RuntimeError` (no free port near *port_hint*) directly from
+    `build_embedded_server`. If uvicorn binds but then raises (TOCTTOU race),
+    the underlying `OSError` is raised here too — no silent swallows.
+    """
+    server, resolved = build_embedded_server(port_hint=port_hint)
+
+    loop = asyncio.new_event_loop()
+    thread = threading.Thread(
+        target=loop.run_forever, daemon=True, name="dft-chat-http"
+    )
+    thread.start()
+
+    serve_future = asyncio.run_coroutine_threadsafe(server.serve(), loop)
+
+    # Wait until uvicorn signals it has started OR the serve coroutine raises.
+    # Polling both protects against `serve()` failing to bind (in which case
+    # serve_future completes with an OSError) — without this, a bind failure
+    # would just look like a 5-second timeout with the real cause swallowed.
+    deadline = threading.Event()
+
+    async def _wait_started() -> None:
+        while not server.started:
+            await asyncio.sleep(0.05)
+        deadline.set()
+
+    asyncio.run_coroutine_threadsafe(_wait_started(), loop)
+
+    import time
+
+    deadline_ts = time.monotonic() + 5.0
+    while not deadline.wait(timeout=0.05):
+        if serve_future.done():
+            # serve() returned/raised before started flipped — surface the
+            # underlying error rather than the generic timeout below.
+            exc = serve_future.exception()
+            if exc is not None:
+                raise exc
+            raise RuntimeError(
+                f"HTTP server exited before signaling started on port {resolved}"
+            )
+        if time.monotonic() >= deadline_ts:
+            server.should_exit = True
+            raise RuntimeError(
+                f"HTTP server failed to start within 5s on port {resolved}"
+            )
+
+    return EmbeddedServerHandle(
+        server=server,
+        port=resolved,
+        loop=loop,
+        thread=thread,
+        serve_future=serve_future,
+    )
+
+
+def stop_http_server(handle: EmbeddedServerHandle) -> None:
+    """Stop the HTTP server started by `start_http_server`.
+
+    The handle's attributes are guaranteed by `start_http_server` (which is
+    the only constructor) — no defensive `getattr` needed.
+    """
+    handle.server.should_exit = True
+
+    # Best-effort: if serve() raises on shutdown, continue teardown anyway.
+    with contextlib.suppress(Exception):
+        handle.serve_future.result(timeout=5.0)
+
+    if not handle.loop.is_closed():
+        handle.loop.call_soon_threadsafe(handle.loop.stop)
+
+    handle.thread.join(timeout=5.0)