kimi-cli 0.40__py3-none-any.whl → 0.41__py3-none-any.whl

kimi_cli/CHANGELOG.md

@@ -9,6 +9,18 @@ Internal builds may append content to the Unreleased section.
 Only write entries that are worth mentioning to users.
 -->
 
+## [0.41] - 2025-10-26
+
+### Fixed
+
+- Fix a bug for Glob tool when no matching files are found
+- Ensure reading files with UTF-8 encoding
+
+### Changed
+
+- Disable reading command/query from stdin in shell mode
+- Clarify the API platform selection in `/setup` meta command
+
 ## [0.40] - 2025-10-24
 
 ### Added

kimi_cli/__init__.py

@@ -1,258 +1,28 @@
-import asyncio
 import contextlib
-import importlib.metadata
-import json
 import os
-import subprocess
-import sys
-import textwrap
 import warnings
-from datetime import datetime
 from pathlib import Path
 from typing import Any, Literal
 
 import click
 from pydantic import SecretStr
 
-from kimi_cli.agent import (
-    DEFAULT_AGENT_FILE,
-    AgentGlobals,
-    BuiltinSystemPromptArgs,
-    load_agent_with_mcp,
-    load_agents_md,
-)
-from kimi_cli.config import (
-    Config,
-    ConfigError,
-    LLMModel,
-    LLMProvider,
-    load_config,
-)
-from kimi_cli.metadata import Session, continue_session, new_session
-from kimi_cli.share import get_share_dir
-from kimi_cli.soul.approval import Approval
+from kimi_cli.agentspec import DEFAULT_AGENT_FILE
+from kimi_cli.config import Config, LLMModel, LLMProvider
+from kimi_cli.llm import augment_provider_with_env_vars, create_llm
+from kimi_cli.metadata import Session
+from kimi_cli.soul.agent import load_agent_with_mcp
 from kimi_cli.soul.context import Context
-from kimi_cli.soul.denwarenji import DenwaRenji
+from kimi_cli.soul.globals import AgentGlobals
 from kimi_cli.soul.kimisoul import KimiSoul
 from kimi_cli.ui.acp import ACPServer
 from kimi_cli.ui.print import InputFormat, OutputFormat, PrintApp
-from kimi_cli.ui.shell import Reload, ShellApp
+from kimi_cli.ui.shell import ShellApp
 from kimi_cli.utils.logging import StreamToLogger, logger
-from kimi_cli.utils.provider import augment_provider_with_env_vars, create_llm
-
-__version__ = importlib.metadata.version("kimi-cli")
-USER_AGENT = f"KimiCLI/{__version__}"
 
 UIMode = Literal["shell", "print", "acp"]
 
 
-@click.command(context_settings=dict(help_option_names=["-h", "--help"]))
-@click.version_option(__version__)
-@click.option(
-    "--verbose",
-    is_flag=True,
-    default=False,
-    help="Print verbose information. Default: no.",
-)
-@click.option(
-    "--debug",
-    is_flag=True,
-    default=False,
-    help="Log debug information. Default: no.",
-)
-@click.option(
-    "--agent-file",
-    type=click.Path(exists=True, file_okay=True, dir_okay=False, path_type=Path),
-    default=DEFAULT_AGENT_FILE,
-    help="Custom agent specification file. Default: builtin Kimi Koder.",
-)
-@click.option(
-    "--model",
-    "-m",
-    "model_name",
-    type=str,
-    default=None,
-    help="LLM model to use. Default: default model set in config file.",
-)
-@click.option(
-    "--work-dir",
-    "-w",
-    type=click.Path(exists=True, file_okay=False, dir_okay=True, path_type=Path),
-    default=Path.cwd(),
-    help="Working directory for the agent. Default: current directory.",
-)
-@click.option(
-    "--continue",
-    "-C",
-    "continue_",
-    is_flag=True,
-    default=False,
-    help="Continue the previous session for the working directory. Default: no.",
-)
-@click.option(
-    "--command",
-    "-c",
-    "--query",
-    "-q",
-    "command",
-    type=str,
-    default=None,
-    help="User query to the agent. Default: prompt interactively.",
-)
-@click.option(
-    "--ui",
-    "ui",
-    type=click.Choice(["shell", "print", "acp"]),
-    default="shell",
-    help="UI mode to use. Default: shell.",
-)
-@click.option(
-    "--print",
-    "ui",
-    flag_value="print",
-    help="Run in print mode. Shortcut for `--ui print`.",
-)
-@click.option(
-    "--acp",
-    "ui",
-    flag_value="acp",
-    help="Start ACP server. Shortcut for `--ui acp`.",
-)
-@click.option(
-    "--input-format",
-    type=click.Choice(["text", "stream-json"]),
-    default=None,
-    help=(
-        "Input format to use. Must be used with `--print` "
-        "and the input must be piped in via stdin. "
-        "Default: text."
-    ),
-)
-@click.option(
-    "--output-format",
-    type=click.Choice(["text", "stream-json"]),
-    default=None,
-    help="Output format to use. Must be used with `--print`. Default: text.",
-)
-@click.option(
-    "--mcp-config-file",
-    type=click.Path(exists=True, file_okay=True, dir_okay=False, path_type=Path),
-    multiple=True,
-    help=(
-        "MCP config file to load. Add this option multiple times to specify multiple MCP configs. "
-        "Default: none."
-    ),
-)
-@click.option(
-    "--mcp-config",
-    type=str,
-    multiple=True,
-    help=(
-        "MCP config JSON to load. Add this option multiple times to specify multiple MCP configs. "
-        "Default: none."
-    ),
-)
-@click.option(
-    "--yolo",
-    "--yes",
-    "-y",
-    "--auto-approve",
-    "yolo",
-    is_flag=True,
-    default=False,
-    help="Automatically approve all actions. Default: no.",
-)
-def kimi(
-    verbose: bool,
-    debug: bool,
-    agent_file: Path,
-    model_name: str | None,
-    work_dir: Path,
-    continue_: bool,
-    command: str | None,
-    ui: UIMode,
-    input_format: InputFormat | None,
-    output_format: OutputFormat | None,
-    mcp_config_file: list[Path],
-    mcp_config: list[str],
-    yolo: bool,
-):
-    """Kimi, your next CLI agent."""
-    echo = click.echo if verbose else lambda *args, **kwargs: None
-
-    logger.add(
-        get_share_dir() / "logs" / "kimi.log",
-        level="DEBUG" if debug else "INFO",
-        rotation="06:00",
-        retention="10 days",
-    )
-
-    work_dir = work_dir.absolute()
-
-    if continue_:
-        session = continue_session(work_dir)
-        if session is None:
-            raise click.BadOptionUsage(
-                "--continue", "No previous session found for the working directory"
-            )
-        echo(f"✓ Continuing previous session: {session.id}")
-    else:
-        session = new_session(work_dir)
-        echo(f"✓ Created new session: {session.id}")
-    echo(f"✓ Session history file: {session.history_file}")
-
-    if input_format is not None and ui != "print":
-        raise click.BadOptionUsage(
-            "--input-format",
-            "Input format is only supported for print UI",
-        )
-    if output_format is not None and ui != "print":
-        raise click.BadOptionUsage(
-            "--output-format",
-            "Output format is only supported for print UI",
-        )
-
-    try:
-        mcp_configs = [json.loads(conf.read_text()) for conf in mcp_config_file]
-    except json.JSONDecodeError as e:
-        raise click.BadOptionUsage("--mcp-config-file", f"Invalid JSON: {e}") from e
-
-    try:
-        mcp_configs += [json.loads(conf) for conf in mcp_config]
-    except json.JSONDecodeError as e:
-        raise click.BadOptionUsage("--mcp-config", f"Invalid JSON: {e}") from e
-
-    while True:
-        try:
-            try:
-                config = load_config()
-            except ConfigError as e:
-                raise click.ClickException(f"Failed to load config: {e}") from e
-            echo(f"✓ Loaded config: {config}")
-
-            succeeded = asyncio.run(
-                kimi_run(
-                    config=config,
-                    model_name=model_name,
-                    work_dir=work_dir,
-                    session=session,
-                    command=command,
-                    agent_file=agent_file,
-                    verbose=verbose,
-                    ui=ui,
-                    input_format=input_format,
-                    output_format=output_format,
-                    mcp_configs=mcp_configs,
-                    yolo=yolo,
-                )
-            )
-            if not succeeded:
-                sys.exit(1)
-            break
-        except Reload:
-            continue
-
-
 async def kimi_run(
     *,
     config: Config,
@@ -261,7 +31,6 @@ async def kimi_run(
     session: Session,
     command: str | None = None,
     agent_file: Path = DEFAULT_AGENT_FILE,
-    verbose: bool = True,
     ui: UIMode = "shell",
     input_format: InputFormat | None = None,
     output_format: OutputFormat | None = None,
@@ -269,8 +38,6 @@ async def kimi_run(
     yolo: bool = False,
 ) -> bool:
     """Run Kimi CLI."""
-    echo = click.echo if verbose else lambda *args, **kwargs: None
-
     model: LLMModel | None = None
     provider: LLMProvider | None = None
 
@@ -296,37 +63,16 @@ async def kimi_run(
     if not provider.base_url or not model.model:
         llm = None
     else:
-        echo(f"✓ Using LLM provider: {provider}")
-        echo(f"✓ Using LLM model: {model}")
+        logger.info("Using LLM provider: {provider}", provider=provider)
+        logger.info("Using LLM model: {model}", model=model)
         stream = ui != "print"  # use non-streaming mode only for print UI
         llm = create_llm(provider, model, stream=stream, session_id=session.id)
 
-    # TODO: support Windows
-    ls = subprocess.run(["ls", "-la"], capture_output=True, text=True)
-    agents_md = load_agents_md(work_dir) or ""
-    if agents_md:
-        echo(f"✓ Loaded agents.md: {textwrap.shorten(agents_md, width=100)}")
-
-    agent_globals = AgentGlobals(
-        config=config,
-        llm=llm,
-        builtin_args=BuiltinSystemPromptArgs(
-            KIMI_NOW=datetime.now().astimezone().isoformat(),
-            KIMI_WORK_DIR=work_dir,
-            KIMI_WORK_DIR_LS=ls.stdout,
-            KIMI_AGENTS_MD=agents_md,
-        ),
-        denwa_renji=DenwaRenji(),
-        session=session,
-        approval=Approval(yolo=yolo),
-    )
+    agent_globals = await AgentGlobals.create(config, llm, session, yolo)
     try:
         agent = await load_agent_with_mcp(agent_file, agent_globals, mcp_configs or [])
     except ValueError as e:
         raise click.BadParameter(f"Failed to load agent: {e}") from e
-    echo(f"✓ Loaded agent: {agent.name}")
-    echo(f"✓ Loaded system prompt: {textwrap.shorten(agent.system_prompt, width=100)}")
-    echo(f"✓ Loaded tools: {[tool.name for tool in agent.toolset.tools]}")
 
     if command is not None:
         command = command.strip()
@@ -334,9 +80,7 @@ async def kimi_run(
             raise click.BadParameter("Command cannot be empty")
 
     context = Context(session.history_file)
-    restored = await context.restore()
-    if restored:
-        echo(f"✓ Restored history from {session.history_file}")
+    await context.restore()
 
     soul = KimiSoul(
         agent,
@@ -350,10 +94,6 @@ async def kimi_run(
 
     try:
         if ui == "shell":
-            if command is None and not sys.stdin.isatty():
-                command = sys.stdin.read().strip()
-                echo(f"✓ Read command from stdin: {command}")
-
             app = ShellApp(
                 soul,
                 welcome_info={
@@ -366,7 +106,13 @@ async def kimi_run(
             with contextlib.redirect_stderr(StreamToLogger()):
                 return await app.run(command)
         elif ui == "print":
-            app = PrintApp(soul, input_format or "text", output_format or "text")
+            soul._approval.set_yolo(True)  # print mode implies yolo mode
+            app = PrintApp(
+                soul,
+                input_format or "text",
+                output_format or "text",
+                context.file_backend,
+            )
             return await app.run(command)
         elif ui == "acp":
             if command is not None:
@@ -377,11 +123,3 @@ async def kimi_run(
             raise click.BadParameter(f"Invalid UI mode: {ui}")
     finally:
         os.chdir(original_cwd)
-
-
-def main():
-    kimi()
-
-
-if __name__ == "__main__":
-    main()

kimi_cli/agents/koder/system.md

@@ -47,7 +47,7 @@ The operating environment is not in a sandbox. Any action especially mutation yo
 
 The current working directory is `${KIMI_WORK_DIR}`. This should be considered as the project root if you are instructed to perform tasks on the project. Every file system operation will be relative to the working directory if you do not explicitly specify the absolute path. Tools may require absolute paths for some parameters, if so, you should strictly follow the requirements.
 
-The `ls -la` output of current working directory is:
+The directory listing of current working directory is:
 
 ```
 ${KIMI_WORK_DIR_LS}

kimi_cli/agentspec.py

@@ -0,0 +1,104 @@
+from pathlib import Path
+from typing import Any, NamedTuple
+
+import yaml
+from pydantic import BaseModel, Field
+
+
+def get_agents_dir() -> Path:
+    return Path(__file__).parent / "agents"
+
+
+DEFAULT_AGENT_FILE = get_agents_dir() / "koder" / "agent.yaml"
+
+
+class AgentSpec(BaseModel):
+    """Agent specification."""
+
+    extend: str | None = Field(default=None, description="Agent file to extend")
+    name: str | None = Field(default=None, description="Agent name")  # required
+    system_prompt_path: Path | None = Field(
+        default=None, description="System prompt path"
+    )  # required
+    system_prompt_args: dict[str, str] = Field(
+        default_factory=dict, description="System prompt arguments"
+    )
+    tools: list[str] | None = Field(default=None, description="Tools")  # required
+    exclude_tools: list[str] | None = Field(default=None, description="Tools to exclude")
+    subagents: dict[str, "SubagentSpec"] | None = Field(default=None, description="Subagents")
+
+
+class SubagentSpec(BaseModel):
+    """Subagent specification."""
+
+    path: Path = Field(description="Subagent file path")
+    description: str = Field(description="Subagent description")
+
+
+class ResolvedAgentSpec(NamedTuple):
+    """Resolved agent specification."""
+
+    name: str
+    system_prompt_path: Path
+    system_prompt_args: dict[str, str]
+    tools: list[str]
+    exclude_tools: list[str]
+    subagents: dict[str, "SubagentSpec"]
+
+
+def load_agent_spec(agent_file: Path) -> ResolvedAgentSpec:
+    """Load agent specification from file."""
+    agent_spec = _load_agent_spec(agent_file)
+    assert agent_spec.extend is None, "agent extension should be recursively resolved"
+    if agent_spec.name is None:
+        raise ValueError("Agent name is required")
+    if agent_spec.system_prompt_path is None:
+        raise ValueError("System prompt path is required")
+    if agent_spec.tools is None:
+        raise ValueError("Tools are required")
+    return ResolvedAgentSpec(
+        name=agent_spec.name,
+        system_prompt_path=agent_spec.system_prompt_path,
+        system_prompt_args=agent_spec.system_prompt_args,
+        tools=agent_spec.tools,
+        exclude_tools=agent_spec.exclude_tools or [],
+        subagents=agent_spec.subagents or {},
+    )
+
+
+def _load_agent_spec(agent_file: Path) -> AgentSpec:
+    assert agent_file.is_file(), "expect agent file to exist"
+    with open(agent_file, encoding="utf-8") as f:
+        data: dict[str, Any] = yaml.safe_load(f)
+
+    version = data.get("version", 1)
+    if version != 1:
+        raise ValueError(f"Unsupported agent spec version: {version}")
+
+    agent_spec = AgentSpec(**data.get("agent", {}))
+    if agent_spec.system_prompt_path is not None:
+        agent_spec.system_prompt_path = agent_file.parent / agent_spec.system_prompt_path
+    if agent_spec.subagents is not None:
+        for v in agent_spec.subagents.values():
+            v.path = agent_file.parent / v.path
+    if agent_spec.extend:
+        if agent_spec.extend == "default":
+            base_agent_file = DEFAULT_AGENT_FILE
+        else:
+            base_agent_file = agent_file.parent / agent_spec.extend
+        base_agent_spec = _load_agent_spec(base_agent_file)
+        if agent_spec.name is not None:
+            base_agent_spec.name = agent_spec.name
+        if agent_spec.system_prompt_path is not None:
+            base_agent_spec.system_prompt_path = agent_spec.system_prompt_path
+        for k, v in agent_spec.system_prompt_args.items():
+            # system prompt args should be merged instead of overwritten
+            base_agent_spec.system_prompt_args[k] = v
+        if agent_spec.tools is not None:
+            base_agent_spec.tools = agent_spec.tools
+        if agent_spec.exclude_tools is not None:
+            base_agent_spec.exclude_tools = agent_spec.exclude_tools
+        if agent_spec.subagents is not None:
+            base_agent_spec.subagents = agent_spec.subagents
+        agent_spec = base_agent_spec
+    return agent_spec