bhu-cli 1.46.0__py3-none-any.whl

kimi_cli/utils/rich/markdown_sample.md

@@ -0,0 +1,108 @@
+# Markdown Sample Document
+
+This is a comprehensive sample document showcasing various Markdown elements.
+
+## Level 2 Heading
+
+### Level 3 Heading
+
+Here's some regular text with **bold text**, *italic text*, and `inline code`.
+
+## Lists
+
+### Unordered List
+
+- First item
+- Second item
+  - Nested item 1
+  - Nested item 2
+- Third item
+
+### Ordered List
+
+1. First step
+2. Second step
+   1. Sub-step A
+   2. Sub-step B
+3. Third step
+
+### Mixed List
+
+1. First item
+   - Sub-item with bullet
+   - Another sub-item
+2. Second item
+   1. Numbered sub-item
+   2. Another numbered sub-item
+
+## Links and References
+
+Here's a [link to GitHub](https://github.com) and another [relative link](../README.md).
+
+## Code Blocks
+
+```python
+def hello_world():
+    """A simple function to demonstrate code blocks."""
+    print("Hello, World!")
+    return 42
+
+# Call the function
+result = hello_world()
+```
+
+```bash
+# Bash example
+echo "This is a bash script"
+ls -la /tmp
+```
+
+## Blockquotes
+
+> This is a blockquote.
+> It can span multiple lines.
+>
+> > And it can be nested too!
+
+## Tables
+
+| Column 1 | Column 2 | Column 3 |
+|----------|----------|----------|
+| Cell 1   | Cell 2   | Cell 3   |
+| Left     | Center   | Right    |
+| Foo      | Bar      | Baz      |
+
+## Horizontal Rules
+
+---
+
+Here's some text after a horizontal rule.
+
+---
+
+## Inline Formatting
+
+You can combine **bold and *italic*** text, or use `code` within paragraphs.
+
+**Important**: Always test your `code` snippets before deployment.
+
+## Advanced Features
+
+### Task Lists
+
+- [x] Completed task
+- [ ] Pending task
+- [ ] Another pending task
+
+### Definition Lists
+
+Term 1
+: Definition of term 1
+
+Term 2
+: Definition of term 2
+: Another definition for term 2
+
+---
+
+*This document demonstrates comprehensive Markdown formatting capabilities.*

kimi_cli/utils/rich/markdown_sample_short.md

@@ -0,0 +1,2 @@
+- First
+- Second

kimi_cli/utils/rich/syntax.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pygments.token import (
+    Comment,
+    Generic,
+    Keyword,
+    Name,
+    Number,
+    Operator,
+    Punctuation,
+    String,
+)
+from pygments.token import (
+    Literal as PygmentsLiteral,
+)
+from pygments.token import (
+    Text as PygmentsText,
+)
+from pygments.token import (
+    Token as PygmentsToken,
+)
+from rich.style import Style
+from rich.syntax import ANSISyntaxTheme, Syntax, SyntaxTheme
+
+KIMI_ANSI_THEME_NAME = "kimi-ansi"
+KIMI_ANSI_THEME = ANSISyntaxTheme(
+    {
+        PygmentsToken: Style(color="default"),
+        PygmentsText: Style(color="default"),
+        Comment: Style(color="bright_black", italic=True),
+        Keyword: Style(color="magenta"),
+        Keyword.Constant: Style(color="cyan"),
+        Keyword.Declaration: Style(color="magenta"),
+        Keyword.Namespace: Style(color="magenta"),
+        Keyword.Pseudo: Style(color="magenta"),
+        Keyword.Reserved: Style(color="magenta"),
+        Keyword.Type: Style(color="magenta"),
+        Name: Style(color="default"),
+        Name.Attribute: Style(color="cyan"),
+        Name.Builtin: Style(color="bright_yellow"),
+        Name.Builtin.Pseudo: Style(color="cyan"),
+        Name.Builtin.Type: Style(color="bright_yellow", bold=True),
+        Name.Class: Style(color="bright_yellow", bold=True),
+        Name.Constant: Style(color="cyan"),
+        Name.Decorator: Style(color="bright_cyan"),
+        Name.Entity: Style(color="bright_yellow"),
+        Name.Exception: Style(color="bright_yellow", bold=True),
+        Name.Function: Style(color="bright_cyan"),
+        Name.Label: Style(color="cyan"),
+        Name.Namespace: Style(color="magenta"),
+        Name.Other: Style(color="bright_cyan"),
+        Name.Property: Style(color="cyan"),
+        Name.Tag: Style(color="bright_green"),
+        Name.Variable: Style(color="bright_yellow"),
+        PygmentsLiteral: Style(color="bright_blue"),
+        PygmentsLiteral.Date: Style(color="bright_blue"),
+        String: Style(color="bright_blue"),
+        String.Doc: Style(color="bright_blue", italic=True),
+        String.Interpol: Style(color="bright_blue"),
+        String.Affix: Style(color="cyan"),
+        Number: Style(color="cyan"),
+        Operator: Style(color="default"),
+        Operator.Word: Style(color="magenta"),
+        Punctuation: Style(color="default"),
+        Generic.Deleted: Style(color="red"),
+        Generic.Emph: Style(italic=True),
+        Generic.Error: Style(color="bright_red", bold=True),
+        Generic.Heading: Style(color="cyan", bold=True),
+        Generic.Inserted: Style(color="green"),
+        Generic.Output: Style(color="bright_black"),
+        Generic.Prompt: Style(color="bright_cyan"),
+        Generic.Strong: Style(bold=True),
+        Generic.Subheading: Style(color="cyan"),
+        Generic.Traceback: Style(color="bright_red", bold=True),
+    }
+)
+
+
+def resolve_code_theme(theme: str | SyntaxTheme) -> str | SyntaxTheme:
+    if isinstance(theme, str) and theme.lower() == KIMI_ANSI_THEME_NAME:
+        return KIMI_ANSI_THEME
+    return theme
+
+
+class KimiSyntax(Syntax):
+    def __init__(self, code: str, lexer: str, **kwargs: Any) -> None:
+        if "theme" not in kwargs or kwargs["theme"] is None:
+            kwargs["theme"] = KIMI_ANSI_THEME
+        super().__init__(code, lexer, **kwargs)
+
+
+if __name__ == "__main__":
+    from rich.console import Console
+    from rich.text import Text
+
+    console = Console()
+
+    examples = [
+        ("diff", "diff", "@@ -1,2 +1,2 @@\n-line one\n+line uno\n"),
+        (
+            "python",
+            "python",
+            'def greet(name: str) -> str:\n    return f"Hi, {name}!"\n',
+        ),
+        ("bash", "bash", "set -euo pipefail\nprintf '%s\\n' \"hello\"\n"),
+    ]
+
+    for idx, (title, lexer, code) in enumerate(examples):
+        if idx:
+            console.print()
+        console.print(Text(f"[{title}]", style="bold"))
+        console.print(KimiSyntax(code, lexer))

kimi_cli/utils/sensitive.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import fnmatch
+from pathlib import PurePath
+
+# High-confidence sensitive file patterns.
+# Only patterns with very low false-positive risk are included.
+SENSITIVE_PATTERNS: list[str] = [
+    # Environment variable / secrets
+    ".env",
+    ".env.*",
+    # SSH private keys
+    "id_rsa",
+    "id_ed25519",
+    "id_ecdsa",
+    # Cloud credentials (path-based, also bare name for stripped-path scenarios)
+    ".aws/credentials",
+    ".gcp/credentials",
+    "credentials",
+]
+
+# Template/example files that match .env.* but are not sensitive.
+SENSITIVE_EXEMPTIONS: set[str] = {
+    ".env.example",
+    ".env.sample",
+    ".env.template",
+}
+
+
+def is_sensitive_file(path: str) -> bool:
+    """Check if a file path matches any sensitive file pattern."""
+    name = PurePath(path).name
+    if name in SENSITIVE_EXEMPTIONS:
+        return False
+    for pattern in SENSITIVE_PATTERNS:
+        if "/" in pattern:
+            if path.endswith(pattern) or ("/" + pattern) in path:
+                return True
+        else:
+            if fnmatch.fnmatch(name, pattern):
+                return True
+    return False
+
+
+def sensitive_file_warning(paths: list[str]) -> str:
+    """Generate a warning message for sensitive files that were skipped."""
+    names = sorted({PurePath(p).name for p in paths})
+    file_list = ", ".join(names[:5])
+    if len(names) > 5:
+        file_list += f", ... ({len(names)} files total)"
+    return (
+        f"Skipped {len(paths)} sensitive file(s) ({file_list}) "
+        f"to protect secrets. These files may contain credentials or private keys."
+    )

kimi_cli/utils/server.py

@@ -0,0 +1,121 @@
+"""Shared utilities for kimi vis and kimi web server startup."""
+
+from __future__ import annotations
+
+import importlib
+import socket
+import textwrap
+
+
+def get_address_family(host: str) -> socket.AddressFamily:
+    """Return AF_INET6 for IPv6 addresses, AF_INET for IPv4 and hostnames."""
+    return socket.AF_INET6 if ":" in host else socket.AF_INET
+
+
+def format_url(host: str, port: int) -> str:
+    """Build ``http://host:port``, bracketing IPv6 literals per RFC 2732."""
+    if ":" in host:
+        return f"http://[{host}]:{port}"
+    return f"http://{host}:{port}"
+
+
+def is_local_host(host: str) -> bool:
+    """Check whether *host* resolves to a loopback address."""
+    return host in {"127.0.0.1", "localhost", "::1"}
+
+
+def find_available_port(host: str, start_port: int, max_attempts: int = 10) -> int:
+    """Find an available port starting from *start_port*.
+
+    Raises ``RuntimeError`` if no port is available within the range.
+    """
+    if max_attempts <= 0:
+        raise ValueError("max_attempts must be positive")
+    if start_port < 1 or start_port > 65535:
+        raise ValueError("start_port must be between 1 and 65535")
+
+    family = get_address_family(host)
+    for offset in range(max_attempts):
+        port = start_port + offset
+        with socket.socket(family, socket.SOCK_STREAM) as s:
+            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            try:
+                s.bind((host, port))
+                return port
+            except OSError:
+                continue
+    raise RuntimeError(
+        f"Cannot find available port in range {start_port}-{start_port + max_attempts - 1}"
+    )
+
+
+def get_network_addresses() -> list[str]:
+    """Get non-loopback IPv4 addresses for this machine."""
+    addresses: list[str] = []
+
+    try:
+        hostname = socket.gethostname()
+        for info in socket.getaddrinfo(hostname, None, socket.AF_INET):
+            ip = info[4][0]
+            if isinstance(ip, str) and not ip.startswith("127.") and ip not in addresses:
+                addresses.append(ip)
+    except OSError:
+        pass
+
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
+            s.connect(("8.8.8.8", 80))
+            ip = s.getsockname()[0]
+        if ip and not ip.startswith("127.") and ip not in addresses:
+            addresses.append(ip)
+    except OSError:
+        pass
+
+    try:
+        netifaces = importlib.import_module("netifaces")
+        for interface in netifaces.interfaces():
+            addrs = netifaces.ifaddresses(interface)
+            if netifaces.AF_INET in addrs:
+                for addr_info in addrs[netifaces.AF_INET]:
+                    addr = addr_info.get("addr")
+                    if addr and not addr.startswith("127.") and addr not in addresses:
+                        addresses.append(addr)
+    except (ImportError, Exception):
+        pass
+
+    return addresses
+
+
+def print_banner(lines: list[str]) -> None:
+    """Print a boxed banner with tag conventions (<center>, <nowrap>, <hr>)."""
+    processed: list[str] = []
+    for line in lines:
+        if line == "<hr>":
+            processed.append(line)
+        elif not line:
+            processed.append("")
+        elif line.startswith("<center>") or line.startswith("<nowrap>"):
+            processed.append(line)
+        else:
+            processed.extend(textwrap.wrap(line, width=78))
+
+    def strip_tags(s: str) -> str:
+        return s.removeprefix("<center>").removeprefix("<nowrap>")
+
+    content_lines = [strip_tags(line) for line in processed if line != "<hr>"]
+    width = max(60, *(len(line) for line in content_lines))
+    top = "+" + "=" * (width + 2) + "+"
+
+    print(top)
+    for line in processed:
+        if line == "<hr>":
+            print("|" + "-" * (width + 2) + "|")
+        elif line.startswith("<center>"):
+            content = line.removeprefix("<center>")
+            print(f"| {content.center(width)} |")
+        elif line.startswith("<nowrap>"):
+            content = line.removeprefix("<nowrap>")
+            print(f"| {content.ljust(width)} |")
+        else:
+            print(f"| {line.ljust(width)} |")
+    print(top)

kimi_cli/utils/shell_quoting.py

@@ -0,0 +1,38 @@
+"""Defensive rewrites applied to shell commands before execution.
+
+The model occasionally hallucinates Windows CMD syntax even when running on
+git-bash (which is POSIX). One such hallucination has caused real damage:
+``cmd 2>nul`` in git-bash creates a literal file named ``nul`` in cwd, which
+is a Windows reserved device name that breaks ``git add .`` / ``git clone``.
+
+The fix here mirrors claude-code's ``rewriteWindowsNullRedirect``
+(see anthropics/claude-code#4928): rewrite the bad redirect to ``/dev/null``
+before the command reaches the shell.
+"""
+
+from __future__ import annotations
+
+import re
+
+# Match `>nul`, `> NUL`, `2>nul`, `&>nul`, `>>nul` (case-insensitive),
+# but NOT `>null`, `>nullable`, `>nul.txt`, `cat nul.txt`.
+#
+# Group 1 captures the redirect operator + optional whitespace, so the rewrite
+# preserves the original spacing (e.g. `2> nul` -> `2> /dev/null`).
+_NUL_REDIRECT = re.compile(r"(\d?&?>+\s*)[Nn][Uu][Ll](?=\s|$|[|&;)\n])")
+
+
+def rewrite_windows_null_redirect(command: str, *, on_windows: bool) -> str:
+    """Rewrite Windows-style ``>nul`` redirects to POSIX ``/dev/null``.
+
+    Only active when ``on_windows`` is True. On Linux/macOS, ``>nul`` is a
+    legitimate redirect to a file named ``nul`` and must not be rewritten.
+
+    The regex's lookahead requires a shell-meaningful character after ``nul``
+    (whitespace, end-of-string, or one of ``|&;)\\n``), so quoted forms like
+    ``echo ">nul"`` slip through unmolested — a useful happy accident, since
+    rewriting inside string literals would corrupt user data.
+    """
+    if not on_windows:
+        return command
+    return _NUL_REDIRECT.sub(r"\1/dev/null", command)

kimi_cli/utils/signals.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import signal
+from collections.abc import Callable
+
+
+def install_sigint_handler(
+    loop: asyncio.AbstractEventLoop, handler: Callable[[], None]
+) -> Callable[[], None]:
+    """
+    Install a SIGINT handler that works on Unix and Windows.
+
+    On Unix event loops, prefer `loop.add_signal_handler`.
+    On Windows (or other platforms) where it is not implemented, fall back to
+    `signal.signal`. The fallback cannot be removed from the loop, but we
+    restore the previous handler on uninstall.
+
+    Returns:
+        A function that removes the installed handler. It is guaranteed that
+        no exceptions are raised when calling the returned function.
+    """
+
+    try:
+        loop.add_signal_handler(signal.SIGINT, handler)
+
+        def remove() -> None:
+            with contextlib.suppress(RuntimeError):
+                loop.remove_signal_handler(signal.SIGINT)
+
+        return remove
+    except RuntimeError:
+        # Windows ProactorEventLoop and some environments do not support
+        # add_signal_handler. Use synchronous signal handling as a fallback.
+        previous = signal.getsignal(signal.SIGINT)
+        signal.signal(signal.SIGINT, lambda signum, frame: handler())
+
+        def remove() -> None:
+            with contextlib.suppress(RuntimeError):
+                signal.signal(signal.SIGINT, previous)
+
+        return remove

kimi_cli/utils/slashcmd.py

@@ -0,0 +1,145 @@
+import re
+from collections.abc import Awaitable, Callable, Sequence
+from dataclasses import dataclass
+from typing import overload
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class SlashCommand[F: Callable[..., None | Awaitable[None]]]:
+    name: str
+    description: str
+    func: F
+    aliases: list[str]
+
+    def display_name(self, trigger: str | None = None) -> str:
+        """/name for canonical triggers, /name (alias) for alias triggers."""
+        if trigger is not None and trigger != self.name and trigger in self.aliases:
+            return f"/{self.name} ({trigger})"
+        return f"/{self.name}"
+
+    def slash_name(self):
+        """/name (aliases)"""
+        if self.aliases:
+            return f"/{self.name} ({', '.join(self.aliases)})"
+        return f"/{self.name}"
+
+
+class SlashCommandRegistry[F: Callable[..., None | Awaitable[None]]]:
+    """Registry for slash commands."""
+
+    def __init__(self) -> None:
+        self._commands: dict[str, SlashCommand[F]] = {}
+        """Primary name -> SlashCommand"""
+        self._command_aliases: dict[str, SlashCommand[F]] = {}
+        """Primary name or alias -> SlashCommand"""
+
+    @overload
+    def command(self, func: F, /) -> F: ...
+
+    @overload
+    def command(
+        self,
+        *,
+        name: str | None = None,
+        aliases: Sequence[str] | None = None,
+    ) -> Callable[[F], F]: ...
+
+    def command(
+        self,
+        func: F | None = None,
+        *,
+        name: str | None = None,
+        aliases: Sequence[str] | None = None,
+    ) -> F | Callable[[F], F]:
+        """
+        Decorator to register a slash command with optional custom name and aliases.
+
+        Usage examples:
+          @registry.command
+          def help(app: App, args: str): ...
+
+          @registry.command(name="run")
+          def start(app: App, args: str): ...
+
+          @registry.command(aliases=["h", "?", "assist"])
+          def help(app: App, args: str): ...
+        """
+
+        def _register(f: F) -> F:
+            primary = name or f.__name__
+            alias_list = list(aliases) if aliases else []
+
+            # Create the primary command with aliases
+            cmd = SlashCommand[F](
+                name=primary,
+                description=(f.__doc__ or "").strip(),
+                func=f,
+                aliases=alias_list,
+            )
+
+            # Register primary command
+            self._commands[primary] = cmd
+            self._command_aliases[primary] = cmd
+
+            # Register aliases pointing to the same command
+            for alias in alias_list:
+                self._command_aliases[alias] = cmd
+
+            return f
+
+        if func is not None:
+            return _register(func)
+        return _register
+
+    def find_command(self, name: str) -> SlashCommand[F] | None:
+        return self._command_aliases.get(name)
+
+    def list_commands(self) -> list[SlashCommand[F]]:
+        """Get all unique primary slash commands (without duplicating aliases)."""
+        return list(self._commands.values())
+
+    def iter_command_entries(self) -> list[tuple[str, SlashCommand[F]]]:
+        """Get canonical and alias entries as (trigger, command) pairs."""
+        entries: list[tuple[str, SlashCommand[F]]] = []
+        for cmd in self._commands.values():
+            entries.append((cmd.name, cmd))
+            seen = {cmd.name}
+            for alias in cmd.aliases:
+                if alias in seen:
+                    continue
+                if self._command_aliases.get(alias) is not cmd:
+                    continue
+                entries.append((alias, cmd))
+                seen.add(alias)
+        return entries
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class SlashCommandCall:
+    name: str
+    args: str
+    raw_input: str
+
+
+def parse_slash_command_call(user_input: str) -> SlashCommandCall | None:
+    """
+    Parse a slash command call from user input.
+
+    Returns:
+        SlashCommandCall if a slash command is found, else None. The `args` field contains
+        the raw argument string after the command name.
+    """
+    user_input = user_input.strip()
+    if not user_input or not user_input.startswith("/"):
+        return None
+
+    name_match = re.match(r"^\/([a-zA-Z0-9_-]+(?::[a-zA-Z0-9_-]+)*)", user_input)
+
+    if not name_match:
+        return None
+
+    command_name = name_match.group(1)
+    if len(user_input) > name_match.end() and not user_input[name_match.end()].isspace():
+        return None
+    raw_args = user_input[name_match.end() :].lstrip()
+    return SlashCommandCall(name=command_name, args=raw_args, raw_input=user_input)

kimi_cli/utils/string.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import random
+import re
+import string
+
+_NEWLINE_RE = re.compile(r"[\r\n]+")
+
+
+def shorten(text: str, *, width: int, placeholder: str = "…") -> str:
+    """Shorten text to at most *width* characters.
+
+    Normalises whitespace, then truncates — preferring a word boundary
+    when one exists near the cut point, but falling back to a hard cut
+    so that CJK text without spaces won't collapse to just the placeholder.
+    """
+    text = " ".join(text.split())
+    if len(text) <= width:
+        return text
+    cut = width - len(placeholder)
+    if cut <= 0:
+        return text[:width]
+    space = text.rfind(" ", 0, cut + 1)
+    if space > 0:
+        cut = space
+    return text[:cut].rstrip() + placeholder
+
+
+def shorten_middle(text: str, width: int, remove_newline: bool = True) -> str:
+    """Shorten the text by inserting ellipsis in the middle."""
+    if len(text) <= width:
+        return text
+    if remove_newline:
+        text = _NEWLINE_RE.sub(" ", text)
+    return text[: width // 2] + "..." + text[-width // 2 :]
+
+
+def random_string(length: int = 8) -> str:
+    """Generate a random string of fixed length."""
+    letters = string.ascii_lowercase
+    return "".join(random.choice(letters) for _ in range(length))