klaude-code 1.2.6__py3-none-any.whl

klaude_code/cli/session_cmd.py

@@ -0,0 +1,80 @@
+import time
+
+import typer
+
+from klaude_code.session import Session
+from klaude_code.trace import log
+
+
+def _session_confirm(sessions: list[Session.SessionMetaBrief], message: str) -> bool:
+    """Show session list and confirm deletion using questionary."""
+    import questionary
+
+    def _fmt(ts: float) -> str:
+        try:
+            return time.strftime("%m-%d %H:%M:%S", time.localtime(ts))
+        except Exception:
+            return str(ts)
+
+    log(f"Sessions to delete ({len(sessions)}):")
+    for s in sessions:
+        msg_count_display = "N/A" if s.messages_count == -1 else str(s.messages_count)
+        first_msg = (s.first_user_message or "").strip().replace("\n", " ")[:50]
+        if len(s.first_user_message or "") > 50:
+            first_msg += "..."
+        log(f"  {_fmt(s.updated_at)}  {msg_count_display:>3} msgs  {first_msg}")
+
+    return (
+        questionary.confirm(
+            message,
+            default=False,
+            style=questionary.Style([("question", "bold")]),
+        ).ask()
+        or False
+    )
+
+
+def session_clean(
+    min_messages: int = typer.Option(5, "--min", "-n", help="Minimum messages to keep a session"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
+) -> None:
+    """Remove sessions with fewer than N messages (default: 5)"""
+    sessions = Session.list_sessions()
+    to_delete = [s for s in sessions if 0 <= s.messages_count < min_messages]
+
+    if not to_delete:
+        log(f"No sessions with fewer than {min_messages} messages found.")
+        return
+
+    if not yes:
+        if not _session_confirm(to_delete, "Delete these sessions?"):
+            log("Aborted.")
+            return
+
+    deleted = Session.clean_small_sessions(min_messages)
+    log(f"Deleted {deleted} session(s).")
+
+
+def session_clean_all(
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
+) -> None:
+    """Remove all sessions for the current project"""
+    sessions = Session.list_sessions()
+
+    if not sessions:
+        log("No sessions found.")
+        return
+
+    if not yes:
+        if not _session_confirm(sessions, "Delete ALL sessions? This cannot be undone."):
+            log("Aborted.")
+            return
+
+    deleted = Session.clean_all_sessions()
+    log(f"Deleted {deleted} session(s).")
+
+
+def register_session_commands(session_app: typer.Typer) -> None:
+    """Register session subcommands to the given Typer app."""
+    session_app.command("clean")(session_clean)
+    session_app.command("clean-all")(session_clean_all)

klaude_code/command/__init__.py

@@ -0,0 +1,43 @@
+from .clear_cmd import ClearCommand
+from .command_abc import CommandABC, CommandResult, InputAction, InputActionType
+from .diff_cmd import DiffCommand
+from .export_cmd import ExportCommand
+from .help_cmd import HelpCommand
+
+# InitCommand is now dynamically loaded via prompt_init.md
+# from .init_cmd import InitCommand
+from .model_cmd import ModelCommand
+from .refresh_cmd import RefreshTerminalCommand
+from .registry import (
+    dispatch_command,
+    get_commands,
+    has_interactive_command,
+    is_slash_command_name,
+    load_prompt_commands,
+    register_command,
+)
+from .status_cmd import StatusCommand
+from .terminal_setup_cmd import TerminalSetupCommand
+
+# Dynamically load prompt commands
+load_prompt_commands()
+
+__all__ = [
+    "ClearCommand",
+    "DiffCommand",
+    "HelpCommand",
+    "ModelCommand",
+    "ExportCommand",
+    "RefreshTerminalCommand",
+    "StatusCommand",
+    "TerminalSetupCommand",
+    "register_command",
+    "CommandABC",
+    "CommandResult",
+    "InputAction",
+    "InputActionType",
+    "dispatch_command",
+    "get_commands",
+    "is_slash_command_name",
+    "has_interactive_command",
+]

klaude_code/command/clear_cmd.py

@@ -0,0 +1,20 @@
+from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
+from klaude_code.command.registry import register_command
+from klaude_code.core.agent import Agent
+from klaude_code.protocol import commands
+
+
+@register_command
+class ClearCommand(CommandABC):
+    """Clear current session and start a new conversation"""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.CLEAR
+
+    @property
+    def summary(self) -> str:
+        return "Clear conversation history and free up context"
+
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
+        return CommandResult(actions=[InputAction.clear()])

klaude_code/command/command_abc.py

@@ -0,0 +1,92 @@
+from abc import ABC, abstractmethod
+from enum import Enum
+
+from pydantic import BaseModel
+
+from klaude_code.core.agent import Agent
+from klaude_code.protocol import commands
+from klaude_code.protocol import events as protocol_events
+
+
+class InputActionType(str, Enum):
+    """Supported input action kinds."""
+
+    RUN_AGENT = "run_agent"
+    CHANGE_MODEL = "change_model"
+    CLEAR = "clear"
+
+
+class InputAction(BaseModel):
+    """Structured executor action derived from a user input."""
+
+    type: InputActionType
+    text: str = ""
+    model_name: str | None = None
+
+    @classmethod
+    def run_agent(cls, text: str) -> "InputAction":
+        """Create a RunAgent action preserving the provided text."""
+
+        return cls(type=InputActionType.RUN_AGENT, text=text)
+
+    @classmethod
+    def change_model(cls, model_name: str) -> "InputAction":
+        """Create a ChangeModel action for the provided model name."""
+
+        return cls(type=InputActionType.CHANGE_MODEL, model_name=model_name)
+
+    @classmethod
+    def clear(cls) -> "InputAction":
+        """Create a Clear action to reset the session."""
+
+        return cls(type=InputActionType.CLEAR)
+
+
+class CommandResult(BaseModel):
+    """Result of a command execution."""
+
+    events: (
+        list[protocol_events.DeveloperMessageEvent | protocol_events.WelcomeEvent | protocol_events.ReplayHistoryEvent]
+        | None
+    ) = None  # List of UI events to display immediately
+    actions: list[InputAction] | None = None
+
+
+class CommandABC(ABC):
+    """Abstract base class for slash commands."""
+
+    @property
+    @abstractmethod
+    def name(self) -> commands.CommandName | str:
+        """Command name without the leading slash."""
+        pass
+
+    @property
+    @abstractmethod
+    def summary(self) -> str:
+        """Brief description of what this command does."""
+        pass
+
+    @property
+    def is_interactive(self) -> bool:
+        """Whether this command is interactive."""
+        return False
+
+    @property
+    def support_addition_params(self) -> bool:
+        """Whether this command support additional parameters."""
+        return False
+
+    @abstractmethod
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
+        """
+        Execute the command.
+
+        Args:
+            raw: The full command string as typed by user (e.g., "/help" or "/model gpt-4")
+            session_id: Current session ID, may be None if no session initialized yet
+
+        Returns:
+            CommandResult: Result of the command execution
+        """
+        pass

klaude_code/command/diff_cmd.py

@@ -0,0 +1,138 @@
+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/export_cmd.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+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
+from klaude_code.session.export import build_export_html, get_default_export_path
+
+
+@register_command
+class ExportCommand(CommandABC):
+    """Export the current session into a standalone HTML transcript."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.EXPORT
+
+    @property
+    def summary(self) -> str:
+        return "Export current session to HTML"
+
+    @property
+    def support_addition_params(self) -> bool:
+        return True
+
+    @property
+    def is_interactive(self) -> bool:
+        return False
+
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
+        try:
+            output_path = self._resolve_output_path(raw, agent)
+            html_doc = self._build_html(agent)
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(html_doc, encoding="utf-8")
+            self._open_file(output_path)
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content=f"Session exported and opened: {output_path}",
+                    command_output=model.CommandOutput(command_name=self.name),
+                ),
+            )
+            return CommandResult(events=[event])
+        except Exception as exc:  # pragma: no cover - safeguard for unexpected errors
+            import traceback
+
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content=f"Failed to export session: {exc}\n{traceback.format_exc()}",
+                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
+                ),
+            )
+            return CommandResult(events=[event])
+
+    def _resolve_output_path(self, raw: str, agent: Agent) -> Path:
+        trimmed = raw.strip()
+        if trimmed:
+            candidate = Path(trimmed).expanduser()
+            if not candidate.is_absolute():
+                candidate = Path(agent.session.work_dir) / candidate
+            if candidate.suffix.lower() != ".html":
+                candidate = candidate.with_suffix(".html")
+            return candidate
+        return get_default_export_path(agent.session)
+
+    def _open_file(self, path: Path) -> None:
+        try:
+            subprocess.run(["open", str(path)], check=True)
+        except FileNotFoundError as exc:  # pragma: no cover - depends on platform
+            msg = "`open` command not found; please open the HTML manually."
+            raise RuntimeError(msg) from exc
+        except subprocess.CalledProcessError as exc:  # pragma: no cover - depends on platform
+            msg = f"Failed to open HTML with `open`: {exc}"
+            raise RuntimeError(msg) from exc
+
+    def _build_html(self, agent: Agent) -> str:
+        profile = agent.profile
+        system_prompt = (profile.system_prompt if profile else "") or ""
+        tools = profile.tools if profile else []
+        model_name = profile.llm_client.model_name if profile else "unknown"
+        return build_export_html(agent.session, system_prompt, tools, model_name)

klaude_code/command/help_cmd.py

@@ -0,0 +1,51 @@
+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 HelpCommand(CommandABC):
+    """Display help information for all available slash commands."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.HELP
+
+    @property
+    def summary(self) -> str:
+        return "Show help and available commands"
+
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
+        lines: list[str] = [
+            """
+Usage:
+  [b]@[/b] to mention file
+  [b]esc[/b] to interrupt agent task
+  [b]shift-enter[/b] or [b]ctrl-j[/b] for new line
+  [b]ctrl-v[/b] for pasting image
+  [b]--continue[/b] or [b]--resume[/b] to continue an old session
+  [b]--select-model[/b] to switch model
+
+Available slash commands:"""
+        ]
+
+        # Import here to avoid circular dependency
+        from .registry import get_commands
+
+        commands = get_commands()
+
+        if commands:
+            for cmd_name, cmd_obj in sorted(commands.items()):
+                additional_instructions = " \\[additional instructions]" if cmd_obj.support_addition_params else ""
+                lines.append(f"  [b]/{cmd_name}[/b]{additional_instructions} — {cmd_obj.summary}")
+
+        event = events.DeveloperMessageEvent(
+            session_id=agent.session.id,
+            item=model.DeveloperMessageItem(
+                content="\n".join(lines),
+                command_output=model.CommandOutput(command_name=self.name),
+            ),
+        )
+
+        return CommandResult(events=[event])

klaude_code/command/model_cmd.py

@@ -0,0 +1,43 @@
+import asyncio
+
+from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
+from klaude_code.command.registry import register_command
+from klaude_code.config import select_model_from_config
+from klaude_code.core.agent import Agent
+from klaude_code.protocol import commands, events, model
+
+
+@register_command
+class ModelCommand(CommandABC):
+    """Display or change the model configuration."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.MODEL
+
+    @property
+    def summary(self) -> str:
+        return "Select and switch LLM"
+
+    @property
+    def is_interactive(self) -> bool:
+        return True
+
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
+        selected_model = await asyncio.to_thread(select_model_from_config, preferred=raw)
+
+        current_model = agent.profile.llm_client.model_name if agent.profile else None
+        if selected_model is None or selected_model == current_model:
+            return CommandResult(
+                events=[
+                    events.DeveloperMessageEvent(
+                        session_id=agent.session.id,
+                        item=model.DeveloperMessageItem(
+                            content="(no change)",
+                            command_output=model.CommandOutput(command_name=self.name),
+                        ),
+                    )
+                ]
+            )
+
+        return CommandResult(actions=[InputAction.change_model(selected_model)])

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

@@ -0,0 +1,56 @@
+---
+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

@@ -0,0 +1,46 @@
+---
+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