kimi-cli 0.35__py3-none-any.whl

kimi_cli/agent.py

@@ -0,0 +1,261 @@
+import importlib
+import inspect
+import string
+from pathlib import Path
+from typing import Any, NamedTuple
+
+import fastmcp
+import yaml
+from kosong.tooling import Toolset
+from kosong.tooling.simple import ToolType
+from pydantic import BaseModel, Field
+
+from kimi_cli.config import Config
+from kimi_cli.llm import LLM
+from kimi_cli.metadata import Session
+from kimi_cli.soul.approval import Approval
+from kimi_cli.soul.denwarenji import DenwaRenji
+from kimi_cli.soul.toolset import CustomToolset
+from kimi_cli.tools.mcp import MCPTool
+from kimi_cli.utils.logging import logger
+
+
+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 BuiltinSystemPromptArgs(NamedTuple):
+    """Builtin system prompt arguments."""
+
+    KIMI_NOW: str
+    """The current datetime."""
+    KIMI_WORK_DIR: Path
+    """The current working directory."""
+    KIMI_WORK_DIR_LS: str
+    """The `ls -la` output of current working directory."""
+    KIMI_AGENTS_MD: str  # TODO: move to first message from system prompt
+    """The content of AGENTS.md."""
+
+
+class AgentGlobals(NamedTuple):
+    """Agent globals."""
+
+    config: Config
+    llm: LLM | None
+    builtin_args: BuiltinSystemPromptArgs
+    denwa_renji: DenwaRenji
+    session: Session
+    approval: Approval
+
+
+class Agent(NamedTuple):
+    """The loaded agent."""
+
+    name: str
+    system_prompt: str
+    toolset: Toolset
+
+
+def get_agents_dir() -> Path:
+    return Path(__file__).parent / "agents"
+
+
+DEFAULT_AGENT_FILE = get_agents_dir() / "koder" / "agent.yaml"
+
+
+async def load_agent_with_mcp(
+    agent_file: Path,
+    globals_: AgentGlobals,
+    mcp_configs: list[dict[str, Any]],
+) -> Agent:
+    agent = load_agent(agent_file, globals_)
+    assert isinstance(agent.toolset, CustomToolset)
+    if mcp_configs:
+        await _load_mcp_tools(agent.toolset, mcp_configs)
+    return agent
+
+
+def load_agent(
+    agent_file: Path,
+    globals_: AgentGlobals,
+) -> Agent:
+    """
+    Load agent from specification file.
+
+    Raises:
+        ValueError: If the agent spec is not valid.
+    """
+    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")
+
+    system_prompt = _load_system_prompt(
+        agent_spec.system_prompt_path, agent_spec.system_prompt_args, globals_.builtin_args
+    )
+
+    tool_deps = {
+        AgentSpec: agent_spec,
+        AgentGlobals: globals_,
+        Config: globals_.config,
+        BuiltinSystemPromptArgs: globals_.builtin_args,
+        Session: globals_.session,
+        DenwaRenji: globals_.denwa_renji,
+        Approval: globals_.approval,
+    }
+    tools = agent_spec.tools
+    if agent_spec.exclude_tools:
+        logger.debug("Excluding tools: {tools}", tools=agent_spec.exclude_tools)
+        tools = [tool for tool in tools if tool not in agent_spec.exclude_tools]
+    toolset = CustomToolset()
+    bad_tools = _load_tools(toolset, tools, tool_deps)
+    if bad_tools:
+        raise ValueError(f"Invalid tools: {bad_tools}")
+
+    return Agent(
+        name=agent_spec.name,
+        system_prompt=system_prompt,
+        toolset=toolset,
+    )
+
+
+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():
+            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
+
+
+def _load_system_prompt(
+    path: Path, args: dict[str, str], builtin_args: BuiltinSystemPromptArgs
+) -> str:
+    system_prompt = path.read_text().strip()
+    logger.debug(
+        "Substituting system prompt with builtin args: {builtin_args}, spec args: {spec_args}",
+        builtin_args=builtin_args,
+        spec_args=args,
+    )
+    return string.Template(system_prompt).substitute(builtin_args._asdict(), **args)
+
+
+def _load_tools(
+    toolset: CustomToolset,
+    tool_paths: list[str],
+    dependencies: dict[type[Any], Any],
+) -> list[str]:
+    bad_tools = []
+    for tool_path in tool_paths:
+        tool = _load_tool(tool_path, dependencies)
+        if tool:
+            toolset += tool
+        else:
+            bad_tools.append(tool_path)
+    logger.debug("Loaded tools: {tools}", tools=toolset.tools)
+    if bad_tools:
+        logger.error("Bad tools: {bad_tools}", bad_tools=bad_tools)
+    return bad_tools
+
+
+def _load_tool(tool_path: str, dependencies: dict[type[Any], Any]) -> ToolType | None:
+    logger.debug("Loading tool: {tool_path}", tool_path=tool_path)
+    module_name, class_name = tool_path.rsplit(":", 1)
+    try:
+        module = importlib.import_module(module_name)
+    except ImportError:
+        return None
+    cls = getattr(module, class_name, None)
+    if cls is None:
+        return None
+    args = []
+    for param in inspect.signature(cls).parameters.values():
+        if param.kind == inspect.Parameter.KEYWORD_ONLY:
+            # once we encounter a keyword-only parameter, we stop injecting dependencies
+            break
+        # all positional parameters should be dependencies to be injected
+        if param.annotation not in dependencies:
+            raise ValueError(f"Tool dependency not found: {param.annotation}")
+        args.append(dependencies[param.annotation])
+    return cls(*args)
+
+
+async def _load_mcp_tools(
+    toolset: CustomToolset,
+    mcp_configs: list[dict[str, Any]],
+):
+    """
+    Raises:
+        ValueError: If the MCP config is not valid.
+        RuntimeError: If the MCP server cannot be connected.
+    """
+    for mcp_config in mcp_configs:
+        client = fastmcp.Client(mcp_config)
+        async with client:
+            for tool in await client.list_tools():
+                toolset += MCPTool(tool, client)
+    return toolset
+
+
+def load_agents_md(work_dir: Path) -> str | None:
+    paths = [
+        work_dir / "AGENTS.md",
+        work_dir / "agents.md",
+    ]
+    for path in paths:
+        if path.is_file():
+            logger.debug("Loaded agents.md: {path}", path=path)
+            return path.read_text().strip()
+    logger.debug("No AGENTS.md found")
+    return None

kimi_cli/agents/koder/README.md

@@ -0,0 +1,3 @@
+# Kimi Koder
+
+Kimi Koder is a CLI agent that can help you with your software development tasks.

kimi_cli/agents/koder/agent.yaml

@@ -0,0 +1,24 @@
+version: 1
+agent:
+  name: ""
+  system_prompt_path: ./system.md
+  system_prompt_args:
+    ROLE_ADDITIONAL: ""
+  tools:
+    - "kimi_cli.tools.task:Task"
+    # - "kimi_cli.tools.dmail:SendDMail"
+    - "kimi_cli.tools.think:Think"
+    - "kimi_cli.tools.todo:SetTodoList"
+    - "kimi_cli.tools.bash:Bash"
+    - "kimi_cli.tools.file:ReadFile"
+    - "kimi_cli.tools.file:Glob"
+    - "kimi_cli.tools.file:Grep"
+    - "kimi_cli.tools.file:WriteFile"
+    - "kimi_cli.tools.file:StrReplaceFile"
+    # - "kimi_cli.tools.file:PatchFile"
+    - "kimi_cli.tools.web:SearchWeb"
+    - "kimi_cli.tools.web:FetchURL"
+  subagents:
+    koder:
+      path: ./sub.yaml
+      description: "Good at general software engineering tasks."

kimi_cli/agents/koder/sub.yaml

@@ -0,0 +1,11 @@
+version: 1
+agent:
+  extend: ./agent.yaml
+  system_prompt_args:
+    ROLE_ADDITIONAL: |
+      You are now running as a subagent. All the `user` messages are sent by the main agent. The main agent cannot see your context, it can only see your last message when you finish the task. You need to provide a comprehensive summary on what you have done and learned in your final message. If you wrote or modified any files, you must mention them in the summary.
+  exclude_tools:
+    - "kimi_cli.tools.task:Task"
+    - "kimi_cli.tools.dmail:SendDMail"
+    - "kimi_cli.tools.todo:SetTodoList"
+  subagents: # make sure no subagents are provided

kimi_cli/agents/koder/system.md

@@ -0,0 +1,72 @@
+You are Kimi CLI. You are an interactive CLI agent specializing in software engineering tasks. Your primary goal is to help users safely and efficiently, adhering strictly to the following instructions and utilizing your available tools.
+
+${ROLE_ADDITIONAL}
+
+# Prompt and Tool Use
+
+The user's requests are provided in natural language within `user` messages, which may contain code snippets, logs, file paths, or specific requirements. ALWAYS follow the user's requests, always stay on track. Do not do anything that is not asked.
+
+When handling the user's request, you can call available tools to accomplish the task. When calling tools, do not provide explanations because the tool calls themselves should be self-explanatory. You MUST follow the description of each tool and its parameters when calling tools.
+
+You have the capability to output any number of tool calls in a single response. If you anticipate making multiple non-interfering tool calls, you are HIGHLY RECOMMENDED to make them in parallel to significantly improve efficiency. This is very important to your performance.
+
+The results of the tool calls will be returned to you in a `tool` message. In some cases, non-plain-text content might be sent as a `user` message following the `tool` message. You must decide on your next action based on the tool call results, which could be one of the following: 1. Continue working on the task, 2. Inform the user that the task is completed or has failed, or 3. Ask the user for more information.
+
+The system may, where appropriate, insert hints or information wrapped in `<system>` and `</system>` tags within `user` or `tool` messages. This information is relevant to the current task or tool calls, may or may not be important to you. Take this info into consideration when determining your next action.
+
+When responding to the user, you MUST use the SAME language as the user, unless explicitly instructed to do otherwise.
+
+# General Coding Guidelines
+
+Always think carefully. Be patient and thorough. Do not give up too early.
+
+ALWAYS, keep it stupidly simple. Do not overcomplicate things.
+
+When building something from scratch, you should:
+
+- Understand the user's requirements.
+- Design the architecture and make a plan for the implementation.
+- Write the code in a modular and maintainable way.
+
+When working on existing codebase, you should:
+
+- Understand the codebase and the user's requirements. Identify the ultimate goal and the most important criteria to achieve the goal.
+- For a bug fix, you typically need to check error logs or failed tests, scan over the codebase to find the root cause, and figure out a fix. If user mentioned any failed tests, you should make sure they pass after the changes.
+- For a feature, you typically need to design the architecture, and write the code in a modular and maintainable way, with minimal intrusions to existing code. Add new tests if the project already has tests.
+- For a code refactoring, you typically need to update all the places that call the code you are refactoring if the interface changes. DO NOT change any existing logic especially in tests, focus only on fixing any errors caused by the interface changes.
+- Make MINIMAL changes to achieve the goal. This is very important to your performance.
+- Follow the coding style of existing code in the project.
+
+# Working Environment
+
+## Operating System
+
+The operating environment is not in a sandbox. Any action especially mutation you do will immediately affect the user's system. So you MUST be extremely cautious. Unless being explicitly instructed to do so, you should never access (read/write/execute) files outside of the working directory.
+
+## Working Directory
+
+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:
+
+```
+${KIMI_WORK_DIR_LS}
+```
+
+Use this as your basic understanding of the project structure.
+
+## Date and Time
+
+The current date and time in ISO format is `${KIMI_NOW}`. This is only a reference for you when searching the web, or checking file modification time, etc. If you need the exact time, use Bash tool with proper command.
+
+# Project Information
+
+Markdown files named `AGENTS.md` usually contain the background, structure, coding styles, user preferences and other relevant information about the project. You should use this information to understand the project and the user's preferences. `AGENTS.md` files may exist at different locations in the project, but typically there is one in the project root. The following content between two `---`s is the content of the root-level `AGENTS.md` file.
+
+`${KIMI_WORK_DIR}/AGENTS.md`:
+
+---
+
+${KIMI_AGENTS_MD}
+
+---

kimi_cli/config.py

@@ -0,0 +1,138 @@
+import json
+from pathlib import Path
+from typing import Literal, Self
+
+from pydantic import BaseModel, Field, SecretStr, ValidationError, field_serializer, model_validator
+
+from kimi_cli.share import get_share_dir
+from kimi_cli.utils.logging import logger
+
+
+class LLMProvider(BaseModel):
+    """LLM provider configuration."""
+
+    type: Literal["kimi", "openai_legacy", "_chaos"]
+    """Provider type"""
+    base_url: str
+    """API base URL"""
+    api_key: SecretStr
+    """API key"""
+
+    @field_serializer("api_key", when_used="json")
+    def dump_secret(self, v: SecretStr):
+        return v.get_secret_value()
+
+
+class LLMModel(BaseModel):
+    """LLM model configuration."""
+
+    provider: str
+    """Provider name"""
+    model: str
+    """Model name"""
+    max_context_size: int
+    """Maximum context size (unit: tokens)"""
+
+
+class LoopControl(BaseModel):
+    """Agent loop control configuration."""
+
+    max_steps_per_run: int = 100
+    """Maximum number of steps in one run"""
+    max_retries_per_step: int = 3
+    """Maximum number of retries in one step"""
+
+
+class MoonshotSearchConfig(BaseModel):
+    """Moonshot Search configuration."""
+
+    base_url: str
+    """Base URL for Moonshot Search service."""
+    api_key: SecretStr
+    """API key for Moonshot Search service."""
+
+    @field_serializer("api_key", when_used="json")
+    def dump_secret(self, v: SecretStr):
+        return v.get_secret_value()
+
+
+class Services(BaseModel):
+    """Services configuration."""
+
+    moonshot_search: MoonshotSearchConfig | None = None
+    """Moonshot Search configuration."""
+
+
+class Config(BaseModel):
+    """Main configuration structure."""
+
+    default_model: str = Field(default="", description="Default model to use")
+    models: dict[str, LLMModel] = Field(default_factory=dict, description="List of LLM models")
+    providers: dict[str, LLMProvider] = Field(
+        default_factory=dict, description="List of LLM providers"
+    )
+    loop_control: LoopControl = Field(default_factory=LoopControl, description="Agent loop control")
+    services: Services = Field(default_factory=Services, description="Services configuration")
+
+    @model_validator(mode="after")
+    def validate_model(self) -> Self:
+        if self.default_model and self.default_model not in self.models:
+            raise ValueError(f"Default model {self.default_model} not found in models")
+        for model in self.models.values():
+            if model.provider not in self.providers:
+                raise ValueError(f"Provider {model.provider} not found in providers")
+        return self
+
+
+def get_config_file() -> Path:
+    """Get the configuration file path."""
+    return get_share_dir() / "config.json"
+
+
+def get_default_config() -> Config:
+    """Get the default configuration."""
+    return Config(
+        default_model="",
+        models={},
+        providers={},
+        services=Services(),
+    )
+
+
+def load_config() -> Config:
+    """Load configuration from config file.
+
+    Returns:
+        Validated Config object.
+    """
+    config_file = get_config_file()
+    logger.debug("Loading config from file: {file}", file=config_file)
+
+    if not config_file.exists():
+        config = get_default_config()
+        logger.debug("No config file found, creating default config: {config}", config=config)
+        with open(config_file, "w", encoding="utf-8") as f:
+            f.write(config.model_dump_json(indent=2, exclude_none=True))
+        return config
+
+    try:
+        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
+
+
+class ConfigError(Exception):
+    """Configuration error."""
+
+    def __init__(self, message: str):
+        super().__init__(message)
+
+
+def save_config(config: Config):
+    """Save configuration to config file."""
+    config_file = 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/llm.py

@@ -0,0 +1,8 @@
+from typing import NamedTuple
+
+from kosong.base.chat_provider import ChatProvider
+
+
+class LLM(NamedTuple):
+    chat_provider: ChatProvider
+    max_context_size: int

kimi_cli/metadata.py

@@ -0,0 +1,117 @@
+import json
+import uuid
+from hashlib import md5
+from pathlib import Path
+from typing import NamedTuple
+
+from pydantic import BaseModel, Field
+
+from kimi_cli.share import get_share_dir
+from kimi_cli.utils.logging import logger
+
+
+def get_metadata_file() -> Path:
+    return get_share_dir() / "kimi.json"
+
+
+class WorkDirMeta(BaseModel):
+    """Metadata for a work directory."""
+
+    path: str
+    """The full path of the work directory."""
+
+    last_session_id: str | None = None
+    """Last session ID of this work directory."""
+
+    @property
+    def sessions_dir(self) -> Path:
+        path = get_share_dir() / "sessions" / md5(self.path.encode()).hexdigest()
+        path.mkdir(parents=True, exist_ok=True)
+        return path
+
+
+class Metadata(BaseModel):
+    """Kimi metadata structure."""
+
+    work_dirs: list[WorkDirMeta] = Field(default_factory=list, description="Work directory list")
+
+
+def _load_metadata() -> Metadata:
+    metadata_file = get_metadata_file()
+    logger.debug("Loading metadata from file: {file}", file=metadata_file)
+    if not metadata_file.exists():
+        logger.debug("No metadata file found, creating empty metadata")
+        return Metadata()
+    with open(metadata_file, encoding="utf-8") as f:
+        data = json.load(f)
+        return Metadata(**data)
+
+
+def _save_metadata(metadata: Metadata):
+    metadata_file = get_metadata_file()
+    logger.debug("Saving metadata to file: {file}", file=metadata_file)
+    with open(metadata_file, "w", encoding="utf-8") as f:
+        json.dump(metadata.model_dump(), f, indent=2, ensure_ascii=False)
+
+
+class Session(NamedTuple):
+    """A session of a work directory."""
+
+    id: str
+    work_dir: WorkDirMeta
+    history_file: Path
+
+
+def new_session(work_dir: Path, _history_file: Path | None = None) -> Session:
+    """Create a new session for a work directory."""
+    logger.debug("Creating new session for work directory: {work_dir}", work_dir=work_dir)
+
+    metadata = _load_metadata()
+    work_dir_meta = next((wd for wd in metadata.work_dirs if wd.path == str(work_dir)), None)
+    if work_dir_meta is None:
+        work_dir_meta = WorkDirMeta(path=str(work_dir))
+        metadata.work_dirs.append(work_dir_meta)
+
+    session_id = str(uuid.uuid4())
+    if _history_file is None:
+        history_file = work_dir_meta.sessions_dir / f"{session_id}.jsonl"
+        work_dir_meta.last_session_id = session_id
+    else:
+        logger.warning("Using provided history file: {history_file}", history_file=_history_file)
+        _history_file.parent.mkdir(parents=True, exist_ok=True)
+        if _history_file.exists():
+            assert _history_file.is_file()
+        history_file = _history_file
+
+    if history_file.exists():
+        # truncate if exists
+        logger.warning(
+            "History file already exists, truncating: {history_file}", history_file=history_file
+        )
+        history_file.unlink()
+        history_file.touch()
+
+    _save_metadata(metadata)
+    return Session(id=session_id, work_dir=work_dir_meta, history_file=history_file)
+
+
+def continue_session(work_dir: Path) -> Session | None:
+    """Get the last session for a work directory."""
+    logger.debug("Continuing session for work directory: {work_dir}", work_dir=work_dir)
+
+    metadata = _load_metadata()
+    work_dir_meta = next((wd for wd in metadata.work_dirs if wd.path == str(work_dir)), None)
+    if work_dir_meta is None:
+        logger.debug("Work directory never been used")
+        return None
+    if work_dir_meta.last_session_id is None:
+        logger.debug("Work directory never had a session")
+        return None
+
+    logger.debug(
+        "Found last session for work directory: {session_id}",
+        session_id=work_dir_meta.last_session_id,
+    )
+    session_id = work_dir_meta.last_session_id
+    history_file = work_dir_meta.sessions_dir / f"{session_id}.jsonl"
+    return Session(id=session_id, work_dir=work_dir_meta, history_file=history_file)

kimi_cli/prompts/metacmds/__init__.py

@@ -0,0 +1,4 @@
+from pathlib import Path
+
+INIT = (Path(__file__).parent / "init.md").read_text()
+COMPACT = (Path(__file__).parent / "compact.md").read_text()