kimi-cli 0.35__py3-none-any.whl → 0.52__py3-none-any.whl

kimi_cli/ui/shell/keyboard.py

@@ -0,0 +1,183 @@
+import asyncio
+import sys
+import threading
+import time
+from collections.abc import AsyncGenerator, Callable
+from enum import Enum, auto
+
+
+class KeyEvent(Enum):
+    UP = auto()
+    DOWN = auto()
+    LEFT = auto()
+    RIGHT = auto()
+    ENTER = auto()
+    ESCAPE = auto()
+    TAB = auto()
+
+
+async def listen_for_keyboard() -> AsyncGenerator[KeyEvent]:
+    loop = asyncio.get_running_loop()
+    queue = asyncio.Queue[KeyEvent]()
+    cancel_event = threading.Event()
+
+    def emit(event: KeyEvent) -> None:
+        # print(f"emit: {event}")
+        loop.call_soon_threadsafe(queue.put_nowait, event)
+
+    listener = threading.Thread(
+        target=_listen_for_keyboard_thread,
+        args=(cancel_event, emit),
+        name="kimi-cli-keyboard-listener",
+        daemon=True,
+    )
+    listener.start()
+
+    try:
+        while True:
+            yield await queue.get()
+    finally:
+        cancel_event.set()
+        if listener.is_alive():
+            await asyncio.to_thread(listener.join)
+
+
+def _listen_for_keyboard_thread(
+    cancel: threading.Event,
+    emit: Callable[[KeyEvent], None],
+) -> None:
+    if sys.platform == "win32":
+        _listen_for_keyboard_windows(cancel, emit)
+    else:
+        _listen_for_keyboard_unix(cancel, emit)
+
+
+def _listen_for_keyboard_unix(
+    cancel: threading.Event,
+    emit: Callable[[KeyEvent], None],
+) -> None:
+    if sys.platform == "win32":
+        raise RuntimeError("Unix keyboard listener requires a non-Windows platform")
+
+    import termios
+
+    # make stdin raw and non-blocking
+    fd = sys.stdin.fileno()
+    oldterm = termios.tcgetattr(fd)
+    newattr = termios.tcgetattr(fd)
+    newattr[3] = newattr[3] & ~termios.ICANON & ~termios.ECHO
+    newattr[6][termios.VMIN] = 0
+    newattr[6][termios.VTIME] = 0
+    termios.tcsetattr(fd, termios.TCSANOW, newattr)
+
+    try:
+        while not cancel.is_set():
+            try:
+                c = sys.stdin.buffer.read(1)
+            except (OSError, ValueError):
+                c = b""
+
+            if not c:
+                if cancel.is_set():
+                    break
+                time.sleep(0.01)
+                continue
+
+            if c == b"\x1b":
+                sequence = c
+                for _ in range(2):
+                    if cancel.is_set():
+                        break
+                    try:
+                        fragment = sys.stdin.buffer.read(1)
+                    except (OSError, ValueError):
+                        fragment = b""
+                    if not fragment:
+                        break
+                    sequence += fragment
+                    if sequence in _ARROW_KEY_MAP:
+                        break
+
+                event = _ARROW_KEY_MAP.get(sequence)
+                if event is not None:
+                    emit(event)
+                elif sequence == b"\x1b":
+                    emit(KeyEvent.ESCAPE)
+            elif c in (b"\r", b"\n"):
+                emit(KeyEvent.ENTER)
+            elif c == b"\t":
+                emit(KeyEvent.TAB)
+    finally:
+        # restore the terminal settings
+        termios.tcsetattr(fd, termios.TCSAFLUSH, oldterm)
+
+
+def _listen_for_keyboard_windows(
+    cancel: threading.Event,
+    emit: Callable[[KeyEvent], None],
+) -> None:
+    if sys.platform != "win32":
+        raise RuntimeError("Windows keyboard listener requires a Windows platform")
+
+    import msvcrt
+
+    while not cancel.is_set():
+        if msvcrt.kbhit():
+            c = msvcrt.getch()
+
+            # Handle special keys (arrow keys, etc.)
+            if c in (b"\x00", b"\xe0"):
+                # Extended key, read the next byte
+                extended = msvcrt.getch()
+                event = _WINDOWS_KEY_MAP.get(extended)
+                if event is not None:
+                    emit(event)
+            elif c == b"\x1b":
+                sequence = c
+                for _ in range(2):
+                    if cancel.is_set():
+                        break
+                    fragment = msvcrt.getch() if msvcrt.kbhit() else b""
+                    if not fragment:
+                        break
+                    sequence += fragment
+                    if sequence in _ARROW_KEY_MAP:
+                        break
+
+                event = _ARROW_KEY_MAP.get(sequence)
+                if event is not None:
+                    emit(event)
+                elif sequence == b"\x1b":
+                    emit(KeyEvent.ESCAPE)
+            elif c in (b"\r", b"\n"):
+                emit(KeyEvent.ENTER)
+            elif c == b"\t":
+                emit(KeyEvent.TAB)
+        else:
+            if cancel.is_set():
+                break
+            time.sleep(0.01)
+
+
+_ARROW_KEY_MAP: dict[bytes, KeyEvent] = {
+    b"\x1b[A": KeyEvent.UP,
+    b"\x1b[B": KeyEvent.DOWN,
+    b"\x1b[C": KeyEvent.RIGHT,
+    b"\x1b[D": KeyEvent.LEFT,
+}
+
+_WINDOWS_KEY_MAP: dict[bytes, KeyEvent] = {
+    b"H": KeyEvent.UP,  # Up arrow
+    b"P": KeyEvent.DOWN,  # Down arrow
+    b"M": KeyEvent.RIGHT,  # Right arrow
+    b"K": KeyEvent.LEFT,  # Left arrow
+}
+
+
+if __name__ == "__main__":
+
+    async def dev_main():
+        async for event in listen_for_keyboard():
+            print(event)
+
+    asyncio.run(dev_main())

kimi_cli/ui/shell/metacmd.py

@@ -2,19 +2,17 @@ import tempfile
 import webbrowser
 from collections.abc import Awaitable, Callable, Sequence
 from pathlib import Path
-from string import Template
 from typing import TYPE_CHECKING, NamedTuple, overload
 
-from kosong.base import generate
-from kosong.base.message import ContentPart, Message, TextPart
+from kosong.message import Message
 from rich.panel import Panel
 
-import kimi_cli.prompts.metacmds as prompts
-from kimi_cli.agent import load_agents_md
-from kimi_cli.soul import LLMNotSet
+import kimi_cli.prompts as prompts
+from kimi_cli.cli import Reload
 from kimi_cli.soul.context import Context
 from kimi_cli.soul.kimisoul import KimiSoul
 from kimi_cli.soul.message import system
+from kimi_cli.soul.runtime import load_agents_md
 from kimi_cli.ui.shell.console import console
 from kimi_cli.utils.changelog import CHANGELOG, format_release_notes
 from kimi_cli.utils.logging import logger
@@ -23,6 +21,17 @@ if TYPE_CHECKING:
     from kimi_cli.ui.shell import ShellApp
 
 type MetaCmdFunc = Callable[["ShellApp", list[str]], None | Awaitable[None]]
+"""
+A function that runs as a meta command.
+
+Raises:
+    LLMNotSet: When the LLM is not set.
+    ChatProviderError: When the LLM provider returns an error.
+    Reload: When the configuration should be reloaded.
+    asyncio.CancelledError: When the command is interrupted by user.
+
+This is quite similar to the `Soul.run` method.
+"""
 
 
 class MetaCommand(NamedTuple):
@@ -165,15 +174,15 @@ def help(app: "ShellApp", args: list[str]):
 @meta_command
 def version(app: "ShellApp", args: list[str]):
     """Show version information"""
-    from kimi_cli import __version__
+    from kimi_cli.constant import VERSION
 
-    console.print(f"kimi, version {__version__}")
+    console.print(f"kimi, version {VERSION}")
 
 
 @meta_command(name="release-notes")
 def release_notes(app: "ShellApp", args: list[str]):
     """Show release notes"""
-    text = format_release_notes(CHANGELOG)
+    text = format_release_notes(CHANGELOG, include_lib_changes=False)
     with console.pager(styles=True):
         console.print(Panel.fit(text, border_style="wheat4", title="Release Notes"))
 
@@ -188,25 +197,18 @@ def feedback(app: "ShellApp", args: list[str]):
     console.print(f"Please submit feedback at [underline]{ISSUE_URL}[/underline].")
 
 
-@meta_command
+@meta_command(kimi_soul_only=True)
 async def init(app: "ShellApp", args: list[str]):
     """Analyze the codebase and generate an `AGENTS.md` file"""
-    soul_bak = app.soul
-    if not isinstance(soul_bak, KimiSoul):
-        console.print("[red]Failed to analyze the codebase.[/red]")
-        return
+    assert isinstance(app.soul, KimiSoul)
 
+    soul_bak = app.soul
     with tempfile.TemporaryDirectory() as temp_dir:
         logger.info("Running `/init`")
         console.print("Analyzing the codebase...")
         tmp_context = Context(file_backend=Path(temp_dir) / "context.jsonl")
-        app.soul = KimiSoul(
-            soul_bak._agent,
-            soul_bak._agent_globals,
-            context=tmp_context,
-            loop_control=soul_bak._loop_control,
-        )
-        ok = await app._run(prompts.INIT)
+        app.soul = KimiSoul(soul_bak._agent, soul_bak._runtime, context=tmp_context)
+        ok = await app._run_soul_command(prompts.INIT, thinking=False)
 
         if ok:
             console.print(
@@ -217,7 +219,7 @@ async def init(app: "ShellApp", args: list[str]):
             console.print("[red]Failed to analyze the codebase.[/red]")
 
     app.soul = soul_bak
-    agents_md = load_agents_md(soul_bak._agent_globals.builtin_args.KIMI_WORK_DIR)
+    agents_md = load_agents_md(soul_bak._runtime.builtin_args.KIMI_WORK_DIR)
     system_message = system(
         "The user just ran `/init` meta command. "
         "The system has analyzed the codebase and generated an `AGENTS.md` file. "
@@ -232,78 +234,29 @@ async def clear(app: "ShellApp", args: list[str]):
     assert isinstance(app.soul, KimiSoul)
 
     if app.soul._context.n_checkpoints == 0:
-        console.print("[yellow]Context is empty.[/yellow]")
-        return
+        raise Reload()
 
     await app.soul._context.revert_to(0)
-    console.print("[green]✓[/green] Context has been cleared.")
+    raise Reload()
 
 
-@meta_command
+@meta_command(kimi_soul_only=True)
 async def compact(app: "ShellApp", args: list[str]):
     """Compact the context"""
     assert isinstance(app.soul, KimiSoul)
 
-    logger.info("Running `/compact`")
-
-    if app.soul._agent_globals.llm is None:
-        raise LLMNotSet()
-
-    # Get current context history
-    current_history = list(app.soul._context.history)
-    if len(current_history) <= 1:
-        console.print("[yellow]Context is too short to compact.[/yellow]")
+    if app.soul._context.n_checkpoints == 0:
+        console.print("[yellow]Context is empty.[/yellow]")
         return
 
-    # Convert history to string for the compact prompt
-    history_text = "\n\n".join(
-        f"## Message {i + 1}\nRole: {msg.role}\nContent: {msg.content}"
-        for i, msg in enumerate(current_history)
-    )
-
-    # Build the compact prompt using string template
-    compact_template = Template(prompts.COMPACT)
-    compact_prompt = compact_template.substitute(CONTEXT=history_text)
-
-    # Create input message for compaction
-    compact_message = Message(role="user", content=compact_prompt)
-
-    # Call generate to get the compacted context
-    try:
-        with console.status("[cyan]Compacting...[/cyan]"):
-            compacted_msg, usage = await generate(
-                chat_provider=app.soul._agent_globals.llm.chat_provider,
-                system_prompt="You are a helpful assistant that compacts conversation context.",
-                tools=[],
-                history=[compact_message],
-            )
-
-        # Clear the context and add the compacted message as the first message
-        await app.soul._context.revert_to(0)
-        content: list[ContentPart] = (
-            [TextPart(text=compacted_msg.content)]
-            if isinstance(compacted_msg.content, str)
-            else compacted_msg.content
-        )
-        content.insert(
-            0, system("Previous context has been compacted. Here is the compaction output:")
-        )
-        await app.soul._context.append_message(Message(role="assistant", content=content))
-
-        console.print("[green]✓[/green] Context has been compacted.")
-        if usage:
-            logger.info(
-                "Compaction used {input} input tokens and {output} output tokens",
-                input=usage.input,
-                output=usage.output,
-            )
-    except Exception as e:
-        logger.error("Failed to compact context: {error}", error=e)
-        console.print(f"[red]Failed to compact the context: {e}[/red]")
-        return
+    logger.info("Running `/compact`")
+    with console.status("[cyan]Compacting...[/cyan]"):
+        await app.soul.compact_context()
+    console.print("[green]✓[/green] Context has been compacted.")
 
 
 from . import (  # noqa: E402
+    debug,  # noqa: F401
     setup,  # noqa: F401
     update,  # noqa: F401
 )