windcode 0.1.0__py3-none-any.whl

windcode/tui/widgets/status.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from rich.text import Text as RichText
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.widgets import Static
+
+from windcode.tui.permission_display import permission_label, permission_style
+
+
+class StatusBar(Horizontal):
+    def compose(self) -> ComposeResult:
+        yield Static("", id="mode-label")
+        yield Static("", id="sandbox-label")
+        yield Static("", id="model-label")
+
+    def set_state(
+        self,
+        *,
+        model: str | None,
+        permission: str,
+        sandbox: bool,
+        state: str,
+        delegation: str | None = None,
+    ) -> None:
+        states = {
+            "idle": "空闲",
+            "running": "运行中",
+            "completed": "已完成",
+            "unverified": "已完成 · 未验证",
+            "failed": "失败",
+            "cancelled": "已取消",
+        }
+        mode_content = RichText()
+        mode_content.append(f"  {states.get(state, state)}", style="#5fa8e8")
+        mode_content.append(" · ", style="#88939b")
+        mode_content.append(permission_label(permission), style=permission_style(permission))
+        self.query_one("#mode-label", Static).update(mode_content)
+        delegation_label = {"explicit": "显式", "proactive": "主动"}.get(
+            delegation or "", delegation or ""
+        )
+        suffix = f" · 委派: {delegation_label}" if delegation_label else ""
+        self.query_one("#sandbox-label", Static).update(
+            f"沙箱: {'开启' if sandbox else '关闭'}{suffix}"
+        )
+        self.query_one("#model-label", Static).update(model or "按配置")

windcode/tui/widgets/subagents.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import ClassVar
+
+from textual.app import ComposeResult
+from textual.binding import Binding, BindingType
+from textual.containers import Vertical
+from textual.widgets import Static
+
+from windcode.domain.events import (
+    SubagentBlocked,
+    SubagentCancelled,
+    SubagentCleanup,
+    SubagentCompleted,
+    SubagentConflict,
+    SubagentEvent,
+    SubagentFailed,
+    SubagentIntegrated,
+    SubagentProgress,
+    SubagentQueued,
+    SubagentStarted,
+)
+from windcode.domain.models import Usage
+
+STATUS_LABELS = {
+    "queued": "排队",
+    "running": "运行",
+    "blocked": "阻塞",
+    "completed": "完成",
+    "failed": "失败",
+    "cancelled": "取消",
+    "conflict": "冲突",
+    "integrated": "已集成",
+}
+
+
+@dataclass(slots=True)
+class SubagentViewState:
+    subagent_id: str
+    task_index: int
+    role: str
+    task_name: str
+    status: str = "queued"
+    summary: str = ""
+    activity: str = "等待调度"
+    usage: Usage = field(default_factory=Usage)
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+    commit: str | None = None
+    verification: tuple[str, ...] = ()
+    retained_path: str | None = None
+
+    @property
+    def elapsed_seconds(self) -> int:
+        if self.created_at is None or self.updated_at is None:
+            return 0
+        return max(0, int((self.updated_at - self.created_at).total_seconds()))
+
+
+class SubagentRow(Vertical, can_focus=True):
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("enter", "toggle_details", "展开详情", priority=True),
+    ]
+
+    def __init__(self, state: SubagentViewState) -> None:
+        super().__init__(classes="subagent-row")
+        self.state = state
+        self.expanded = False
+
+    def compose(self) -> ComposeResult:
+        yield Static(classes="subagent-summary")
+        yield Static(classes="subagent-details")
+
+    def on_mount(self) -> None:
+        self.refresh_state()
+
+    def refresh_state(self) -> None:
+        status = STATUS_LABELS.get(self.state.status, self.state.status)
+        tokens = self.state.usage.input_tokens + self.state.usage.output_tokens
+        self.set_classes(f"subagent-row subagent-status-{self.state.status}")
+        self.query_one(".subagent-summary", Static).update(
+            f"[{status}] {self.state.role} · {self.state.task_name}\n"
+            f"{self.state.elapsed_seconds}s · {tokens} tokens · {self.state.activity}"
+        )
+        details = self.query_one(".subagent-details", Static)
+        detail_lines = [self.state.summary] if self.state.summary else []
+        if self.state.commit:
+            detail_lines.append(f"提交: {self.state.commit}")
+        if self.state.verification:
+            detail_lines.append("验证: " + "; ".join(self.state.verification))
+        if self.state.retained_path:
+            detail_lines.append(f"保留 Worktree: {self.state.retained_path}")
+        details.update("\n".join(detail_lines))
+        details.display = self.expanded and bool(detail_lines)
+
+    def action_toggle_details(self) -> None:
+        self.expanded = not self.expanded
+        self.refresh_state()
+
+
+class SubagentGroup(Vertical):
+    """One stable, incrementally updated group for a root run's child tasks."""
+
+    def __init__(self) -> None:
+        super().__init__(classes="subagent-group")
+        self.states: dict[str, SubagentViewState] = {}
+        self.rows: dict[str, SubagentRow] = {}
+
+    def compose(self) -> ComposeResult:
+        yield Static("子智能体", classes="subagent-group-title")
+
+    async def apply_event(self, event: SubagentEvent) -> None:
+        state = self.states.get(event.subagent_id)
+        if state is None:
+            state = SubagentViewState(
+                subagent_id=event.subagent_id,
+                task_index=event.task_index,
+                role=event.role,
+                task_name=event.task_name,
+                summary=event.summary,
+                created_at=event.created_at,
+                updated_at=event.created_at,
+            )
+            self.states[event.subagent_id] = state
+        state.updated_at = event.created_at
+        state.summary = event.summary or state.summary
+        self._apply_details(state, event)
+
+        row = self.rows.get(event.subagent_id)
+        if row is None:
+            row = SubagentRow(state)
+            self.rows[event.subagent_id] = row
+            before = next(
+                (
+                    existing
+                    for child_id, existing in self.rows.items()
+                    if child_id != event.subagent_id
+                    and self.states[child_id].task_index > state.task_index
+                    and existing.is_attached
+                ),
+                None,
+            )
+            await self.mount(row, before=before)
+        row.refresh_state()
+
+    @staticmethod
+    def _apply_details(state: SubagentViewState, event: SubagentEvent) -> None:
+        if isinstance(event, SubagentQueued):
+            state.status = "queued"
+            state.activity = "等待调度"
+        elif isinstance(event, SubagentStarted):
+            state.status = "running"
+            state.activity = "已启动"
+        elif isinstance(event, SubagentProgress):
+            state.status = "running"
+            state.activity = event.activity or "运行中"
+            if event.usage != Usage():
+                state.usage = event.usage
+        elif isinstance(event, SubagentBlocked):
+            state.status = "blocked"
+            state.activity = event.reason or "需要父智能体处理"
+        elif isinstance(event, SubagentCompleted):
+            state.status = "completed"
+            state.activity = "等待检查或集成"
+            state.commit = event.commit
+            state.verification = event.verification
+            state.usage = event.usage
+        elif isinstance(event, SubagentFailed):
+            state.status = "failed"
+            state.activity = event.message or event.category
+            if event.usage != Usage():
+                state.usage = event.usage
+        elif isinstance(event, SubagentCancelled):
+            state.status = "cancelled"
+            state.activity = event.reason
+            if event.usage != Usage():
+                state.usage = event.usage
+        elif isinstance(event, SubagentIntegrated):
+            state.status = "integrated"
+            state.activity = "提交已集成"
+            state.commit = event.commit
+            state.verification = event.verification
+        elif isinstance(event, SubagentConflict):
+            state.status = "conflict"
+            state.activity = event.message or "集成冲突"
+            if event.conflict_files:
+                state.verification = ("冲突文件: " + ", ".join(event.conflict_files),)
+        elif isinstance(event, SubagentCleanup):
+            state.retained_path = event.retained_path
+            if event.removed:
+                state.activity = "Worktree 已清理"
+            elif event.reason:
+                state.activity = event.reason

windcode/tui/widgets/tools.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from rich.text import Text as RichText
+from textual.widgets import Static
+
+from windcode.domain.events import ToolFinished, ToolProgress, ToolStarted
+
+TOOL_LABELS = {
+    "read_file": "读取文件",
+    "write_file": "写入文件",
+    "edit_file": "编辑文件",
+    "apply_patch": "应用补丁",
+    "glob": "查找文件",
+    "grep": "搜索文本",
+    "shell": "执行命令",
+    "ask_user": "询问用户",
+    "memory_search": "检索长期记忆",
+    "memory_list": "列出长期记忆",
+    "memory_get": "读取长期记忆",
+    "memory_write": "写入长期记忆",
+}
+
+
+def format_duration(seconds: float) -> str:
+    if seconds < 0.01:
+        return "<0.01 秒"
+    if seconds < 1:
+        return f"{seconds:.2f} 秒"
+    return f"{seconds:.1f} 秒"
+
+
+class ToolBlock(Static, can_focus=True):
+    def __init__(self, event: ToolStarted) -> None:
+        self.call_id = event.call_id
+        self.tool_name = event.tool_name
+        command = event.arguments.get("command")
+        self.command = str(command) if command is not None else None
+        self.title = TOOL_LABELS.get(event.tool_name, event.tool_name)
+        super().__init__(
+            self._content(f"● {self.title} ..."),
+            classes="tool-block tool-block-loading",
+        )
+
+    def _content(self, status: str) -> RichText:
+        content = RichText(f"  {status}")
+        if self.tool_name == "shell" and self.command:
+            content.append("\n    ")
+            content.append("bash:", style="bold cyan")
+            content.append(f" {self.command}")
+        return content
+
+    def progress(self, event: ToolProgress) -> None:
+        self.update(self._content(f"● {self.title} ... {event.message}"))
+
+    def finish(self, event: ToolFinished) -> None:
+        self.remove_class("tool-block-loading")
+        marker = "✗" if event.result.is_error else "✓"
+        if event.result.is_error:
+            self.add_class("tool-block-error")
+        exit_code = event.result.data.get("exit_code")
+        detail = f" · 退出码 {exit_code}" if exit_code is not None else ""
+        self.title = (
+            f"{TOOL_LABELS.get(self.tool_name, self.tool_name)}{detail}"
+            f" ({format_duration(event.result.elapsed_seconds)})"
+        )
+        self.update(self._content(f"{marker} {self.title}"))

windcode/tui/widgets/welcome.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from rich.text import Text as RichText
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.events import Resize
+from textual.timer import Timer
+from textual.widgets import Static
+
+from windcode.tui.permission_display import permission_label, permission_style
+
+WIDE_LOGO = r"""
+             _           _
+__      _____(_)_ __   __| | ___ ___   ___  ___
+\ \ /\ / / _ \ | '_ \ / _` |/ __/ _ \ / _ \/ _ \
+ \ V  V /  __/ | | | | (_| | (_| (_) |  __/  __/
+  \_/\_/ \___|_|_| |_|\__,_|\___\___/ \___|\___|
+""".strip("\n")
+
+COMPACT_LOGO = "[ windcode ]"
+MCP_SPINNER_FRAMES = ("⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏")
+LOGO_PALETTE = ("#59c7d6", "#5fa8e8", "#8b8fe8", "#d9a557", "#63c28d")
+
+
+class WelcomeView(Vertical):
+    """Brand-focused empty state for a new Windcode session."""
+
+    def __init__(
+        self,
+        *,
+        model: str,
+        permission: str,
+        sandbox: bool,
+        workspace: Path,
+        id: str | None = None,
+    ) -> None:
+        super().__init__(id=id)
+        self._model = model
+        self._permission = permission
+        self._sandbox = sandbox
+        self._workspace = workspace
+        self._mcp_spinner_timer: Timer | None = None
+        self._mcp_spinner_index = 0
+        self._logo_timer: Timer | None = None
+        self._logo_frame = 0
+
+    def compose(self) -> ComposeResult:
+        yield Static(self._logo(), id="welcome-logo")
+        yield Static("本地编码 Agent", id="welcome-subtitle")
+        yield Static(self._context_content(), id="welcome-context")
+        yield Static("", id="welcome-notice")
+
+    def on_mount(self) -> None:
+        self._logo_timer = self.set_interval(0.12, self._tick_logo)
+
+    def on_unmount(self) -> None:
+        if self._logo_timer is not None:
+            self._logo_timer.stop()
+            self._logo_timer = None
+        self.stop_mcp_loading()
+
+    def _tick_logo(self) -> None:
+        self._logo_frame = (self._logo_frame + 1) % 10_000
+        self.query_one("#welcome-logo", Static).update(self._logo())
+
+    def set_context(
+        self,
+        *,
+        model: str,
+        permission: str,
+        sandbox: bool,
+        workspace: Path,
+    ) -> None:
+        self._model = model
+        self._permission = permission
+        self._sandbox = sandbox
+        self._workspace = workspace
+        if self.is_mounted:
+            self.query_one("#welcome-logo", Static).update(self._logo())
+            self.query_one("#welcome-context", Static).update(self._context_content())
+
+    def show_notice(self, text: str, *, error: bool = False) -> None:
+        notice = self.query_one("#welcome-notice", Static)
+        notice.set_class(error, "welcome-notice-error")
+        notice.update(f"{'错误' if error else '状态'} · {text}")
+
+    def clear_notice(self) -> None:
+        if self.is_mounted:
+            notice = self.query_one("#welcome-notice", Static)
+            notice.remove_class("welcome-notice-error")
+            notice.update("")
+
+    def start_mcp_loading(self) -> None:
+        self.stop_mcp_loading()
+        self._mcp_spinner_index = 0
+        self._render_mcp_loading()
+        self._mcp_spinner_timer = self.set_interval(0.08, self._tick_mcp_loading)
+
+    def stop_mcp_loading(self) -> None:
+        if self._mcp_spinner_timer is not None:
+            self._mcp_spinner_timer.stop()
+            self._mcp_spinner_timer = None
+
+    def _tick_mcp_loading(self) -> None:
+        self._mcp_spinner_index = (self._mcp_spinner_index + 1) % len(MCP_SPINNER_FRAMES)
+        self._render_mcp_loading()
+
+    def _render_mcp_loading(self) -> None:
+        if not self.is_mounted:
+            return
+        frame = MCP_SPINNER_FRAMES[self._mcp_spinner_index]
+        notice = self.query_one("#welcome-notice", Static)
+        notice.remove_class("welcome-notice-error")
+        notice.update(f"{frame} 正在加载 MCP 服务...")
+
+    def on_resize(self, event: Resize) -> None:
+        del event
+        self.query_one("#welcome-logo", Static).update(self._logo())
+
+    def _logo(self) -> RichText:
+        logo = COMPACT_LOGO if self.size.width and self.size.width < 64 else WIDE_LOGO
+        output = RichText(justify="center")
+        lines = logo.splitlines()
+        for row, line in enumerate(lines):
+            for column, char in enumerate(line):
+                if char.isspace():
+                    output.append(char)
+                    continue
+                wave = (column + row * 2 + self._logo_frame) // 3
+                color = LOGO_PALETTE[wave % len(LOGO_PALETTE)]
+                highlight = (column + row + self._logo_frame) % 17 in {0, 1}
+                style = f"bold {color}" + (" on #26343d" if highlight else "")
+                output.append(char, style=style)
+            if row < len(lines) - 1:
+                output.append("\n")
+        return output
+
+    def _context_content(self) -> RichText:
+        context = RichText(justify="center")
+        context.append(self._model, style="bold color(252)")
+        context.append("  ·  ", style="color(240)")
+        context.append(permission_label(self._permission), style=permission_style(self._permission))
+        context.append("  ·  ", style="color(240)")
+        context.append(f"沙箱{'开启' if self._sandbox else '关闭'}", style="color(246)")
+        context.append("\n")
+        context.append(str(self._workspace), style="color(242)")
+        return context

windcode/types.py

@@ -0,0 +1,80 @@
+"""Stable public types for embedding Windcode."""
+
+from windcode.domain.events import (
+    AgentEventType,
+    ApprovalRequested,
+    ApprovalResponse,
+    RunRequest,
+    RunResponse,
+    RunResult,
+    SubagentBlocked,
+    SubagentCancelled,
+    SubagentCleanup,
+    SubagentCompleted,
+    SubagentConflict,
+    SubagentFailed,
+    SubagentIntegrated,
+    SubagentProgress,
+    SubagentQueued,
+    SubagentStarted,
+    UserInputRequested,
+    UserResponse,
+)
+from windcode.domain.subagents import (
+    SubagentRecord,
+    SubagentResult,
+    SubagentRole,
+    SubagentStatus,
+    SubagentTaskKind,
+    SubagentTaskSpec,
+    VerificationResult,
+)
+from windcode.domain.tools import Tool, ToolContext, ToolEffect, ToolResult
+from windcode.extensions.models import (
+    CapabilityRecord,
+    Diagnostic,
+    ExtensionSnapshot,
+    ManagementResult,
+)
+from windcode.extensions.plugins.installer import InstallResult
+from windcode.extensions.state import ManagementAuditRecord
+
+AgentEvent = AgentEventType
+
+__all__ = [
+    "AgentEvent",
+    "ApprovalRequested",
+    "ApprovalResponse",
+    "CapabilityRecord",
+    "Diagnostic",
+    "ExtensionSnapshot",
+    "InstallResult",
+    "ManagementAuditRecord",
+    "ManagementResult",
+    "RunRequest",
+    "RunResponse",
+    "RunResult",
+    "SubagentBlocked",
+    "SubagentCancelled",
+    "SubagentCleanup",
+    "SubagentCompleted",
+    "SubagentConflict",
+    "SubagentFailed",
+    "SubagentIntegrated",
+    "SubagentProgress",
+    "SubagentQueued",
+    "SubagentRecord",
+    "SubagentResult",
+    "SubagentRole",
+    "SubagentStarted",
+    "SubagentStatus",
+    "SubagentTaskKind",
+    "SubagentTaskSpec",
+    "Tool",
+    "ToolContext",
+    "ToolEffect",
+    "ToolResult",
+    "UserInputRequested",
+    "UserResponse",
+    "VerificationResult",
+]

windcode/worktrees/__init__.py

@@ -0,0 +1,24 @@
+from windcode.worktrees.git import GitCommandResult, GitRunner
+from windcode.worktrees.manager import WorktreeManager
+from windcode.worktrees.models import (
+    CleanupResult,
+    GitBaseline,
+    GitErrorCategory,
+    IntegrationResult,
+    WorktreeError,
+    WorktreeLease,
+    WorktreeResult,
+)
+
+__all__ = [
+    "CleanupResult",
+    "GitBaseline",
+    "GitCommandResult",
+    "GitErrorCategory",
+    "GitRunner",
+    "IntegrationResult",
+    "WorktreeError",
+    "WorktreeLease",
+    "WorktreeManager",
+    "WorktreeResult",
+]

windcode/worktrees/git.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import asyncio
+import os
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+
+from windcode.worktrees.models import GitErrorCategory, WorktreeError
+
+
+def _resolve(path: Path) -> Path:
+    return path.expanduser().resolve()
+
+
+@dataclass(frozen=True, slots=True)
+class GitCommandResult:
+    arguments: tuple[str, ...]
+    cwd: Path
+    returncode: int
+    stdout: str
+    stderr: str
+
+
+class GitRunner:
+    def __init__(self, *, timeout_seconds: float = 30.0) -> None:
+        self.timeout_seconds = timeout_seconds
+
+    async def run(
+        self,
+        arguments: Sequence[str],
+        *,
+        cwd: Path,
+        check: bool = True,
+        timeout_seconds: float | None = None,
+        cancelled: Callable[[], bool] | None = None,
+    ) -> GitCommandResult:
+        if cancelled is not None and cancelled():
+            raise WorktreeError(GitErrorCategory.CANCELLED, "Git operation was cancelled")
+        resolved_cwd = _resolve(cwd)
+        environment = os.environ.copy()
+        environment.update(
+            {
+                "GIT_TERMINAL_PROMPT": "0",
+                "GCM_INTERACTIVE": "never",
+                "GIT_ASKPASS": "/bin/false",
+                "SSH_ASKPASS": "/bin/false",
+            }
+        )
+        process = await asyncio.create_subprocess_exec(
+            "git",
+            *arguments,
+            cwd=resolved_cwd,
+            env=environment,
+            stdin=asyncio.subprocess.DEVNULL,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            start_new_session=True,
+        )
+        timeout = self.timeout_seconds if timeout_seconds is None else timeout_seconds
+        try:
+            stdout_bytes, stderr_bytes = await asyncio.wait_for(process.communicate(), timeout)
+        except TimeoutError as exc:
+            process.kill()
+            await process.wait()
+            raise WorktreeError(
+                GitErrorCategory.TIMEOUT,
+                f"Git command timed out after {timeout:g} seconds",
+            ) from exc
+        except asyncio.CancelledError:
+            process.kill()
+            await process.wait()
+            raise
+        result = GitCommandResult(
+            arguments=tuple(arguments),
+            cwd=resolved_cwd,
+            returncode=process.returncode or 0,
+            stdout=stdout_bytes.decode("utf-8", errors="replace"),
+            stderr=stderr_bytes.decode("utf-8", errors="replace"),
+        )
+        if check and result.returncode != 0:
+            message = result.stderr.strip() or result.stdout.strip() or "Git command failed"
+            lowered = message.lower()
+            category = (
+                GitErrorCategory.NOT_REPOSITORY
+                if "not a git repository" in lowered
+                else GitErrorCategory.COMMAND_FAILED
+            )
+            raise WorktreeError(category, message)
+        if cancelled is not None and cancelled():
+            raise WorktreeError(GitErrorCategory.CANCELLED, "Git operation was cancelled")
+        return result