klaude-code 1.2.6__py3-none-any.whl → 1.8.0__py3-none-any.whl

klaude_code/command/diff_cmd.py

@@ -1,138 +0,0 @@
-import subprocess
-from pathlib import Path
-
-from klaude_code.command.command_abc import CommandABC, CommandResult
-from klaude_code.command.registry import register_command
-from klaude_code.core.agent import Agent
-from klaude_code.protocol import commands, events, model
-
-
-@register_command
-class DiffCommand(CommandABC):
-    """Show git diff for the current repository."""
-
-    @property
-    def name(self) -> commands.CommandName:
-        return commands.CommandName.DIFF
-
-    @property
-    def summary(self) -> str:
-        return "Show git diff"
-
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
-        try:
-            # Check if current directory is in a git repository
-            git_check = subprocess.run(
-                ["git", "rev-parse", "--is-inside-work-tree"],
-                cwd=Path.cwd(),
-                capture_output=True,
-                text=True,
-                timeout=5.0,
-            )
-
-            if git_check.returncode != 0:
-                # Not in a git repository
-                event = events.DeveloperMessageEvent(
-                    session_id=agent.session.id,
-                    item=model.DeveloperMessageItem(
-                        content="No in a git repo",
-                        command_output=model.CommandOutput(command_name=self.name, is_error=True),
-                    ),
-                )
-                return CommandResult(events=[event])
-
-            # Run git diff in current directory
-            result = subprocess.run(
-                ["git", "diff", "HEAD"],
-                cwd=Path.cwd(),
-                capture_output=True,
-                text=True,
-                timeout=10.0,
-            )
-
-            if result.returncode != 0:
-                # Git command failed
-                error_msg = result.stderr.strip() or "git diff command failed"
-                event = events.DeveloperMessageEvent(
-                    session_id=agent.session.id,
-                    item=model.DeveloperMessageItem(
-                        content=f"Error: {error_msg}",
-                        command_output=model.CommandOutput(command_name=self.name, is_error=True),
-                    ),
-                )
-                return CommandResult(events=[event])
-
-            diff_output = result.stdout.strip()
-
-            # Get untracked files
-            untracked_result = subprocess.run(
-                ["git", "ls-files", "--others", "--exclude-standard"],
-                cwd=Path.cwd(),
-                capture_output=True,
-                text=True,
-                timeout=10.0,
-            )
-
-            untracked_files = untracked_result.stdout.strip()
-
-            # Combine diff output and untracked files
-            output_parts: list[str] = []
-
-            if diff_output:
-                output_parts.append(diff_output)
-
-            if untracked_files:
-                untracked_lines = untracked_files.split("\n")
-                untracked_section = "git ls-files --others --exclude-standard\n" + "\n".join(
-                    f"{file}" for file in untracked_lines
-                )
-                output_parts.append(untracked_section)
-
-            if not output_parts:
-                # No changes and no untracked files
-                event = events.DeveloperMessageEvent(
-                    session_id=agent.session.id,
-                    item=model.DeveloperMessageItem(
-                        content="", command_output=model.CommandOutput(command_name=self.name)
-                    ),
-                )
-                return CommandResult(events=[event])
-
-            # Has changes or untracked files
-            combined_output = "\n\n".join(output_parts)
-            event = events.DeveloperMessageEvent(
-                session_id=agent.session.id,
-                item=model.DeveloperMessageItem(
-                    content=combined_output,
-                    command_output=model.CommandOutput(command_name=self.name),
-                ),
-            )
-            return CommandResult(events=[event])
-
-        except subprocess.TimeoutExpired:
-            event = events.DeveloperMessageEvent(
-                session_id=agent.session.id,
-                item=model.DeveloperMessageItem(
-                    content="Error: git diff command timeout",
-                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
-                ),
-            )
-            return CommandResult(events=[event])
-        except FileNotFoundError:
-            event = events.DeveloperMessageEvent(
-                session_id=agent.session.id,
-                item=model.DeveloperMessageItem(
-                    content="Error: git command not found",
-                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
-                ),
-            )
-            return CommandResult(events=[event])
-        except Exception as e:
-            event = events.DeveloperMessageEvent(
-                session_id=agent.session.id,
-                item=model.DeveloperMessageItem(
-                    content=f"Error：{e}",
-                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
-                ),
-            )
-            return CommandResult(events=[event])

klaude_code/command/prompt-dev-docs-update.md

@@ -1,56 +0,0 @@
----
-description: Update dev documentation before context compaction
-from: https://github.com/diet103/claude-code-infrastructure-showcase/blob/main/.claude/commands/dev-docs-update.md
----
-
-We're approaching context limits. Please update the development documentation to ensure seamless continuation after context reset.
-
-## Required Updates
-
-### 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 as ✅ 
-  - 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
-
-## Additional Context:
-$ARGUMENTS
-
-**Priority**: Focus on capturing information that would be hard to rediscover or reconstruct from code alone.

klaude_code/command/prompt-dev-docs.md

@@ -1,46 +0,0 @@
----
-description: Create a comprehensive strategic plan with structured task breakdown
-from: https://github.com/diet103/claude-code-infrastructure-showcase/blob/main/.claude/commands/dev-docs.md
----
-
-Create a comprehensive, actionable plan for: 
-$ARGUMENTS
-
-## Instructions
-
-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
-   - Timeline Estimates
-
-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

klaude_code/config/list_model.py

@@ -1,162 +0,0 @@
-from rich.console import Console, Group
-from rich.panel import Panel
-from rich.table import Table
-from rich.text import Text
-
-from klaude_code.config import Config
-from klaude_code.protocol.sub_agent import iter_sub_agent_profiles
-from klaude_code.ui.rich.theme import ThemeKey, get_theme
-
-
-def mask_api_key(api_key: str | None) -> str:
-    """Mask API key to show only first 6 and last 6 characters with *** in between"""
-    if not api_key or api_key == "N/A":
-        return "N/A"
-
-    if len(api_key) <= 12:
-        return api_key
-
-    return f"{api_key[:6]} … {api_key[-6:]}"
-
-
-def display_models_and_providers(config: Config):
-    """Display models and providers configuration using rich formatting"""
-    themes = get_theme(config.theme)
-    console = Console(theme=themes.app_theme)
-
-    # Display providers section
-    providers_table = Table.grid(padding=(0, 1), expand=True)
-    providers_table.add_column(width=2, no_wrap=True)  # Status
-    providers_table.add_column(overflow="fold")  # Name
-    providers_table.add_column(overflow="fold")  # Protocol
-    providers_table.add_column(overflow="fold")  # Base URL
-    providers_table.add_column(overflow="fold")  # API Key
-
-    # Add header
-    providers_table.add_row(
-        Text("", style="bold"),
-        Text("Name", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-        Text("Protocol", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-        Text("Base URL", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-        Text("API Key", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-    )
-
-    # Add providers
-    for provider in config.provider_list:
-        status = Text("✔", style=f"bold {ThemeKey.CONFIG_STATUS_OK}")
-        name = Text(provider.provider_name, style=ThemeKey.CONFIG_ITEM_NAME)
-        protocol = Text(str(provider.protocol.value), style="")
-        base_url = Text(provider.base_url or "N/A", style="")
-        api_key = Text(mask_api_key(provider.api_key), style="")
-
-        providers_table.add_row(status, name, protocol, base_url, api_key)
-
-    # Display models section
-    models_table = Table.grid(padding=(0, 1), expand=True)
-    models_table.add_column(width=2, no_wrap=True)  # Status
-    models_table.add_column(overflow="fold", ratio=1)  # Name
-    models_table.add_column(overflow="fold", ratio=2)  # Model
-    models_table.add_column(overflow="fold", ratio=2)  # Provider
-    models_table.add_column(overflow="fold", ratio=3)  # Params
-
-    # Add header
-    models_table.add_row(
-        Text("", style="bold"),
-        Text("Name", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-        Text("Model", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-        Text("Provider", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-        Text("Params", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-    )
-
-    # Add models
-    for model in config.model_list:
-        status = Text("✔", style=f"bold {ThemeKey.CONFIG_STATUS_OK}")
-        if model.model_name == config.main_model:
-            status = Text("★", style=f"bold {ThemeKey.CONFIG_STATUS_PRIMARY}")  # Mark main model
-
-        name = Text(
-            model.model_name,
-            style=ThemeKey.CONFIG_STATUS_PRIMARY
-            if model.model_name == config.main_model
-            else ThemeKey.CONFIG_ITEM_NAME,
-        )
-        model_name = Text(model.model_params.model or "N/A", style="")
-        provider = Text(model.provider, style="")
-        params: list[Text] = []
-        if model.model_params.thinking:
-            if model.model_params.thinking.reasoning_effort is not None:
-                params.append(
-                    Text.assemble(
-                        ("reason-effort", ThemeKey.CONFIG_PARAM_LABEL),
-                        ": ",
-                        model.model_params.thinking.reasoning_effort,
-                    )
-                )
-            if model.model_params.thinking.reasoning_summary is not None:
-                params.append(
-                    Text.assemble(
-                        ("reason-summary", ThemeKey.CONFIG_PARAM_LABEL),
-                        ": ",
-                        model.model_params.thinking.reasoning_summary,
-                    )
-                )
-            if model.model_params.thinking.budget_tokens is not None:
-                params.append(
-                    Text.assemble(
-                        ("thinking-budget-tokens", ThemeKey.CONFIG_PARAM_LABEL),
-                        ": ",
-                        str(model.model_params.thinking.budget_tokens),
-                    )
-                )
-        if model.model_params.provider_routing:
-            params.append(
-                Text.assemble(
-                    ("provider-routing", ThemeKey.CONFIG_PARAM_LABEL),
-                    ": ",
-                    model.model_params.provider_routing.model_dump_json(exclude_none=True),
-                )
-            )
-        if len(params) == 0:
-            params.append(Text("N/A", style=ThemeKey.CONFIG_PARAM_LABEL))
-        models_table.add_row(status, name, model_name, provider, Group(*params))
-
-    # Create panels and display
-    providers_panel = Panel(
-        providers_table,
-        title=Text("Providers Configuration", style="white bold"),
-        border_style=ThemeKey.CONFIG_PANEL_BORDER,
-        padding=(0, 1),
-        title_align="left",
-    )
-
-    models_panel = Panel(
-        models_table,
-        title=Text("Models Configuration", style="white bold"),
-        border_style=ThemeKey.CONFIG_PANEL_BORDER,
-        padding=(0, 1),
-        title_align="left",
-    )
-
-    console.print(providers_panel)
-    console.print()
-    console.print(models_panel)
-
-    # Display main model info
-    console.print()
-    console.print(
-        Text.assemble(
-            ("Default Model: ", "bold"),
-            (config.main_model, ThemeKey.CONFIG_STATUS_PRIMARY),
-        )
-    )
-
-    for profile in iter_sub_agent_profiles():
-        sub_model_name = config.subagent_models.get(profile.name)
-        if not sub_model_name:
-            continue
-        console.print(
-            Text.assemble(
-                (f"{profile.name} Model: ", "bold"),
-                (sub_model_name, ThemeKey.CONFIG_STATUS_PRIMARY),
-            )
-        )

klaude_code/core/manager/agent_manager.py

@@ -1,127 +0,0 @@
-"""Agent and session manager.
-
-This module contains :class:`AgentManager`, a helper responsible for
-creating and tracking agents per session, applying model changes, and
-clearing conversations. It is used by the executor context to keep
-agent-related responsibilities separate from operation dispatch.
-"""
-
-from __future__ import annotations
-
-import asyncio
-
-from klaude_code.config import load_config
-from klaude_code.core.agent import Agent, DefaultModelProfileProvider, ModelProfileProvider
-from klaude_code.core.manager.llm_clients import LLMClients
-from klaude_code.llm.registry import create_llm_client
-from klaude_code.protocol import commands, events, model
-from klaude_code.session.session import Session
-from klaude_code.trace import DebugType, log_debug
-
-
-class AgentManager:
-    """Manager component that tracks agents and their sessions."""
-
-    def __init__(
-        self,
-        event_queue: asyncio.Queue[events.Event],
-        llm_clients: LLMClients,
-        model_profile_provider: ModelProfileProvider | None = None,
-    ) -> None:
-        self._event_queue: asyncio.Queue[events.Event] = event_queue
-        self._llm_clients: LLMClients = llm_clients
-        self._model_profile_provider: ModelProfileProvider = model_profile_provider or DefaultModelProfileProvider()
-        self._active_agents: dict[str, Agent] = {}
-
-    async def emit_event(self, event: events.Event) -> None:
-        """Emit an event to the shared event queue."""
-
-        await self._event_queue.put(event)
-
-    async def ensure_agent(self, session_id: str) -> Agent:
-        """Return an existing agent for the session or create a new one."""
-
-        agent = self._active_agents.get(session_id)
-        if agent is not None:
-            return agent
-
-        session = Session.load(session_id)
-        profile = self._model_profile_provider.build_profile(self._llm_clients.main)
-        agent = Agent(session=session, profile=profile)
-
-        async for evt in agent.replay_history():
-            await self.emit_event(evt)
-
-        await self.emit_event(
-            events.WelcomeEvent(
-                work_dir=str(session.work_dir),
-                llm_config=self._llm_clients.main.get_llm_config(),
-            )
-        )
-
-        self._active_agents[session_id] = agent
-        log_debug(
-            f"Initialized agent for session: {session_id}",
-            style="cyan",
-            debug_type=DebugType.EXECUTION,
-        )
-        return agent
-
-    async def apply_model_change(self, agent: Agent, model_name: str) -> None:
-        """Change the model used by an agent and notify the UI."""
-
-        config = load_config()
-        if config is None:
-            raise ValueError("Configuration must be initialized before changing model")
-
-        llm_config = config.get_model_config(model_name)
-        llm_client = create_llm_client(llm_config)
-        agent.set_model_profile(self._model_profile_provider.build_profile(llm_client))
-
-        developer_item = model.DeveloperMessageItem(
-            content=f"switched to model: {model_name}",
-            command_output=model.CommandOutput(command_name=commands.CommandName.MODEL),
-        )
-        agent.session.append_history([developer_item])
-
-        await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
-        await self.emit_event(events.WelcomeEvent(llm_config=llm_config, work_dir=str(agent.session.work_dir)))
-
-    async def apply_clear(self, agent: Agent) -> None:
-        """Start a new conversation for an agent and notify the UI."""
-
-        old_session_id = agent.session.id
-
-        # Create a new session instance to replace the current one
-        new_session = Session(work_dir=agent.session.work_dir)
-        new_session.model_name = agent.session.model_name
-
-        # Replace the agent's session with the new one
-        agent.session = new_session
-        agent.session.save()
-
-        # Update the active_agents mapping
-        self._active_agents.pop(old_session_id, None)
-        self._active_agents[new_session.id] = agent
-
-        developer_item = model.DeveloperMessageItem(
-            content="started new conversation",
-            command_output=model.CommandOutput(command_name=commands.CommandName.CLEAR),
-        )
-
-        await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
-
-    def get_active_agent(self, session_id: str) -> Agent | None:
-        """Return the active agent for a session id if present."""
-
-        return self._active_agents.get(session_id)
-
-    def active_session_ids(self) -> list[str]:
-        """Return a snapshot list of session ids that currently have agents."""
-
-        return list(self._active_agents.keys())
-
-    def all_active_agents(self) -> dict[str, Agent]:
-        """Return a snapshot of all active agents keyed by session id."""
-
-        return dict(self._active_agents)

klaude_code/core/prompts/prompt-subagent-webfetch.md

@@ -1,46 +0,0 @@
-You are a web content fetching and analysis specialist. Your job is to retrieve content from URLs and extract or analyze information according to the user's instructions.
-
-Your available tools:
-- WebFetch: Fetch content from a URL. HTML pages are automatically converted to Markdown.
-- Read: Read files from the filesystem (useful when WebFetch output is truncated and saved to a file)
-- Bash: Run shell commands (use `rg` to search through large saved files)
-
-Workflow:
-1. Use WebFetch to retrieve the URL content
-2. Analyze the content according to the user's prompt
-3. If the output was truncated and saved to a file, use Read or `rg` to search through the full content
-4. If you need information from a linked page, use WebFetch to follow that link
-5. Return a clear, structured summary of your findings
-
-Guidelines:
-- Focus on extracting the specific information requested
-- For large pages, prioritize the most relevant sections
-- If content is truncated, look for the saved file path in the system reminder and use rg to search it
-- Return structured data when appropriate (lists, tables, key-value pairs)
-- Be concise but comprehensive in your final response
-- Use absolute file paths when referencing saved files
-- Avoid using emojis
-
-Following links:
-- If a link on the page seems relevant to answering the question, use WebFetch to follow it
-- You can fetch multiple pages in sequence to gather all needed information
-- After fetching a link, analyze the content yourself to extract what's needed
-- Remember to include any fetched URLs in your Sources section if they were helpful
-
-Handling truncated content:
-When WebFetch output is too large, it will be truncated and the full content saved to a temporary file.
-The file path will be shown in a system-reminder tag. Use these approaches to access the full content:
-- `rg "pattern" /path/to/file` to search for specific content
-- Read tool with offset/limit to read specific sections
-
-Response format:
-Your response should be structured as follows:
-
-[Your answer to the user's question]
-
-## Sources
-- [URL 1] (saved to local: /path/to/file if saved)
-- [URL 2]
-...
-
-Only include URLs that actually contributed information to your answer. The main URL is always included. Add any additional URLs you fetched that provided relevant information.

klaude_code/core/tool/file/multi_edit_tool.md

@@ -1,42 +0,0 @@
-This is a tool for making multiple edits to a single file in one operation. It is built on top of the Edit tool and allows you to perform multiple find-and-replace operations efficiently. Prefer this tool over the Edit tool when you need to make multiple edits to the same file.
-
-Before using this tool:
-
-1. Use the Read tool to understand the file's contents and context
-2. Verify the directory path is correct
-
-To make multiple file edits, provide the following:
-1. file_path: The absolute path to the file to modify (must be absolute, not relative)
-2. edits: An array of edit operations to perform, where each edit contains:
-   - old_string: The text to replace (must match the file contents exactly, including all whitespace and indentation)
-   - new_string: The edited text to replace the old_string
-   - replace_all: Replace all occurences of old_string. This parameter is optional and defaults to false.
-
-IMPORTANT:
-- All edits are applied in sequence, in the order they are provided
-- Each edit operates on the result of the previous edit
-- All edits must be valid for the operation to succeed - if any edit fails, none will be applied
-- This tool is ideal when you need to make several changes to different parts of the same file
-- For Jupyter notebooks (.ipynb files), use the NotebookEdit instead
-
-CRITICAL REQUIREMENTS:
-1. All edits follow the same requirements as the single Edit tool
-2. The edits are atomic - either all succeed or none are applied
-3. Plan your edits carefully to avoid conflicts between sequential operations
-
-WARNING:
-- The tool will fail if edits.old_string doesn't match the file contents exactly (including whitespace)
-- The tool will fail if edits.old_string and edits.new_string are the same
-- Since edits are applied in sequence, ensure that earlier edits don't affect the text that later edits are trying to find
-
-When making edits:
-- Ensure all edits result in idiomatic, correct code
-- Do not leave the code in a broken state
-- Always use absolute file paths (starting with /)
-- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
-- Use replace_all for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.
-
-If you want to create a new file, use:
-- A new file path, including dir name if needed
-- First edit: empty old_string and the new file's contents as new_string
-- Subsequent edits: normal edit operations on the created content