klaude-code 1.2.3__tar.gz → 1.2.4__tar.gz

{klaude_code-1.2.3 → klaude_code-1.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.2.3
+Version: 1.2.4
 Summary: Add your description here
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: openai>=1.102.0

{klaude_code-1.2.3 → klaude_code-1.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "1.2.3"
+version = "1.2.4"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.13"

{klaude_code-1.2.3 → klaude_code-1.2.4}/src/klaude_code/command/__init__.py

@@ -16,6 +16,7 @@ from .registry import (
     load_prompt_commands,
     register_command,
 )
+from .status_cmd import StatusCommand
 from .terminal_setup_cmd import TerminalSetupCommand
 
 # Dynamically load prompt commands
@@ -28,6 +29,7 @@ __all__ = [
     "ModelCommand",
     "ExportCommand",
     "RefreshTerminalCommand",
+    "StatusCommand",
     "TerminalSetupCommand",
     "register_command",
     "CommandABC",

{klaude_code-1.2.3 → klaude_code-1.2.4}/src/klaude_code/command/export_cmd.py

@@ -46,10 +46,12 @@ class ExportCommand(CommandABC):
             )
             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}",
+                    content=f"Failed to export session: {exc}\n{traceback.format_exc()}",
                     command_output=model.CommandOutput(command_name=self.name, is_error=True),
                 ),
             )

klaude_code-1.2.4/src/klaude_code/command/status_cmd.py

@@ -0,0 +1,111 @@
+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.session import Session
+
+
+def accumulate_session_usage(session: Session) -> tuple[model.Usage, int]:
+    """Accumulate usage statistics from all ResponseMetadataItems in session history.
+
+    Returns:
+        A tuple of (accumulated_usage, task_count)
+    """
+    total = model.Usage()
+    task_count = 0
+
+    for item in session.conversation_history:
+        if isinstance(item, model.ResponseMetadataItem) and item.usage:
+            task_count += 1
+            usage = item.usage
+            total.input_tokens += usage.input_tokens
+            total.cached_tokens += usage.cached_tokens
+            total.reasoning_tokens += usage.reasoning_tokens
+            total.output_tokens += usage.output_tokens
+            total.total_tokens += usage.total_tokens
+
+            # Accumulate costs
+            if usage.input_cost is not None:
+                total.input_cost = (total.input_cost or 0.0) + usage.input_cost
+            if usage.output_cost is not None:
+                total.output_cost = (total.output_cost or 0.0) + usage.output_cost
+            if usage.cache_read_cost is not None:
+                total.cache_read_cost = (total.cache_read_cost or 0.0) + usage.cache_read_cost
+            if usage.total_cost is not None:
+                total.total_cost = (total.total_cost or 0.0) + usage.total_cost
+
+            # Keep the latest context_usage_percent
+            if usage.context_usage_percent is not None:
+                total.context_usage_percent = usage.context_usage_percent
+
+    return total, task_count
+
+
+def _format_tokens(tokens: int) -> str:
+    """Format token count with K/M suffix for readability."""
+    if tokens >= 1_000_000:
+        return f"{tokens / 1_000_000:.2f}M"
+    if tokens >= 1_000:
+        return f"{tokens / 1_000:.1f}K"
+    return str(tokens)
+
+
+def _format_cost(cost: float | None) -> str:
+    """Format cost in USD."""
+    if cost is None:
+        return "-"
+    if cost < 0.01:
+        return f"${cost:.4f}"
+    return f"${cost:.2f}"
+
+
+def format_status_content(usage: model.Usage) -> str:
+    """Format session status as comma-separated text."""
+    parts: list[str] = []
+
+    parts.append(f"Input: {_format_tokens(usage.input_tokens)}")
+    if usage.cached_tokens > 0:
+        parts.append(f"Cached: {_format_tokens(usage.cached_tokens)}")
+    parts.append(f"Output: {_format_tokens(usage.output_tokens)}")
+    parts.append(f"Total: {_format_tokens(usage.total_tokens)}")
+
+    if usage.total_cost is not None:
+        parts.append(f"Cost: {_format_cost(usage.total_cost)}")
+
+    return ", ".join(parts)
+
+
+@register_command
+class StatusCommand(CommandABC):
+    """Display session usage statistics."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.STATUS
+
+    @property
+    def summary(self) -> str:
+        return "Show session usage statistics"
+
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
+        session = agent.session
+        usage, task_count = accumulate_session_usage(session)
+
+        event = events.DeveloperMessageEvent(
+            session_id=session.id,
+            item=model.DeveloperMessageItem(
+                content=format_status_content(usage),
+                command_output=model.CommandOutput(
+                    command_name=self.name,
+                    ui_extra=model.ToolResultUIExtra(
+                        type=model.ToolResultUIExtraType.SESSION_STATUS,
+                        session_status=model.SessionStatusUIExtra(
+                            usage=usage,
+                            task_count=task_count,
+                        ),
+                    ),
+                ),
+            ),
+        )
+
+        return CommandResult(events=[event])

{klaude_code-1.2.3 → klaude_code-1.2.4}/src/klaude_code/protocol/commands.py

@@ -11,6 +11,7 @@ class CommandName(str, Enum):
     CLEAR = "clear"
     TERMINAL_SETUP = "terminal-setup"
     EXPORT = "export"
+    STATUS = "status"
     # PLAN and DOC are dynamically registered now, but kept here if needed for reference
     # or we can remove them if no code explicitly imports them.
     # PLAN = "plan"

{klaude_code-1.2.3 → klaude_code-1.2.4}/src/klaude_code/protocol/model.py

@@ -45,6 +45,7 @@ class ToolResultUIExtraType(str, Enum):
     SESSION_ID = "session_id"
     MERMAID_LINK = "mermaid_link"
     TRUNCATION = "truncation"
+    SESSION_STATUS = "session_status"
 
 
 class ToolSideEffect(str, Enum):
@@ -62,6 +63,11 @@ class TruncationUIExtra(BaseModel):
     truncated_length: int
 
 
+class SessionStatusUIExtra(BaseModel):
+    usage: "Usage"
+    task_count: int
+
+
 class ToolResultUIExtra(BaseModel):
     type: ToolResultUIExtraType
     diff_text: str | None = None
@@ -69,6 +75,7 @@ class ToolResultUIExtra(BaseModel):
     session_id: str | None = None
     mermaid_link: MermaidLinkUIExtra | None = None
     truncation: TruncationUIExtra | None = None
+    session_status: SessionStatusUIExtra | None = None
 
 
 class AtPatternParseResult(BaseModel):

{klaude_code-1.2.3 → klaude_code-1.2.4}/src/klaude_code/session/templates/export_session.html

@@ -908,9 +908,81 @@
         font-size: var(--font-size-sm);
         margin-top: 2px;
       }
+      /* TOC Sidebar */
+      .toc-sidebar {
+        position: fixed;
+        top: 33vh;
+        left: 20px;
+        width: 220px;
+        bottom: 33vh;
+        overflow-y: auto;
+        padding-right: 12px;
+        /* Vertical padding to offset mask */
+        padding-top: 30px;
+        padding-bottom: 30px;
+        display: none;
+        scrollbar-width: none;
+        z-index: 100;
+        /* Linear mask for fading edges */
+        -webkit-mask-image: linear-gradient(
+          to bottom,
+          transparent 0%,
+          black 30px,
+          black calc(100% - 30px),
+          transparent 100%
+        );
+        mask-image: linear-gradient(
+          to bottom,
+          transparent 0%,
+          black 30px,
+          black calc(100% - 30px),
+          transparent 100%
+        );
+      }
+
+      .toc-sidebar::-webkit-scrollbar {
+        display: none;
+      }
+
+      /* Show TOC on wide screens */
+      @media (min-width: 1400px) {
+        .toc-sidebar {
+          display: block;
+        }
+      }
+
+      .toc-item {
+        display: block;
+        padding: 3px 10px;
+        margin-bottom: 1px;
+        font-family: var(--font-mono);
+        font-size: 12px;
+        line-height: 1.3;
+        color: var(--text-dim);
+        text-decoration: none;
+        cursor: pointer;
+        transition: all 0.2s;
+        white-space: nowrap;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        border-radius: 4px;
+      }
+
+      .toc-item:hover {
+        color: var(--text);
+        background: rgba(0, 0, 0, 0.03);
+      }
+
+      .toc-item.active {
+        color: var(--text);
+        background: var(--bg-card);
+        font-weight: bold;
+        box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+      }
     </style>
   </head>
   <body>
+    <div id="toc-sidebar" class="toc-sidebar"></div>
     <div class="container">
       <div class="header">
         <h1>Klaude Code</h1>
@@ -941,7 +1013,9 @@
         <div
           class="details-content system-prompt-content"
           style="font-family: var(--font-mono); white-space: pre-wrap"
-        >$system_prompt</div>
+        >
+          $system_prompt
+        </div>
       </details>
 
       <details class="collapsible-section">
@@ -1215,6 +1289,138 @@
           behavior: "smooth",
         });
       });
+
+      // TOC Logic
+      document.addEventListener("DOMContentLoaded", () => {
+        const tocSidebar = document.getElementById("toc-sidebar");
+        if (!tocSidebar) return;
+
+        const sections = [];
+        let userCount = 0;
+        let assistantCount = 0;
+
+        // 1. System Prompt
+        const sysPrompt = document.querySelector(
+          ".collapsible-section summary"
+        );
+        if (sysPrompt && sysPrompt.textContent.includes("System Prompt")) {
+          const details = sysPrompt.parentElement;
+          details.id = details.id || "section-system-prompt";
+          sections.push({
+            id: details.id,
+            label: "System Prompt",
+            el: details,
+          });
+        }
+
+        // 2. Messages and Tools
+        const stream = document.querySelector(".message-stream");
+        if (stream) {
+          // Use a Walker to find top-level relevant items if structure is complex
+          // But assuming flat children of message-stream based on CSS
+          Array.from(stream.children).forEach((child) => {
+            let label = null;
+            let idPrefix = "section";
+
+            if (child.classList.contains("message-group")) {
+              const roleLabel = child.querySelector(".role-label");
+              if (roleLabel) {
+                if (roleLabel.classList.contains("user")) {
+                  userCount++;
+                  label = `USER $${userCount}`;
+                  idPrefix = "user";
+                } else if (roleLabel.classList.contains("assistant")) {
+                  assistantCount++;
+                  label = `ASSISTANT $${assistantCount}`;
+                  idPrefix = "assistant";
+                } else {
+                  label = roleLabel.textContent.trim();
+                }
+              }
+            } else if (child.classList.contains("tool-call")) {
+              const toolName = child.querySelector(".tool-name");
+              if (toolName) {
+                label = toolName.textContent.trim();
+                idPrefix = "tool";
+              } else {
+                label = "Tool";
+              }
+            }
+
+            if (label) {
+              child.id =
+                child.id ||
+                `$${idPrefix}-$${Math.random().toString(36).substr(2, 9)}`;
+              sections.push({ id: child.id, label: label, el: child });
+            }
+          });
+        }
+
+        // Render TOC
+        sections.forEach((section) => {
+          const item = document.createElement("div");
+          item.className = "toc-item";
+          item.textContent = section.label;
+          item.dataset.target = section.id;
+          item.addEventListener("click", () => {
+            section.el.scrollIntoView({ behavior: "smooth", block: "start" });
+          });
+          tocSidebar.appendChild(item);
+        });
+
+        // Scroll Spy with throttling
+        let ticking = false;
+        const offset = 150; // Pixel offset for "active" area
+
+        function updateActiveSection() {
+          let currentId = sections.length > 0 ? sections[0].id : null;
+          const scrollY = window.scrollY;
+
+          // We look for the last section that has passed the top threshold (+ offset)
+          for (let i = 0; i < sections.length; i++) {
+            const el = sections[i].el;
+            // If element top is above the "active line" (scrollY + offset)
+            if (el.offsetTop <= scrollY + offset) {
+              currentId = sections[i].id;
+            } else {
+              // Since sections are ordered by position, we can stop once we find one below the line
+              break;
+            }
+          }
+
+          // Update UI
+          document.querySelectorAll(".toc-item").forEach((item) => {
+            const isActive = item.dataset.target === currentId;
+            if (item.classList.contains("active") !== isActive) {
+              item.classList.toggle("active", isActive);
+              if (isActive) {
+                // Auto-scroll sidebar to visible
+                const sidebarRect = tocSidebar.getBoundingClientRect();
+                const itemRect = item.getBoundingClientRect();
+                // Check if item is out of view in sidebar (accounting for mask)
+                if (
+                  itemRect.top < sidebarRect.top + 40 ||
+                  itemRect.bottom > sidebarRect.bottom - 40
+                ) {
+                  item.scrollIntoView({ behavior: "smooth", block: "center" });
+                }
+              }
+            }
+          });
+
+          ticking = false;
+        }
+
+        window.addEventListener("scroll", () => {
+          if (!ticking) {
+            window.requestAnimationFrame(updateActiveSection);
+            ticking = true;
+          }
+        });
+
+        // Initial update
+        updateActiveSection();
+      });
     </script>
   </body>
 </html>

{klaude_code-1.2.3 → klaude_code-1.2.4}/src/klaude_code/ui/renderers/developer.py

@@ -1,8 +1,9 @@
 from rich.console import Group, RenderableType
 from rich.padding import Padding
+from rich.table import Table
 from rich.text import Text
 
-from klaude_code.protocol import commands, events
+from klaude_code.protocol import commands, events, model
 from klaude_code.ui.renderers import diffs as r_diffs
 from klaude_code.ui.renderers.common import create_grid
 from klaude_code.ui.renderers.tools import render_path
@@ -97,7 +98,61 @@ def render_command_output(e: events.DeveloperMessageEvent) -> RenderableType:
             return r_diffs.render_diff_panel(e.item.content, show_file_name=True)
         case commands.CommandName.HELP:
             return Padding.indent(Text.from_markup(e.item.content or ""), level=2)
+        case commands.CommandName.STATUS:
+            return _render_status_output(e.item.command_output)
         case _:
             content = e.item.content or "(no content)"
             style = ThemeKey.TOOL_RESULT if not e.item.command_output.is_error else ThemeKey.ERROR
             return Padding.indent(Text(truncate_display(content), style=style), level=2)
+
+
+def _format_tokens(tokens: int) -> str:
+    """Format token count with K/M suffix for readability."""
+    if tokens >= 1_000_000:
+        return f"{tokens / 1_000_000:.2f}M"
+    if tokens >= 1_000:
+        return f"{tokens / 1_000:.1f}K"
+    return str(tokens)
+
+
+def _format_cost(cost: float | None) -> str:
+    """Format cost in USD."""
+    if cost is None:
+        return "-"
+    if cost < 0.01:
+        return f"${cost:.4f}"
+    return f"${cost:.2f}"
+
+
+def _render_status_output(command_output: model.CommandOutput) -> RenderableType:
+    """Render session status as a two-column table with sections."""
+    if not command_output.ui_extra or not command_output.ui_extra.session_status:
+        return Text("(no status data)", style=ThemeKey.TOOL_RESULT)
+
+    status = command_output.ui_extra.session_status
+    usage = status.usage
+
+    table = Table.grid(padding=(0, 2))
+    table.add_column(style=ThemeKey.TOOL_RESULT, no_wrap=True)
+    table.add_column(style=ThemeKey.TOOL_RESULT, no_wrap=True)
+    # Token Usage section
+    table.add_row(Text("Token Usage", style="bold"), "")
+    table.add_row("Input Tokens", _format_tokens(usage.input_tokens))
+    if usage.cached_tokens > 0:
+        table.add_row("Cached Tokens", _format_tokens(usage.cached_tokens))
+    if usage.reasoning_tokens > 0:
+        table.add_row("Reasoning Tokens", _format_tokens(usage.reasoning_tokens))
+    table.add_row("Output Tokens", _format_tokens(usage.output_tokens))
+    table.add_row("Total Tokens", _format_tokens(usage.total_tokens))
+
+    # Cost section
+    if usage.total_cost is not None:
+        table.add_row("", "")  # Empty line
+        table.add_row(Text("Cost", style="bold"), "")
+        table.add_row("Input Cost", _format_cost(usage.input_cost))
+        if usage.cache_read_cost is not None and usage.cache_read_cost > 0:
+            table.add_row("Cache Read Cost", _format_cost(usage.cache_read_cost))
+        table.add_row("Output Cost", _format_cost(usage.output_cost))
+        table.add_row("Total Cost", _format_cost(usage.total_cost))
+
+    return Padding.indent(table, level=2)