mosscode 0.1.0__py3-none-any.whl

mosscode/usage.py

@@ -0,0 +1,68 @@
+"""Normalize service-reported counters without inventing missing measurements."""
+
+from .messages import Usage, UsageTotals
+
+
+def usage_data(value) -> dict:
+    if value is None:
+        return {}
+    return value if isinstance(value, dict) else value.model_dump()
+
+
+def counter(data: dict, name: str) -> int | None:
+    value = data.get(name)
+    return value if type(value) is int and value >= 0 else None
+
+
+def parse_usage(value, protocol: str) -> Usage:
+    data = usage_data(value)
+    output = counter(data, "output_tokens" if protocol != "openai-chat-completions" else "completion_tokens")
+    if protocol == "anthropic-messages":
+        uncached = counter(data, "input_tokens")
+        read = counter(data, "cache_read_input_tokens")
+        write = counter(data, "cache_creation_input_tokens")
+        if data.get("cache_read_input_tokens") is None and data.get("cache_creation_input_tokens") is None:
+            total = uncached  # Older compatible endpoints may report only total input.
+            uncached = None  # No reliable decomposition of that reported total.
+        else:
+            total = uncached + read + write if all(v is not None for v in (uncached, read, write)) else None
+        return Usage(total, output, read, write, uncached)
+    chat = protocol == "openai-chat-completions"
+    total = counter(data, "prompt_tokens" if chat else "input_tokens")
+    details = data.get("prompt_tokens_details" if chat else "input_tokens_details") or {}
+    if not isinstance(details, dict):
+        details = {}
+    read = counter(details, "cached_tokens")
+    write = counter(details, "cache_write_tokens")
+    miss = None
+    if chat:
+        vendor_read = counter(data, "prompt_cache_hit_tokens")
+        if read is None:
+            read = vendor_read
+        miss = counter(data, "prompt_cache_miss_tokens")
+    return Usage(total, output, read, write, miss)
+
+
+def accumulated(value: int, missing: int, requests: int, unknown: str = "未提供") -> str:
+    if missing == requests:
+        return unknown
+    return ("≥" if missing else "") + str(value)
+
+
+def cache_summary(total: UsageTotals) -> str:
+    read = accumulated(total.cached_input_tokens, total.missing_cached, total.requests)
+    text = f"缓存读 {read}"
+    if total.missing_cache_write < total.requests:
+        text += " / 写 " + accumulated(total.cache_write_tokens, total.missing_cache_write, total.requests)
+    return text
+
+
+def request_usage_text(usage: Usage, iteration: int) -> str:
+    def show(value):
+        return "未提供" if value is None else str(value)
+
+    return (
+        f"第 {iteration} 次请求 · Token 入 {show(usage.input_tokens)} / 出 {show(usage.output_tokens)}"
+        f" · 缓存读 {show(usage.cached_input_tokens)} / 写 {show(usage.cache_write_tokens)}"
+        f" · 未缓存输入 {show(usage.uncached_input_tokens)}"
+    )

mosscode/windows_inline.py

@@ -0,0 +1,148 @@
+"""Use Textual's inline compositor with its existing Windows input driver.
+
+Textual 8 does not ship a Windows inline driver. Keep its console input and mode
+restoration, but stay in the main buffer and consume cursor-position reports.
+"""
+
+import asyncio
+import ctypes
+from ctypes import byref, wintypes
+
+from textual import constants, events
+from textual._xterm_parser import XTermParser
+from textual.drivers import win32
+from textual.drivers._writer_thread import WriterThread
+from textual.drivers.windows_driver import WindowsDriver
+
+KEY_EVENT, WINDOW_BUFFER_SIZE_EVENT = 0x0001, 0x0004
+VK_RETURN, VK_SHIFT = 0x0D, 0x10
+SHIFT_PRESSED = 0x0010
+CTRL_OR_ALT = 0x000F  # Right/left Alt and Ctrl.
+# Kitty keyboard protocol encoding, which Textual's parser reads as "shift+enter".
+SHIFT_ENTER = "\x1b[13;2u"
+
+
+def physical_shift_down() -> bool:
+    return bool(ctypes.windll.user32.GetAsyncKeyState(VK_SHIFT) & 0x8000)
+
+
+def _shift_enter(records, index: int, shift_down) -> bool:
+    event = records[index].Event.KeyEvent
+    state = event.dwControlKeyState
+    if event.wVirtualKeyCode != VK_RETURN:
+        # With VT input enabled the console replaces Enter's key-down record by a
+        # bare "\r" without key code or modifiers, so Shift+Enter would submit.
+        # conhost keeps the modifiers on the key-up record when it follows in the
+        # same batch; Windows Terminal leaves them out there too.
+        following = records[index + 1] if index + 1 < len(records) else None
+        if (
+            following is not None
+            and following.EventType == KEY_EVENT
+            and not following.Event.KeyEvent.bKeyDown
+            and following.Event.KeyEvent.wVirtualKeyCode == VK_RETURN
+        ):
+            state = following.Event.KeyEvent.dwControlKeyState
+    # A record may omit Shift; the keyboard state read right after the key press
+    # covers that, so either source is enough.
+    return (bool(state & SHIFT_PRESSED) or shift_down()) and not state & CTRL_OR_ALT
+
+
+def key_text(records, shift_down=physical_shift_down) -> str:
+    """Text for the parser from one batch of console input records."""
+    keys = []
+    for index, record in enumerate(records):
+        if record.EventType != KEY_EVENT:
+            continue
+        event = record.Event.KeyEvent
+        if not event.bKeyDown or (event.dwControlKeyState and event.wVirtualKeyCode == 0):
+            continue
+        key = event.uChar.UnicodeChar
+        keys.append(SHIFT_ENTER if key == "\r" and _shift_enter(records, index, shift_down) else key)
+    # Textual issue 3178: join surrogate pairs typed as two records.
+    return "".join(keys).encode("utf-16", "surrogatepass").decode("utf-16")
+
+
+class EventMonitor(win32.EventMonitor):
+    """Textual's console input thread with Shift+Enter kept apart from Enter."""
+
+    def run(self) -> None:
+        exit_requested = self.exit_event.is_set
+        parser = XTermParser(debug=constants.DEBUG)
+        try:
+            read_count = wintypes.DWORD(0)
+            handle = win32.GetStdHandle(win32.STD_INPUT_HANDLE)
+            input_records = (win32.INPUT_RECORD * 1024)()
+            while not exit_requested():
+                for event in parser.tick():
+                    self.process_event(event)
+                if win32.wait_for_handles([handle], 100) is None:
+                    continue
+                win32.KERNEL32.ReadConsoleInputW(handle, byref(input_records), 1024, byref(read_count))
+                records = input_records[: read_count.value]
+                text = key_text(records)
+                new_size = None
+                for record in records:
+                    if record.EventType == WINDOW_BUFFER_SIZE_EVENT:
+                        size = record.Event.WindowBufferSizeEvent.dwSize
+                        new_size = (size.X, size.Y)
+                if text:
+                    for event in parser.feed(text):
+                        self.process_event(event)
+                if new_size is not None:
+                    self.on_size_change(*new_size)
+        except Exception as error:
+            self.app.log.error("EVENT MONITOR ERROR", error)
+
+
+class WindowsInlineDriver(WindowsDriver):
+    @property
+    def is_inline(self) -> bool:
+        return True
+
+    def start_application_mode(self) -> None:
+        # Same sequence as WindowsDriver, with the input thread replaced.
+        loop = asyncio.get_running_loop()
+        self._restore_console = win32.enable_application_mode()
+        self._writer_thread = WriterThread(self._file)
+        self._writer_thread.start()
+        self.write("\x1b[?1049h")
+        self._enable_mouse_support()
+        self.write("\x1b[?25l")
+        self.write("\033[?1004h")
+        self.write("\x1b[>1u")
+        self.flush()
+        self._enable_bracketed_paste()
+        self._event_thread = EventMonitor(loop, self._app, self.exit_event, self.process_message)
+        self._event_thread.start()
+
+    def write(self, data: str) -> None:
+        # WindowsDriver emits these only at startup / shutdown. Do not enter or
+        # leave the alternate screen: inline rendering uses relative cursor moves.
+        data = data.replace("\x1b[?1049h", "\r\n" * self._app.INLINE_PADDING)
+        # On exit Textual has already placed the cursor after retained output,
+        # or at the top of a temporary picker. Clear only below that cursor.
+        data = data.replace("\x1b[?1049l", "\x1b[J")
+        if data:
+            # Textual prints the retained screen directly on inline exit. Keep
+            # cursor updates synchronous so queued writes cannot race that print.
+            self._file.write(data)
+
+    def flush(self) -> None:
+        self._file.flush()
+
+    def _enable_mouse_support(self) -> None:
+        # Inline transcript uses the terminal's scrollback, even if a caller
+        # supplied mouse=True or an interrupted older app left tracking enabled.
+        self.write("\x1b[?1000l\x1b[?1003l\x1b[?1015l\x1b[?1006l")
+        self.flush()
+
+    def process_message(self, message) -> None:
+        if isinstance(message, events.MouseEvent):
+            # This interface is keyboard-operated: mouse clicks cannot execute
+            # commands or shift focus away from the prompt. Native wheel input
+            # belongs to the terminal; ignore any stale mouse reports.
+            return
+        elif isinstance(message, events.CursorPosition):
+            self.cursor_origin = (message.x, message.y)
+        else:
+            super().process_message(message)

mosscode/worktree/__init__.py

@@ -0,0 +1,29 @@
+"""Git worktrees, so a sub-agent can change files without touching the main directory."""
+
+from .changes import Changes, count_changes
+from .git import WorktreeError, find_repo, read_head
+from .manager import CleanReport, Created, Entry, Finished, WorktreeChanged, WorktreeManager
+from .meta import WorktreeMeta, load_meta, process_alive
+from .names import EPHEMERAL, branch_of, ephemeral_name, flatten, validate_name
+
+__all__ = [
+    "Changes",
+    "CleanReport",
+    "Created",
+    "EPHEMERAL",
+    "Entry",
+    "Finished",
+    "WorktreeChanged",
+    "WorktreeError",
+    "WorktreeManager",
+    "WorktreeMeta",
+    "branch_of",
+    "count_changes",
+    "ephemeral_name",
+    "find_repo",
+    "flatten",
+    "load_meta",
+    "process_alive",
+    "read_head",
+    "validate_name",
+]

mosscode/worktree/changes.py

@@ -0,0 +1,59 @@
+"""Does a worktree hold work that deleting it would lose? Any doubt counts as yes."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from . import git
+from .git import WorktreeError
+
+FILE_LIMIT = 10
+
+
+@dataclass(frozen=True)
+class Changes:
+    uncommitted: int = 0
+    commits: int = 0
+    files: tuple[str, ...] = ()
+    error: str = ""  # The check failed; uncommitted is then 1.
+
+    @property
+    def any(self) -> bool:
+        return self.uncommitted > 0 or self.commits > 0
+
+    def describe(self) -> str:
+        if self.error:
+            return f"无法确认是否有改动（{self.error}），按有改动处理"
+        parts = []
+        if self.uncommitted:
+            parts.append(f"未提交 {self.uncommitted} 个文件")
+        if self.commits:
+            parts.append(f"独有提交 {self.commits} 个")
+        return "，".join(parts) or "无改动"
+
+
+def count_changes(path: Path, branch: str, skip=()) -> Changes:
+    """skip: links and copied files MossCode put there itself."""
+    skip = {item.rstrip("/") for item in skip}
+    try:
+        status = git.run_git(["status", "--porcelain", "--untracked-files=all"], path)
+        if status.returncode != 0:
+            return Changes(1, 0, (), (status.stderr or "git status 失败").strip()[:200])
+        files = []
+        for line in status.stdout.splitlines():
+            name = line[3:].split(" -> ")[-1].strip().strip('"').rstrip("/")
+            # On Windows git walks into a junction, so the files under a link show up one by one.
+            if name and not any(name == item or name.startswith(item + "/") for item in skip):
+                files.append(name)
+        # With --branches the exclude pattern is relative to refs/heads/.
+        commits = git.run_git(
+            ["rev-list", "--count", "HEAD", "--not", f"--exclude={branch}", "--branches", "--remotes"], path
+        )
+        if commits.returncode != 0:
+            return Changes(
+                max(len(files), 1), 0, tuple(files[:FILE_LIMIT]), (commits.stderr or "git rev-list 失败").strip()[:200]
+            )
+        return Changes(len(files), int(commits.stdout.strip() or "0"), tuple(files[:FILE_LIMIT]))
+    except (WorktreeError, ValueError) as exc:
+        return Changes(1, 0, (), str(exc)[:200])

mosscode/worktree/git.py

@@ -0,0 +1,125 @@
+"""Git plumbing for worktrees: run git without prompts, find the repository, read HEAD without git."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+from pathlib import Path
+
+GIT_TIMEOUT = 120
+EXCLUDE_LINE = "/.mosscode/worktrees/"
+
+
+class WorktreeError(Exception):
+    def __init__(self, message: str, code: str = "worktree_error"):
+        super().__init__(message)
+        self.code = code
+
+
+def run_git(args, cwd: Path, *, timeout: float = GIT_TIMEOUT) -> subprocess.CompletedProcess:
+    """No terminal prompt, no stdin; a missing git is a WorktreeError."""
+    executable = shutil.which("git")
+    if executable is None:
+        raise WorktreeError("找不到 git，无法使用工作树。", "worktree_unavailable")
+    env = {**os.environ, "GIT_TERMINAL_PROMPT": "0", "GIT_ASKPASS": "", "LC_ALL": "C"}
+    try:
+        return subprocess.run(
+            [executable, "-c", "core.quotepath=false", *args],
+            cwd=str(cwd),
+            env=env,
+            stdin=subprocess.DEVNULL,
+            capture_output=True,
+            timeout=timeout,
+            encoding="utf-8",
+            errors="replace",
+        )
+    except subprocess.TimeoutExpired:
+        raise WorktreeError(f"git {args[0]} 超过 {timeout:g} 秒未完成。") from None
+    except OSError as exc:
+        raise WorktreeError(f"无法运行 git：{exc}", "worktree_unavailable") from None
+
+
+def git_text(args, cwd: Path) -> str:
+    """stdout of a git command that must succeed."""
+    done = run_git(args, cwd)
+    if done.returncode != 0:
+        raise WorktreeError(f"git {' '.join(args)} 失败：{(done.stderr or done.stdout).strip()[:500]}")
+    return done.stdout.strip()
+
+
+def find_repo(start: Path) -> tuple[Path, Path]:
+    """(top level of the work tree, common git directory)."""
+    done = run_git(["rev-parse", "--is-bare-repository", "--show-toplevel", "--git-common-dir"], start)
+    lines = done.stdout.strip().splitlines()
+    if done.returncode != 0 or len(lines) < 3:
+        if lines[:1] == ["true"]:
+            raise WorktreeError("当前仓库是裸仓库，无法使用工作树。", "worktree_unavailable")
+        raise WorktreeError("项目目录不在 git 仓库中，无法使用工作树。", "worktree_unavailable")
+    if lines[0] == "true":
+        raise WorktreeError("当前仓库是裸仓库，无法使用工作树。", "worktree_unavailable")
+    top = Path(lines[1]).resolve()
+    common = Path(lines[2])
+    common = (common if common.is_absolute() else start / common).resolve()
+    if run_git(["rev-parse", "--verify", "--quiet", "HEAD^{commit}"], top).returncode != 0:
+        raise WorktreeError("仓库还没有任何提交，无法创建工作树。", "worktree_unavailable")
+    return top, common
+
+
+def ensure_excluded(common: Path) -> bool:
+    """True when the line was added."""
+    path = common / "info" / "exclude"
+    try:
+        text = path.read_text(encoding="utf-8", errors="replace")
+    except FileNotFoundError:
+        text = ""
+    if any(line.strip() == EXCLUDE_LINE for line in text.splitlines()):
+        return False
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a", encoding="utf-8", newline="\n") as stream:
+        stream.write(("" if not text or text.endswith("\n") else "\n") + EXCLUDE_LINE + "\n")
+    return True
+
+
+def _read(path: Path) -> str | None:
+    try:
+        return path.read_text(encoding="utf-8", errors="replace").strip()
+    except OSError:
+        return None
+
+
+def _resolve_ref(ref: str, gitdir: Path, common: Path) -> str | None:
+    for base in (gitdir, common):
+        value = _read(base / ref)
+        if value:
+            return value
+    packed = _read(common / "packed-refs") or ""
+    for line in packed.splitlines():
+        if line and line[0] not in "#^":
+            sha, _, name = line.partition(" ")
+            if name.strip() == ref:
+                return sha
+    return None
+
+
+def read_head(worktree: Path) -> tuple[str, str] | None:
+    """(commit SHA, ref or "") from .git -> gitdir -> HEAD -> loose ref or packed-refs; no git process."""
+    pointer = _read(worktree / ".git")
+    if not pointer or not pointer.startswith("gitdir:"):
+        return None
+    gitdir = Path(pointer.split(":", 1)[1].strip())
+    gitdir = gitdir if gitdir.is_absolute() else (worktree / gitdir).resolve()
+    head = _read(gitdir / "HEAD")
+    if not head:
+        return None
+    relative = _read(gitdir / "commondir")
+    common = (gitdir / relative).resolve() if relative else gitdir
+    if head.startswith("ref:"):
+        ref = head[4:].strip()
+        sha = _resolve_ref(ref, gitdir, common)
+        return (sha, ref) if sha and _is_sha(sha) else None
+    return (head, "") if _is_sha(head) else None
+
+
+def _is_sha(value: str) -> bool:
+    return len(value) in {40, 64} and all(c in "0123456789abcdef" for c in value)