windcode 0.1.0__py3-none-any.whl

windcode/tui/widgets/approval.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from typing import ClassVar
+
+from rich.markup import escape
+from textual.app import ComposeResult
+from textual.binding import Binding, BindingType
+from textual.containers import Vertical
+from textual.message import Message
+from textual.widgets import Static
+
+from windcode.domain.events import ApprovalRequested
+
+CHOICE_LABELS = {
+    "allow_once": "仅本次允许",
+    "allow_session": "会话内允许",
+    "deny": "拒绝",
+}
+
+
+class ApprovalWidget(Vertical, can_focus=True):
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("up", "cursor_up", "向上", priority=True),
+        Binding("down", "cursor_down", "向下", priority=True),
+        Binding("enter", "select", "选择", priority=True),
+        Binding("escape", "deny", "拒绝", priority=True),
+    ]
+
+    class Decision(Message):
+        def __init__(self, request_id: str, decision: str) -> None:
+            super().__init__()
+            self.request_id = request_id
+            self.decision = decision
+
+    def __init__(self, request: ApprovalRequested) -> None:
+        super().__init__(classes="interaction", id=f"approval-{request.request_id}")
+        self.request = request
+        self.cursor = 0
+
+    def compose(self) -> ComposeResult:
+        yield Static(self._build_content(), id="approval-content")
+
+    def on_mount(self) -> None:
+        self.focus()
+
+    def _build_content(self) -> str:
+        risk = {"low": "低风险", "medium": "中风险", "high": "高风险"}.get(
+            self.request.risk, self.request.risk
+        )
+        lines = [
+            f"\n  [bold yellow]需要授权 · {risk}[/bold yellow]\n",
+        ]
+        if self.request.subagent_id is not None:
+            role = escape(self.request.subagent_role or "unknown")
+            subagent_id = escape(self.request.subagent_id)
+            lines.append(f"  [bold cyan]子智能体 {subagent_id} · {role}[/bold cyan]")
+        if self.request.tool_name:
+            tool_name = escape(self.request.tool_name)
+            arguments = (
+                None
+                if self.request.arguments_summary is None
+                else escape(self.request.arguments_summary)
+            )
+            if self.request.tool_name == "shell" and arguments:
+                lines.append(f"  [bold cyan]bash:[/bold cyan] {arguments}")
+            elif arguments:
+                lines.append(f"  [bold cyan]{tool_name}:[/bold cyan] {arguments}")
+            else:
+                lines.append(f"  工具: {tool_name}")
+        summary = escape(self.request.summary)
+        lines.extend((f"    {summary}\n", "  [dim]是否继续执行?[/dim]\n"))
+        for index, choice in enumerate(self.request.choices):
+            label = CHOICE_LABELS.get(choice, choice)
+            if index == self.cursor:
+                lines.append(f" [bold cyan]>[/bold cyan] {index + 1}. [bold]{label}[/bold]")
+            else:
+                lines.append(f"   {index + 1}. [dim]{label}[/dim]")
+        return "\n".join(lines)
+
+    def _refresh(self) -> None:
+        self.query_one("#approval-content", Static).update(self._build_content())
+
+    def action_cursor_up(self) -> None:
+        if self.cursor > 0:
+            self.cursor -= 1
+            self._refresh()
+
+    def action_cursor_down(self) -> None:
+        if self.cursor < len(self.request.choices) - 1:
+            self.cursor += 1
+            self._refresh()
+
+    def action_select(self) -> None:
+        decision = self.request.choices[self.cursor]
+        self.post_message(self.Decision(self.request.request_id, decision))
+
+    def action_deny(self) -> None:
+        self.post_message(self.Decision(self.request.request_id, "deny"))

windcode/tui/widgets/command_menu.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from rich.markup import escape
+from textual.widgets import Static
+
+from windcode.tui.commands import CompletionDefinition
+
+
+class CommandMenu(Static):
+    """Keyboard-driven command and Skill candidates shown above the prompt."""
+
+    visible_items = 8
+
+    def __init__(
+        self,
+        *,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+        disabled: bool = False,
+    ) -> None:
+        super().__init__("", name=name, id=id, classes=classes, disabled=disabled)
+        self._items: tuple[CompletionDefinition, ...] = ()
+        self._cursor = 0
+        self.display = False
+
+    @property
+    def is_open(self) -> bool:
+        return bool(self.display and self._items)
+
+    @property
+    def items(self) -> tuple[CompletionDefinition, ...]:
+        return self._items
+
+    @property
+    def cursor(self) -> int:
+        return self._cursor
+
+    def show_commands(self, items: tuple[CompletionDefinition, ...]) -> None:
+        if not items:
+            self.hide()
+            return
+        self._items = items
+        self._cursor = 0
+        self.display = True
+        self._render_items()
+
+    def hide(self) -> None:
+        self.display = False
+        self._items = ()
+        self._cursor = 0
+        self.update("")
+
+    def move_up(self) -> None:
+        if self._cursor > 0:
+            self._cursor -= 1
+            self._render_items()
+
+    def move_down(self) -> None:
+        if self._cursor < len(self._items) - 1:
+            self._cursor += 1
+            self._render_items()
+
+    def selected_value(self) -> str | None:
+        if not self._items:
+            return None
+        return self._items[self._cursor].value
+
+    def _render_items(self) -> None:
+        window_start = min(
+            max(0, self._cursor - self.visible_items + 1),
+            max(0, len(self._items) - self.visible_items),
+        )
+        visible = self._items[window_start : window_start + self.visible_items]
+        command_width = max(
+            len(item.value) + (len(item.argument_hint) + 1 if item.argument_hint else 0)
+            for item in visible
+        )
+        lines: list[str] = []
+        for offset, item in enumerate(visible):
+            index = window_start + offset
+            command = item.value
+            if item.argument_hint:
+                command = f"{command} {item.argument_hint}"
+            label = f"{command:<{command_width}}  {item.description}"
+            if index == self._cursor:
+                lines.append(f"[bold reverse]> {escape(label)} [/]")
+            else:
+                lines.append(f"  [dim]{escape(label)}[/]")
+        self.update("\n".join(lines))

windcode/tui/widgets/extensions.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from textual.widgets import Static
+
+from windcode.extensions.models import CapabilityRecord
+
+
+class ExtensionList(Static):
+    """Responsive textual representation of the shared extension catalog."""
+
+    DEFAULT_CSS = """
+    ExtensionList {
+        width: 100%;
+        height: auto;
+        max-height: 16;
+        overflow-y: auto;
+        padding: 0 2;
+    }
+    """
+
+    @staticmethod
+    def render_text(records: tuple[CapabilityRecord, ...]) -> str:
+        lines = ["扩展能力:"]
+        for record in records:
+            state = record.activation.value
+            trust = "trusted" if record.trusted else "untrusted"
+            permissions = [
+                name
+                for name, required in (
+                    ("read", record.permissions.filesystem_read),
+                    ("write", record.permissions.filesystem_write),
+                    ("network", record.permissions.network),
+                    ("process", record.permissions.process),
+                )
+                if required
+            ]
+            lines.append(
+                f"{record.capability_id}\n  {record.kind.value} · {record.source.scope.value} · "
+                f"{state} · {trust} · permissions={','.join(permissions) or 'none'}"
+            )
+            lines.extend(
+                f"  diagnostic={diagnostic.category}: {diagnostic.message}"
+                for diagnostic in record.diagnostics
+            )
+        return "\n".join(lines) if records else "扩展能力:\n未发现扩展能力"
+
+    def __init__(self, records: tuple[CapabilityRecord, ...]) -> None:
+        super().__init__(self.render_text(records))

windcode/tui/widgets/input.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from typing import Any, ClassVar
+
+from textual.binding import Binding
+from textual.message import Message
+from textual.widgets import TextArea
+
+from windcode.tui.widgets.command_menu import CommandMenu
+
+
+class ChatInput(TextArea):
+    BINDINGS: ClassVar[list[Binding]] = [
+        Binding("enter", "submit", "发送", priority=True),
+        Binding("shift+enter", "newline", "换行", priority=True),
+        Binding("ctrl+j", "newline", "换行", priority=True),
+        Binding("tab", "complete", "补全", priority=True),
+        Binding("escape", "dismiss_menu", "关闭菜单", priority=True),
+        Binding("up", "nav_up", "向上选择", priority=True),
+        Binding("down", "nav_down", "向下选择", priority=True),
+    ]
+
+    class Submitted(Message):
+        def __init__(self, text: str) -> None:
+            super().__init__()
+            self.text = text
+
+    class SlashMenuUpdate(Message):
+        def __init__(self, prefix: str | None) -> None:
+            super().__init__()
+            self.prefix = prefix
+
+    class SkillMenuUpdate(Message):
+        def __init__(self, prefix: str | None) -> None:
+            super().__init__()
+            self.prefix = prefix
+
+    class EscapePressed(Message):
+        pass
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self.cursor_blink = False
+
+    def action_submit(self) -> None:
+        menu = self._command_menu()
+        if menu is not None and menu.is_open:
+            selected = menu.selected_value()
+            menu.hide()
+            if selected is not None:
+                self.post_message(self.Submitted(selected))
+                self.clear()
+                return
+        text = self.text.strip()
+        if text:
+            self.post_message(self.Submitted(text))
+            self.clear()
+
+    def action_newline(self) -> None:
+        self.insert("\n")
+
+    def action_complete(self) -> None:
+        menu = self._command_menu()
+        if menu is not None and menu.is_open:
+            selected = menu.selected_value()
+            if selected is not None:
+                menu.hide()
+                self.clear()
+                self.insert(f"{selected} ")
+            return
+        self.insert("\t")
+
+    def action_dismiss_menu(self) -> None:
+        menu = self._command_menu()
+        if menu is not None and menu.is_open:
+            menu.hide()
+        else:
+            self.post_message(self.EscapePressed())
+        self.focus()
+
+    def action_nav_up(self) -> None:
+        menu = self._command_menu()
+        if menu is not None and menu.is_open:
+            menu.move_up()
+            return
+        self.action_cursor_up()
+
+    def action_nav_down(self) -> None:
+        menu = self._command_menu()
+        if menu is not None and menu.is_open:
+            menu.move_down()
+            return
+        self.action_cursor_down()
+
+    def on_text_area_changed(self, event: TextArea.Changed) -> None:
+        event.stop()
+        value = self.text
+        single_token = " " not in value and "\n" not in value
+        if value.startswith("/") and single_token:
+            self.post_message(self.SlashMenuUpdate(value))
+        elif value.startswith("$") and single_token:
+            self.post_message(self.SkillMenuUpdate(value))
+        else:
+            self.post_message(self.SlashMenuUpdate(None))
+
+    def _command_menu(self) -> CommandMenu | None:
+        try:
+            return self.screen.query_one(CommandMenu)
+        except Exception:
+            return None

windcode/tui/widgets/memory.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+from typing import ClassVar, cast
+
+from rich.text import Text
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.message import Message
+from textual.screen import ModalScreen
+from textual.widgets import Button, OptionList, Select, Static, Switch
+from textual.widgets.option_list import Option
+
+from windcode.memory import MemoryActivation, MemoryRecord, MemoryStatus
+
+
+class MemoryManager(ModalScreen[None]):
+    BINDINGS: ClassVar[list[Binding]] = [Binding("escape", "close", "关闭")]
+
+    class EnabledChanged(Message):
+        def __init__(self, enabled: bool) -> None:
+            super().__init__()
+            self.enabled = enabled
+
+    class Forget(Message):
+        def __init__(self, memory_id: str) -> None:
+            super().__init__()
+            self.memory_id = memory_id
+
+    class ActivationChanged(Message):
+        def __init__(self, memory_id: str, activation: MemoryActivation) -> None:
+            super().__init__()
+            self.memory_id = memory_id
+            self.activation = activation
+
+    class Rebuild(Message):
+        pass
+
+    class Closed(Message):
+        pass
+
+    def __init__(self, records: tuple[MemoryRecord, ...], *, enabled: bool) -> None:
+        super().__init__(id="memory-manager")
+        self.records = records
+        self.enabled = enabled
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="memory-dialog"):
+            yield Static("长期记忆", id="memory-manager-title")
+            with Horizontal(id="memory-enabled-row"):
+                yield Static("启用跨会话记忆", id="memory-enabled-label")
+                yield Switch(value=self.enabled, id="memory-enabled")
+            yield Static(
+                "稳定事实与用户偏好自动保存; 经验遵循 No Execution, No Memory。",
+                id="memory-policy",
+            )
+            yield OptionList(*self._options(), id="memory-list")
+            yield Static("选择一条记忆查看详情", id="memory-details")
+            yield Select(
+                ((item.value, item.value) for item in MemoryActivation),
+                id="memory-activation",
+                prompt="激活策略",
+                allow_blank=False,
+                disabled=True,
+            )
+            with Horizontal(id="memory-actions", classes="dialog-actions"):
+                yield Button("忘记所选", id="memory-forget", variant="error")
+                yield Button("重建索引", id="memory-rebuild")
+                yield Button("关闭", id="memory-close", variant="primary")
+
+    def _options(self) -> tuple[Option, ...]:
+        options: list[Option] = []
+        for record in self.records:
+            text = Text()
+            text.append("● " if record.status.value == "active" else "○ ", style="cyan")
+            text.append(record.title, style="bold")
+            text.append(
+                f"  {record.kind.value} · {record.scope.value} · {record.status.value} · "
+                f"{record.activation.value}",
+                style="dim",
+            )
+            options.append(Option(text, id=record.memory_id))
+        return tuple(options)
+
+    def _selected_id(self) -> str | None:
+        option = self.query_one("#memory-list", OptionList).highlighted_option
+        return option.id if option is not None else None
+
+    @on(OptionList.OptionHighlighted, "#memory-list")
+    def highlighted(self, event: OptionList.OptionHighlighted) -> None:
+        record = next(item for item in self.records if item.memory_id == event.option.id)
+        summary = " ".join(record.summary.split())
+        body = " ".join(record.body.split())
+        content = (
+            record.body if summary == body else f"摘要: {record.summary}\n\n内容: {record.body}"
+        )
+        self.query_one("#memory-details", Static).update(
+            f"类型: {record.kind.value} · 状态: {record.status.value} · "
+            f"激活: {record.activation.value} · 优先级: {record.priority}\n\n{content}\n\n"
+            f"更新时间: {record.updated_at.isoformat()} · "
+            f"置信度: {record.confidence:.0%}"
+        )
+        selector = cast(Select[str], self.query_one("#memory-activation", Select))
+        selector.value = record.activation.value
+        selector.disabled = record.status is not MemoryStatus.ACTIVE
+
+    @on(Select.Changed, "#memory-activation")
+    def activation_changed(self, event: Select.Changed) -> None:
+        memory_id = self._selected_id()
+        if memory_id is None or event.value is Select.BLANK:
+            return
+        record = next(item for item in self.records if item.memory_id == memory_id)
+        activation = MemoryActivation(str(event.value))
+        if record.status is MemoryStatus.ACTIVE and activation is not record.activation:
+            self.post_message(self.ActivationChanged(memory_id, activation))
+
+    @on(Switch.Changed, "#memory-enabled")
+    def enabled_changed(self, event: Switch.Changed) -> None:
+        if event.value != self.enabled:
+            self.enabled = event.value
+            self.post_message(self.EnabledChanged(event.value))
+
+    @on(Button.Pressed)
+    def button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "memory-forget":
+            if memory_id := self._selected_id():
+                self.post_message(self.Forget(memory_id))
+        elif event.button.id == "memory-rebuild":
+            self.post_message(self.Rebuild())
+        elif event.button.id == "memory-close":
+            self.action_close()
+
+    def refresh_records(self, records: tuple[MemoryRecord, ...]) -> None:
+        self.records = records
+        listing = self.query_one("#memory-list", OptionList)
+        listing.clear_options()
+        listing.add_options(self._options())
+        self.query_one("#memory-details", Static).update("选择一条记忆查看详情")
+        cast(Select[str], self.query_one("#memory-activation", Select)).disabled = True
+
+    def action_close(self) -> None:
+        self.post_message(self.Closed())