klaude-code 1.2.6__py3-none-any.whl

klaude_code/ui/terminal/notifier.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import os
+import sys
+from dataclasses import dataclass
+from enum import Enum
+from typing import TextIO, cast
+
+from klaude_code.trace import DebugType, log_debug
+
+ST = "\033\\"
+BEL = "\a"
+
+
+def resolve_stream(stream: TextIO | None) -> TextIO:
+    """Use the original stdout when available to avoid interception by Rich wrappers."""
+    if stream is not None:
+        return stream
+    if hasattr(sys, "__stdout__") and sys.__stdout__ is not None:
+        return cast(TextIO, sys.__stdout__)
+    return sys.stdout
+
+
+class NotificationType(Enum):
+    AGENT_TASK_COMPLETE = "agent_task_complete"
+
+
+@dataclass
+class Notification:
+    type: NotificationType
+    title: str
+    body: str | None = None
+
+
+@dataclass
+class TerminalNotifierConfig:
+    enabled: bool = True
+    use_bel: bool = False
+    stream: TextIO | None = None
+
+    @classmethod
+    def from_env(cls) -> "TerminalNotifierConfig":
+        env = os.getenv("KLAUDE_NOTIFY", "").strip().lower()
+        if env in {"0", "off", "false", "disable", "disabled"}:
+            return cls(enabled=False)
+        return cls(enabled=True)
+
+
+class TerminalNotifier:
+    def __init__(self, config: TerminalNotifierConfig | None = None) -> None:
+        self.config = config or TerminalNotifierConfig.from_env()
+
+    def notify(self, notification: Notification) -> bool:
+        if not self.config.enabled:
+            log_debug(
+                "Terminal notifier skipped: disabled via config",
+                debug_type=DebugType.TERMINAL,
+            )
+            return False
+
+        output = resolve_stream(self.config.stream)
+        if not self._supports_osc9(output):
+            log_debug(
+                "Terminal notifier skipped: OSC 9 unsupported or not a TTY",
+                debug_type=DebugType.TERMINAL,
+            )
+            return False
+
+        payload = self._render_payload(notification)
+        return self._emit(payload, output)
+
+    def _render_payload(self, notification: Notification) -> str:
+        title = _compact(notification.title)
+        body = _compact(notification.body) if notification.body else None
+        if body:
+            return f"{title} - {body}"
+        return title
+
+    def _emit(self, payload: str, output: TextIO) -> bool:
+        terminator = BEL if self.config.use_bel else ST
+        seq = f"\033]9;{payload}{terminator}"
+        try:
+            output.write(seq)
+            output.flush()
+            log_debug("Terminal notifier sent OSC 9 payload", debug_type=DebugType.TERMINAL)
+            return True
+        except Exception as exc:
+            log_debug(f"Terminal notifier send failed: {exc}", debug_type=DebugType.TERMINAL)
+            return False
+
+    @staticmethod
+    def _supports_osc9(stream: TextIO) -> bool:
+        if sys.platform == "win32":
+            return False
+        if not getattr(stream, "isatty", lambda: False)():
+            return False
+        term = os.getenv("TERM", "")
+        if term.lower() in {"", "dumb"}:
+            return False
+        return True
+
+
+def _compact(text: str, limit: int = 160) -> str:
+    squashed = " ".join(text.split())
+    if len(squashed) > limit:
+        return squashed[: limit - 3] + "…"
+    return squashed

klaude_code/ui/terminal/progress_bar.py

@@ -0,0 +1,87 @@
+"""
+Use OSC 9;4;... to control progress bar in terminal like Ghostty
+States:
+  0/hidden
+  1/normal
+  2/error
+  3/indeterminate
+  4/warning
+"""
+
+import os
+import sys
+import time
+from enum import Enum
+from typing import TextIO, cast
+
+is_ghostty = os.environ.get("TERM") == "xterm-ghostty" or "GHOSTTY_RESOURCES_DIR" in os.environ
+
+ST = "\033\\"  # ESC \
+BEL = "\a"  # Some terminals also accept BEL as terminator
+
+
+class OSC94States(Enum):
+    HIDDEN = 0
+    NORMAL = 1
+    ERROR = 2
+    INDETERMINATE = 3
+    WARNING = 4
+
+
+def resolve_stream(stream: TextIO | None) -> TextIO:
+    """
+    Rich's status.start() (backed by Live) temporarily replaces sys.stdout/sys.stderr with a
+    Console._redirect_stdio wrapper. The wrapper strips control codes like OSC and BEL before
+    writing, so sequences such as \\x1b]9;4;3\\x1b\\ are truncated to ]9;4;3. Using sys.__stdout__ or
+    an explicit Console file handle bypasses the wrapper and preserves the full OSC payload.
+    """
+    if stream is not None:
+        return stream
+    if hasattr(sys, "__stdout__") and sys.__stdout__ is not None:
+        return cast(TextIO, sys.__stdout__)
+    return sys.stdout
+
+
+def emit_osc94(
+    state: OSC94States,
+    progress: int | None = None,
+    *,
+    use_bel: bool = False,
+    stream: TextIO | None = None,
+):
+    if not is_ghostty:
+        return
+
+    seq = f"\033]9;4;{state.value}"
+    if state == OSC94States.NORMAL:  # Normal progress needs percentage
+        if progress is None:
+            progress = 0
+        seq += f";{int(progress)}"
+    terminator = BEL if use_bel else ST
+    output = resolve_stream(stream)
+    output.write(seq + terminator)
+    output.flush()
+
+
+if __name__ == "__main__":
+    for i in range(101):
+        emit_osc94(OSC94States.NORMAL, i)
+        time.sleep(0.02)
+
+    # Clear progress bar
+    emit_osc94(OSC94States.HIDDEN)
+
+    print("Waiting...")
+    # Indeterminate
+    emit_osc94(OSC94States.INDETERMINATE)
+
+    time.sleep(2)
+    print("Error...")
+    # Error
+    emit_osc94(OSC94States.ERROR)
+
+    time.sleep(2)
+    print("Warning...")
+    # Warning
+    emit_osc94(OSC94States.WARNING)
+    time.sleep(2)

klaude_code/ui/utils/__init__.py

@@ -0,0 +1 @@
+# UI utilities

klaude_code/ui/utils/common.py

@@ -0,0 +1,108 @@
+import re
+import subprocess
+from pathlib import Path
+
+from klaude_code import const
+
+LEADING_NEWLINES_REGEX = re.compile(r"^\n{2,}")
+
+
+def remove_leading_newlines(text: str) -> str:
+    return text.lstrip("\n")
+
+
+def format_number(tokens: int) -> str:
+    if tokens < 1000:
+        return f"{tokens}"
+    elif tokens < 1000000:
+        # 12.3k
+        k = tokens / 1000
+        if k == int(k):
+            return f"{int(k)}k"
+        else:
+            return f"{k:.1f}k"
+    else:
+        # 2M345k
+        m = tokens // 1000000
+        remaining = (tokens % 1000000) // 1000
+        if remaining == 0:
+            return f"{m}M"
+        else:
+            return f"{m}M{remaining}k"
+
+
+def get_current_git_branch(path: Path | None = None) -> str | None:
+    """Get current git branch name, return None if not in a git repository"""
+    if path is None:
+        path = Path.cwd()
+
+    try:
+        # Check if in git repository
+        git_dir = subprocess.run(
+            ["git", "rev-parse", "--git-dir"],
+            cwd=path,
+            capture_output=True,
+            text=True,
+            timeout=2,
+        )
+
+        if git_dir.returncode != 0:
+            return None
+
+        # Get current branch name
+        result = subprocess.run(
+            ["git", "branch", "--show-current"],
+            cwd=path,
+            capture_output=True,
+            text=True,
+            timeout=2,
+        )
+
+        if result.returncode == 0:
+            branch = result.stdout.strip()
+            return branch if branch else None
+
+        # Fallback: get HEAD reference
+        head_file = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            cwd=path,
+            capture_output=True,
+            text=True,
+            timeout=2,
+        )
+
+        if head_file.returncode == 0:
+            branch = head_file.stdout.strip()
+            return branch if branch and branch != "HEAD" else None
+
+    except (subprocess.TimeoutExpired, subprocess.SubprocessError, FileNotFoundError):
+        pass
+
+    return None
+
+
+def show_path_with_tilde(path: Path | None = None):
+    if path is None:
+        path = Path.cwd()
+
+    try:
+        relative_path = path.relative_to(Path.home())
+        return f"~/{relative_path}"
+    except ValueError:
+        return str(path)
+
+
+def truncate_display(
+    text: str,
+    max_lines: int = const.TRUNCATE_DISPLAY_MAX_LINES,
+    max_line_length: int = const.TRUNCATE_DISPLAY_MAX_LINE_LENGTH,
+) -> str:
+    lines = text.split("\n")
+    if len(lines) > max_lines:
+        lines = lines[:max_lines] + ["… (more " + str(len(lines) - max_lines) + " lines)"]
+    for i, line in enumerate(lines):
+        if len(line) > max_line_length:
+            lines[i] = (
+                line[:max_line_length] + "… (more " + str(len(line) - max_line_length) + " characters in this line)"
+            )
+    return "\n".join(lines)

klaude_code/ui/utils/debouncer.py

@@ -0,0 +1,42 @@
+import asyncio
+from typing import Awaitable, Callable, Optional
+
+
+class Debouncer:
+    """Debouncing mechanism"""
+
+    def __init__(self, interval: float, callback: Callable[[], Awaitable[None]]):
+        """
+        Initialize debouncer
+
+        Args:
+            interval: Debounce interval in seconds
+            callback: Async callback function to execute after debouncing
+        """
+        self.interval = interval
+        self.callback = callback
+        self._task: Optional[asyncio.Task[None]] = None
+
+    def cancel(self) -> None:
+        """Cancel current debounce task"""
+        if self._task is not None and not self._task.done():
+            self._task.cancel()
+        self._task = None
+
+    def schedule(self) -> None:
+        """Schedule debounce task"""
+        self.cancel()
+        self._task = asyncio.create_task(self._debounced_execute())
+
+    async def _debounced_execute(self) -> None:
+        """Execute debounced callback function"""
+        try:
+            await asyncio.sleep(self.interval)
+            await self.callback()
+        except asyncio.CancelledError:
+            return
+
+    async def flush(self) -> None:
+        """Immediately execute debounce task (without waiting)"""
+        self.cancel()
+        await self.callback()

klaude_code/version.py

@@ -0,0 +1,163 @@
+"""Version checking utilities for klaude-code."""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+import threading
+import time
+import urllib.request
+from typing import NamedTuple
+
+PACKAGE_NAME = "klaude-code"
+PYPI_URL = f"https://pypi.org/pypi/{PACKAGE_NAME}/json"
+CHECK_INTERVAL_SECONDS = 3600  # Check at most once per hour
+
+
+class VersionInfo(NamedTuple):
+    """Version check result."""
+
+    installed: str | None
+    latest: str | None
+    update_available: bool
+
+
+# Async check state
+_cached_version_info: VersionInfo | None = None
+_last_check_time: float = 0.0
+_check_lock = threading.Lock()
+_check_in_progress = False
+
+
+def _has_uv() -> bool:
+    """Check if uv command is available."""
+    return shutil.which("uv") is not None
+
+
+def _get_installed_version() -> str | None:
+    """Get installed version of klaude-code via uv tool list."""
+    try:
+        result = subprocess.run(
+            ["uv", "tool", "list"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode != 0:
+            return None
+        # Parse output like "klaude-code v0.1.0"
+        for line in result.stdout.splitlines():
+            if line.startswith(PACKAGE_NAME):
+                parts = line.split()
+                if len(parts) >= 2:
+                    ver = parts[1]
+                    # Remove 'v' prefix if present
+                    if ver.startswith("v"):
+                        ver = ver[1:]
+                    return ver
+        return None
+    except Exception:
+        return None
+
+
+def _get_latest_version() -> str | None:
+    """Get latest version from PyPI."""
+    try:
+        with urllib.request.urlopen(PYPI_URL, timeout=5) as response:
+            data = json.loads(response.read().decode())
+            return data.get("info", {}).get("version")
+    except Exception:
+        return None
+
+
+def _parse_version(v: str) -> tuple[int, ...]:
+    """Parse version string into comparable tuple of integers."""
+    parts: list[int] = []
+    for part in v.split("."):
+        # Extract leading digits
+        digits = ""
+        for c in part:
+            if c.isdigit():
+                digits += c
+            else:
+                break
+        if digits:
+            parts.append(int(digits))
+    return tuple(parts)
+
+
+def _compare_versions(installed: str, latest: str) -> bool:
+    """Return True if latest is newer than installed."""
+    try:
+        installed_tuple = _parse_version(installed)
+        latest_tuple = _parse_version(latest)
+        return latest_tuple > installed_tuple
+    except Exception:
+        return False
+
+
+def _do_version_check() -> None:
+    """Perform version check in background thread."""
+    global _cached_version_info, _last_check_time, _check_in_progress
+
+    try:
+        installed = _get_installed_version()
+        latest = _get_latest_version()
+
+        update_available = False
+        if installed and latest:
+            update_available = _compare_versions(installed, latest)
+
+        with _check_lock:
+            _cached_version_info = VersionInfo(
+                installed=installed,
+                latest=latest,
+                update_available=update_available,
+            )
+            _last_check_time = time.time()
+    finally:
+        with _check_lock:
+            _check_in_progress = False
+
+
+def check_for_updates() -> VersionInfo | None:
+    """Check for updates to klaude-code asynchronously.
+
+    Returns cached VersionInfo immediately if available.
+    Triggers background check if cache is stale or missing.
+    Returns None if uv is not available or no cached result yet.
+    """
+    global _check_in_progress
+
+    if not _has_uv():
+        return None
+
+    now = time.time()
+
+    with _check_lock:
+        cache_valid = _cached_version_info is not None and (now - _last_check_time) < CHECK_INTERVAL_SECONDS
+
+        if cache_valid:
+            return _cached_version_info
+
+        # Start background check if not already in progress
+        if not _check_in_progress:
+            _check_in_progress = True
+            thread = threading.Thread(target=_do_version_check, daemon=True)
+            thread.start()
+
+        # Return cached result (may be stale) or None if no cache yet
+        return _cached_version_info
+
+
+def get_update_message() -> str | None:
+    """Get update message if an update is available.
+
+    Returns immediately with cached result. Triggers async check if needed.
+    Returns None if no update, uv unavailable, or check not complete yet.
+    """
+    info = check_for_updates()
+    if info is None or not info.update_available:
+        return None
+    return f"New version available: {info.latest}. Please run `uv tool upgrade {PACKAGE_NAME}` to upgrade."

klaude_code-1.2.6.dist-info/METADATA

@@ -0,0 +1,178 @@
+Metadata-Version: 2.3
+Name: klaude-code
+Version: 1.2.6
+Summary: Add your description here
+Requires-Dist: anthropic>=0.66.0
+Requires-Dist: openai>=1.102.0
+Requires-Dist: pillow>=12.0.0
+Requires-Dist: prompt-toolkit>=3.0.52
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: questionary>=2.1.1
+Requires-Dist: rich>=14.1.0
+Requires-Dist: trafilatura>=2.0.0
+Requires-Dist: typer>=0.17.3
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# Minimal Code Agent CLI (Klaude Code)
+
+An minimal and opinionated code agent with multi-model support.
+
+## Key Features
+- **Adaptive Tooling**: Model-aware toolsets (Claude Code tools for Sonnet, Codex `apply_patch` for GPT-5.1/Codex).
+- **Multi-Provider Support**: Compatible with `anthropic-messages-api`,`openai-responses-api`, and `openai-compatible-api`(`openrouter-api`),  featuring interleaved thinking, OpenRouter's provider sorting etc.
+- **Skill System**: Extensible support for loading Claude Skills.
+- **Session Management**: Robust context preservation with resumable sessions (`--continue`).
+- **Simple TUI**: Clean interface offering full visibility into model responses, reasoning and actions.
+- **Core Utilities**: Slash commands, sub-agents, image pasting, terminal notifications, file mentioning, and auto-theming.
+
+## Installation
+
+```bash
+uv tool install klaude-code
+```
+
+To update:
+
+```bash
+uv tool upgrade klaude-code
+```
+
+## Usage
+
+### Interactive Mode
+
+```bash
+klaude [--model <name>] [--select-model]
+```
+
+**Options:**
+- `--version`/`-V`: Show version and exit.
+- `--model`/`-m`: Select a model by logical name from config.
+- `--select-model`/`-s`: Interactively choose a model at startup.
+- `--continue`/`-c`: Resume the most recent session.
+- `--resume`/`-r`: Select a session to resume for this project.
+- `--vanilla`: Minimal mode with only basic tools (Bash, Read, Edit) and no system prompts.
+
+**Debug Options:**
+- `--debug`/`-d`: Enable debug mode with verbose logging and LLM trace.
+- `--debug-filter`: Filter debug output by type (comma-separated).
+
+
+### Configuration
+
+An example config will be created in `~/.klaude/config.yaml` when first run.
+
+Open the configuration file in editor:
+
+```bash
+klaude config
+```
+
+An minimal example config yaml using OpenRouter's API Key:
+
+```yaml
+provider_list:
+- provider_name: openrouter-work
+  protocol: openrouter # support <responses|openrouter|anthropic|openai>
+  api_key: <your-openrouter-api-key>
+model_list:
+- model_name: gpt-5.1-codex
+  provider: openrouter
+  model_params:
+    model: openai/gpt-5.1-codex
+    context_limit: 368000
+    thinking:
+      reasoning_effort: medium
+- model_name: gpt-5.1-high
+  provider: openrouter
+  model_params:
+    model: openai/gpt-5.1
+    context_limit: 368000
+    thinking:
+      reasoning_effort: high
+- model_name: sonnet
+  provider: openrouter
+  model_params:
+    model: anthropic/claude-4.5-sonnet
+    context_limit: 168000
+    provider_routing:
+      sort: throughput
+- model_name: haiku
+  provider: openrouter
+  model_params:
+    model: anthropic/claude-haiku-4.5
+    context_limit: 168000
+    provider_routing:
+      sort: throughput
+main_model: gpt-5.1-codex
+subagent_models:
+  oracle: gpt-5.1-high
+  explore: haiku
+  task: sonnet
+```
+
+List configured providers and models:
+
+```bash
+klaude list
+```
+
+### Session Management
+
+Clean up sessions with few messages:
+
+```bash
+# Remove sessions with fewer than 5 messages (default)
+klaude session clean
+
+# Remove sessions with fewer than 10 messages
+klaude session clean --min 10
+
+# Remove all sessions for the current project
+klaude session clean-all
+```
+
+### Slash Commands
+
+Inside the interactive session (`klaude`), use these commands to streamline your workflow:
+
+- `/dev-doc [feature]` - Generate a comprehensive execution plan for a feature.
+- `/export` - Export last assistant message to a temp Markdown file.
+- `/init` - Bootstrap a new project structure or module.
+- `/model` - Switch the active LLM during the session.
+- `/clear` - Clear the current conversation context.
+- `/diff` - Show local git diff changes.
+- `/help` - List all available commands.
+
+
+### Input Shortcuts
+
+| Key                  | Action                                      |
+| -------------------- | ------------------------------------------- |
+| `Enter`              | Submit input                                |
+| `Shift+Enter`        | Insert newline (requires `/terminal-setup`) |
+| `Ctrl+J`             | Insert newline                              |
+| `Ctrl+V`             | Paste image from clipboard                  |
+| `Left/Right`         | Move cursor (wraps across lines)            |
+| `Backspace`          | Delete character or selected text           |
+| `c` (with selection) | Copy selected text to clipboard             |
+
+Mouse support is automatically enabled when input spans multiple lines.
+
+
+### Non-Interactive Headless Mode (exec)
+
+Execute a single command without starting the interactive REPL:
+
+```bash
+# Direct input
+klaude exec "what is 2+2?"
+
+# Pipe input
+echo "hello world" | klaude exec
+
+# With model selection
+echo "generate quicksort in python" | klaude exec --model gpt-5.1
+```