dulus 0.2.0__py3-none-any.whl

ui/render.py

@@ -0,0 +1,272 @@
+"""
+ui/render.py — All terminal rendering for Dulus.
+
+Provides:
+  - ANSI color helpers (C, clr, info, ok, warn, err)
+  - Rich Markdown streaming (stream_text, flush_response)
+  - Spinner management
+  - Tool call display (print_tool_start, print_tool_end)
+  - Diff rendering (render_diff)
+"""
+from __future__ import annotations
+
+import sys
+import json
+import threading
+
+# ── Optional rich for markdown rendering ──────────────────────────────────
+try:
+    from rich.console import Console
+    from rich.markdown import Markdown
+    from rich.live import Live
+    _RICH = True
+    console = Console()
+except ImportError:
+    _RICH = False
+    console = None
+    Live = None
+    Markdown = None
+
+# ── ANSI helpers ───────────────────────────────────────────────────────────
+# Prefer the global theme-aware palette from common.py; fall back to Dulus
+# orange (default theme accent) so this module never emits generic cyan.
+try:
+    from common import C, clr, info, ok, warn, err
+except ImportError:
+    _DULUS_ORANGE = "\033[38;2;255;135;0m"
+    _WARN = "\033[38;2;255;175;0m"
+    C = {
+        "cyan": _DULUS_ORANGE, "green": _DULUS_ORANGE, "blue": _DULUS_ORANGE,
+        "yellow": _WARN, "magenta": _WARN, "red": "\033[38;5;196m",
+        "white": "\033[97m", "gray": "\033[90m",
+        "bold": "\033[1m", "dim": "\033[2m", "reset": "\033[0m",
+    }
+    def clr(text: str, *keys: str) -> str:
+        return "".join(C[k] for k in keys) + str(text) + C["reset"]
+    def info(msg: str):   print(clr(msg, "cyan"))
+    def ok(msg: str):     print(clr(msg, "green"))
+    def warn(msg: str):   print(clr(f"Warning: {msg}", "yellow"))
+    def err(msg: str):    print(clr(f"Error: {msg}", "red"), file=sys.stderr)
+
+def _truncate_err_global(s: str, max_len: int = 200) -> str:
+    if len(s) <= max_len:
+        return s
+    return s[:max_len - 3] + "..."
+
+
+# ── Diff rendering ─────────────────────────────────────────────────────────
+
+def render_diff(text: str):
+    """Print diff text with ANSI colors: red for removals, green for additions."""
+    for line in text.splitlines():
+        if line.startswith("+++") or line.startswith("---"):
+            print(C["bold"] + line + C["reset"])
+        elif line.startswith("+"):
+            print(C["green"] + line + C["reset"])
+        elif line.startswith("-"):
+            print(C["red"] + line + C["reset"])
+        elif line.startswith("@@"):
+            print(C["cyan"] + line + C["reset"])
+        else:
+            print(line)
+
+def _has_diff(text: str) -> bool:
+    """Check if text contains a unified diff."""
+    return "--- a/" in text and "+++ b/" in text
+
+
+# ── Conversation rendering ─────────────────────────────────────────────────
+
+_accumulated_text: list[str] = []   # buffer text during streaming
+_current_live = None                # active Rich Live instance (one at a time)
+_RICH_LIVE = True                   # set False (via config rich_live=false) to disable
+
+def set_rich_live(enabled: bool) -> None:
+    """Called from repl.py to apply the rich_live config setting."""
+    global _RICH_LIVE
+    _RICH_LIVE = _RICH and enabled
+
+def _make_renderable(text: str):
+    """Return a Rich renderable: Markdown if text contains markup, else plain."""
+    if any(c in text for c in ("#", "*", "`", "_", "[")):
+        return Markdown(text)
+    return text
+
+def _start_live() -> None:
+    """Start a Rich Live block for in-place Markdown streaming (no-op if not Rich)."""
+    global _current_live
+    if _RICH and _RICH_LIVE and _current_live is None:
+        _current_live = Live(console=console, auto_refresh=False,
+                             vertical_overflow="visible")
+        _current_live.start()
+
+_LIVE_LINE_LIMIT = 80  # auto-switch to plain streaming beyond this many lines
+
+
+def stream_text(chunk: str) -> None:
+    """Buffer chunk; update Live in-place when Rich available, else print directly.
+
+    Safety: if accumulated text exceeds _LIVE_LINE_LIMIT lines, auto-switch
+    from Rich Live to plain streaming to prevent terminal re-render duplication
+    on terminals that can't handle large Live areas (macOS Terminal, etc.).
+    """
+    global _current_live
+    _accumulated_text.append(chunk)
+
+    if _RICH and _RICH_LIVE:
+        full = "".join(_accumulated_text)
+        line_count = full.count("\n")
+
+        # Safety: too many lines → kill Live and fall back to plain streaming
+        if _current_live is not None and line_count > _LIVE_LINE_LIMIT:
+            _current_live.stop()
+            _current_live = None
+            # Print the full text once (Live already displayed partial content,
+            # but stopping Live clears it — so we re-print cleanly)
+            console.print(_make_renderable(full))
+            _accumulated_text.clear()
+            return
+
+        if line_count <= _LIVE_LINE_LIMIT:
+            if _current_live is None:
+                _start_live()
+            _current_live.update(_make_renderable(full), refresh=True)
+        else:
+            # Already past limit, no Live — just append new chunk
+            print(chunk, end="", flush=True)
+    else:
+        print(chunk, end="", flush=True)
+
+def stream_thinking(chunk: str, verbose: bool):
+    if verbose:
+        clean_chunk = chunk.replace("\n", " ")
+        if clean_chunk:
+            print(f"{C['dim']}{clean_chunk}", end="", flush=True)
+
+def flush_response() -> None:
+    """Commit buffered text to screen: stop Live (freezes rendered Markdown in place)."""
+    global _current_live
+    full = "".join(_accumulated_text)
+    _accumulated_text.clear()
+    if _current_live is not None:
+        _current_live.stop()
+        _current_live = None
+    elif _RICH and _RICH_LIVE and full.strip():
+        console.print(_make_renderable(full))
+    else:
+        print()  # ensure newline after plain-text stream
+
+
+# ── Spinner ────────────────────────────────────────────────────────────────
+
+from spinner import TOOL_SPINNER_PHRASES as _TOOL_SPINNER_PHRASES
+from spinner import DEBATE_SPINNER_PHRASES as _DEBATE_SPINNER_PHRASES
+
+_tool_spinner_thread = None
+_tool_spinner_stop = threading.Event()
+_spinner_phrase = ""
+_spinner_lock = threading.Lock()
+
+
+def _run_tool_spinner():
+    """Background spinner on a single line using carriage return."""
+    chars = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+    i = 0
+    while not _tool_spinner_stop.is_set():
+        with _spinner_lock:
+            phrase = _spinner_phrase
+        frame = chars[i % len(chars)]
+        sys.stdout.write(f"\r  {frame} {clr(phrase, 'dim')}   ")
+        sys.stdout.flush()
+        i += 1
+        _tool_spinner_stop.wait(0.1)
+
+def _start_tool_spinner():
+    global _tool_spinner_thread
+    if _tool_spinner_thread and _tool_spinner_thread.is_alive():
+        return
+    import random
+    with _spinner_lock:
+        global _spinner_phrase
+        _spinner_phrase = random.choice(_TOOL_SPINNER_PHRASES)
+    _tool_spinner_stop.clear()
+    _tool_spinner_thread = threading.Thread(target=_run_tool_spinner, daemon=True)
+    _tool_spinner_thread.start()
+
+def _change_spinner_phrase():
+    """Change the spinner phrase without stopping it."""
+    import random
+    with _spinner_lock:
+        global _spinner_phrase
+        _spinner_phrase = random.choice(_TOOL_SPINNER_PHRASES)
+
+def set_spinner_phrase(phrase: str) -> None:
+    """Set a specific spinner phrase (used by SSJ debate mode)."""
+    global _spinner_phrase
+    with _spinner_lock:
+        _spinner_phrase = phrase
+
+def _stop_tool_spinner():
+    global _tool_spinner_thread
+    if not _tool_spinner_thread:
+        return
+    _tool_spinner_stop.set()
+    _tool_spinner_thread.join(timeout=1)
+    _tool_spinner_thread = None
+    sys.stdout.write(f"\r{' ' * 50}\r")
+    sys.stdout.flush()
+
+
+# ── Tool call display ──────────────────────────────────────────────────────
+
+def _tool_desc(name: str, inputs: dict) -> str:
+    if name == "Read":   return f"Read({inputs.get('file_path','')})"
+    if name == "Write":  return f"Write({inputs.get('file_path','')})"
+    if name == "Edit":   return f"Edit({inputs.get('file_path','')})"
+    if name == "Bash":   return f"Bash({inputs.get('command','')[:80]})"
+    if name == "Glob":   return f"Glob({inputs.get('pattern','')})"
+    if name == "Grep":   return f"Grep({inputs.get('pattern','')})"
+    if name == "WebFetch":    return f"WebFetch({inputs.get('url','')[:60]})"
+    if name == "WebSearch":   return f"WebSearch({inputs.get('query','')})"
+    if name == "Agent":
+        atype = inputs.get("subagent_type", "")
+        aname = inputs.get("name", "")
+        iso   = inputs.get("isolation", "")
+        parts = []
+        if atype:  parts.append(atype)
+        if aname:  parts.append(f"name={aname}")
+        if iso:    parts.append(f"isolation={iso}")
+        suffix = f"({', '.join(parts)})" if parts else ""
+        prompt_short = inputs.get("prompt", "")[:60]
+        return f"Agent{suffix}: {prompt_short}"
+    if name == "SendMessage":
+        return f"SendMessage(to={inputs.get('to','')}: {inputs.get('message','')[:50]})"
+    if name == "CheckAgentResult": return f"CheckAgentResult({inputs.get('task_id','')})"
+    if name == "ListAgentTasks":   return "ListAgentTasks()"
+    if name == "ListAgentTypes":   return "ListAgentTypes()"
+    return f"{name}({list(inputs.values())[:1]})"
+
+
+def print_tool_start(name: str, inputs: dict, verbose: bool):
+    """Show tool invocation."""
+    desc = _tool_desc(name, inputs)
+    print(clr(f"  ⚙  {desc}", "dim", "cyan"), flush=True)
+    if verbose:
+        print(clr(f"     inputs: {json.dumps(inputs, ensure_ascii=False)[:200]}", "dim"))
+
+def print_tool_end(name: str, result: str, verbose: bool):
+    lines = result.count("\n") + 1
+    size = len(result)
+    summary = f"→ {lines} lines ({size} chars)"
+    if not result.startswith("Error") and not result.startswith("Denied"):
+        print(clr(f"  ✓ {summary}", "dim", "green"), flush=True)
+        if name in ("Edit", "Write") and _has_diff(result):
+            parts = result.split("\n\n", 1)
+            if len(parts) == 2:
+                print(clr(f"  {parts[0]}", "dim"))
+                render_diff(parts[1])
+    else:
+        print(clr(f"  ✗ {result[:120]}", "dim", "red"), flush=True)
+    if verbose and not result.startswith("Denied"):
+        preview = result[:500] + ("…" if len(result) > 500 else "")
+        print(clr(f"     {preview.replace(chr(10), chr(10)+'     ')}", "dim"))

voice/__init__.py

@@ -0,0 +1,56 @@
+"""Voice package for dulus.
+
+Public API
+----------
+check_voice_deps()   → (available: bool, reason: str | None)
+record_once(...)     → raw PCM bytes  (int16, 16 kHz, mono)
+transcribe(...)      → text string
+voice_input(...)     → transcribed text (record + transcribe in one call)
+"""
+
+from .recorder import check_recording_availability, record_until_silence, list_input_devices
+from .stt import check_stt_availability, transcribe, transcribe_audio_file
+from .tts import check_tts_availability, say
+from .keyterms import get_voice_keyterms
+
+
+def check_voice_deps() -> tuple[bool, str | None]:
+    """Return (available, reason_if_not)."""
+    rec_ok, rec_reason = check_recording_availability()
+    if not rec_ok:
+        return False, rec_reason
+    stt_ok, stt_reason = check_stt_availability()
+    if not stt_ok:
+        return False, stt_reason
+    # TTS is optional, so we don't fail here if it's missing,
+    # but we could add a check if needed.
+    return True, None
+
+
+def voice_input(
+    language: str = "auto",
+    max_seconds: int = 30,
+    on_energy: "callable | None" = None,
+    device_index: "int | None" = None,
+) -> str:
+    """Record until silence, then transcribe.  Returns transcribed text."""
+    keyterms = get_voice_keyterms()
+    pcm = record_until_silence(max_seconds=max_seconds, on_energy=on_energy, device_index=device_index)
+    if not pcm:
+        return ""
+    return transcribe(pcm, keyterms=keyterms, language=language)
+
+
+__all__ = [
+    "check_voice_deps",
+    "check_recording_availability",
+    "check_stt_availability",
+    "check_tts_availability",
+    "record_until_silence",
+    "list_input_devices",
+    "transcribe",
+    "transcribe_audio_file",
+    "get_voice_keyterms",
+    "voice_input",
+    "say",
+]

voice/keyterms.py

@@ -0,0 +1,179 @@
+"""Voice keyterms: domain-specific vocabulary hints for STT accuracy.
+
+Passed as Whisper's `initial_prompt` so that coding terminology
+(grep, MCP, TypeScript, JSON, …) is recognised correctly instead of being
+mistranscribed as phonetically similar common words.
+
+Inspired by Claude Code's voiceKeyterms.ts, but expanded for a multi-provider
+setting and adapted to pull context from the Python runtime environment.
+"""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from pathlib import Path
+
+# ── Global coding keyterms ────────────────────────────────────────────────
+# Terms that speech engines consistently mishear during coding dictation.
+# Exclude anything trivially recognised (e.g. "file", "code") — only add
+# terms where phonetic ambiguity is high.
+
+GLOBAL_KEYTERMS: list[str] = [
+    # Tools and protocols
+    "MCP",
+    "grep",
+    "regex",
+    "regex pattern",
+    "ripgrep",
+    "localhost",
+    "codebase",
+    "webhook",
+    "OAuth",
+    "gRPC",
+    "JSON",
+    "YAML",
+    "dotfiles",
+    "symlink",
+    "subprocess",
+    "subagent",
+    "worktree",
+    # Languages / runtimes
+    "TypeScript",
+    "JavaScript",
+    "Python",
+    "Rust",
+    "Golang",
+    "Dockerfile",
+    "bash",
+    # Common coding words with phonetic twins
+    "pytest",
+    "linter",
+    "formatter",
+    "middleware",
+    "endpoint",
+    "namespace",
+    "async",
+    "await",
+    "refactor",
+    "deprecate",
+    "serialize",
+    "deserialize",
+    "Pydantic",
+    "FastAPI",
+    "SQLAlchemy",
+]
+
+MAX_KEYTERMS = 50
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────
+
+def split_identifier(name: str) -> list[str]:
+    """Split camelCase / PascalCase / kebab-case / snake_case into words.
+
+    Fragments ≤ 2 chars or > 20 chars are discarded.
+
+    Examples:
+        "dulus" → ["nano", "claude", "code"]
+        "MyWebhookHandler" → ["My", "Webhook", "Handler"]
+    """
+    # camelCase / PascalCase
+    spaced = re.sub(r"([a-z])([A-Z])", r"\1 \2", name)
+    parts = re.split(r"[-_./\s]+", spaced)
+    return [p.strip() for p in parts if 3 <= len(p.strip()) <= 20]
+
+
+def _git_branch() -> str | None:
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            capture_output=True, text=True, timeout=3,
+        )
+        branch = result.stdout.strip()
+        return branch if branch and branch != "HEAD" else None
+    except Exception:
+        return None
+
+
+def _project_root() -> Path | None:
+    """Find the git root or fall back to cwd."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            capture_output=True, text=True, timeout=3,
+        )
+        root = result.stdout.strip()
+        if root:
+            return Path(root)
+    except Exception:
+        pass
+    return Path.cwd()
+
+
+def _recent_py_files(root: Path, limit: int = 20) -> list[Path]:
+    """Return the most-recently modified Python/TS/JS files in the repo."""
+    try:
+        result = subprocess.run(
+            ["git", "ls-files", "--cached", "--others", "--exclude-standard"],
+            capture_output=True, text=True, timeout=5, cwd=str(root),
+        )
+        files = [
+            root / f for f in result.stdout.splitlines()
+            if f.endswith((".py", ".ts", ".tsx", ".js", ".jsx", ".go", ".rs"))
+        ]
+        # Sort by mtime descending
+        files.sort(key=lambda p: p.stat().st_mtime if p.exists() else 0, reverse=True)
+        return files[:limit]
+    except Exception:
+        return []
+
+
+# ── Public API ────────────────────────────────────────────────────────────
+
+def get_voice_keyterms(recent_files: list[str] | None = None) -> list[str]:
+    """Build a list of keyterms for the STT engine.
+
+    Combines:
+      • Hardcoded global coding vocabulary
+      • Project root directory name
+      • Git branch words
+      • Recent source file stem words
+
+    Returns up to MAX_KEYTERMS unique terms.
+    """
+    terms: list[str] = list(GLOBAL_KEYTERMS)
+
+    # Project name
+    root = _project_root()
+    if root and root.name:
+        name = root.name
+        if 2 < len(name) <= 50:
+            terms.append(name)
+        terms.extend(split_identifier(name))
+
+    # Git branch words (e.g. "feat/voice-input" → ["feat", "voice", "input"])
+    branch = _git_branch()
+    if branch:
+        terms.extend(split_identifier(branch))
+
+    # Recent file stems
+    files = [Path(f) for f in (recent_files or [])] + _recent_py_files(root or Path.cwd())
+    for fpath in files:
+        if len(terms) >= MAX_KEYTERMS:
+            break
+        stem = fpath.stem
+        if stem:
+            terms.extend(split_identifier(stem))
+
+    # Deduplicate preserving order, trim to limit
+    seen: set[str] = set()
+    result: list[str] = []
+    for t in terms:
+        if t not in seen:
+            seen.add(t)
+            result.append(t)
+        if len(result) >= MAX_KEYTERMS:
+            break
+
+    return result