deepy-cli 0.1.1__py3-none-any.whl

deepy/ui/prompt_buffer.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class PromptBufferState:
+    text: str = ""
+    cursor: int = 0
+
+    def normalized(self) -> "PromptBufferState":
+        return PromptBufferState(self.text, _clamp(self.cursor, 0, len(self.text)))
+
+
+EMPTY_BUFFER = PromptBufferState()
+
+
+def insert_text(state: PromptBufferState, value: str) -> PromptBufferState:
+    state = state.normalized()
+    if not value:
+        return state
+    text = state.text[: state.cursor] + value + state.text[state.cursor :]
+    return PromptBufferState(text, state.cursor + len(value))
+
+
+def backspace(state: PromptBufferState) -> PromptBufferState:
+    state = state.normalized()
+    if state.cursor == 0:
+        return state
+    text = state.text[: state.cursor - 1] + state.text[state.cursor :]
+    return PromptBufferState(text, state.cursor - 1)
+
+
+def delete_forward(state: PromptBufferState) -> PromptBufferState:
+    state = state.normalized()
+    if state.cursor >= len(state.text):
+        return state
+    text = state.text[: state.cursor] + state.text[state.cursor + 1 :]
+    return PromptBufferState(text, state.cursor)
+
+
+def move_left(state: PromptBufferState) -> PromptBufferState:
+    state = state.normalized()
+    return PromptBufferState(state.text, max(state.cursor - 1, 0))
+
+
+def move_right(state: PromptBufferState) -> PromptBufferState:
+    state = state.normalized()
+    return PromptBufferState(state.text, min(state.cursor + 1, len(state.text)))
+
+
+def move_word_left(state: PromptBufferState) -> PromptBufferState:
+    state = state.normalized()
+    cursor = state.cursor
+    while cursor > 0 and state.text[cursor - 1].isspace():
+        cursor -= 1
+    while cursor > 0 and not state.text[cursor - 1].isspace():
+        cursor -= 1
+    return PromptBufferState(state.text, cursor)
+
+
+def move_word_right(state: PromptBufferState) -> PromptBufferState:
+    state = state.normalized()
+    cursor = state.cursor
+    while cursor < len(state.text) and state.text[cursor].isspace():
+        cursor += 1
+    while cursor < len(state.text) and not state.text[cursor].isspace():
+        cursor += 1
+    return PromptBufferState(state.text, cursor)
+
+
+def move_up(state: PromptBufferState) -> PromptBufferState:
+    state = state.normalized()
+    location = _locate(state)
+    if location.line == 0:
+        return PromptBufferState(state.text, 0)
+    previous_line_end = location.line_start - 1
+    previous_line_start = state.text.rfind("\n", 0, previous_line_end) + 1
+    previous_line_length = previous_line_end - previous_line_start
+    target_column = min(location.column, previous_line_length)
+    return PromptBufferState(state.text, previous_line_start + target_column)
+
+
+def move_down(state: PromptBufferState) -> PromptBufferState:
+    state = state.normalized()
+    location = _locate(state)
+    if location.line_end >= len(state.text):
+        return PromptBufferState(state.text, len(state.text))
+    next_line_start = location.line_end + 1
+    next_line_newline = state.text.find("\n", next_line_start)
+    next_line_end = len(state.text) if next_line_newline == -1 else next_line_newline
+    next_line_length = next_line_end - next_line_start
+    target_column = min(location.column, next_line_length)
+    return PromptBufferState(state.text, next_line_start + target_column)
+
+
+def move_line_start(state: PromptBufferState) -> PromptBufferState:
+    state = state.normalized()
+    return PromptBufferState(state.text, _locate(state).line_start)
+
+
+def move_line_end(state: PromptBufferState) -> PromptBufferState:
+    state = state.normalized()
+    return PromptBufferState(state.text, _locate(state).line_end)
+
+
+def kill_line(state: PromptBufferState) -> PromptBufferState:
+    state = state.normalized()
+    line_end = _locate(state).line_end
+    if state.cursor >= line_end:
+        return state
+    text = state.text[: state.cursor] + state.text[line_end:]
+    return PromptBufferState(text, state.cursor)
+
+
+def delete_word_before(state: PromptBufferState) -> PromptBufferState:
+    state = state.normalized()
+    end = state.cursor
+    start = end
+    while start > 0 and state.text[start - 1].isspace():
+        start -= 1
+    while start > 0 and not state.text[start - 1].isspace():
+        start -= 1
+    if start == end:
+        return state
+    return PromptBufferState(state.text[:start] + state.text[end:], start)
+
+
+def reset() -> PromptBufferState:
+    return EMPTY_BUFFER
+
+
+def is_empty(state: PromptBufferState) -> bool:
+    return len(state.text) == 0
+
+
+def get_current_slash_token(state: PromptBufferState) -> str | None:
+    state = state.normalized()
+    if not state.text:
+        return None
+    before_cursor = state.text[: state.cursor]
+    line_start = before_cursor.rfind("\n") + 1
+    line = before_cursor[line_start:]
+    if not line.startswith("/"):
+        return None
+    if re.search(r"\s", line):
+        return None
+    return line
+
+
+@dataclass(frozen=True)
+class _Location:
+    line: int
+    column: int
+    line_start: int
+    line_end: int
+
+
+def _locate(state: PromptBufferState) -> _Location:
+    before = state.text[: state.cursor]
+    line_start = before.rfind("\n") + 1
+    line = before.count("\n")
+    after = state.text[state.cursor :]
+    next_newline = after.find("\n")
+    line_end = len(state.text) if next_newline == -1 else state.cursor + next_newline
+    return _Location(
+        line=line,
+        column=state.cursor - line_start,
+        line_start=line_start,
+        line_end=line_end,
+    )
+
+
+def _clamp(value: int, minimum: int, maximum: int) -> int:
+    return max(minimum, min(value, maximum))

deepy/ui/prompt_input.py

@@ -0,0 +1,286 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable
+from unicodedata import normalize
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.completion import WordCompleter
+from prompt_toolkit.formatted_text import AnyFormattedText
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.keys import Keys
+from prompt_toolkit.styles import Style
+
+from deepy.skills import SkillInfo
+from deepy.ui.prompt_buffer import PromptBufferState
+from deepy.ui.slash_commands import SlashCommandItem
+
+
+DEFAULT_PROMPT_HISTORY = Path.home() / ".deepy" / "prompt-history.txt"
+CTRL_D_EXIT_CONFIRM_SIGNAL = "\0deepy:ctrl-d-exit-confirm\0"
+PROMPT_TOOLBAR_BACKGROUND = "#24283b"
+PROMPT_TOOLBAR_FOREGROUND = "#d7def8"
+PROMPT_TOOLBAR_HELP = "Enter send · Shift+Enter newline · / commands · Esc interrupt · Ctrl+D twice exit"
+PROMPT_MESSAGE: AnyFormattedText = [("class:prompt", "> ")]
+PROMPT_PLACEHOLDER: AnyFormattedText = [("class:placeholder", "Type your message...")]
+PROMPT_TOOLBAR: AnyFormattedText = [("class:toolbar.help", PROMPT_TOOLBAR_HELP)]
+PROMPT_STYLE = Style.from_dict(
+    {
+        "prompt": "ansicyan bold",
+        "placeholder": "#8a90aa",
+        "toolbar": f"bg:{PROMPT_TOOLBAR_BACKGROUND} {PROMPT_TOOLBAR_FOREGROUND}",
+        "toolbar.context": f"bg:{PROMPT_TOOLBAR_BACKGROUND} #8bd5ca bold",
+        "toolbar.separator": f"bg:{PROMPT_TOOLBAR_BACKGROUND} #6c7086",
+        "toolbar.help": f"bg:{PROMPT_TOOLBAR_BACKGROUND} {PROMPT_TOOLBAR_FOREGROUND}",
+        "bottom-toolbar": f"bg:{PROMPT_TOOLBAR_BACKGROUND} {PROMPT_TOOLBAR_FOREGROUND}",
+    }
+)
+SHIFT_ENTER_SEQUENCES = (
+    "\x1b[27;2;13~",  # xterm modified-key format.
+    "\x1b[13;2u",  # Kitty/fixterms CSI-u format, used by modern terminals.
+)
+
+
+@dataclass(frozen=True)
+class PromptCursorPlacement:
+    rows_up: int
+    column: int
+
+
+def create_prompt_session(
+    *,
+    slash_commands: list[SlashCommandItem] | None = None,
+    history_path: Path | None = None,
+    on_interrupt: Callable[[], None] | None = None,
+) -> PromptSession[str]:
+    install_shift_enter_key_sequence_overrides()
+    path = history_path or DEFAULT_PROMPT_HISTORY
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.touch(exist_ok=True)
+    labels = [item.label for item in slash_commands or []]
+    return PromptSession(
+        history=FileHistory(str(path)),
+        completer=WordCompleter(labels, ignore_case=True, sentence=True),
+        complete_while_typing=True,
+        multiline=True,
+        key_bindings=build_prompt_key_bindings(on_interrupt=on_interrupt),
+        style=PROMPT_STYLE,
+    )
+
+
+def build_prompt_key_bindings(
+    *,
+    on_interrupt: Callable[[], None] | None = None,
+) -> KeyBindings:
+    install_shift_enter_key_sequence_overrides()
+    bindings = KeyBindings()
+
+    @bindings.add("escape")
+    def _(event) -> None:  # pragma: no cover - prompt_toolkit calls this callback
+        if on_interrupt is not None:
+            on_interrupt()
+
+    @bindings.add("enter")
+    def _(event) -> None:  # pragma: no cover - prompt_toolkit calls this callback
+        event.current_buffer.validate_and_handle()
+
+    @bindings.add("c-d")
+    def _(event) -> None:  # pragma: no cover - prompt_toolkit calls this callback
+        if event.current_buffer.text:
+            event.current_buffer.delete()
+            return
+        event.app.exit(result=CTRL_D_EXIT_CONFIRM_SIGNAL)
+
+    @bindings.add("escape", "enter")
+    @bindings.add("escape", "c-j")
+    def _(event) -> None:  # pragma: no cover - prompt_toolkit calls this callback
+        event.current_buffer.insert_text("\n")
+
+    return bindings
+
+
+def install_shift_enter_key_sequence_overrides() -> None:
+    from prompt_toolkit.input import vt100_parser
+    from prompt_toolkit.input.ansi_escape_sequences import ANSI_SEQUENCES
+
+    for sequence in SHIFT_ENTER_SEQUENCES:
+        ANSI_SEQUENCES[sequence] = (Keys.Escape, Keys.ControlM)
+    prefix_cache = getattr(vt100_parser, "_IS_PREFIX_OF_LONGER_MATCH_CACHE", None)
+    if hasattr(prefix_cache, "clear"):
+        prefix_cache.clear()
+
+
+def prompt_for_input(
+    session: PromptSession[str],
+    message: AnyFormattedText | None = None,
+    bottom_toolbar: AnyFormattedText | None = None,
+) -> str:
+    prompt_message = PROMPT_MESSAGE if message is None else message
+    return session.prompt(
+        prompt_message,
+        placeholder=PROMPT_PLACEHOLDER,
+        bottom_toolbar=PROMPT_TOOLBAR if bottom_toolbar is None else bottom_toolbar,
+    ).strip()
+
+
+def build_prompt_toolbar(context_status: str = "") -> AnyFormattedText:
+    if not context_status:
+        return PROMPT_TOOLBAR
+    return [
+        ("class:toolbar.context", context_status),
+        ("class:toolbar.separator", " · "),
+        ("class:toolbar.help", PROMPT_TOOLBAR_HELP),
+    ]
+
+
+def format_selected_skills_status(skills: list[SkillInfo]) -> str:
+    names = [skill.name for skill in skills if skill.name]
+    if not names:
+        return ""
+    return f"⚡ {', '.join(names)}"
+
+
+def is_skill_selected(skills: list[SkillInfo], skill: SkillInfo) -> bool:
+    return any(item.name == skill.name for item in skills)
+
+
+def add_unique_skill(skills: list[SkillInfo], skill: SkillInfo) -> list[SkillInfo]:
+    if is_skill_selected(skills, skill):
+        return skills
+    return [*skills, skill]
+
+
+def toggle_skill_selection(skills: list[SkillInfo], skill: SkillInfo) -> list[SkillInfo]:
+    if is_skill_selected(skills, skill):
+        return [item for item in skills if item.name != skill.name]
+    return [*skills, skill]
+
+
+def remove_current_slash_token(state: PromptBufferState) -> PromptBufferState:
+    start = state.cursor
+    while start > 0 and not state.text[start - 1].isspace():
+        start -= 1
+
+    token = state.text[start : state.cursor]
+    if not token.startswith("/"):
+        return state
+
+    text = f"{state.text[:start]}{state.text[state.cursor:]}"
+    return PromptBufferState(text=text, cursor=start)
+
+
+def render_buffer_with_cursor(
+    state: PromptBufferState,
+    is_focused: bool,
+    placeholder: str | None = None,
+) -> str:
+    text = state.text or ""
+    cursor = min(max(state.cursor, 0), len(text))
+    before = text[:cursor]
+    at = text[cursor] if cursor < len(text) else None
+    after = text[cursor + 1 :]
+
+    if not text and placeholder:
+        return _dim(f"  {placeholder}")
+
+    if not is_focused:
+        return f"{text} " if text.endswith("\n") else text
+
+    if at is None:
+        return before + _inverse(" ")
+    if at == "\n":
+        return before + _inverse(" ") + "\n" + after
+    return before + _inverse(at) + after
+
+
+def get_prompt_cursor_placement(
+    state: PromptBufferState,
+    screen_width: int,
+    prefix_width: int,
+    footer_text: str,
+) -> PromptCursorPlacement:
+    width = max(1, screen_width)
+    cursor = min(max(state.cursor, 0), len(state.text))
+    before_cursor = state.text[:cursor]
+    at = state.text[cursor] if cursor < len(state.text) else None
+    display_text = (
+        before_cursor
+        + (" " if at is None or at == "\n" else at)
+        + ("\n" if at == "\n" else "")
+        + ("" if at is None else state.text[cursor + 1 :])
+    )
+
+    cursor_position = measure_text_position(before_cursor, width=width, initial_column=prefix_width)
+    prompt_rows = measure_text_rows(display_text, width=width, initial_column=prefix_width)
+    footer_rows = 1 + measure_text_rows(footer_text, width=width, initial_column=0)
+    return PromptCursorPlacement(
+        rows_up=(prompt_rows - 1 - cursor_position.row) + footer_rows + 1,
+        column=cursor_position.column,
+    )
+
+
+@dataclass(frozen=True)
+class TextPosition:
+    row: int
+    column: int
+
+
+def measure_text_rows(text: str, *, width: int, initial_column: int) -> int:
+    return measure_text_position(text, width=width, initial_column=initial_column).row + 1
+
+
+def measure_text_position(text: str, *, width: int, initial_column: int) -> TextPosition:
+    effective_width = max(1, width)
+    row = 0
+    column = min(initial_column, effective_width - 1)
+
+    for char in text:
+        if char == "\n":
+            row += 1
+            column = min(initial_column, effective_width - 1)
+            continue
+
+        char_columns = text_width(char)
+        if column + char_columns > effective_width:
+            row += 1
+            column = min(initial_column, effective_width - 1)
+        column += char_columns
+        if column >= effective_width:
+            row += 1
+            column = min(initial_column, effective_width - 1)
+
+    return TextPosition(row=row, column=column)
+
+
+def text_width(value: str) -> int:
+    return sum(character_width(char) for char in normalize("NFC", value))
+
+
+def character_width(char: str) -> int:
+    code_point = ord(char)
+    if code_point == 0 or code_point < 32 or (0x7F <= code_point < 0xA0):
+        return 0
+    if 0x300 <= code_point <= 0x36F:
+        return 0
+    if (
+        (0x1100 <= code_point <= 0x115F)
+        or (0x2E80 <= code_point <= 0xA4CF)
+        or (0xAC00 <= code_point <= 0xD7A3)
+        or (0xF900 <= code_point <= 0xFAFF)
+        or (0xFE10 <= code_point <= 0xFE19)
+        or (0xFE30 <= code_point <= 0xFE6F)
+        or (0xFF00 <= code_point <= 0xFF60)
+        or (0xFFE0 <= code_point <= 0xFFE6)
+    ):
+        return 2
+    return 1
+
+
+def _inverse(value: str) -> str:
+    return f"\x1b[7m{value}\x1b[0m"
+
+
+def _dim(value: str) -> str:
+    return f"\x1b[2m{value}\x1b[0m"

deepy/ui/session_list.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Protocol, TypeVar
+
+
+T = TypeVar("T")
+
+
+class SessionChoice(Protocol):
+    id: str
+    updated_at: int
+    active_tokens: int
+
+
+@dataclass(frozen=True)
+class SessionListWindow:
+    safe_index: int
+    scroll_offset: int
+    max_visible: int
+
+
+def format_session_title(value: str | None, max_chars: int = 70) -> str:
+    title = " ".join((value or "Untitled").split()).strip() or "Untitled"
+    return _truncate(title, max_chars)
+
+
+def max_visible_sessions(rows: int) -> int:
+    reserved_lines = 8
+    lines_per_session = 3
+    available_lines = max(0, min(rows, 30) - reserved_lines)
+    return max(1, available_lines // lines_per_session)
+
+
+def session_list_window(
+    *,
+    session_count: int,
+    selected_index: int,
+    rows: int,
+) -> SessionListWindow:
+    visible = max_visible_sessions(rows)
+    if session_count <= 0:
+        return SessionListWindow(safe_index=0, scroll_offset=0, max_visible=visible)
+    safe_index = min(max(selected_index, 0), session_count - 1)
+    scroll_offset = 0 if safe_index < visible else safe_index - visible + 1
+    return SessionListWindow(
+        safe_index=safe_index,
+        scroll_offset=scroll_offset,
+        max_visible=visible,
+    )
+
+
+def visible_sessions(
+    sessions: list[T],
+    *,
+    selected_index: int,
+    rows: int,
+) -> list[T]:
+    window = session_list_window(
+        session_count=len(sessions),
+        selected_index=selected_index,
+        rows=rows,
+    )
+    return sessions[window.scroll_offset : window.scroll_offset + window.max_visible]
+
+
+def format_session_choice(entry: SessionChoice, index: int) -> str:
+    return (
+        f"{index}. {entry.id}  updated={entry.updated_at}  "
+        f"history_tokens={entry.active_tokens}"
+    )
+
+
+def format_session_choices(entries: Sequence[SessionChoice], *, max_entries: int = 10) -> str:
+    if not entries:
+        return "No sessions found."
+    lines = [
+        format_session_choice(entry, index)
+        for index, entry in enumerate(entries[:max_entries], 1)
+    ]
+    remaining = len(entries) - len(lines)
+    if remaining > 0:
+        lines.append(f"...and {remaining} more.")
+    return "\n".join(lines)
+
+
+def resolve_session_selection(
+    entries: Sequence[SessionChoice],
+    selection: str,
+) -> SessionChoice | None:
+    value = selection.strip()
+    if not value:
+        return None
+    if value.isdigit():
+        index = int(value) - 1
+        if 0 <= index < len(entries):
+            return entries[index]
+    exact = [entry for entry in entries if entry.id == value]
+    if len(exact) == 1:
+        return exact[0]
+    prefix = [entry for entry in entries if entry.id.startswith(value)]
+    if len(prefix) == 1:
+        return prefix[0]
+    return None
+
+
+def move_session_selection(
+    *,
+    selected_index: int,
+    session_count: int,
+    action: str,
+    rows: int,
+) -> int:
+    if session_count <= 0:
+        return 0
+    visible = max_visible_sessions(rows)
+    if action == "up":
+        next_index = selected_index - 1
+    elif action == "down":
+        next_index = selected_index + 1
+    elif action == "page_up":
+        next_index = selected_index - visible
+    elif action == "page_down":
+        next_index = selected_index + visible
+    elif action == "home":
+        next_index = 0
+    elif action == "end":
+        next_index = session_count - 1
+    else:
+        next_index = selected_index
+    return min(max(next_index, 0), session_count - 1)
+
+
+def _truncate(value: str, max_chars: int) -> str:
+    if max_chars <= 0:
+        return ""
+    if len(value) <= max_chars:
+        return value
+    return value[:max_chars] + "…"