mosscode 0.1.0__py3-none-any.whl

mosscode/teams/view.py

@@ -0,0 +1,182 @@
+"""A member's conversation as short lines — the same in the lead's member view
+(read from its transcript) and in the member's own window (from the events of its turns)."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+from rich.text import Text
+
+from ..appearance import ERROR_COLOR, OPERATION_COLOR, PARAMETER_COLOR
+from ..messages import Completed, Message, ProviderError, RunStopped, ToolCall, ToolProgress, ToolResult
+from ..permissions import safe_display
+from ..serialization import message_from_json
+from .member import TYPE_LABELS
+
+# render_incoming's head of each message: "[来自 lead · 消息 · id=m-1] 摘要：…".
+HEAD = re.compile(r"^\[来自 (\S+) · (.+?) · id=[^\]]*\]\s*(.*)$")
+COMPACTED = "（较早的对话已压缩）"
+
+
+def incoming_line(sender: str, label: str, summary: str) -> Text:
+    line = Text(f"← {sender} · {label}", style="bold")
+    if summary:
+        line.append(f"：{summary[:200]}")
+    return line
+
+
+def call_line(call: ToolCall) -> Text:
+    line = Text("● ", style=OPERATION_COLOR)
+    line.append(call.name, style="bold")
+    line.append(" " + safe_display(call.arguments, 160), style=PARAMETER_COLOR)
+    return line
+
+
+def result_line(result: ToolResult) -> Text:
+    first = (result.output or "").strip().splitlines()[:1]
+    style = ERROR_COLOR if result.is_error else "dim"
+    return Text("  └ " + safe_display(first[0] if first else "完成", 200), style=style)
+
+
+def _incoming(text: str) -> list[Text]:
+    lines, rows = text.splitlines(), []
+    for index, line in enumerate(lines):
+        match = HEAD.match(line)
+        if match is None:
+            continue
+        sender, label, rest = match.groups()
+        rest = rest.removeprefix("摘要：").strip()
+        if not rest:  # The body starts on the next line.
+            rest = next((item.strip() for item in lines[index + 1 :] if item.strip()), "")
+            rest = "" if HEAD.match(rest) or rest.startswith("</incoming") else rest
+        rows.append(incoming_line(sender, label, rest))
+    return rows
+
+
+def message_lines(message: Message) -> list[Text]:
+    """One committed message of the transcript, without its tool calls (Feed pairs them with their results)."""
+    if message.role == "tool":
+        return [result_line(result) for result in message.tool_results]
+    if message.role == "user":
+        if message.synthetic == "compact":
+            return [Text(COMPACTED, style="dim")]
+        text = message.text.strip()
+        if text.startswith("<incoming-messages>"):
+            return _incoming(text)
+        first = text.splitlines()[0] if text else ""
+        return [Text("❯ " + safe_display(first, 200), style="dim")] if first else []
+    return [Text(message.text.strip())] if message.text.strip() else []
+
+
+class Feed:
+    """A member's conversation as lines, from its transcript (lead) or its turn's events (own window).
+
+    A tool call is written together with its result, so the results of parallel calls sit under their own
+    calls; until then the call is in `running`, shown apart from the log as the lead shows its own."""
+
+    def __init__(self) -> None:
+        self.waiting: dict[str, ToolCall] = {}
+
+    @property
+    def running(self) -> list[Text]:
+        return [call_line(call) for call in self.waiting.values()]
+
+    def running_text(self) -> Text:
+        text = Text("\n").join(self.running)
+        text.no_wrap, text.overflow = True, "ellipsis"
+        return text
+
+    def flush(self) -> list[Text]:
+        """Calls whose results never came (an interrupted turn) are written as they were."""
+        lines, self.waiting = self.running, {}
+        return lines
+
+    def result(self, result: ToolResult) -> list[Text]:
+        call = self.waiting.pop(result.call_id, None)
+        return ([call_line(call)] if call is not None else []) + [result_line(result)]
+
+    def message(self, message: Message) -> list[Text]:
+        if message.role == "tool":
+            return [line for result in message.tool_results for line in self.result(result)]
+        lines = self.flush() + message_lines(message)
+        self.waiting.update((call.id, call) for call in message.tool_calls)
+        return lines
+
+    def record(self, record: dict) -> list[Text]:
+        kind = record.get("type")
+        if kind == "message":
+            try:
+                message = message_from_json(record.get("message"))
+            except (ValueError, TypeError, KeyError):
+                return []
+            return self.message(message)
+        if kind == "compact":
+            return self.flush() + [Text(COMPACTED, style="dim")]
+        return []
+
+    def event(self, event) -> list[Text]:
+        """A member's own window, as its turn runs."""
+        if isinstance(event, list):  # The messages of a new turn.
+            return self.flush() + [
+                incoming_line(
+                    message.sender,
+                    TYPE_LABELS.get(message.type, message.type),
+                    message.summary or (message.body.strip().splitlines() or [""])[0],
+                )
+                for message in event
+            ]
+        if isinstance(event, ToolProgress):
+            if event.phase == "running":
+                self.waiting[event.call.id] = event.call
+            elif event.phase == "finished" and event.result is not None:
+                return self.result(event.result)
+        elif isinstance(event, Completed) and event.message.text:
+            return self.flush() + [Text(event.message.text)]
+        elif isinstance(event, RunStopped):
+            lines = self.flush()
+            return lines + (
+                [Text(event.notice, style=ERROR_COLOR)] if event.reason not in {"completed", "max_tokens"} else []
+            )
+        elif isinstance(event, ProviderError):
+            return self.flush() + [Text(str(event), style=ERROR_COLOR)]
+        return []
+
+
+class TranscriptTail:
+    """The records appended to a transcript since the last read. A line still being written stays
+    for the next read; a line that cannot be parsed is skipped."""
+
+    def __init__(self, path: Path):
+        self.path = path
+        self.offset = 0
+        self._partial = b""
+
+    def read(self) -> list[dict]:
+        """Blocking. OSError when the file cannot be read; [] while it does not exist yet."""
+        try:
+            size = self.path.stat().st_size
+        except FileNotFoundError:
+            return []
+        if size < self.offset:  # Replaced by a shorter file: start over.
+            self.offset, self._partial = 0, b""
+        if size == self.offset:
+            return []
+        with self.path.open("rb") as stream:
+            stream.seek(self.offset)
+            data = stream.read(size - self.offset)
+        self.offset += len(data)
+        data = self._partial + data
+        *complete, self._partial = data.split(b"\n")
+        records = []
+        for raw in complete:
+            if not raw.strip():
+                continue
+            try:
+                record = json.loads(raw)
+            except (ValueError, UnicodeError):
+                continue
+            if isinstance(record, dict):
+                records.append(record)
+        return records

mosscode/tool_budget.py

@@ -0,0 +1,86 @@
+"""Layer 1: oversized tool results go to the session directory; the history keeps a preview.
+
+Decided once, before a result enters the history, and never revisited, so requests already sent
+keep a byte-identical prefix for prompt caching.
+"""
+
+from dataclasses import replace
+from pathlib import Path
+from typing import Any
+
+from .context import estimate_text
+from .messages import Message, ToolResult
+from .session import Session
+
+RESULT_TOKENS = 12_500
+MESSAGE_TOKENS = 50_000
+HEAD, TAIL = 2_000, 1_000
+# read_file is paged and reads files already on disk; storing it would loop on the stored copy.
+EXEMPT = frozenset({"read_file"})
+
+
+def preview(text: str, tokens: int, path: Path | None) -> str:
+    size = f"输出过大（约 {tokens} Token，{len(text)} 字符）"
+    if path is None:
+        lead = f"{size}，本次未能保存完整内容。"
+    else:
+        lead = (
+            f"{size}，完整内容已保存到：\n{path}\n"
+            "需要完整内容时用 read_file 读取这个文件（可用 offset 和 limit 分页）。"
+        )
+    omitted = len(text) - HEAD - TAIL
+    return (
+        f"{lead}\n以下是开头 {HEAD} 字符和末尾 {TAIL} 字符：\n{text[:HEAD]}\n"
+        f"…（中间省略 {omitted} 字符）…\n{text[-TAIL:]}"
+    )
+
+
+def store(text: str, details: dict[str, Any], session: Session | None, call_id: str) -> tuple[str, dict[str, Any]]:
+    tokens = estimate_text(text)
+    path = None
+    if session is not None:
+        try:
+            path = session.persist_result(call_id, text)
+        except OSError:
+            path = None
+    extra = {"persisted": str(path)} if path else {"truncated": True}
+    extra["budgeted"] = True  # Already a preview: never stored again.
+    return preview(text, tokens, path), {**details, **extra}
+
+
+def bound_result(
+    name: str, call_id: str, text: str, details: dict[str, Any], session: Session | None
+) -> tuple[str, dict[str, Any]]:
+    """One result over the threshold is stored."""
+    if name in EXEMPT or estimate_text(text) <= RESULT_TOKENS:
+        return text, details
+    return store(text, details, session, call_id)
+
+
+def bound_message(message: Message, session: Session | None) -> Message:
+    """Results of one batch over the combined budget are stored, largest first."""
+    results = list(message.tool_results)
+    sizes = [estimate_text(r.model_text()) for r in results]
+    total = sum(sizes)
+    if total <= MESSAGE_TOKENS:
+        return message
+    candidates = sorted(
+        (i for i, r in enumerate(results) if r.name not in EXEMPT and not r.details.get("budgeted")),
+        key=lambda i: sizes[i],
+        reverse=True,
+    )
+    for index in candidates:
+        if total <= MESSAGE_TOKENS:
+            break
+        result = results[index]
+        output, details = store(result.output, result.details, session, result.call_id)
+        results[index] = replace(result, output=output, details=details)
+        updated = estimate_text(results[index].model_text())
+        total += updated - sizes[index]
+        sizes[index] = updated
+    return replace(message, tool_results=tuple(results))
+
+
+def persisted_note(result: ToolResult) -> str:
+    path = result.details.get("persisted")
+    return f"完整结果已存盘：{path}" if path else ""

mosscode/tools/__init__.py

@@ -0,0 +1,38 @@
+from pathlib import Path
+
+from ..permissions import PermissionPolicy
+from .base import ToolRegistry
+from .files import EditFile, FileState, ReadFile, WriteFile
+from .plan import ExitPlanMode
+from .process import ExecuteCommand
+from .search import Glob, Grep
+from .shell import Shell
+
+
+def create_default_registry(
+    root: Path | None = None,
+    *,
+    permission_mode: str | None = None,
+    load_permissions: bool = True,
+    permissions: PermissionPolicy | None = None,
+    shell: Shell | str | None = "auto",
+) -> ToolRegistry:
+    root = Path.cwd() if root is None else root
+    policy = permissions or PermissionPolicy(root, mode=permission_mode, load=load_permissions)
+    state = FileState()  # Shared so edits can see what read_file returned.
+    tools = (
+        ReadFile(root, state),
+        WriteFile(root, state),
+        EditFile(root, state),
+        ExecuteCommand(root, shell),
+        Glob(root),
+        Grep(root),
+        ExitPlanMode(root),
+    )
+    return ToolRegistry(tools, permissions=policy)
+
+
+def shell_label(registry: ToolRegistry | None) -> str | None:
+    """The execute_command shell's name, e.g. "Git Bash", for prompts and the UI."""
+    shell = getattr(registry.get("execute_command"), "shell", None) if registry is not None else None
+    return shell.label if isinstance(shell, Shell) else None

mosscode/tools/agent.py

@@ -0,0 +1,127 @@
+"""The agent tool and the two task tools of the main conversation."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING, Literal
+
+from pydantic import Field
+
+from .base import CURRENT_CALL, Params, Tool, ToolFailure
+
+if TYPE_CHECKING:
+    from ..agents.runtime import SubAgents
+
+WAIT_LIMIT = 300
+PREVIEW = 4000  # Characters of a running task's last reply shown by task_output.
+
+
+class AgentParams(Params):
+    description: str = Field(min_length=1, max_length=60)
+    prompt: str = Field(min_length=1, max_length=40000)
+    agent_type: str = Field(default="", max_length=64)
+    run_in_background: bool = False
+    isolation: Literal["none", "worktree"] = "none"
+
+
+class AgentTool(Tool):
+    name = "agent"
+    permission_kind = "agent"  # No approval: every call the sub-agent makes is checked on its own.
+    plan_allowed = True  # In plan mode its sub-agents are in plan mode too.
+    timeout = None  # Foreground sub-agents end on their own, or move to the background.
+    description = (
+        "把一段可以独立完成的工作交给子 Agent，你只收到它的结论。系统提示的“子 Agent”一节列出了可用的类型。"
+        "agent_type 写类型名时，子 Agent 从空白对话开始，prompt 必须写清楚完整的任务、背景和期望的结果；"
+        "省略 agent_type 时为 Fork：它继承当前对话的全部内容，总在后台运行，完成后你会收到 <task-notification>。"
+        "description 是 3–10 个字的任务标签。isolation 为 worktree 时，子 Agent 在独立的 git 工作树中运行。"
+    )
+    prompt_summary = "把独立的子任务交给子 Agent"
+    prompt_guidelines = (
+        "适合委派：需要大量搜索或阅读、但只需要结论的调查；互不依赖的多个子任务（在一次回复中同时发起，它们会并行运行）。",
+        "不适合委派：一两次工具调用就能完成的事；需要与用户来回确认的事。",
+        "子 Agent 不能向用户提问；它的结论不会直接显示给用户，需要时由你转述。",
+        "run_in_background 为 true 时立即返回任务 id；不要在等待通知期间重复做同一件事，需要结果时用 task_output。",
+        "会改动文件、且可能与你或其他子 Agent 的改动冲突的任务（例如并行的实验性修改），用 isolation: worktree 让它在独立的"
+        "工作树中进行；有改动时工作树会保留，结果中给出分支名，由你决定是否合并。Fork 不能隔离。",
+    )
+    params_model = AgentParams
+
+    def __init__(self, root, runner: SubAgents):
+        super().__init__(root)
+        self.runner = runner
+
+    async def execute(self, params: AgentParams):
+        call = CURRENT_CALL.get()
+        return await self.runner.call(
+            params.description.strip(),
+            params.prompt,
+            params.agent_type.strip(),
+            params.run_in_background,
+            call.id if call is not None else "",
+            isolation=params.isolation,
+        )
+
+
+class TaskOutputParams(Params):
+    task_id: str = Field(min_length=1, max_length=20)
+    wait: int = Field(default=0, ge=0, le=WAIT_LIMIT)
+
+
+class TaskOutput(Tool):
+    name = "task_output"
+    permission_kind = "agent"
+    read_only = True
+    timeout = WAIT_LIMIT + 10
+    description = (
+        "查看后台任务（子 Agent）的状态与结果。wait 为等待完成的秒数（最多 300），0 表示立即返回；"
+        "任务完成时你也会自动收到 <task-notification>，一般不需要轮询。"
+    )
+    prompt_summary = "查看后台任务的状态与结果"
+    params_model = TaskOutputParams
+
+    def __init__(self, root, runner: SubAgents):
+        super().__init__(root)
+        self.runner = runner
+
+    async def execute(self, params: TaskOutputParams):
+        task = self.runner.tasks.get(params.task_id.strip())
+        if task is None:
+            raise ToolFailure("unknown_task", f"没有任务 {params.task_id}。")
+        if task.status == "running" and params.wait and task.job is not None:
+            await asyncio.wait({task.job}, timeout=params.wait)
+        from ..agents.runtime import stats
+        from ..agents.tasks import STATUS_LABELS
+
+        head = f"任务 {task.id}（{task.label}）：{STATUS_LABELS[task.status]}，{stats(task)}。"
+        if task.status == "running":
+            last = f"最近一次工具调用：{task.last_tool}。" if task.last_tool else "尚未调用工具。"
+            return f"{head}\n{last}", {"task": task.id, "status": task.status}
+        return f"{head}\n\n{task.result or ''}", {"task": task.id, "status": task.status}
+
+
+class TaskStopParams(Params):
+    task_id: str = Field(min_length=1, max_length=20)
+
+
+class TaskStop(Tool):
+    name = "task_stop"
+    permission_kind = "agent"
+    plan_allowed = True
+    description = "停止一个运行中的后台任务（子 Agent）。停止后任务记为已取消，不再收到它的通知。"
+    prompt_summary = "停止后台任务"
+    params_model = TaskStopParams
+
+    def __init__(self, root, runner: SubAgents):
+        super().__init__(root)
+        self.runner = runner
+
+    async def execute(self, params: TaskStopParams):
+        task_id = params.task_id.strip()
+        task = self.runner.tasks.get(task_id)
+        if task is None:
+            raise ToolFailure("unknown_task", f"没有任务 {task_id}。")
+        if not await self.runner.tasks.stop(task_id):
+            from ..agents.tasks import STATUS_LABELS
+
+            return f"任务 {task_id} 已结束（{STATUS_LABELS[task.status]}），无需停止。", {"task": task_id}
+        return f"已停止任务 {task_id}。", {"task": task_id, "stopped": True}