klaude-code 1.5.0__tar.gz → 1.6.0__tar.gz

{klaude_code-1.5.0 → klaude_code-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.5.0
+Version: 1.6.0
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0

{klaude_code-1.5.0 → klaude_code-1.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "1.5.0"
+version = "1.6.0"
 description = "Minimal code agent CLI"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -33,6 +33,7 @@ module-name = "klaude_code"
 
 [dependency-groups]
 dev = [
+    "hypothesis>=6.148.8",
     "import-linter>=2.6",
     "pyright>=1.1.407",
     "pytest>=8.4.1",

{klaude_code-1.5.0 → klaude_code-1.6.0}/src/klaude_code/cli/main.py

@@ -11,64 +11,11 @@ from klaude_code.cli.config_cmd import register_config_commands
 from klaude_code.cli.debug import DEBUG_FILTER_HELP, open_log_file_in_editor, resolve_debug_settings
 from klaude_code.cli.self_update import register_self_update_commands, version_option_callback
 from klaude_code.cli.session_cmd import register_session_commands
-from klaude_code.session import Session, build_session_select_options
+from klaude_code.command.resume_cmd import select_session_sync
+from klaude_code.session import Session
 from klaude_code.trace import DebugType, prepare_debug_log_file
 
 
-def select_session_interactive() -> str | None:
-    """Interactive session selection for CLI.
-
-    Returns:
-        Selected session ID, or None if no session selected or no sessions exist.
-    """
-    from klaude_code.trace import log
-
-    options = build_session_select_options()
-    if not options:
-        log("No sessions found for this project.")
-        return None
-
-    from prompt_toolkit.styles import Style
-
-    from klaude_code.ui.terminal.selector import SelectItem, select_one
-
-    items: list[SelectItem[str]] = []
-    for opt in options:
-        title = [
-            ("class:msg", f"{opt.first_user_message}\n"),
-            ("class:meta", f"   {opt.messages_count} · {opt.relative_time} · {opt.model_name} · {opt.session_id}\n\n"),
-        ]
-        items.append(
-            SelectItem(
-                title=title,
-                value=opt.session_id,
-                search_text=f"{opt.first_user_message} {opt.model_name} {opt.session_id}",
-            )
-        )
-
-    try:
-        return select_one(
-            message="Select a session to resume:",
-            items=items,
-            pointer="→",
-            style=Style(
-                [
-                    ("msg", ""),
-                    ("meta", "fg:ansibrightblack"),
-                    ("pointer", "bold fg:ansigreen"),
-                    ("highlighted", "fg:ansigreen"),
-                    ("search_prefix", "fg:ansibrightblack"),
-                    ("search_success", "noinherit fg:ansigreen"),
-                    ("search_none", "noinherit fg:ansired"),
-                    ("question", "bold"),
-                    ("text", ""),
-                ]
-            ),
-        )
-    except KeyboardInterrupt:
-        return None
-
-
 def set_terminal_title(title: str) -> None:
     """Set terminal window title using ANSI escape sequence."""
     # Never write terminal control sequences when stdout is not a TTY (pipes/CI/redirects).
@@ -361,7 +308,7 @@ def main_callback(
         session_id: str | None = None
 
         if resume:
-            session_id = select_session_interactive()
+            session_id = select_session_sync()
             if session_id is None:
                 return
         # If user didn't pick, allow fallback to --continue

klaude_code-1.6.0/src/klaude_code/command/fork_session_cmd.py

@@ -0,0 +1,260 @@
+import asyncio
+import sys
+from dataclasses import dataclass
+from typing import Literal
+
+from prompt_toolkit.styles import Style
+
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
+from klaude_code.protocol import commands, events, model
+from klaude_code.ui.terminal.selector import SelectItem, select_one
+
+FORK_SELECT_STYLE = Style(
+    [
+        ("msg", ""),
+        ("meta", "fg:ansibrightblack"),
+        ("separator", "fg:ansibrightblack"),
+        ("assistant", "fg:ansiblue"),
+        ("pointer", "bold fg:ansigreen"),
+        ("search_prefix", "fg:ansibrightblack"),
+        ("search_success", "noinherit fg:ansigreen"),
+        ("search_none", "noinherit fg:ansired"),
+        ("question", "bold"),
+        ("text", ""),
+    ]
+)
+
+
+@dataclass
+class ForkPoint:
+    """A fork point in conversation history."""
+
+    history_index: int | None  # None means fork entire conversation
+    user_message: str
+    tool_call_stats: dict[str, int]  # tool_name -> count
+    last_assistant_summary: str
+
+
+def _truncate(text: str, max_len: int = 60) -> str:
+    """Truncate text to max_len, adding ellipsis if needed."""
+    text = text.replace("\n", " ").strip()
+    if len(text) <= max_len:
+        return text
+    return text[: max_len - 3] + "..."
+
+
+def _build_fork_points(conversation_history: list[model.ConversationItem]) -> list[ForkPoint]:
+    """Build list of fork points from conversation history.
+
+    Fork points are:
+    - Each UserMessageItem position (for UI display, including first which would be empty session)
+    - The end of the conversation (fork entire conversation)
+    """
+    fork_points: list[ForkPoint] = []
+    user_indices: list[int] = []
+
+    for i, item in enumerate(conversation_history):
+        if isinstance(item, model.UserMessageItem):
+            user_indices.append(i)
+
+    # For each UserMessageItem, create a fork point at that position
+    for i, user_idx in enumerate(user_indices):
+        user_item = conversation_history[user_idx]
+        assert isinstance(user_item, model.UserMessageItem)
+
+        # Find the end of this "task" (next UserMessageItem or end of history)
+        next_user_idx = user_indices[i + 1] if i + 1 < len(user_indices) else len(conversation_history)
+
+        # Count tool calls by name and find last assistant message in this segment
+        tool_stats: dict[str, int] = {}
+        last_assistant_content = ""
+        for j in range(user_idx, next_user_idx):
+            item = conversation_history[j]
+            if isinstance(item, model.ToolCallItem):
+                tool_stats[item.name] = tool_stats.get(item.name, 0) + 1
+            elif isinstance(item, model.AssistantMessageItem) and item.content:
+                last_assistant_content = item.content
+
+        fork_points.append(
+            ForkPoint(
+                history_index=user_idx,
+                user_message=user_item.content or "(empty)",
+                tool_call_stats=tool_stats,
+                last_assistant_summary=_truncate(last_assistant_content) if last_assistant_content else "",
+            )
+        )
+
+    # Add the "fork entire conversation" option at the end
+    if user_indices:
+        fork_points.append(
+            ForkPoint(
+                history_index=None,  # None means fork entire conversation
+                user_message="",  # No specific message, this represents the end
+                tool_call_stats={},
+                last_assistant_summary="",
+            )
+        )
+
+    return fork_points
+
+
+def _build_select_items(fork_points: list[ForkPoint]) -> list[SelectItem[int | None]]:
+    """Build SelectItem list from fork points."""
+    items: list[SelectItem[int | None]] = []
+
+    for i, fp in enumerate(fork_points):
+        is_first = i == 0
+        is_last = i == len(fork_points) - 1
+
+        # Build the title
+        title_parts: list[tuple[str, str]] = []
+
+        # First line: separator (with special markers for first/last fork points)
+        if is_first and not is_last:
+            title_parts.append(("class:separator", "----- fork from here (empty session) -----\n\n"))
+        elif is_last:
+            title_parts.append(("class:separator", "----- fork from here (entire session) -----\n\n"))
+        else:
+            title_parts.append(("class:separator", "----- fork from here -----\n\n"))
+
+        if not is_last:
+            # Second line: user message
+            title_parts.append(("class:msg", f"user:   {_truncate(fp.user_message, 70)}\n"))
+
+            # Third line: tool call stats (if any)
+            if fp.tool_call_stats:
+                tool_parts = [f"{name} × {count}" for name, count in fp.tool_call_stats.items()]
+                title_parts.append(("class:meta", f"tools:  {', '.join(tool_parts)}\n"))
+
+            # Fourth line: last assistant message summary (if any)
+            if fp.last_assistant_summary:
+                title_parts.append(("class:assistant", f"ai:     {fp.last_assistant_summary}\n"))
+
+        # Empty line at the end
+        title_parts.append(("class:text", "\n"))
+
+        items.append(
+            SelectItem(
+                title=title_parts,
+                value=fp.history_index,
+                search_text=fp.user_message if not is_last else "fork entire conversation",
+            )
+        )
+
+    return items
+
+
+def _select_fork_point_sync(fork_points: list[ForkPoint]) -> int | None | Literal["cancelled"]:
+    """Interactive fork point selection (sync version for asyncio.to_thread).
+
+    Returns:
+        - int: history index to fork at (exclusive)
+        - None: fork entire conversation
+        - "cancelled": user cancelled selection
+    """
+    items = _build_select_items(fork_points)
+    if not items:
+        return None
+
+    # Default to the last option (fork entire conversation)
+    last_value = items[-1].value
+
+    # Non-interactive environments default to forking entire conversation
+    if not sys.stdin.isatty() or not sys.stdout.isatty():
+        return last_value
+
+    try:
+        result = select_one(
+            message="Select fork point (messages before this point will be included):",
+            items=items,
+            pointer="→",
+            style=FORK_SELECT_STYLE,
+            initial_value=last_value,
+            highlight_pointed_item=False,
+        )
+        if result is None:
+            return "cancelled"
+        return result
+    except KeyboardInterrupt:
+        return "cancelled"
+
+
+class ForkSessionCommand(CommandABC):
+    """Fork current session to a new session id and show a resume command."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.FORK_SESSION
+
+    @property
+    def summary(self) -> str:
+        return "Fork the current session and show a resume-by-id command"
+
+    @property
+    def is_interactive(self) -> bool:
+        return True
+
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        del user_input  # unused
+
+        if agent.session.messages_count == 0:
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content="(no messages to fork)",
+                    command_output=model.CommandOutput(command_name=self.name),
+                ),
+            )
+            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+
+        # Build fork points from conversation history
+        fork_points = _build_fork_points(agent.session.conversation_history)
+
+        if not fork_points:
+            # Only one user message, just fork entirely
+            new_session = agent.session.fork()
+            await new_session.wait_for_flush()
+
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content=f"Session forked successfully. New session id: {new_session.id}",
+                    command_output=model.CommandOutput(
+                        command_name=self.name,
+                        ui_extra=model.SessionIdUIExtra(session_id=new_session.id),
+                    ),
+                ),
+            )
+            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+
+        # Interactive selection
+        selected = await asyncio.to_thread(_select_fork_point_sync, fork_points)
+
+        if selected == "cancelled":
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content="(fork cancelled)",
+                    command_output=model.CommandOutput(command_name=self.name),
+                ),
+            )
+            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+
+        # Perform the fork
+        new_session = agent.session.fork(until_index=selected)
+        await new_session.wait_for_flush()
+
+        # Build result message
+        fork_description = "entire conversation" if selected is None else f"up to message index {selected}"
+
+        event = events.DeveloperMessageEvent(
+            session_id=agent.session.id,
+            item=model.DeveloperMessageItem(
+                content=f"Session forked ({fork_description}). New session id: {new_session.id}",
+                command_output=model.CommandOutput(
+                    command_name=self.name,
+                    ui_extra=model.SessionIdUIExtra(session_id=new_session.id),
+                ),
+            ),
+        )
+        return CommandResult(events=[event], persist_user_input=False, persist_events=False)

{klaude_code-1.5.0 → klaude_code-1.6.0}/src/klaude_code/command/refresh_cmd.py

@@ -23,7 +23,7 @@ class RefreshTerminalCommand(CommandABC):
 
         os.system("cls" if os.name == "nt" else "clear")
 
-        result = CommandResult(
+        return CommandResult(
             events=[
                 events.WelcomeEvent(
                     work_dir=str(agent.session.work_dir),
@@ -35,7 +35,7 @@ class RefreshTerminalCommand(CommandABC):
                     updated_at=agent.session.updated_at,
                     is_load=False,
                 ),
-            ]
+            ],
+            persist_user_input=False,
+            persist_events=False,
         )
-
-        return result

{klaude_code-1.5.0 → klaude_code-1.6.0}/src/klaude_code/command/resume_cmd.py

@@ -4,14 +4,14 @@ from prompt_toolkit.styles import Style
 
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model, op
-from klaude_code.session.selector import build_session_select_options
+from klaude_code.session.selector import build_session_select_options, format_user_messages_display
 from klaude_code.trace import log
 from klaude_code.ui.terminal.selector import SelectItem, select_one
 
 SESSION_SELECT_STYLE = Style(
     [
-        ("msg", ""),
-        ("meta", "fg:ansibrightblack"),
+        ("msg", "fg:ansibrightblack"),
+        ("meta", ""),
         ("pointer", "bold fg:ansigreen"),
         ("highlighted", "fg:ansigreen"),
         ("search_prefix", "fg:ansibrightblack"),
@@ -23,7 +23,7 @@ SESSION_SELECT_STYLE = Style(
 )
 
 
-def _select_session_sync() -> str | None:
+def select_session_sync() -> str | None:
     """Interactive session selection (sync version for asyncio.to_thread)."""
     options = build_session_select_options()
     if not options:
@@ -31,16 +31,26 @@ def _select_session_sync() -> str | None:
         return None
 
     items: list[SelectItem[str]] = []
-    for opt in options:
-        title = [
-            ("class:msg", f"{opt.first_user_message}\n"),
-            ("class:meta", f"   {opt.messages_count} · {opt.relative_time} · {opt.model_name} · {opt.session_id}\n\n"),
-        ]
+    for idx, opt in enumerate(options, 1):
+        display_msgs = format_user_messages_display(opt.user_messages)
+        title: list[tuple[str, str]] = []
+        title.append(("fg:ansibrightblack", f"{idx:2}. "))
+        title.append(
+            ("class:meta", f"{opt.relative_time} · {opt.messages_count} · {opt.model_name} · {opt.session_id}\n")
+        )
+        for msg in display_msgs:
+            if msg == "⋮":
+                title.append(("class:msg", f"    {msg}\n"))
+            else:
+                title.append(("class:msg", f"    > {msg}\n"))
+        title.append(("", "\n"))
+
+        search_text = " ".join(opt.user_messages) + f" {opt.model_name} {opt.session_id}"
         items.append(
             SelectItem(
                 title=title,
                 value=opt.session_id,
-                search_text=f"{opt.first_user_message} {opt.model_name} {opt.session_id}",
+                search_text=search_text,
             )
         )
 
@@ -83,7 +93,7 @@ class ResumeCommand(CommandABC):
             )
             return CommandResult(events=[event], persist_user_input=False, persist_events=False)
 
-        selected_session_id = await asyncio.to_thread(_select_session_sync)
+        selected_session_id = await asyncio.to_thread(select_session_sync)
         if selected_session_id is None:
             event = events.DeveloperMessageEvent(
                 session_id=agent.session.id,

{klaude_code-1.5.0 → klaude_code-1.6.0}/src/klaude_code/llm/usage.py

@@ -81,7 +81,7 @@ class MetadataTracker:
             ) * 1000
 
             if self._last_token_time is not None and self._metadata_item.usage.output_tokens > 0:
-                time_duration = self._last_token_time - self._first_token_time
+                time_duration = self._last_token_time - self._request_start_time
                 if time_duration >= 0.15:
                     self._metadata_item.usage.throughput_tps = self._metadata_item.usage.output_tokens / time_duration
 

{klaude_code-1.5.0 → klaude_code-1.6.0}/src/klaude_code/session/__init__.py

@@ -1,4 +1,4 @@
-from .selector import SessionSelectOption, build_session_select_options
+from .selector import SessionSelectOption, build_session_select_options, format_user_messages_display
 from .session import Session
 
-__all__ = ["Session", "SessionSelectOption", "build_session_select_options"]
+__all__ = ["Session", "SessionSelectOption", "build_session_select_options", "format_user_messages_display"]

{klaude_code-1.5.0 → klaude_code-1.6.0}/src/klaude_code/session/selector.py

@@ -33,12 +33,39 @@ class SessionSelectOption:
     """Option data for session selection UI."""
 
     session_id: str
-    first_user_message: str
+    user_messages: list[str]
     messages_count: str
     relative_time: str
     model_name: str
 
 
+def _format_message(msg: str) -> str:
+    """Format a user message for display (strip and collapse newlines)."""
+    return msg.strip().replace("\n", " ")
+
+
+def format_user_messages_display(messages: list[str]) -> list[str]:
+    """Format user messages for display in session selection.
+
+    Shows up to 6 messages. If more than 6, shows first 3 and last 3 with ellipsis.
+    Each message is on its own line.
+
+    Args:
+        messages: List of user messages.
+
+    Returns:
+        List of formatted message lines for display.
+    """
+    if len(messages) <= 6:
+        return messages
+
+    # More than 6: show first 3, ellipsis, last 3
+    result = messages[:3]
+    result.append("⋮")
+    result.extend(messages[-3:])
+    return result
+
+
 def build_session_select_options() -> list[SessionSelectOption]:
     """Build session selection options data.
 
@@ -51,8 +78,9 @@ def build_session_select_options() -> list[SessionSelectOption]:
 
     options: list[SessionSelectOption] = []
     for s in sessions:
-        first_msg = s.first_user_message or "N/A"
-        first_msg = first_msg.strip().replace("\n", " ")
+        user_messages = [_format_message(m) for m in s.user_messages if m.strip()]
+        if not user_messages:
+            user_messages = ["N/A"]
 
         msg_count = "N/A" if s.messages_count == -1 else f"{s.messages_count} messages"
         model = s.model_name or "N/A"
@@ -60,7 +88,7 @@ def build_session_select_options() -> list[SessionSelectOption]:
         options.append(
             SessionSelectOption(
                 session_id=str(s.id),
-                first_user_message=first_msg,
+                user_messages=user_messages,
                 messages_count=msg_count,
                 relative_time=_relative_time(s.updated_at),
                 model_name=model,

{klaude_code-1.5.0 → klaude_code-1.6.0}/src/klaude_code/session/session.py

@@ -197,11 +197,16 @@ class Session(BaseModel):
         )
         self._store.append_and_flush(session_id=self.id, items=items, meta=meta)
 
-    def fork(self, *, new_id: str | None = None) -> Session:
+    def fork(self, *, new_id: str | None = None, until_index: int | None = None) -> Session:
         """Create a new session as a fork of the current session.
 
         The forked session copies metadata and conversation history, but does not
         modify the current session.
+
+        Args:
+            new_id: Optional ID for the forked session.
+            until_index: If provided, only copy conversation history up to (but not including) this index.
+                         If None, copy all history.
         """
 
         forked = Session.create(id=new_id, work_dir=self.work_dir)
@@ -213,7 +218,8 @@ class Session(BaseModel):
         forked.file_tracker = {k: v.model_copy(deep=True) for k, v in self.file_tracker.items()}
         forked.todos = [todo.model_copy(deep=True) for todo in self.todos]
 
-        items = [it.model_copy(deep=True) for it in self.conversation_history]
+        history_to_copy = self.conversation_history[:until_index] if until_index is not None else self.conversation_history
+        items = [it.model_copy(deep=True) for it in history_to_copy]
         if items:
             forked.append_history(items)
 
@@ -338,7 +344,7 @@ class Session(BaseModel):
         updated_at: float
         work_dir: str
         path: str
-        first_user_message: str | None = None
+        user_messages: list[str] = []
         messages_count: int = -1
         model_name: str | None = None
 
@@ -346,10 +352,11 @@ class Session(BaseModel):
     def list_sessions(cls) -> list[SessionMetaBrief]:
         store = get_default_store()
 
-        def _get_first_user_message(session_id: str) -> str | None:
+        def _get_user_messages(session_id: str) -> list[str]:
             events_path = store.paths.events_file(session_id)
             if not events_path.exists():
-                return None
+                return []
+            messages: list[str] = []
             try:
                 for line in events_path.read_text(encoding="utf-8").splitlines():
                     obj_raw = json.loads(line)
@@ -360,15 +367,14 @@ class Session(BaseModel):
                         continue
                     data_raw = obj.get("data")
                     if not isinstance(data_raw, dict):
-                        return None
+                        continue
                     data = cast(dict[str, Any], data_raw)
                     content = data.get("content")
                     if isinstance(content, str):
-                        return content
-                    return None
+                        messages.append(content)
             except (OSError, json.JSONDecodeError):
-                return None
-            return None
+                pass
+            return messages
 
         items: list[Session.SessionMetaBrief] = []
         for meta_path in store.iter_meta_files():
@@ -382,7 +388,7 @@ class Session(BaseModel):
             created = float(data.get("created_at", meta_path.stat().st_mtime))
             updated = float(data.get("updated_at", meta_path.stat().st_mtime))
             work_dir = str(data.get("work_dir", ""))
-            first_user_message = _get_first_user_message(sid)
+            user_messages = _get_user_messages(sid)
             messages_count = int(data.get("messages_count", -1))
             model_name = data.get("model_name") if isinstance(data.get("model_name"), str) else None
 
@@ -393,7 +399,7 @@ class Session(BaseModel):
                     updated_at=updated,
                     work_dir=work_dir,
                     path=str(meta_path),
-                    first_user_message=first_user_message,
+                    user_messages=user_messages,
                     messages_count=messages_count,
                     model_name=model_name,
                 )