kimi-cli 0.35__py3-none-any.whl

kimi_cli/ui/shell/setup.py

@@ -0,0 +1,192 @@
+import asyncio
+from typing import TYPE_CHECKING, NamedTuple
+
+import aiohttp
+from prompt_toolkit import PromptSession
+from prompt_toolkit.shortcuts.choice_input import ChoiceInput
+from pydantic import SecretStr
+
+from kimi_cli.config import LLMModel, LLMProvider, MoonshotSearchConfig, load_config, save_config
+from kimi_cli.soul.kimisoul import KimiSoul
+from kimi_cli.ui.shell.console import console
+from kimi_cli.ui.shell.metacmd import meta_command
+
+if TYPE_CHECKING:
+    from kimi_cli.ui.shell import ShellApp
+
+
+class _Platform(NamedTuple):
+    id: str
+    name: str
+    base_url: str
+    search_url: str | None = None
+    allowed_models: list[str] | None = None
+
+
+_PLATFORMS = [
+    _Platform(
+        id="kimi-coding",
+        name="Kimi Coding Plan",
+        base_url="https://api.kimi.com/coding/v1",
+        search_url="https://api.kimi.com/coding/v1/search",
+    ),
+    _Platform(
+        id="moonshot-cn",
+        name="Moonshot AI 开放平台",
+        base_url="https://api.moonshot.cn/v1",
+        allowed_models=["kimi-k2-turbo-preview", "kimi-k2-0905-preview", "kimi-k2-0711-preview"],
+    ),
+    _Platform(
+        id="moonshot-ai",
+        name="Moonshot AI Open Platform",
+        base_url="https://api.moonshot.ai/v1",
+        allowed_models=["kimi-k2-turbo-preview", "kimi-k2-0905-preview", "kimi-k2-0711-preview"],
+    ),
+]
+
+
+@meta_command(kimi_soul_only=True)
+async def setup(app: "ShellApp", args: list[str]):
+    """Setup Kimi CLI"""
+    assert isinstance(app.soul, KimiSoul)
+
+    result = await _setup()
+    if not result:
+        # error message already printed
+        return
+
+    config = load_config()
+    config.providers[result.platform.id] = LLMProvider(
+        type="kimi",
+        base_url=result.platform.base_url,
+        api_key=result.api_key,
+    )
+    config.models[result.model_id] = LLMModel(
+        provider=result.platform.id,
+        model=result.model_id,
+        max_context_size=result.max_context_size,
+    )
+    config.default_model = result.model_id
+
+    if result.platform.search_url:
+        config.services.moonshot_search = MoonshotSearchConfig(
+            base_url=result.platform.search_url,
+            api_key=result.api_key,
+        )
+
+    save_config(config)
+    console.print("[green]✓[/green] Kimi CLI has been setup! Reloading...")
+    await asyncio.sleep(1)
+    console.clear()
+
+    from kimi_cli import Reload
+
+    raise Reload
+
+
+class _SetupResult(NamedTuple):
+    platform: _Platform
+    api_key: SecretStr
+    model_id: str
+    max_context_size: int
+
+
+async def _setup() -> _SetupResult | None:
+    # select the API platform
+    platform_name = await _prompt_choice(
+        header="Select the API platform",
+        choices=[platform.name for platform in _PLATFORMS],
+    )
+    if not platform_name:
+        console.print("[red]No platform selected[/red]")
+        return None
+
+    platform = next(platform for platform in _PLATFORMS if platform.name == platform_name)
+
+    # enter the API key
+    api_key = await _prompt_text("Enter your API key", is_password=True)
+    if not api_key:
+        return None
+
+    # list models
+    models_url = f"{platform.base_url}/models"
+    try:
+        async with (
+            aiohttp.ClientSession() as session,
+            session.get(
+                models_url,
+                headers={
+                    "Authorization": f"Bearer {api_key}",
+                },
+                raise_for_status=True,
+            ) as response,
+        ):
+            resp_json = await response.json()
+    except aiohttp.ClientError as e:
+        console.print(f"[red]Failed to get models: {e}[/red]")
+        return None
+
+    model_dict = {model["id"]: model for model in resp_json["data"]}
+
+    # select the model
+    if platform.allowed_models is None:
+        model_ids = [model["id"] for model in resp_json["data"]]
+    else:
+        id_set = set(model["id"] for model in resp_json["data"])
+        model_ids = [model_id for model_id in platform.allowed_models if model_id in id_set]
+
+    if not model_ids:
+        console.print("[red]No models available for the selected platform[/red]")
+        return None
+
+    model_id = await _prompt_choice(
+        header="Select the model",
+        choices=model_ids,
+    )
+    if not model_id:
+        console.print("[red]No model selected[/red]")
+        return None
+
+    model = model_dict[model_id]
+
+    return _SetupResult(
+        platform=platform,
+        api_key=SecretStr(api_key),
+        model_id=model_id,
+        max_context_size=model["context_length"],
+    )
+
+
+async def _prompt_choice(*, header: str, choices: list[str]) -> str | None:
+    if not choices:
+        return None
+
+    try:
+        return await ChoiceInput(
+            message=header,
+            options=[(choice, choice) for choice in choices],
+            default=choices[0],
+        ).prompt_async()
+    except (EOFError, KeyboardInterrupt):
+        return None
+
+
+async def _prompt_text(prompt: str, *, is_password: bool = False) -> str | None:
+    session = PromptSession()
+    try:
+        return str(
+            await session.prompt_async(
+                f" {prompt}: ",
+                is_password=is_password,
+            )
+        ).strip()
+    except (EOFError, KeyboardInterrupt):
+        return None
+
+
+@meta_command
+def reload(app: "ShellApp", args: list[str]):
+    """Reload configuration"""
+    from kimi_cli import Reload
+
+    raise Reload

kimi_cli/ui/shell/update.py

@@ -0,0 +1,204 @@
+import asyncio
+import os
+import platform
+import re
+import shutil
+import stat
+import tarfile
+import tempfile
+from enum import Enum, auto
+from pathlib import Path
+
+import aiohttp
+
+from kimi_cli.ui.shell.console import console
+from kimi_cli.utils.logging import logger
+
+BASE_URL = "https://cdn.kimi.com/binaries/kimi-cli"
+LATEST_VERSION_URL = f"{BASE_URL}/latest"
+INSTALL_DIR = Path.home() / ".local" / "bin"
+
+
+class UpdateResult(Enum):
+    UPDATE_AVAILABLE = auto()
+    UPDATED = auto()
+    UP_TO_DATE = auto()
+    FAILED = auto()
+    UNSUPPORTED = auto()
+
+
+_UPDATE_LOCK = asyncio.Lock()
+
+
+def _semver_tuple(version: str) -> tuple[int, int, int]:
+    v = version.strip()
+    if v.startswith("v"):
+        v = v[1:]
+    match = re.match(r"^(\d+)\.(\d+)(?:\.(\d+))?", v)
+    if not match:
+        return (0, 0, 0)
+    major = int(match.group(1))
+    minor = int(match.group(2))
+    patch = int(match.group(3) or 0)
+    return (major, minor, patch)
+
+
+def _detect_target() -> str | None:
+    sys_name = platform.system()
+    mach = platform.machine()
+    if mach in ("x86_64", "amd64", "AMD64"):
+        arch = "x86_64"
+    elif mach in ("arm64", "aarch64"):
+        arch = "aarch64"
+    else:
+        logger.error("Unsupported architecture: {mach}", mach=mach)
+        return None
+    if sys_name == "Darwin":
+        os_name = "apple-darwin"
+    elif sys_name == "Linux":
+        os_name = "unknown-linux-gnu"
+    else:
+        logger.error("Unsupported OS: {sys_name}", sys_name=sys_name)
+        return None
+    return f"{arch}-{os_name}"
+
+
+async def _get_latest_version(session: aiohttp.ClientSession) -> str | None:
+    try:
+        async with session.get(LATEST_VERSION_URL) as resp:
+            resp.raise_for_status()
+            data = await resp.text()
+            return data.strip()
+    except aiohttp.ClientError:
+        logger.exception("Failed to get latest version:")
+        return None
+
+
+async def do_update(*, print: bool = True, check_only: bool = False) -> UpdateResult:
+    async with _UPDATE_LOCK:
+        return await _do_update(print=print, check_only=check_only)
+
+
+async def _do_update(*, print: bool, check_only: bool) -> UpdateResult:
+    from kimi_cli import __version__ as current_version
+
+    def _print(message: str) -> None:
+        if print:
+            console.print(message)
+
+    target = _detect_target()
+    if not target:
+        _print("[red]Failed to detect target platform.[/red]")
+        return UpdateResult.UNSUPPORTED
+
+    async with aiohttp.ClientSession() as session:
+        logger.info("Checking for updates...")
+        _print("Checking for updates...")
+        latest_version = await _get_latest_version(session)
+        if not latest_version:
+            _print("[red]Failed to check for updates.[/red]")
+            return UpdateResult.FAILED
+
+        logger.debug("Latest version: {latest_version}", latest_version=latest_version)
+
+        cur_t = _semver_tuple(current_version)
+        lat_t = _semver_tuple(latest_version)
+
+        if cur_t >= lat_t:
+            logger.debug("Already up to date: {current_version}", current_version=current_version)
+            _print("[green]Already up to date.[/green]")
+            return UpdateResult.UP_TO_DATE
+
+        if check_only:
+            logger.info(
+                "Update available: current={current_version}, latest={latest_version}",
+                current_version=current_version,
+                latest_version=latest_version,
+            )
+            _print(f"[yellow]Update available: {latest_version}[/yellow]")
+            return UpdateResult.UPDATE_AVAILABLE
+
+        logger.info(
+            "Updating from {current_version} to {latest_version}...",
+            current_version=current_version,
+            latest_version=latest_version,
+        )
+        _print(f"Updating from {current_version} to {latest_version}...")
+
+        filename = f"kimi-{latest_version}-{target}.tar.gz"
+        download_url = f"{BASE_URL}/{latest_version}/{filename}"
+
+        with tempfile.TemporaryDirectory(prefix="kimi-cli-") as tmpdir:
+            tar_path = os.path.join(tmpdir, filename)
+
+            logger.info("Downloading from {download_url}...", download_url=download_url)
+            _print("[grey50]Downloading...[/grey50]")
+            try:
+                async with session.get(download_url) as resp:
+                    resp.raise_for_status()
+                    with open(tar_path, "wb") as f:
+                        async for chunk in resp.content.iter_chunked(1024 * 64):
+                            if chunk:
+                                f.write(chunk)
+            except aiohttp.ClientError:
+                logger.exception(
+                    "Failed to download update from {download_url}",
+                    download_url=download_url,
+                )
+                _print("[red]Failed to download.[/red]")
+                return UpdateResult.FAILED
+            except Exception:
+                logger.exception("Failed to download:")
+                _print("[red]Failed to download.[/red]")
+                return UpdateResult.FAILED
+
+            logger.info("Extracting archive {tar_path}...", tar_path=tar_path)
+            _print("[grey50]Extracting...[/grey50]")
+            try:
+                with tarfile.open(tar_path, "r:gz") as tar:
+                    tar.extractall(tmpdir)
+                binary_path = None
+                for root, _, files in os.walk(tmpdir):
+                    if "kimi" in files:
+                        binary_path = os.path.join(root, "kimi")
+                        break
+                if not binary_path:
+                    logger.error("Binary 'kimi' not found in archive.")
+                    _print("[red]Binary 'kimi' not found in archive.[/red]")
+                    return UpdateResult.FAILED
+            except Exception:
+                logger.exception("Failed to extract archive:")
+                _print("[red]Failed to extract archive.[/red]")
+                return UpdateResult.FAILED
+
+            INSTALL_DIR.mkdir(parents=True, exist_ok=True)
+            dest_path = INSTALL_DIR / "kimi"
+            logger.info("Installing to {dest_path}...", dest_path=dest_path)
+            _print("[grey50]Installing...[/grey50]")
+
+            try:
+                shutil.copy2(binary_path, dest_path)
+                os.chmod(
+                    dest_path,
+                    os.stat(dest_path).st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH,
+                )
+            except Exception:
+                logger.exception("Failed to install:")
+                _print("[red]Failed to install.[/red]")
+                return UpdateResult.FAILED
+
+    _print("[green]Updated successfully![/green]")
+    _print("[yellow]Restart Kimi CLI to use the new version.[/yellow]")
+    return UpdateResult.UPDATED
+
+
+# @meta_command
+# async def update(app: "ShellApp", args: list[str]):
+#     """Check for updates"""
+#     await do_update(print=True)
+
+
+# @meta_command(name="check-update")
+# async def check_update(app: "ShellApp", args: list[str]):
+#     """Check for updates"""
+#     await do_update(print=True, check_only=True)

kimi_cli/utils/changelog.py

@@ -0,0 +1,101 @@
+from pathlib import Path
+from typing import NamedTuple
+
+
+class ReleaseEntry(NamedTuple):
+    description: str
+    entries: list[str]
+
+
+def parse_changelog(md_text: str) -> dict[str, ReleaseEntry]:
+    """Parse a subset of Keep a Changelog-style markdown into a map:
+    version -> (description, entries)
+
+    Parsing rules:
+    - Versions are denoted by level-2 headings starting with '## ['
+      Example: `## [v0.10.1] - 2025-09-18` or `## [Unreleased]`
+    - For each version section, description is the first contiguous block of
+      non-empty lines that do not start with '-' or '#'.
+    - Entries are all markdown list items starting with '- ' under that version
+      (across any subheadings like '### Added').
+    """
+    lines = md_text.splitlines()
+    result: dict[str, ReleaseEntry] = {}
+
+    current_ver: str | None = None
+    collecting_desc = False
+    desc_lines: list[str] = []
+    bullet_lines: list[str] = []
+    seen_content_after_header = False
+
+    def commit():
+        nonlocal current_ver, desc_lines, bullet_lines, result
+        if current_ver is None:
+            return
+        description = "\n".join([line.strip() for line in desc_lines]).strip()
+        # Deduplicate and normalize entries
+        norm_entries = [
+            line.strip()[2:].strip() for line in bullet_lines if line.strip().startswith("- ")
+        ]
+        result[current_ver] = ReleaseEntry(description=description, entries=norm_entries)
+
+    for raw in lines:
+        line = raw.rstrip()
+        if line.startswith("## ["):
+            # New version section, flush previous
+            commit()
+            # Extract version token inside brackets
+            end = line.find("]")
+            ver = line[4:end] if end != -1 else line[3:].strip()
+            current_ver = ver.strip()
+            desc_lines = []
+            bullet_lines = []
+            collecting_desc = True
+            seen_content_after_header = False
+            continue
+
+        if current_ver is None:
+            # Skip until first version section
+            continue
+
+        if not line.strip():
+            # blank line ends initial description block only after we've seen content
+            if collecting_desc and seen_content_after_header:
+                collecting_desc = False
+            continue
+
+        seen_content_after_header = True
+
+        if line.lstrip().startswith("### "):
+            collecting_desc = False
+            continue
+
+        if line.lstrip().startswith("- "):
+            collecting_desc = False
+            bullet_lines.append(line.strip())
+            continue
+
+        if collecting_desc:
+            # Accumulate description until a blank line or bullets/subheadings
+            desc_lines.append(line.strip())
+        # else: ignore any other free-form text after description block
+
+    # Final flush
+    commit()
+    return result
+
+
+def format_release_notes(changelog: dict[str, ReleaseEntry]) -> str:
+    parts: list[str] = []
+    for ver, entry in changelog.items():
+        s = f"[bold]{ver}[/bold]"
+        if entry.description:
+            s += f": {entry.description}"
+        if entry.entries:
+            for it in entry.entries:
+                s += "\n[markdown.item.bullet]• [/]" + it
+        parts.append(s + "\n")
+    return "\n".join(parts).strip()
+
+
+CHANGELOG = parse_changelog((Path(__file__).parent.parent / "CHANGELOG.md").read_text())

kimi_cli/utils/logging.py

@@ -0,0 +1,18 @@
+from typing import IO
+
+from loguru import logger
+
+logger.remove()
+
+
+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():
+            logger.opt(depth=1).log(self._level, line.rstrip())
+        return len(buffer)
+
+    def flush(self) -> None:
+        pass

kimi_cli/utils/message.py

@@ -0,0 +1,8 @@
+from kosong.base.message import Message, TextPart
+
+
+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))

kimi_cli/utils/path.py

@@ -0,0 +1,23 @@
+import re
+from pathlib import Path
+
+import aiofiles.os
+
+
+async def next_available_rotation(path: Path) -> Path | None:
+    """
+    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)))
+    next_num = max_num + 1
+    next_path = path.parent / f"{base_name}_{next_num}{suffix}"
+    return next_path

kimi_cli/utils/provider.py

@@ -0,0 +1,64 @@
+import os
+
+from kosong.chat_provider import ChaosChatProvider, Kimi, OpenAILegacy
+from kosong.chat_provider.chaos import ChaosConfig
+from pydantic import SecretStr
+
+import kimi_cli
+from kimi_cli.config import LLMModel, LLMProvider
+from kimi_cli.llm import LLM
+
+
+def augment_provider_with_env_vars(provider: LLMProvider, model: LLMModel):
+    match provider.type:
+        case "kimi":
+            if base_url := os.getenv("KIMI_BASE_URL"):
+                provider.base_url = base_url
+            if api_key := os.getenv("KIMI_API_KEY"):
+                provider.api_key = SecretStr(api_key)
+            if model_name := os.getenv("KIMI_MODEL_NAME"):
+                model.model = model_name
+            if max_context_size := os.getenv("KIMI_MODEL_MAX_CONTEXT_SIZE"):
+                model.max_context_size = int(max_context_size)
+        case "openai_legacy":
+            if base_url := os.getenv("OPENAI_BASE_URL"):
+                provider.base_url = base_url
+            if api_key := os.getenv("OPENAI_API_KEY"):
+                provider.api_key = SecretStr(api_key)
+        case _:
+            pass
+
+
+def create_llm(provider: LLMProvider, model: LLMModel, stream: bool = True) -> LLM:
+    match provider.type:
+        case "kimi":
+            chat_provider = Kimi(
+                model=model.model,
+                base_url=provider.base_url,
+                api_key=provider.api_key.get_secret_value(),
+                stream=stream,
+                default_headers={
+                    "User-Agent": kimi_cli.USER_AGENT,
+                },
+            )
+        case "openai_legacy":
+            chat_provider = OpenAILegacy(
+                model=model.model,
+                base_url=provider.base_url,
+                api_key=provider.api_key.get_secret_value(),
+                stream=stream,
+            )
+        case "_chaos":
+            chat_provider = ChaosChatProvider(
+                model=model.model,
+                base_url=provider.base_url,
+                api_key=provider.api_key.get_secret_value(),
+                chaos_config=ChaosConfig(
+                    error_probability=0.8,
+                    error_types=[429, 500, 503],
+                ),
+            )
+        case _:
+            raise ValueError(f"Unsupported provider: {provider.type}")
+
+    return LLM(chat_provider=chat_provider, max_context_size=model.max_context_size)

kimi_cli/utils/pyinstaller.py

@@ -0,0 +1,24 @@
+from PyInstaller.utils.hooks import collect_data_files, collect_submodules
+
+hiddenimports = collect_submodules("kimi_cli.tools")
+datas = (
+    collect_data_files(
+        "kimi_cli",
+        includes=[
+            "agents/**/*.yaml",
+            "agents/**/*.md",
+            "deps/bin/**",
+            "prompts/**/*.md",
+            "tools/**/*.md",
+            "CHANGELOG.md",
+        ],
+    )
+    + collect_data_files(
+        "dateparser",
+        includes=["**/*.pkl"],
+    )
+    + collect_data_files(
+        "fastmcp",
+        includes=["../fastmcp-*.dist-info/*"],
+    )
+)

kimi_cli/utils/string.py

@@ -0,0 +1,12 @@
+import re
+
+_NEWLINE_RE = re.compile(r"[\r\n]+")
+
+
+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 :]

kimi_cli-0.35.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.3
+Name: kimi-cli
+Version: 0.35
+Summary: Kimi CLI is your next CLI agent.
+Requires-Dist: agent-client-protocol>=0.4.9
+Requires-Dist: aiofiles>=25.1.0
+Requires-Dist: aiohttp>=3.13.1
+Requires-Dist: click>=8.3.0
+Requires-Dist: kosong>=0.14.1
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: patch-ng>=1.19.0
+Requires-Dist: prompt-toolkit>=3.0.52
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: rich>=14.2.0
+Requires-Dist: ripgrepy>=2.2.0
+Requires-Dist: streamingjson>=0.0.5
+Requires-Dist: trafilatura>=2.0.0
+Requires-Dist: tenacity>=9.1.2
+Requires-Dist: fastmcp>=2.12.5
+Requires-Dist: pydantic>=2.12.3
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# Kimi CLI