kimi-cli 0.35__py3-none-any.whl → 0.52__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/signals.py

@@ -0,0 +1,41 @@
+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/string.py

@@ -1,4 +1,6 @@
+import random
 import re
+import string
 
 _NEWLINE_RE = re.compile(r"[\r\n]+")
 
@@ -10,3 +12,9 @@ def shorten_middle(text: str, width: int, remove_newline: bool = True) -> str:
     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))

kimi_cli/utils/term.py

@@ -0,0 +1,114 @@
+import os
+import re
+import sys
+import time
+
+
+def ensure_new_line() -> None:
+    """Ensure the next prompt starts at column 0 regardless of prior command output."""
+
+    if not sys.stdout.isatty() or not sys.stdin.isatty():
+        return
+
+    needs_break = True
+    if sys.platform == "win32":
+        column = _cursor_column_windows()
+        needs_break = column not in (None, 0)
+    else:
+        column = _cursor_column_unix()
+        needs_break = column not in (None, 1)
+
+    if needs_break:
+        _write_newline()
+
+
+def _cursor_column_unix() -> int | None:
+    assert sys.platform != "win32"
+
+    import select
+    import termios
+    import tty
+
+    _CURSOR_QUERY = "\x1b[6n"
+    _CURSOR_POSITION_RE = re.compile(r"\x1b\[(\d+);(\d+)R")
+
+    fd = sys.stdin.fileno()
+    oldterm = termios.tcgetattr(fd)
+
+    try:
+        tty.setcbreak(fd)
+        sys.stdout.write(_CURSOR_QUERY)
+        sys.stdout.flush()
+
+        response = ""
+        deadline = time.monotonic() + 0.2
+        while time.monotonic() < deadline:
+            timeout = max(0.01, deadline - time.monotonic())
+            ready, _, _ = select.select([sys.stdin], [], [], timeout)
+            if not ready:
+                continue
+            try:
+                chunk = os.read(fd, 32)
+            except OSError:
+                break
+            if not chunk:
+                break
+            response += chunk.decode(encoding="utf-8", errors="ignore")
+            match = _CURSOR_POSITION_RE.search(response)
+            if match:
+                return int(match.group(2))
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, oldterm)
+
+    return None
+
+
+def _cursor_column_windows() -> int | None:
+    assert sys.platform == "win32"
+
+    import ctypes
+    from ctypes import wintypes
+
+    kernel32 = ctypes.windll.kernel32
+    _STD_OUTPUT_HANDLE = -11  # Windows API constant for standard output handle
+    handle = kernel32.GetStdHandle(_STD_OUTPUT_HANDLE)
+    invalid_handle_value = ctypes.c_void_p(-1).value
+    if handle in (0, invalid_handle_value):
+        return None
+
+    class COORD(ctypes.Structure):
+        _fields_ = [("X", wintypes.SHORT), ("Y", wintypes.SHORT)]
+
+    class SMALL_RECT(ctypes.Structure):
+        _fields_ = [
+            ("Left", wintypes.SHORT),
+            ("Top", wintypes.SHORT),
+            ("Right", wintypes.SHORT),
+            ("Bottom", wintypes.SHORT),
+        ]
+
+    class CONSOLE_SCREEN_BUFFER_INFO(ctypes.Structure):
+        _fields_ = [
+            ("dwSize", COORD),
+            ("dwCursorPosition", COORD),
+            ("wAttributes", wintypes.WORD),
+            ("srWindow", SMALL_RECT),
+            ("dwMaximumWindowSize", COORD),
+        ]
+
+    csbi = CONSOLE_SCREEN_BUFFER_INFO()
+    if not kernel32.GetConsoleScreenBufferInfo(handle, ctypes.byref(csbi)):
+        return None
+
+    return int(csbi.dwCursorPosition.X)
+
+
+def _write_newline() -> None:
+    sys.stdout.write("\n")
+    sys.stdout.flush()
+
+
+if __name__ == "__main__":
+    print("test", end="", flush=True)
+    ensure_new_line()
+    print("next line")

kimi_cli/wire/__init__.py

@@ -0,0 +1,73 @@
+import asyncio
+
+from kosong.message import ContentPart, ToolCallPart
+
+from kimi_cli.utils.logging import logger
+from kimi_cli.wire.message import WireMessage
+
+
+class Wire:
+    """
+    A channel for communication between the soul and the UI during a soul run.
+    """
+
+    def __init__(self):
+        self._queue = asyncio.Queue[WireMessage]()
+        self._soul_side = WireSoulSide(self._queue)
+        self._ui_side = WireUISide(self._queue)
+
+    @property
+    def soul_side(self) -> "WireSoulSide":
+        return self._soul_side
+
+    @property
+    def ui_side(self) -> "WireUISide":
+        return self._ui_side
+
+    def shutdown(self) -> None:
+        logger.debug("Shutting down wire")
+        self._queue.shutdown()
+
+
+class WireSoulSide:
+    """
+    The soul side of a wire.
+    """
+
+    def __init__(self, queue: asyncio.Queue[WireMessage]):
+        self._queue = queue
+
+    def send(self, msg: WireMessage) -> None:
+        if not isinstance(msg, ContentPart | ToolCallPart):
+            logger.debug("Sending wire message: {msg}", msg=msg)
+        try:
+            self._queue.put_nowait(msg)
+        except asyncio.QueueShutDown:
+            logger.info("Failed to send wire message, queue is shut down: {msg}", msg=msg)
+
+
+class WireUISide:
+    """
+    The UI side of a wire.
+    """
+
+    def __init__(self, queue: asyncio.Queue[WireMessage]):
+        self._queue = queue
+
+    async def receive(self) -> WireMessage:
+        msg = await self._queue.get()
+        if not isinstance(msg, ContentPart | ToolCallPart):
+            logger.debug("Receiving wire message: {msg}", msg=msg)
+        return msg
+
+    def receive_nowait(self) -> WireMessage | None:
+        """
+        Try receive a message without waiting. If no message is available, return None.
+        """
+        try:
+            msg = self._queue.get_nowait()
+        except asyncio.QueueEmpty:
+            return None
+        if not isinstance(msg, ContentPart | ToolCallPart):
+            logger.debug("Receiving wire message: {msg}", msg=msg)
+        return msg

kimi_cli/wire/message.py

@@ -0,0 +1,191 @@
+import asyncio
+import uuid
+from collections.abc import Sequence
+from enum import Enum
+from typing import TYPE_CHECKING, Any, NamedTuple
+
+from kosong.message import ContentPart, ToolCall, ToolCallPart
+from kosong.tooling import ToolOk, ToolResult
+
+if TYPE_CHECKING:
+    from kimi_cli.soul import StatusSnapshot
+
+
+class StepBegin(NamedTuple):
+    n: int
+
+
+class StepInterrupted:
+    pass
+
+
+class CompactionBegin:
+    """
+    Indicates that a compaction just began.
+    This event must be sent during a step, which means, between `StepBegin` and `StepInterrupted`.
+    And, there must be a `CompactionEnd` directly following this event.
+    """
+
+    pass
+
+
+class CompactionEnd:
+    """
+    Indicates that a compaction just ended.
+    This event must be sent directly after a `CompactionBegin` event.
+    """
+
+    pass
+
+
+class StatusUpdate(NamedTuple):
+    status: "StatusSnapshot"
+
+
+class SubagentEvent(NamedTuple):
+    task_tool_call_id: str
+    event: "Event"
+
+
+type ControlFlowEvent = StepBegin | StepInterrupted | CompactionBegin | CompactionEnd | StatusUpdate
+type Event = ControlFlowEvent | ContentPart | ToolCall | ToolCallPart | ToolResult | SubagentEvent
+
+
+class ApprovalResponse(Enum):
+    APPROVE = "approve"
+    APPROVE_FOR_SESSION = "approve_for_session"
+    REJECT = "reject"
+
+
+class ApprovalRequest:
+    def __init__(self, tool_call_id: str, sender: str, action: str, description: str):
+        self.id = str(uuid.uuid4())
+        self.tool_call_id = tool_call_id
+        self.sender = sender
+        self.action = action
+        self.description = description
+        self._future = asyncio.Future[ApprovalResponse]()
+
+    def __repr__(self) -> str:
+        return (
+            f"ApprovalRequest(id={self.id}, tool_call_id={self.tool_call_id}, "
+            f"sender={self.sender}, action={self.action}, description={self.description})"
+        )
+
+    async def wait(self) -> ApprovalResponse:
+        """
+        Wait for the request to be resolved or cancelled.
+
+        Returns:
+            ApprovalResponse: The response to the approval request.
+        """
+        return await self._future
+
+    def resolve(self, response: ApprovalResponse) -> None:
+        """
+        Resolve the approval request with the given response.
+        This will cause the `wait()` method to return the response.
+        """
+        self._future.set_result(response)
+
+    @property
+    def resolved(self) -> bool:
+        """Whether the request is resolved."""
+        return self._future.done()
+
+
+type WireMessage = Event | ApprovalRequest
+
+
+def serialize_event(event: Event) -> dict[str, Any]:
+    """
+    Convert an event message into a JSON-serializable dictionary.
+    """
+    match event:
+        case StepBegin():
+            return {"type": "step_begin", "payload": {"n": event.n}}
+        case StepInterrupted():
+            return {"type": "step_interrupted"}
+        case CompactionBegin():
+            return {"type": "compaction_begin"}
+        case CompactionEnd():
+            return {"type": "compaction_end"}
+        case StatusUpdate():
+            return {
+                "type": "status_update",
+                "payload": {"context_usage": event.status.context_usage},
+            }
+        case ContentPart():
+            return {
+                "type": "content_part",
+                "payload": event.model_dump(mode="json", exclude_none=True),
+            }
+        case ToolCall():
+            return {
+                "type": "tool_call",
+                "payload": event.model_dump(mode="json", exclude_none=True),
+            }
+        case ToolCallPart():
+            return {
+                "type": "tool_call_part",
+                "payload": event.model_dump(mode="json", exclude_none=True),
+            }
+        case ToolResult():
+            return {
+                "type": "tool_result",
+                "payload": serialize_tool_result(event),
+            }
+        case SubagentEvent():
+            return {
+                "type": "subagent_event",
+                "payload": {
+                    "task_tool_call_id": event.task_tool_call_id,
+                    "event": serialize_event(event.event),
+                },
+            }
+
+
+def serialize_approval_request(request: ApprovalRequest) -> dict[str, Any]:
+    """
+    Convert an ApprovalRequest into a JSON-serializable dictionary.
+    """
+    return {
+        "id": request.id,
+        "tool_call_id": request.tool_call_id,
+        "sender": request.sender,
+        "action": request.action,
+        "description": request.description,
+    }
+
+
+def serialize_tool_result(result: ToolResult) -> dict[str, Any]:
+    if isinstance(result.result, ToolOk):
+        ok = True
+        result_data = {
+            "output": _serialize_tool_output(result.result.output),
+            "message": result.result.message,
+            "brief": result.result.brief,
+        }
+    else:
+        ok = False
+        result_data = {
+            "output": result.result.output,
+            "message": result.result.message,
+            "brief": result.result.brief,
+        }
+    return {
+        "tool_call_id": result.tool_call_id,
+        "ok": ok,
+        "result": result_data,
+    }
+
+
+def _serialize_tool_output(
+    output: str | ContentPart | Sequence[ContentPart],
+) -> str | list[Any] | dict[str, Any]:
+    if isinstance(output, str):
+        return output
+    elif isinstance(output, ContentPart):
+        return output.model_dump(mode="json", exclude_none=True)
+    else:  # Sequence[ContentPart]
+        return [part.model_dump(mode="json", exclude_none=True) for part in output]