klaude-code 2.0.2__py3-none-any.whl → 2.1.1__py3-none-any.whl

klaude_code/core/tool/skill/skill_tool.py

@@ -1,87 +0,0 @@
-"""SkillTool - Tool for agent to activate and load skills."""
-
-from pathlib import Path
-
-from pydantic import BaseModel
-
-from klaude_code.core.tool.tool_abc import ToolABC, load_desc
-from klaude_code.core.tool.tool_registry import register
-from klaude_code.protocol import llm_param, message, tools
-from klaude_code.skill import get_available_skills, get_skill, list_skill_names
-
-
-@register(tools.SKILL)
-class SkillTool(ToolABC):
-    """Tool to execute/load a skill within the main conversation."""
-
-    @classmethod
-    def schema(cls) -> llm_param.ToolSchema:
-        """Generate schema with embedded available skills metadata."""
-        skills_xml = cls._generate_skills_xml()
-
-        return llm_param.ToolSchema(
-            name=tools.SKILL,
-            type="function",
-            description=load_desc(Path(__file__).parent / "skill_tool.md", {"skills_xml": skills_xml}),
-            parameters={
-                "type": "object",
-                "properties": {
-                    "command": {
-                        "type": "string",
-                        "description": "Name of the skill to execute",
-                    }
-                },
-                "required": ["command"],
-            },
-        )
-
-    @classmethod
-    def _generate_skills_xml(cls) -> str:
-        """Generate XML format skills metadata."""
-        skills = get_available_skills()
-        if not skills:
-            return ""
-
-        xml_parts: list[str] = []
-        for name, description, location in skills:
-            xml_parts.append(f"""<skill>
-<name>{name}</name>
-<description>{description}</description>
-<location>{location}</location>
-</skill>""")
-        return "\n".join(xml_parts)
-
-    class SkillArguments(BaseModel):
-        command: str
-
-    @classmethod
-    async def call(cls, arguments: str) -> message.ToolResultMessage:
-        """Load and return full skill content."""
-        try:
-            args = cls.SkillArguments.model_validate_json(arguments)
-        except ValueError as e:
-            return message.ToolResultMessage(
-                status="error",
-                output_text=f"Invalid arguments: {e}",
-            )
-
-        skill = get_skill(args.command)
-
-        if not skill:
-            available = ", ".join(list_skill_names())
-            return message.ToolResultMessage(
-                status="error",
-                output_text=f"Skill '{args.command}' does not exist. Available skills: {available}",
-            )
-
-        # Get base directory from skill_path
-        base_dir = str(skill.skill_path.parent) if skill.skill_path else "unknown"
-
-        # Return with loading message format
-        result = f"""<command-message>The "{skill.name}" skill is activated</command-message>
-<command-name>{skill.name}</command-name>
-
-Base directory for this skill: {base_dir}
-
-{skill.to_prompt()}"""
-        return message.ToolResultMessage(status="success", output_text=result)

klaude_code/core/tool/tool_context.py

@@ -1,148 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Awaitable, Callable, Generator, MutableMapping
-from contextlib import contextmanager
-from contextvars import ContextVar, Token
-from dataclasses import dataclass
-
-from klaude_code.protocol import model
-from klaude_code.protocol.sub_agent import SubAgentResult
-from klaude_code.session.session import Session
-
-type FileTracker = MutableMapping[str, model.FileStatus]
-
-
-@dataclass
-class TodoContext:
-    """Todo access interface exposed to tools.
-
-    Tools can only read the current todo list and replace it with
-    a new list; they cannot access the full Session object.
-    """
-
-    get_todos: Callable[[], list[model.TodoItem]]
-    set_todos: Callable[[list[model.TodoItem]], None]
-
-
-@dataclass
-class SessionTodoStore:
-    """Adapter exposing session todos through an explicit interface."""
-
-    session: Session
-
-    def get(self) -> list[model.TodoItem]:
-        return self.session.todos
-
-    def set(self, todos: list[model.TodoItem]) -> None:
-        self.session.todos = todos
-
-
-@dataclass
-class ToolContextToken:
-    """Tokens used to restore tool execution context.
-
-    This captures the contextvar tokens for the current file tracker
-    and todo context so callers can safely reset them after a tool
-    finishes running.
-    """
-
-    file_tracker_token: Token[FileTracker | None] | None
-    todo_token: Token[TodoContext | None] | None
-
-
-# Holds the current file tracker mapping for tool execution context.
-# Set by Agent/Reminder right before invoking a tool.
-current_file_tracker_var: ContextVar[FileTracker | None] = ContextVar("current_file_tracker", default=None)
-
-
-# Holds the todo access context for tools.
-current_todo_context_var: ContextVar[TodoContext | None] = ContextVar("current_todo_context", default=None)
-
-
-def set_tool_context_from_session(session: Session) -> ToolContextToken:
-    """Bind the given session's file tracker and todos into tool context.
-
-    This should be called by the Agent or reminder helpers immediately
-    before invoking tools so that file and todo tools can operate on
-    the correct per-session state without seeing the full Session.
-    """
-
-    file_tracker_token = current_file_tracker_var.set(session.file_tracker)
-    todo_ctx = build_todo_context(session)
-    todo_token = current_todo_context_var.set(todo_ctx)
-    return ToolContextToken(file_tracker_token=file_tracker_token, todo_token=todo_token)
-
-
-def reset_tool_context(token: ToolContextToken) -> None:
-    """Restore tool execution context from a previously captured token."""
-
-    if token.file_tracker_token is not None:
-        current_file_tracker_var.reset(token.file_tracker_token)
-    if token.todo_token is not None:
-        current_todo_context_var.reset(token.todo_token)
-
-
-@contextmanager
-def tool_context(file_tracker: FileTracker, todo_ctx: TodoContext) -> Generator[ToolContextToken]:
-    """Context manager for setting and resetting tool execution context."""
-
-    file_tracker_token = current_file_tracker_var.set(file_tracker)
-    todo_token = current_todo_context_var.set(todo_ctx)
-    token = ToolContextToken(file_tracker_token=file_tracker_token, todo_token=todo_token)
-    try:
-        yield token
-    finally:
-        reset_tool_context(token)
-
-
-def build_todo_context(session: Session) -> TodoContext:
-    """Create a TodoContext backed by the given session."""
-
-    store = SessionTodoStore(session)
-    return TodoContext(get_todos=store.get, set_todos=store.set)
-
-
-def get_current_file_tracker() -> FileTracker | None:
-    """Return the current file tracker mapping for this tool context."""
-
-    return current_file_tracker_var.get()
-
-
-def get_current_todo_context() -> TodoContext | None:
-    """Return the current todo access context for this tool context."""
-
-    return current_todo_context_var.get()
-
-
-# Holds a handle to run a nested subtask (sub-agent) from within a tool call.
-# The callable takes a model.SubAgentState and returns a SubAgentResult.
-current_run_subtask_callback: ContextVar[Callable[[model.SubAgentState], Awaitable[SubAgentResult]] | None] = (
-    ContextVar("current_run_subtask_callback", default=None)
-)
-
-
-# Allows sub-agent execution to record the created/used session id for the currently
-# executing tool call (used by ToolExecutor.cancel() to include session_id in UIExtra).
-current_sub_agent_session_id_recorder: ContextVar[Callable[[str], None] | None] = ContextVar(
-    "current_sub_agent_session_id_recorder",
-    default=None,
-)
-
-
-def record_sub_agent_session_id(session_id: str) -> None:
-    """Record the sub-agent session id for the current tool call, if supported."""
-
-    recorder = current_sub_agent_session_id_recorder.get()
-    if recorder is None:
-        return
-    recorder(session_id)
-
-
-# Tracks sub-agent resume claims for the current turn.
-#
-# This is used to reject multiple sub-agent tool calls in the same LLM response
-# that attempt to resume the same agent ID.
-current_sub_agent_resume_claims: ContextVar[set[str] | None] = ContextVar(
-    "current_sub_agent_resume_claims",
-    default=None,
-)

klaude_code/protocol/events.py

@@ -1,195 +0,0 @@
-from typing import Literal
-
-from pydantic import BaseModel
-
-from klaude_code.protocol import llm_param, message, model
-
-"""
-Event is how Agent Executor and UI Display communicate.
-"""
-
-
-class EndEvent(BaseModel):
-    pass
-
-
-class ErrorEvent(BaseModel):
-    error_message: str
-    can_retry: bool = False
-    session_id: str | None = None
-
-
-class TaskStartEvent(BaseModel):
-    session_id: str
-    sub_agent_state: model.SubAgentState | None = None
-
-
-class TaskFinishEvent(BaseModel):
-    session_id: str
-    task_result: str
-    has_structured_output: bool = False
-
-
-class TurnStartEvent(BaseModel):
-    """For now, this event is used for UI to flush developer message buffer and print an empty line"""
-
-    session_id: str
-
-
-class TurnEndEvent(BaseModel):
-    session_id: str
-
-
-class TurnToolCallStartEvent(BaseModel):
-    """For UI changing status text"""
-
-    session_id: str
-    response_id: str | None = None
-    tool_call_id: str
-    tool_name: str
-    arguments: str
-
-
-class ThinkingDeltaEvent(BaseModel):
-    session_id: str
-    response_id: str | None = None
-    content: str
-
-
-class AssistantTextDeltaEvent(BaseModel):
-    session_id: str
-    response_id: str | None = None
-    content: str
-
-
-class AssistantImageDeltaEvent(BaseModel):
-    session_id: str
-    response_id: str | None = None
-    file_path: str
-
-
-class AssistantMessageEvent(BaseModel):
-    response_id: str | None = None
-    session_id: str
-    content: str
-    thinking_text: str | None = None
-
-
-class DeveloperMessageEvent(BaseModel):
-    """DeveloperMessages are reminders in user messages or tool results, see: core/reminders.py"""
-
-    session_id: str
-    item: message.DeveloperMessage
-
-
-class ToolCallEvent(BaseModel):
-    session_id: str
-    response_id: str | None = None
-    tool_call_id: str
-    tool_name: str
-    arguments: str
-
-
-class ToolResultEvent(BaseModel):
-    session_id: str
-    response_id: str | None = None
-    tool_call_id: str
-    tool_name: str
-    result: str
-    ui_extra: model.ToolResultUIExtra | None = None
-    status: Literal["success", "error"]
-    task_metadata: model.TaskMetadata | None = None  # Sub-agent task metadata
-    # Whether this tool result is the last one emitted in the current turn.
-    # Used by UI renderers to close tree-style prefixes.
-    is_last_in_turn: bool = True
-
-
-class ResponseMetadataEvent(BaseModel):
-    """Internal event for turn-level metadata. Not exposed to UI directly."""
-
-    session_id: str
-    metadata: model.Usage
-
-
-class TaskMetadataEvent(BaseModel):
-    """Task-level aggregated metadata for UI display."""
-
-    session_id: str
-    metadata: model.TaskMetadataItem
-
-
-class UserMessageEvent(BaseModel):
-    session_id: str
-    content: str
-    images: list[message.ImageURLPart] | None = None
-
-
-class WelcomeEvent(BaseModel):
-    work_dir: str
-    llm_config: llm_param.LLMConfigParameter
-    show_klaude_code_info: bool = True
-
-
-class InterruptEvent(BaseModel):
-    session_id: str
-
-
-class TodoChangeEvent(BaseModel):
-    session_id: str
-    todos: list[model.TodoItem]
-
-
-class ContextUsageEvent(BaseModel):
-    """Real-time context usage update during task execution."""
-
-    session_id: str
-    context_percent: float  # Context usage percentage (0-100)
-
-
-HistoryItemEvent = (
-    TaskStartEvent
-    | TaskFinishEvent
-    | TurnStartEvent  # This event is used for UI to print new empty line
-    | AssistantImageDeltaEvent
-    | AssistantMessageEvent
-    | ToolCallEvent
-    | ToolResultEvent
-    | UserMessageEvent
-    | TaskMetadataEvent
-    | InterruptEvent
-    | DeveloperMessageEvent
-    | ErrorEvent
-)
-
-
-class ReplayHistoryEvent(BaseModel):
-    session_id: str
-    events: list[HistoryItemEvent]
-    updated_at: float
-    is_load: bool = True
-
-
-Event = (
-    TaskStartEvent
-    | TaskFinishEvent
-    | ThinkingDeltaEvent
-    | AssistantTextDeltaEvent
-    | AssistantImageDeltaEvent
-    | AssistantMessageEvent
-    | ToolCallEvent
-    | ToolResultEvent
-    | ResponseMetadataEvent
-    | TaskMetadataEvent
-    | ReplayHistoryEvent
-    | ErrorEvent
-    | EndEvent
-    | WelcomeEvent
-    | UserMessageEvent
-    | InterruptEvent
-    | DeveloperMessageEvent
-    | TodoChangeEvent
-    | TurnStartEvent
-    | TurnEndEvent
-    | TurnToolCallStartEvent
-    | ContextUsageEvent
-)

klaude_code/skill/assets/dev-docs/SKILL.md

@@ -1,108 +0,0 @@
----
-name: dev-docs
-description: Manage development documentation for complex tasks. Use this skill when users want to create a strategic plan with structured task breakdown, or update development documentation before context compaction/reset. Triggers include "create a plan", "dev docs", "update docs before context reset", "context limit approaching".
-metadata:
-  short-description: Create and update development documentation
----
-
-# Dev Docs
-
-Manage development documentation for complex, multi-phase tasks. This skill supports two workflows:
-1. **Create**: Generate a comprehensive strategic plan with structured task breakdown
-2. **Update**: Update documentation before context compaction or reset
-
-## Create Development Plan
-
-When creating a new plan:
-
-1. **Analyze the request** and determine the scope of planning needed
-2. **Examine relevant files** in the codebase to understand current state
-3. **Create a structured plan** with:
-   - Executive Summary
-   - Current State Analysis
-   - Proposed Future State
-   - Implementation Phases (broken into sections)
-   - Detailed Tasks (actionable items with clear acceptance criteria)
-   - Risk Assessment and Mitigation Strategies
-   - Success Metrics
-   - Required Resources and Dependencies
-
-4. **Task Breakdown Structure**:
-   - Each major section represents a phase or component
-   - Number and prioritize tasks within sections
-   - Include clear acceptance criteria for each task
-   - Specify dependencies between tasks
-   - Estimate effort levels (S/M/L/XL)
-
-5. **Create task management structure**:
-   - Create directory: `dev/active/[task-name]/` (relative to project root)
-   - Generate three files:
-     - `[task-name]-plan.md` - The comprehensive plan
-     - `[task-name]-context.md` - Key files, decisions, dependencies
-     - `[task-name]-tasks.md` - Checklist format for tracking progress
-   - Include "Last Updated: YYYY-MM-DD" in each file
-
-6. **Stop and Consult**: Pause and negotiate the plan with the user.
-
-### Quality Standards
-
-- Plans must be self-contained with all necessary context
-- Use clear, actionable language
-- Include specific technical details where relevant
-- Consider both technical and business perspectives
-- Account for potential risks and edge cases
-
-## Update Development Documentation
-
-When approaching context limits or before context reset:
-
-### 1. Update Active Task Documentation
-
-For each task in `/dev/active/`:
-
-Update `[task-name]-context.md` with:
-- Current implementation state
-- Key decisions made this session
-- Files modified and why
-- Any blockers or issues discovered
-- Next immediate steps
-- Last Updated timestamp
-
-Update `[task-name]-tasks.md` with:
-- Mark completed tasks with checkmark
-- Add any new tasks discovered
-- Update in-progress tasks with current status
-- Reorder priorities if needed
-
-### 2. Capture Session Context
-
-Include any relevant information about:
-- Complex problems solved
-- Architectural decisions made
-- Tricky bugs found and fixed
-- Integration points discovered
-- Testing approaches used
-- Performance optimizations made
-
-### 3. Update Memory (if applicable)
-
-- Store any new patterns or solutions in project memory/documentation
-- Update entity relationships discovered
-- Add observations about system behavior
-
-### 4. Document Unfinished Work
-
-- What was being worked on when context limit approached
-- Exact state of any partially completed features
-- Commands that need to be run on restart
-- Any temporary workarounds that need permanent fixes
-
-### 5. Create Handoff Notes
-
-If switching to a new conversation:
-- Exact file and line being edited
-- The goal of current changes
-- Any uncommitted changes that need attention
-- Test commands to verify work
-
-**Priority**: Focus on capturing information that would be hard to rediscover or reconstruct from code alone.

klaude_code/trace/__init__.py

@@ -1,21 +0,0 @@
-from .log import (
-    DebugType,
-    get_current_log_file,
-    is_debug_enabled,
-    log,
-    log_debug,
-    logger,
-    prepare_debug_log_file,
-    set_debug_logging,
-)
-
-__all__ = [
-    "DebugType",
-    "get_current_log_file",
-    "is_debug_enabled",
-    "log",
-    "log_debug",
-    "logger",
-    "prepare_debug_log_file",
-    "set_debug_logging",
-]

klaude_code/ui/core/stage_manager.py

@@ -1,48 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Awaitable, Callable
-from enum import Enum
-
-
-class Stage(Enum):
-    WAITING = "waiting"
-    THINKING = "thinking"
-    ASSISTANT = "assistant"
-    TOOL_CALL = "tool_call"
-    TOOL_RESULT = "tool_result"
-
-
-class StageManager:
-    """Manage display stage transitions and invoke lifecycle callbacks."""
-
-    def __init__(
-        self,
-        *,
-        finish_assistant: Callable[[], Awaitable[None]],
-        finish_thinking: Callable[[], Awaitable[None]],
-    ):
-        self._stage = Stage.WAITING
-        self._finish_assistant = finish_assistant
-        self._finish_thinking = finish_thinking
-
-    @property
-    def current_stage(self) -> Stage:
-        return self._stage
-
-    async def transition_to(self, new_stage: Stage) -> None:
-        if self._stage == new_stage:
-            return
-        await self._leave_current_stage()
-        self._stage = new_stage
-
-    async def enter_thinking_stage(self) -> None:
-        if self._stage == Stage.THINKING:
-            return
-        await self.transition_to(Stage.THINKING)
-
-    async def _leave_current_stage(self) -> None:
-        if self._stage == Stage.THINKING:
-            await self._finish_thinking()
-        elif self._stage == Stage.ASSISTANT:
-            await self._finish_assistant()
-        self._stage = Stage.WAITING

klaude_code/ui/modes/__init__.py

@@ -1 +0,0 @@
-# UI mode implementations

klaude_code/ui/modes/debug/__init__.py

@@ -1 +0,0 @@
-# Debug mode

klaude_code/ui/modes/exec/__init__.py

@@ -1 +0,0 @@
-# Exec mode

klaude_code/ui/modes/repl/display.py

@@ -1,61 +0,0 @@
-from __future__ import annotations
-
-import contextlib
-from typing import override
-
-from klaude_code.protocol import events
-from klaude_code.ui.core.display import DisplayABC
-from klaude_code.ui.modes.repl.event_handler import DisplayEventHandler
-from klaude_code.ui.modes.repl.renderer import REPLRenderer
-from klaude_code.ui.terminal.notifier import TerminalNotifier
-
-
-class REPLDisplay(DisplayABC):
-    """
-    Interactive terminal display using Rich for rendering.
-
-    REPLDisplay provides a full-featured terminal UI with:
-    - Rich markdown rendering for assistant messages
-    - Syntax-highlighted code blocks and diffs
-    - Animated spinners for in-progress operations
-    - Tool call and result visualization
-    - OSC94 error indicator (for supported terminals)
-    - Desktop notifications on task completion
-
-    This is the primary display mode for interactive klaude-code sessions.
-    For non-interactive use, see ExecDisplay. For debugging, wrap with
-    DebugEventDisplay.
-
-    Lifecycle:
-        1. start(): No-op (initialization happens in __init__)
-        2. consume_event(): Delegates to DisplayEventHandler for event processing
-        3. stop(): Stops the event handler and ensures spinner is cleaned up
-
-    Attributes:
-        renderer: The REPLRenderer instance for terminal output
-        notifier: TerminalNotifier for desktop notifications
-        event_handler: DisplayEventHandler that processes events
-    """
-
-    def __init__(self, theme: str | None = None, notifier: TerminalNotifier | None = None):
-        self.renderer = REPLRenderer(theme)
-        self.notifier = notifier or TerminalNotifier()
-        self.event_handler = DisplayEventHandler(self.renderer, notifier=self.notifier)
-
-    @override
-    async def consume_event(self, event: events.Event) -> None:
-        await self.event_handler.consume_event(event)
-
-    @override
-    async def start(self) -> None:
-        pass
-
-    @override
-    async def stop(self) -> None:
-        await self.event_handler.stop()
-        # Ensure any active spinner is stopped so Rich restores the cursor.
-        # Spinner may already be stopped or not started; ignore.
-        with contextlib.suppress(Exception):
-            self.renderer.spinner_stop()
-        with contextlib.suppress(Exception):
-            self.renderer.stop_bottom_live()