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

kimi_cli/app.py

@@ -0,0 +1,208 @@
+import contextlib
+import os
+import warnings
+from collections.abc import Generator
+from pathlib import Path
+from typing import Any
+
+from pydantic import SecretStr
+
+from kimi_cli.agentspec import DEFAULT_AGENT_FILE
+from kimi_cli.cli import InputFormat, OutputFormat
+from kimi_cli.config import LLMModel, LLMProvider, load_config
+from kimi_cli.llm import augment_provider_with_env_vars, create_llm
+from kimi_cli.session import Session
+from kimi_cli.soul import LLMNotSet, LLMNotSupported
+from kimi_cli.soul.agent import load_agent
+from kimi_cli.soul.context import Context
+from kimi_cli.soul.kimisoul import KimiSoul
+from kimi_cli.soul.runtime import Runtime
+from kimi_cli.utils.logging import StreamToLogger, logger
+
+
+class KimiCLI:
+    @staticmethod
+    async def create(
+        session: Session,
+        *,
+        yolo: bool = False,
+        stream: bool = True,  # TODO: remove this when we have a correct print mode impl
+        mcp_configs: list[dict[str, Any]] | None = None,
+        config_file: Path | None = None,
+        model_name: str | None = None,
+        thinking: bool = False,
+        agent_file: Path | None = None,
+    ) -> "KimiCLI":
+        """
+        Create a KimiCLI instance.
+
+        Args:
+            session (Session): A session created by `Session.create` or `Session.continue_`.
+            yolo (bool, optional): Approve all actions without confirmation. Defaults to False.
+            stream (bool, optional): Use stream mode when calling LLM API. Defaults to True.
+            config_file (Path | None, optional): Path to the configuration file. Defaults to None.
+            model_name (str | None, optional): Name of the model to use. Defaults to None.
+            agent_file (Path | None, optional): Path to the agent file. Defaults to None.
+
+        Raises:
+            FileNotFoundError: When the agent file is not found.
+            ConfigError(KimiCLIException): When the configuration is invalid.
+            AgentSpecError(KimiCLIException): When the agent specification is invalid.
+        """
+        config = load_config(config_file)
+        logger.info("Loaded config: {config}", config=config)
+
+        model: LLMModel | None = None
+        provider: LLMProvider | None = None
+
+        # try to use config file
+        if not model_name and config.default_model:
+            # no --model specified && default model is set in config
+            model = config.models[config.default_model]
+            provider = config.providers[model.provider]
+        if model_name and model_name in config.models:
+            # --model specified && model is set in config
+            model = config.models[model_name]
+            provider = config.providers[model.provider]
+
+        if not model:
+            model = LLMModel(provider="", model="", max_context_size=100_000)
+            provider = LLMProvider(type="kimi", base_url="", api_key=SecretStr(""))
+
+        # try overwrite with environment variables
+        assert provider is not None
+        assert model is not None
+        env_overrides = augment_provider_with_env_vars(provider, model)
+
+        if not provider.base_url or not model.model:
+            llm = None
+        else:
+            logger.info("Using LLM provider: {provider}", provider=provider)
+            logger.info("Using LLM model: {model}", model=model)
+            llm = create_llm(provider, model, stream=stream, session_id=session.id)
+
+        runtime = await Runtime.create(config, llm, session, yolo)
+
+        if agent_file is None:
+            agent_file = DEFAULT_AGENT_FILE
+        agent = await load_agent(agent_file, runtime, mcp_configs=mcp_configs or [])
+
+        context = Context(session.history_file)
+        await context.restore()
+
+        soul = KimiSoul(
+            agent,
+            runtime,
+            context=context,
+        )
+        try:
+            soul.set_thinking(thinking)
+        except (LLMNotSet, LLMNotSupported) as e:
+            logger.warning("Failed to enable thinking mode: {error}", error=e)
+        return KimiCLI(soul, runtime, env_overrides)
+
+    def __init__(
+        self,
+        _soul: KimiSoul,
+        _runtime: Runtime,
+        _env_overrides: dict[str, str],
+    ) -> None:
+        self._soul = _soul
+        self._runtime = _runtime
+        self._env_overrides = _env_overrides
+
+    @property
+    def soul(self) -> KimiSoul:
+        """Get the KimiSoul instance."""
+        return self._soul
+
+    @property
+    def session(self) -> Session:
+        """Get the Session instance."""
+        return self._runtime.session
+
+    @contextlib.contextmanager
+    def _app_env(self) -> Generator[None]:
+        original_cwd = Path.cwd()
+        os.chdir(self._runtime.session.work_dir)
+        try:
+            # to ignore possible warnings from dateparser
+            warnings.filterwarnings("ignore", category=DeprecationWarning)
+            with contextlib.redirect_stderr(StreamToLogger()):
+                yield
+        finally:
+            os.chdir(original_cwd)
+
+    async def run_shell_mode(self, command: str | None = None) -> bool:
+        from kimi_cli.ui.shell import ShellApp, WelcomeInfoItem
+
+        welcome_info = [
+            WelcomeInfoItem(name="Directory", value=str(self._runtime.session.work_dir)),
+            WelcomeInfoItem(name="Session", value=self._runtime.session.id),
+        ]
+        if base_url := self._env_overrides.get("KIMI_BASE_URL"):
+            welcome_info.append(
+                WelcomeInfoItem(
+                    name="API URL",
+                    value=f"{base_url} (from KIMI_BASE_URL)",
+                    level=WelcomeInfoItem.Level.WARN,
+                )
+            )
+        if not self._runtime.llm:
+            welcome_info.append(
+                WelcomeInfoItem(
+                    name="Model",
+                    value="not set, send /setup to configure",
+                    level=WelcomeInfoItem.Level.WARN,
+                )
+            )
+        elif "KIMI_MODEL_NAME" in self._env_overrides:
+            welcome_info.append(
+                WelcomeInfoItem(
+                    name="Model",
+                    value=f"{self._soul.model_name} (from KIMI_MODEL_NAME)",
+                    level=WelcomeInfoItem.Level.WARN,
+                )
+            )
+        else:
+            welcome_info.append(
+                WelcomeInfoItem(
+                    name="Model",
+                    value=self._soul.model_name,
+                    level=WelcomeInfoItem.Level.INFO,
+                )
+            )
+        with self._app_env():
+            app = ShellApp(self._soul, welcome_info=welcome_info)
+            return await app.run(command)
+
+    async def run_print_mode(
+        self,
+        input_format: InputFormat,
+        output_format: OutputFormat,
+        command: str | None = None,
+    ) -> bool:
+        from kimi_cli.ui.print import PrintApp
+
+        with self._app_env():
+            app = PrintApp(
+                self._soul,
+                input_format,
+                output_format,
+                self._runtime.session.history_file,
+            )
+            return await app.run(command)
+
+    async def run_acp_server(self) -> bool:
+        from kimi_cli.ui.acp import ACPServer
+
+        with self._app_env():
+            app = ACPServer(self._soul)
+            return await app.run()
+
+    async def run_wire_server(self) -> bool:
+        from kimi_cli.ui.wire import WireServer
+
+        with self._app_env():
+            server = WireServer(self._soul)
+            return await server.run()

kimi_cli/cli.py

@@ -0,0 +1,321 @@
+import asyncio
+import json
+import sys
+from collections.abc import Callable
+from pathlib import Path
+from typing import Annotated, Any, Literal
+
+import typer
+
+from kimi_cli.constant import VERSION
+
+
+class Reload(Exception):
+    """Reload configuration."""
+
+    pass
+
+
+cli = typer.Typer(
+    add_completion=False,
+    context_settings={"help_option_names": ["-h", "--help"]},
+    help="Kimi, your next CLI agent.",
+)
+
+UIMode = Literal["shell", "print", "acp", "wire"]
+InputFormat = Literal["text", "stream-json"]
+OutputFormat = Literal["text", "stream-json"]
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"kimi, version {VERSION}")
+        raise typer.Exit()
+
+
+@cli.command()
+def kimi(
+    version: Annotated[
+        bool,
+        typer.Option(
+            "--version",
+            "-V",
+            help="Show version and exit.",
+            callback=_version_callback,
+            is_eager=True,
+        ),
+    ] = False,
+    verbose: Annotated[
+        bool,
+        typer.Option(
+            "--verbose",
+            help="Print verbose information. Default: no.",
+        ),
+    ] = False,
+    debug: Annotated[
+        bool,
+        typer.Option(
+            "--debug",
+            help="Log debug information. Default: no.",
+        ),
+    ] = False,
+    agent_file: Annotated[
+        Path | None,
+        typer.Option(
+            "--agent-file",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            help="Custom agent specification file. Default: builtin default agent.",
+        ),
+    ] = None,
+    model_name: Annotated[
+        str | None,
+        typer.Option(
+            "--model",
+            "-m",
+            help="LLM model to use. Default: default model set in config file.",
+        ),
+    ] = None,
+    work_dir: Annotated[
+        Path | None,
+        typer.Option(
+            "--work-dir",
+            "-w",
+            exists=True,
+            file_okay=False,
+            dir_okay=True,
+            readable=True,
+            writable=True,
+            help="Working directory for the agent. Default: current directory.",
+        ),
+    ] = None,
+    continue_: Annotated[
+        bool,
+        typer.Option(
+            "--continue",
+            "-C",
+            help="Continue the previous session for the working directory. Default: no.",
+        ),
+    ] = False,
+    command: Annotated[
+        str | None,
+        typer.Option(
+            "--command",
+            "-c",
+            "--query",
+            "-q",
+            help="User query to the agent. Default: prompt interactively.",
+        ),
+    ] = None,
+    print_mode: Annotated[
+        bool,
+        typer.Option(
+            "--print",
+            help=(
+                "Run in print mode (non-interactive). Note: print mode implicitly adds `--yolo`."
+            ),
+        ),
+    ] = False,
+    acp_mode: Annotated[
+        bool,
+        typer.Option(
+            "--acp",
+            help="Run as ACP server.",
+        ),
+    ] = False,
+    wire_mode: Annotated[
+        bool,
+        typer.Option(
+            "--wire",
+            help="Run as Wire server (experimental).",
+        ),
+    ] = False,
+    input_format: Annotated[
+        InputFormat | None,
+        typer.Option(
+            "--input-format",
+            help=(
+                "Input format to use. Must be used with `--print` "
+                "and the input must be piped in via stdin. "
+                "Default: text."
+            ),
+        ),
+    ] = None,
+    output_format: Annotated[
+        OutputFormat | None,
+        typer.Option(
+            "--output-format",
+            help="Output format to use. Must be used with `--print`. Default: text.",
+        ),
+    ] = None,
+    mcp_config_file: Annotated[
+        list[Path] | None,
+        typer.Option(
+            "--mcp-config-file",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            help=(
+                "MCP config file to load. Add this option multiple times to specify multiple MCP "
+                "configs. Default: none."
+            ),
+        ),
+    ] = None,
+    mcp_config: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--mcp-config",
+            help=(
+                "MCP config JSON to load. Add this option multiple times to specify multiple MCP "
+                "configs. Default: none."
+            ),
+        ),
+    ] = None,
+    yolo: Annotated[
+        bool,
+        typer.Option(
+            "--yolo",
+            "--yes",
+            "-y",
+            "--auto-approve",
+            help="Automatically approve all actions. Default: no.",
+        ),
+    ] = False,
+    thinking: Annotated[
+        bool,
+        typer.Option(
+            "--thinking",
+            help="Enable thinking mode if supported. Default: no.",
+        ),
+    ] = False,
+):
+    """Kimi, your next CLI agent."""
+    del version  # handled in the callback
+
+    from kimi_cli.app import KimiCLI
+    from kimi_cli.session import Session
+    from kimi_cli.share import get_share_dir
+    from kimi_cli.utils.logging import logger
+
+    def _noop_echo(*args: Any, **kwargs: Any):
+        pass
+
+    special_flags = {
+        "--print": print_mode,
+        "--acp": acp_mode,
+        "--wire": wire_mode,
+    }
+    active_specials = [flag for flag, active in special_flags.items() if active]
+    if len(active_specials) > 1:
+        raise typer.BadParameter(
+            f"Cannot combine {', '.join(active_specials)}.",
+            param_hint=active_specials[0],
+        )
+
+    ui: UIMode = "shell"
+    if print_mode:
+        ui = "print"
+    elif acp_mode:
+        ui = "acp"
+    elif wire_mode:
+        ui = "wire"
+
+    echo: Callable[..., None] = typer.echo if verbose else _noop_echo
+
+    if debug:
+        logger.enable("kosong")
+    logger.add(
+        get_share_dir() / "logs" / "kimi.log",
+        # FIXME: configure level for different modules
+        level="TRACE" if debug else "INFO",
+        rotation="06:00",
+        retention="10 days",
+    )
+
+    work_dir = (work_dir or Path.cwd()).absolute()
+    if continue_:
+        session = Session.continue_(work_dir)
+        if session is None:
+            raise typer.BadParameter(
+                "No previous session found for the working directory",
+                param_hint="--continue",
+            )
+        echo(f"✓ Continuing previous session: {session.id}")
+    else:
+        session = Session.create(work_dir)
+        echo(f"✓ Created new session: {session.id}")
+    echo(f"✓ Session history file: {session.history_file}")
+
+    if command is not None:
+        command = command.strip()
+        if not command:
+            raise typer.BadParameter("Command cannot be empty", param_hint="--command")
+
+    if input_format is not None and ui != "print":
+        raise typer.BadParameter(
+            "Input format is only supported for print UI",
+            param_hint="--input-format",
+        )
+    if output_format is not None and ui != "print":
+        raise typer.BadParameter(
+            "Output format is only supported for print UI",
+            param_hint="--output-format",
+        )
+
+    file_configs = list(mcp_config_file or [])
+    raw_mcp_config = list(mcp_config or [])
+
+    try:
+        mcp_configs = [json.loads(conf.read_text(encoding="utf-8")) for conf in file_configs]
+    except json.JSONDecodeError as e:
+        raise typer.BadParameter(f"Invalid JSON: {e}", param_hint="--mcp-config-file") from e
+
+    try:
+        mcp_configs += [json.loads(conf) for conf in raw_mcp_config]
+    except json.JSONDecodeError as e:
+        raise typer.BadParameter(f"Invalid JSON: {e}", param_hint="--mcp-config") from e
+
+    async def _run() -> bool:
+        instance = await KimiCLI.create(
+            session,
+            yolo=yolo or (ui == "print"),  # print mode implies yolo
+            stream=ui != "print",  # use non-streaming mode only for print UI
+            mcp_configs=mcp_configs,
+            model_name=model_name,
+            thinking=thinking,
+            agent_file=agent_file,
+        )
+        match ui:
+            case "shell":
+                return await instance.run_shell_mode(command)
+            case "print":
+                return await instance.run_print_mode(
+                    input_format or "text",
+                    output_format or "text",
+                    command,
+                )
+            case "acp":
+                if command is not None:
+                    logger.warning("ACP server ignores command argument")
+                return await instance.run_acp_server()
+            case "wire":
+                if command is not None:
+                    logger.warning("Wire server ignores command argument")
+                return await instance.run_wire_server()
+
+    while True:
+        try:
+            succeeded = asyncio.run(_run())
+            if succeeded:
+                session.mark_as_last()
+                break
+            sys.exit(1)
+        except Reload:
+            continue
+
+
+if __name__ == "__main__":
+    cli()

kimi_cli/config.py

@@ -1,9 +1,11 @@
 import json
 from pathlib import Path
-from typing import Literal, Self
+from typing import Self
 
 from pydantic import BaseModel, Field, SecretStr, ValidationError, field_serializer, model_validator
 
+from kimi_cli.exception import ConfigError
+from kimi_cli.llm import ModelCapability, ProviderType
 from kimi_cli.share import get_share_dir
 from kimi_cli.utils.logging import logger
 
@@ -11,12 +13,14 @@ from kimi_cli.utils.logging import logger
 class LLMProvider(BaseModel):
     """LLM provider configuration."""
 
-    type: Literal["kimi", "openai_legacy", "_chaos"]
+    type: ProviderType
     """Provider type"""
     base_url: str
     """API base URL"""
     api_key: SecretStr
     """API key"""
+    custom_headers: dict[str, str] | None = None
+    """Custom headers to include in API requests"""
 
     @field_serializer("api_key", when_used="json")
     def dump_secret(self, v: SecretStr):
@@ -32,6 +36,8 @@ class LLMModel(BaseModel):
     """Model name"""
     max_context_size: int
     """Maximum context size (unit: tokens)"""
+    capabilities: set[ModelCapability] | None = None
+    """Model capabilities"""
 
 
 class LoopControl(BaseModel):
@@ -50,6 +56,8 @@ class MoonshotSearchConfig(BaseModel):
     """Base URL for Moonshot Search service."""
     api_key: SecretStr
     """API key for Moonshot Search service."""
+    custom_headers: dict[str, str] | None = None
+    """Custom headers to include in API requests."""
 
     @field_serializer("api_key", when_used="json")
     def dump_secret(self, v: SecretStr):
@@ -99,13 +107,21 @@ def get_default_config() -> Config:
     )
 
 
-def load_config() -> Config:
-    """Load configuration from config file.
+def load_config(config_file: Path | None = None) -> Config:
+    """
+    Load configuration from config file.
+    If the config file does not exist, create it with default configuration.
+
+    Args:
+        config_file (Path | None): Path to the configuration file. If None, use default path.
 
     Returns:
         Validated Config object.
+
+    Raises:
+        ConfigError: If the configuration file is invalid.
     """
-    config_file = get_config_file()
+    config_file = config_file or get_config_file()
     logger.debug("Loading config from file: {file}", file=config_file)
 
     if not config_file.exists():
@@ -119,20 +135,21 @@ def load_config() -> Config:
         with open(config_file, encoding="utf-8") as f:
             data = json.load(f)
         return Config(**data)
-    except (json.JSONDecodeError, ValidationError) as e:
-        raise ConfigError(f"Invalid configuration file: {config_file}") from e
-
+    except json.JSONDecodeError as e:
+        raise ConfigError(f"Invalid JSON in configuration file: {e}") from e
+    except ValidationError as e:
+        raise ConfigError(f"Invalid configuration file: {e}") from e
 
-class ConfigError(Exception):
-    """Configuration error."""
-
-    def __init__(self, message: str):
-        super().__init__(message)
 
+def save_config(config: Config, config_file: Path | None = None):
+    """
+    Save configuration to config file.
 
-def save_config(config: Config):
-    """Save configuration to config file."""
-    config_file = get_config_file()
+    Args:
+        config (Config): Config object to save.
+        config_file (Path | None): Path to the configuration file. If None, use default path.
+    """
+    config_file = config_file or get_config_file()
     logger.debug("Saving config to file: {file}", file=config_file)
     with open(config_file, "w", encoding="utf-8") as f:
         f.write(config.model_dump_json(indent=2, exclude_none=True))

kimi_cli/constant.py

@@ -0,0 +1,4 @@
+import importlib.metadata
+
+VERSION = importlib.metadata.version("kimi-cli")
+USER_AGENT = f"KimiCLI/{VERSION}"

kimi_cli/exception.py

@@ -0,0 +1,16 @@
+class KimiCLIException(Exception):
+    """Base exception class for Kimi CLI."""
+
+    pass
+
+
+class ConfigError(KimiCLIException):
+    """Configuration error."""
+
+    pass
+
+
+class AgentSpecError(KimiCLIException):
+    """Agent specification error."""
+
+    pass