kimi-cli 0.44__py3-none-any.whl → 0.78__py3-none-any.whl

kimi_cli/utils/envvar.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import os
+
+_TRUE_VALUES = {"1", "true", "t", "yes", "y"}
+
+
+def get_env_bool(name: str, default: bool = False) -> bool:
+    value = os.getenv(name)
+    if value is None:
+        return default
+    return value.strip().lower() in _TRUE_VALUES

kimi_cli/utils/frontmatter.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, cast
+
+import yaml
+
+
+def read_frontmatter(path: Path) -> dict[str, Any] | None:
+    """
+    Read the YAML frontmatter at the start of a file.
+
+    Args:
+        path: Path to an existing file that may contain frontmatter.
+
+    Raises:
+        ValueError: If the frontmatter YAML is invalid.
+    """
+    with path.open(encoding="utf-8", errors="replace") as handle:
+        first_line = handle.readline()
+        if not first_line or first_line.strip() != "---":
+            return None
+
+        frontmatter_lines: list[str] = []
+        for line in handle:
+            if line.strip() == "---":
+                break
+            frontmatter_lines.append(line)
+        else:
+            return None
+
+    frontmatter = "".join(frontmatter_lines).strip()
+    if not frontmatter:
+        return None
+
+    try:
+        raw_data: Any = yaml.safe_load(frontmatter)
+    except yaml.YAMLError as exc:
+        raise ValueError("Invalid frontmatter YAML.") from exc
+
+    if not isinstance(raw_data, dict):
+        raise ValueError("Frontmatter YAML must be a mapping.")
+
+    return cast(dict[str, Any], raw_data)

kimi_cli/utils/logging.py

@@ -1,18 +1,19 @@
-from typing import IO
+from __future__ import annotations
 
-from loguru import logger
+from typing import IO, AnyStr
 
-logger.remove()
+from loguru import logger
 
 
 class StreamToLogger(IO[str]):
     def __init__(self, level: str = "ERROR"):
         self._level = level
 
-    def write(self, buffer: str) -> int:
-        for line in buffer.rstrip().splitlines():
+    def write(self, s: AnyStr, /) -> int:
+        text = repr(s) if isinstance(s, bytes) else s
+        for line in text.rstrip().splitlines():
             logger.opt(depth=1).log(self._level, line.rstrip())
-        return len(buffer)
+        return len(s)
 
     def flush(self) -> None:
         pass

kimi_cli/utils/message.py

@@ -1,22 +1,17 @@
-from kosong.base.message import Message, TextPart
+from __future__ import annotations
 
+from kosong.message import Message
 
-def message_extract_text(message: Message) -> str:
-    """Extract text from a message."""
-    if isinstance(message.content, str):
-        return message.content
-    return "\n".join(part.text for part in message.content if isinstance(part, TextPart))
+from kimi_cli.wire.types import TextPart
 
 
 def message_stringify(message: Message) -> str:
     """Get a string representation of a message."""
+    # TODO: this should be merged into `kosong.message.Message.extract_text`
     parts: list[str] = []
-    if isinstance(message.content, str):
-        parts.append(message.content)
-    else:
-        for part in message.content:
-            if isinstance(part, TextPart):
-                parts.append(part.text)
-            else:
-                parts.append(f"[{part.type}]")
+    for part in message.content:
+        if isinstance(part, TextPart):
+            parts.append(part.text)
+        else:
+            parts.append(f"[{part.type}]")
     return "".join(parts)

kimi_cli/utils/path.py

@@ -1,23 +1,113 @@
+from __future__ import annotations
+
+import asyncio
+import os
 import re
-from pathlib import Path
+from pathlib import Path, PurePath
+from stat import S_ISDIR
 
 import aiofiles.os
+from kaos.path import KaosPath
+
+_ROTATION_OPEN_FLAGS = os.O_CREAT | os.O_EXCL | os.O_WRONLY
+_ROTATION_FILE_MODE = 0o600
+
+
+async def _reserve_rotation_path(path: Path) -> bool:
+    """Atomically create an empty file as a reservation for *path*."""
+
+    def _create() -> None:
+        fd = os.open(str(path), _ROTATION_OPEN_FLAGS, _ROTATION_FILE_MODE)
+        os.close(fd)
+
+    try:
+        await asyncio.to_thread(_create)
+    except FileExistsError:
+        return False
+    return True
 
 
 async def next_available_rotation(path: Path) -> Path | None:
+    """Return a reserved rotation path for *path* or ``None`` if parent is missing.
+
+    The caller must overwrite/reuse the returned path immediately because this helper
+    commits an empty placeholder file to guarantee uniqueness. It is therefore suited
+    for rotating *files* (like history logs) but **not** directory creation.
     """
-    Find the next available rotation path for a given path.
-    """
+
     if not path.parent.exists():
         return None
+
     base_name = path.stem
     suffix = path.suffix
     pattern = re.compile(rf"^{re.escape(base_name)}_(\d+){re.escape(suffix)}$")
     max_num = 0
-    # FIXME: protect from race condition
-    for p in await aiofiles.os.listdir(path.parent):
-        if m := pattern.match(p):
-            max_num = max(max_num, int(m.group(1)))
+    for entry in await aiofiles.os.listdir(path.parent):
+        if match := pattern.match(entry):
+            max_num = max(max_num, int(match.group(1)))
+
     next_num = max_num + 1
-    next_path = path.parent / f"{base_name}_{next_num}{suffix}"
-    return next_path
+    while True:
+        next_path = path.parent / f"{base_name}_{next_num}{suffix}"
+        if await _reserve_rotation_path(next_path):
+            return next_path
+        next_num += 1
+
+
+async def list_directory(work_dir: KaosPath) -> str:
+    """Return an ``ls``-like listing of *work_dir*.
+
+    This helper is used mainly to provide context to the LLM (for example
+    ``KIMI_WORK_DIR_LS``) and to show top-level directory contents in tools.
+    It should therefore be robust against per-entry filesystem issues such as
+    broken symlinks or permission errors: a single bad entry must not crash
+    the whole CLI.
+    """
+
+    entries: list[str] = []
+    # Iterate entries; tolerate per-entry stat failures (broken symlinks, permissions, etc.).
+    async for entry in work_dir.iterdir():
+        try:
+            st = await entry.stat()
+        except OSError:
+            # Broken symlink, permission error, etc. – keep listing other entries.
+            entries.append(f"?--------- {'?':>10} {entry.name} [stat failed]")
+            continue
+        mode = "d" if S_ISDIR(st.st_mode) else "-"
+        mode += "r" if st.st_mode & 0o400 else "-"
+        mode += "w" if st.st_mode & 0o200 else "-"
+        mode += "x" if st.st_mode & 0o100 else "-"
+        mode += "r" if st.st_mode & 0o040 else "-"
+        mode += "w" if st.st_mode & 0o020 else "-"
+        mode += "x" if st.st_mode & 0o010 else "-"
+        mode += "r" if st.st_mode & 0o004 else "-"
+        mode += "w" if st.st_mode & 0o002 else "-"
+        mode += "x" if st.st_mode & 0o001 else "-"
+        entries.append(f"{mode} {st.st_size:>10} {entry.name}")
+    return "\n".join(entries)
+
+
+def shorten_home(path: KaosPath) -> KaosPath:
+    """
+    Convert absolute path to use `~` for home directory.
+    """
+    try:
+        home = KaosPath.home()
+        p = path.relative_to(home)
+        return KaosPath("~") / p
+    except Exception:
+        return path
+
+
+def is_within_directory(path: KaosPath, directory: KaosPath) -> bool:
+    """
+    Check whether *path* is contained within *directory* using pure path semantics.
+    Both arguments should already be canonicalized (e.g. via KaosPath.canonical()).
+    """
+    candidate = PurePath(str(path))
+    base = PurePath(str(directory))
+    try:
+        candidate.relative_to(base)
+        return True
+    except ValueError:
+        return False

kimi_cli/utils/pyinstaller.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from PyInstaller.utils.hooks import collect_data_files, collect_submodules
 
 hiddenimports = collect_submodules("kimi_cli.tools")
@@ -9,9 +11,13 @@ datas = (
             "agents/**/*.md",
             "deps/bin/**",
             "prompts/**/*.md",
+            "skills/**",
             "tools/**/*.md",
             "CHANGELOG.md",
         ],
+        excludes=[
+            "tools/*.md",
+        ],
     )
     + collect_data_files(
         "dateparser",

kimi_cli/utils/rich/__init__.py

@@ -0,0 +1,33 @@
+"""Project-wide Rich configuration helpers."""
+
+from __future__ import annotations
+
+import re
+from typing import Final
+
+from rich import _wrap
+
+# Regex used by Rich to compute break opportunities during wrapping.
+_DEFAULT_WRAP_PATTERN: Final[re.Pattern[str]] = re.compile(r"\s*\S+\s*")
+_CHAR_WRAP_PATTERN: Final[re.Pattern[str]] = re.compile(r".", re.DOTALL)
+
+
+def enable_character_wrap() -> None:
+    """Switch Rich's wrapping logic to break on every character.
+
+    Rich's default behavior tries to preserve whole words; we override the
+    internal regex so markdown rendering can fold text at any column once it
+    exceeds the terminal width.
+    """
+
+    _wrap.re_word = _CHAR_WRAP_PATTERN
+
+
+def restore_word_wrap() -> None:
+    """Restore Rich's default word-based wrapping."""
+
+    _wrap.re_word = _DEFAULT_WRAP_PATTERN
+
+
+# Apply character-based wrapping globally for the CLI.
+enable_character_wrap()

kimi_cli/utils/rich/columns.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from rich.columns import Columns
+from rich.console import Console, ConsoleOptions, RenderableType, RenderResult
+from rich.measure import Measurement
+from rich.segment import Segment
+from rich.text import Text
+
+
+class _ShrinkToWidth:
+    def __init__(self, renderable: RenderableType, max_width: int) -> None:
+        self._renderable = renderable
+        self._max_width = max(max_width, 1)
+
+    def __rich_measure__(self, console: Console, options: ConsoleOptions) -> Measurement:
+        width = self._resolve_width(options)
+        return Measurement(0, width)
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        width = self._resolve_width(options)
+        child_options = options.update(width=width)
+        yield from console.render(self._renderable, child_options)
+
+    def _resolve_width(self, options: ConsoleOptions) -> int:
+        return max(1, min(self._max_width, options.max_width))
+
+
+def _strip_trailing_spaces(segments: list[Segment]) -> list[Segment]:
+    lines = list(Segment.split_lines(segments))
+    trimmed: list[Segment] = []
+    n_lines = len(lines)
+    for index, line in enumerate(lines):
+        line_segments = list(line)
+        while line_segments:
+            segment = line_segments[-1]
+            if segment.control is not None:
+                break
+            trimmed_text = segment.text.rstrip(" ")
+            if trimmed_text != segment.text:
+                if trimmed_text:
+                    line_segments[-1] = Segment(trimmed_text, segment.style, segment.control)
+                    break
+                line_segments.pop()
+                continue
+            break
+        trimmed.extend(line_segments)
+        if index != n_lines - 1:
+            trimmed.append(Segment.line())
+    if trimmed:
+        trimmed.append(Segment.line())
+    return trimmed
+
+
+class BulletColumns:
+    def __init__(
+        self,
+        renderable: RenderableType,
+        *,
+        bullet_style: str | None = None,
+        bullet: RenderableType | None = None,
+        padding: int = 1,
+    ) -> None:
+        self._renderable = renderable
+        self._bullet = bullet
+        self._bullet_style = bullet_style
+        self._padding = padding
+
+    def _bullet_renderable(self) -> RenderableType:
+        if self._bullet is not None:
+            return self._bullet
+        return Text("•", style=self._bullet_style or "")
+
+    def _available_width(self, console: Console, options: ConsoleOptions, bullet_width: int) -> int:
+        max_width = options.max_width or console.width or (bullet_width + self._padding + 1)
+        available = max_width - bullet_width - self._padding
+        return max(available, 1)
+
+    def __rich_measure__(self, console: Console, options: ConsoleOptions) -> Measurement:
+        bullet = self._bullet_renderable()
+        bullet_measure = Measurement.get(console, options, bullet)
+        bullet_width = max(bullet_measure.maximum, 1)
+        available = self._available_width(console, options, bullet_width)
+        constrained = _ShrinkToWidth(self._renderable, available)
+        columns = Columns([bullet, constrained], expand=False, padding=(0, self._padding))
+        return Measurement.get(console, options, columns)
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        bullet = self._bullet_renderable()
+        bullet_measure = Measurement.get(console, options, bullet)
+        bullet_width = max(bullet_measure.maximum, 1)
+        available = self._available_width(console, options, bullet_width)
+        columns = Columns(
+            [bullet, _ShrinkToWidth(self._renderable, available)],
+            expand=False,
+            padding=(0, self._padding),
+        )
+        segments = list(console.render(columns, options))
+        trimmed = _strip_trailing_spaces(segments)
+        yield from trimmed