mosscode 0.1.0__py3-none-any.whl

mosscode/member_ui.py

@@ -0,0 +1,289 @@
+"""The lead's member panel and member view.
+
+The widgets only show what MossCodeApp hands them; reading the team record and transcripts, and the
+keys that route between them, stay in tui.py.
+"""
+
+from __future__ import annotations
+
+from rich.table import Table
+from rich.text import Text
+from textual import events
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.widgets import OptionList, RichLog, Static
+
+from .appearance import OPERATION_COLOR, TOOL_SUCCESS_COLOR
+from .teams.runtime import STATUS_NAMES, MemberRow
+from .teams.view import Feed
+
+COMPACT_ROWS = 4
+EXPANDED_ROWS = 8
+VIEW_MESSAGES = 200
+VIEW_SHARE = 1.0  # Of the rows left by the status line (and a card).
+STOP_CONFIRM = 2.0  # Seconds between the two presses of x.
+ASKING = "待审批"
+SYMBOLS = {
+    "running": ("●", TOOL_SUCCESS_COLOR),
+    "idle": ("○", "dim"),
+    "stopped": ("·", "dim"),
+    "asking": ("◆", OPERATION_COLOR),
+}
+PANEL_HELP = "↑ / ↓ 选择 · Enter 查看对话 · x 停止成员 · Esc 收起"
+VIEW_HELP = "PgUp / PgDn 滚动 · ← / → 切换成员 · Esc 返回 Lead"
+
+
+def elapsed(seconds: float) -> str:
+    seconds = max(0, int(seconds))
+    if seconds < 60:
+        return f"{seconds}s"
+    if seconds < 3600:
+        return f"{seconds // 60}m{seconds % 60:02d}s"
+    return f"{seconds // 3600}h{seconds % 3600 // 60:02d}m"
+
+
+def state_of(row: MemberRow, asking: dict[str, int]) -> str:
+    """A waiting approval shows over running."""
+    return "asking" if asking.get(row.name) and row.status != "stopped" else row.status
+
+
+def state_name(row: MemberRow, asking: dict[str, int]) -> str:
+    state = state_of(row, asking)
+    return ASKING if state == "asking" else STATUS_NAMES.get(state, state)
+
+
+def _grid() -> Table:
+    grid = Table.grid(padding=(0, 1), expand=True)
+    grid.add_column(no_wrap=True)  # Symbol and name.
+    grid.add_column(no_wrap=True)  # State.
+    grid.add_column(ratio=1, no_wrap=True, overflow="ellipsis")  # Task and tool: cut, never wrapped.
+    grid.add_column(no_wrap=True, justify="right")  # Elapsed, pane.
+    return grid
+
+
+def _cells(row: MemberRow, asking: dict[str, int], now: float) -> tuple[Text, Text, Text, Text]:
+    state = state_of(row, asking)
+    symbol, style = SYMBOLS.get(state, ("·", "dim"))
+    name = Text(symbol + " ", style=style)
+    name.append(row.name, style="bold" if state != "stopped" else "dim")
+    detail = " · ".join(part for part in (row.task, row.last_tool if row.status == "running" else "") if part)
+    tail = []
+    if row.status == "running" and row.since is not None:
+        tail.append(elapsed(now - row.since))
+    if row.pane:
+        tail.append("窗格")
+    return (
+        name,
+        Text(state_name(row, asking), style=style if state != "idle" else "dim"),
+        Text(detail, style="dim"),
+        Text(" · ".join(tail), style="dim"),
+    )
+
+
+def row_line(row: MemberRow, asking: dict[str, int], now: float) -> Table:
+    grid = _grid()
+    grid.add_row(*_cells(row, asking, now))
+    return grid
+
+
+def compact_rows(rows: list[MemberRow], asking: dict[str, int], now: float, limit: int = COMPACT_ROWS):
+    """At most `limit` lines; stopped members, then idle ones, then the rest are summed up."""
+    live = [row for row in rows if row.status != "stopped"]
+    stopped = len(rows) - len(live)
+    entries: list[tuple[MemberRow | Text, int]] = [(row, 1) for row in live]
+    tail: list[tuple[Text, int]] = [(Text(f"已停止 {stopped}", style="dim"), stopped)] if stopped else []
+    if len(entries) + len(tail) > limit:
+        idle = [row for row in live if row.status == "idle" and not asking.get(row.name)]
+        if len(idle) > 1:
+            entries = [(row, 1) for row in live if row not in idle]
+            names = "、".join(row.name for row in idle)
+            entries.append(
+                (Text(f"○ 空闲 {len(idle)}：{names}", style="dim", no_wrap=True, overflow="ellipsis"), len(idle))
+            )
+    entries += tail
+    if len(entries) > limit:
+        hidden = sum(count for _, count in entries[limit - 1 :])
+        entries = entries[: limit - 1] + [(Text(f"另有 {hidden} 个成员 · Ctrl+T 展开", style="dim"), hidden)]
+    grid = _grid()
+    for entry, _ in entries:
+        if isinstance(entry, MemberRow):
+            grid.add_row(*_cells(entry, asking, now))
+        else:
+            grid.add_row(entry, Text(""), Text(""), Text(""))
+    return grid, len(entries)
+
+
+class MemberList(OptionList):
+    """Keys only; a click does not choose (as KeyboardOptions in tui.py)."""
+
+    BINDINGS = [Binding("x", "app.stop_member", "停止成员", show=False)]
+
+    async def _on_click(self, event: events.Click) -> None:
+        event.prevent_default()
+        event.stop()
+
+
+class MemberPanel(Vertical):
+    """Compact lines under the prompt; Ctrl+T turns it into a list to pick from."""
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.rows: list[MemberRow] = []
+        self.asking: dict[str, int] = {}
+        self.expanded = False
+        self.lines = 0  # Rows it takes on screen, for MossCodeApp._fit_chat.
+
+    def compose(self) -> ComposeResult:
+        yield Static("", id="member-compact")
+        members = MemberList(id="member-list")
+        members.display = False
+        yield members
+        help_line = Static(PANEL_HELP, id="member-help", markup=False)
+        help_line.display = False
+        yield help_line
+
+    @property
+    def live(self) -> bool:
+        return any(row.status != "stopped" for row in self.rows)
+
+    @property
+    def selected(self) -> str:
+        members = self.query_one("#member-list", MemberList)
+        index = members.highlighted
+        return self.rows[index].name if index is not None and index < len(self.rows) else ""
+
+    def show(self, rows: list[MemberRow], asking: dict[str, int], now: float) -> None:
+        self.rows, self.asking = rows, asking
+        if self.expanded:
+            members = self.query_one("#member-list", MemberList)
+            chosen = self.selected
+            members.clear_options()
+            members.add_options([row_line(row, asking, now) for row in rows])
+            members.styles.height = max(1, min(EXPANDED_ROWS, len(rows)))
+            names = [row.name for row in rows]
+            if rows:
+                members.highlighted = names.index(chosen) if chosen in names else 0
+            self.lines = min(EXPANDED_ROWS, max(1, len(rows))) + 1
+        else:
+            grid, self.lines = compact_rows(rows, asking, now)
+            self.query_one("#member-compact", Static).update(grid)
+
+    def expand(self, now: float, select: str = "") -> None:
+        self.expanded = True
+        self.query_one("#member-compact").display = False
+        members = self.query_one("#member-list", MemberList)
+        members.display = True
+        self.query_one("#member-help").display = True
+        self.help(PANEL_HELP)
+        self.show(self.rows, self.asking, now)
+        names = [row.name for row in self.rows]
+        if select in names:
+            members.highlighted = names.index(select)
+        members.focus()
+
+    def collapse(self, now: float) -> None:
+        self.expanded = False
+        self.query_one("#member-list").display = False
+        self.query_one("#member-help").display = False
+        self.query_one("#member-compact").display = True
+        self.show(self.rows, self.asking, now)
+
+    def help(self, text: str) -> None:
+        self.query_one("#member-help", Static).update(text)
+
+
+class MemberLog(RichLog):
+    """PgUp/PgDn, Home/End and ↑/↓ scroll (RichLog's own keys); ←/→ switch members."""
+
+    BINDINGS = [Binding("left", "app.member_step(-1)", show=False), Binding("right", "app.member_step(1)", show=False)]
+
+
+class MemberView(Vertical):
+    """Header, the member's conversation, its calls still running, help."""
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.name_shown = ""
+        self.team = ""
+        self.tail = None  # teams.view.TranscriptTail of the member shown.
+        self.feed = Feed()
+        self.unseen = False
+
+    def compose(self) -> ComposeResult:
+        yield Static("", id="member-head", markup=False)
+        yield MemberLog(id="member-log", wrap=True, markup=False, max_lines=5000)
+        running = Static("", id="member-running", markup=False)
+        running.display = False
+        yield running
+        yield Static(VIEW_HELP, id="member-view-help", markup=False)
+
+    @property
+    def member_log(self) -> MemberLog:
+        return self.query_one("#member-log", MemberLog)
+
+    def head(self, row: MemberRow | None, asking: dict[str, int]) -> None:
+        text = Text(f"成员 {self.name_shown} · 团队 {self.team}", style="bold")
+        if row is None:
+            text.append(" · 已不在团队中", style="dim")
+        else:
+            text.append(" · " + state_name(row, asking), style=OPERATION_COLOR if row.status != "stopped" else "dim")
+            if row.status == "running" and row.last_tool:
+                text.append(" · " + row.last_tool, style="dim")
+        self.query_one("#member-head", Static).update(text)
+
+    def reset(self, name: str, team: str, tail) -> None:
+        self.name_shown, self.team, self.tail, self.unseen = name, team, tail, False
+        self.feed = Feed()
+        self.member_log.clear()
+        self.show_running()
+        self.help()
+
+    def write(self, lines: list, *, follow: bool | None = None) -> None:
+        """Follow only while at the bottom; otherwise say there is more."""
+        if not lines:
+            return
+        log = self.member_log
+        follow = log.is_vertical_scroll_end if follow is None else follow
+        for line in lines:
+            log.write(line, scroll_end=follow)
+        if not follow and not self.unseen:
+            self.unseen = True
+            self.help()
+
+    def show_running(self) -> None:
+        running = self.query_one("#member-running", Static)
+        running.update(self.feed.running_text())
+        running.display = bool(self.feed.waiting)
+
+    def help(self) -> None:
+        text = Text(VIEW_HELP, style="dim")
+        if self.unseen:
+            text = Text("有新内容 · End 回到底部", style=OPERATION_COLOR)
+            text.append(" · " + VIEW_HELP, style="dim")
+        self.query_one("#member-view-help", Static).update(text)
+
+    def seen(self) -> None:
+        if self.unseen and self.member_log.is_vertical_scroll_end:
+            self.unseen = False
+            self.help()
+
+
+__all__ = [
+    "ASKING",
+    "COMPACT_ROWS",
+    "EXPANDED_ROWS",
+    "MemberList",
+    "MemberLog",
+    "MemberPanel",
+    "MemberView",
+    "PANEL_HELP",
+    "STOP_CONFIRM",
+    "VIEW_HELP",
+    "VIEW_MESSAGES",
+    "VIEW_SHARE",
+    "compact_rows",
+    "elapsed",
+    "row_line",
+    "state_name",
+]

mosscode/memory.py

@@ -0,0 +1,291 @@
+"""Memory notes: two scopes, one Markdown file per note, and a program-generated MEMORY.md.
+
+The memory tool and the background extractor share every check here, so neither can write
+outside the two note directories, store a credential, or leave an index out of step with its notes.
+"""
+
+import os
+import re
+import secrets
+import threading
+from dataclasses import dataclass
+from datetime import date
+from pathlib import Path
+
+from .context import estimate_text
+from .paths import mosscode_home, project_dir
+
+SLUG = re.compile(r"[a-z0-9][a-z0-9-]{0,59}")
+TYPES = ("user", "feedback", "project", "reference")
+SCOPES = ("user", "project")
+SCOPE_LABELS = {"user": "用户级", "project": "项目级"}
+INDEX_FILE = "MEMORY.md"
+DESCRIPTION_LIMIT = 150
+BODY_LIMIT = 4096  # UTF-8 bytes.
+INDEX_TOKENS = 3000  # Both indexes together, as injected into the system prompt.
+INDEX_LINES = 200  # Per index.
+MAX_OPERATIONS = 5
+_DATE = re.compile(r"\d{4}-\d{2}-\d{2}")
+
+# An aid, not a guarantee; the tool description and extraction prompt carry the rule as well.
+SECRET_PATTERNS = (
+    re.compile(r"\bsk-[A-Za-z0-9_-]{16,}"),
+    re.compile(r"\bAKIA[0-9A-Z]{16}\b"),
+    re.compile(r"-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----"),
+    re.compile(r"(?i)(?:api[_-]?key|token|password|passwd|secret)[\"']?\s*[=:：]\s*[\"']?[^\s\"']{8,}"),
+    re.compile(r"\b(?:ghp|gho|ghs|ghu|ghr|github_pat)_[A-Za-z0-9_]{16,}"),
+    re.compile(r"\bxox[abprs]-[A-Za-z0-9-]{10,}"),
+)
+
+
+class MemoryFailure(Exception):
+    def __init__(self, code: str, message: str):
+        super().__init__(message)
+        self.code = code
+
+
+@dataclass(frozen=True)
+class Note:
+    scope: str
+    name: str
+    type: str
+    description: str
+    updated: str
+    body: str
+    path: Path
+    error: str = ""  # Set when the file could not be parsed; such notes stay out of the index.
+
+    @property
+    def filename(self) -> str:
+        return self.path.name
+
+    def index_line(self) -> str:
+        return f"- [{self.name}]({self.filename}) — {self.description}"
+
+    def text(self) -> str:
+        return render_note(self.name, self.type, self.description, self.updated, self.body)
+
+
+def render_note(name: str, type_: str, description: str, updated: str, body: str) -> str:
+    return f"---\nname: {name}\ndescription: {description}\ntype: {type_}\nupdated: {updated}\n---\n\n{body.strip()}\n"
+
+
+def parse_note(scope: str, path: Path, text: str) -> Note:
+    """The frontmatter this module writes; anything else is marked as a format error."""
+
+    def broken(reason: str) -> Note:
+        return Note(scope, path.stem, "", "", "", text, path, reason)
+
+    lines = text.lstrip("").replace("\r\n", "\n").split("\n")
+    if not lines or lines[0].strip() != "---":
+        return broken("缺少 frontmatter")
+    try:
+        end = next(i for i in range(1, len(lines)) if lines[i].strip() == "---")
+    except StopIteration:
+        return broken("frontmatter 没有结束标记")
+    fields = {}
+    for line in lines[1:end]:
+        key, sep, value = line.partition(":")
+        if sep and key.strip():
+            fields[key.strip()] = value.strip()
+    body = "\n".join(lines[end + 1 :]).strip()
+    name, type_ = fields.get("name", ""), fields.get("type", "")
+    description, updated = fields.get("description", ""), fields.get("updated", "")
+    if name != path.stem or not SLUG.fullmatch(name):
+        return broken("name 与文件名不一致")
+    if type_ not in TYPES:
+        return broken("type 不合法")
+    if not description:
+        return broken("缺少 description")
+    if not _DATE.fullmatch(updated):
+        return broken("updated 不是 YYYY-MM-DD")
+    return Note(scope, name, type_, description, updated, body, path)
+
+
+def find_secret(*texts: str) -> bool:
+    return any(pattern.search(text) for text in texts for pattern in SECRET_PATTERNS)
+
+
+def validate(scope, name, type_, description, body) -> None:
+    """Shared by the tool and the extractor; raises MemoryFailure with a code the model can act on."""
+    if scope not in SCOPES:
+        raise MemoryFailure("invalid_scope", "scope 只能是 user 或 project。")
+    if not isinstance(name, str) or not SLUG.fullmatch(name):
+        if isinstance(name, str) and any(sep in name for sep in "/\\.:"):
+            raise MemoryFailure("invalid_name", "name 不能包含路径分隔符或扩展名；只写笔记名，例如 prefer-pnpm。")
+        raise MemoryFailure("invalid_name", "name 只能用小写字母、数字和连字符，以字母或数字开头，最长 60 字符。")
+    if type_ not in TYPES:
+        raise MemoryFailure("invalid_type", "type 只能是 user、feedback、project 或 reference。")
+    if type_ == "project" and scope != "project":
+        raise MemoryFailure("scope_mismatch", "project 类型的笔记只能写到项目级（scope: project）。")
+    if not isinstance(description, str) or not description.strip():
+        raise MemoryFailure("invalid_description", "description 不能为空，用一行说明这条笔记什么时候有用。")
+    if "\n" in description.strip() or "\r" in description:
+        raise MemoryFailure("invalid_description", "description 只能写一行。")
+    if len(description.strip()) > DESCRIPTION_LIMIT:
+        raise MemoryFailure(
+            "description_too_long", f"description 最多 {DESCRIPTION_LIMIT} 字符，当前 {len(description.strip())}。"
+        )
+    if not isinstance(body, str) or not body.strip():
+        raise MemoryFailure("invalid_body", "body 不能为空。")
+    size = len(body.strip().encode("utf-8"))
+    if size > BODY_LIMIT:
+        raise MemoryFailure("body_too_large", f"body 最多 {BODY_LIMIT} 字节（UTF-8），当前 {size}；请精简。")
+    if find_secret(name, description, body):
+        raise MemoryFailure("secret_detected", "内容疑似包含密钥、令牌或密码，未保存；笔记中不要记录凭据。")
+
+
+def atomic_write(path: Path, text: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temp = path.with_name(f".{path.name}.{secrets.token_hex(4)}.tmp")
+    try:
+        with open(temp, "w", encoding="utf-8", newline="\n") as handle:
+            handle.write(text)
+        os.replace(temp, path)
+    except BaseException:
+        temp.unlink(missing_ok=True)
+        raise
+
+
+class MemoryStore:
+    def __init__(self, user_dir: Path, project_dir: Path):
+        self.dirs = {"user": Path(user_dir), "project": Path(project_dir)}
+        self._lock = threading.Lock()
+
+    @classmethod
+    def for_project(cls, root: Path, home: Path | None = None) -> "MemoryStore":
+        return cls(mosscode_home(home) / "memory", project_dir(root, home) / "memory")
+
+    def directory(self, scope: str) -> Path:
+        return self.dirs[scope]
+
+    # Reading ----------------------------------------------------------------------------------
+
+    def load(self, scope: str | None = None) -> list[Note]:
+        """Valid and broken notes, newest first within each scope; user scope before project."""
+        notes = []
+        for name in (scope,) if scope else SCOPES:
+            folder = self.dirs[name]
+            try:
+                files = sorted(p for p in folder.glob("*.md") if p.name != INDEX_FILE and p.is_file())
+            except OSError:
+                files = []
+            loaded = []
+            for path in files:
+                try:
+                    loaded.append(parse_note(name, path, path.read_text(encoding="utf-8")))
+                except (OSError, UnicodeError):
+                    loaded.append(Note(name, path.stem, "", "", "", "", path, "无法读取"))
+            loaded.sort(key=lambda n: (n.updated, n.name), reverse=True)
+            notes += loaded
+        return notes
+
+    def find(self, name: str) -> list[Note]:
+        return [note for note in self.load() if note.name == name]
+
+    def render_index(self, scope: str) -> str:
+        notes = [note for note in self.load(scope) if not note.error]
+        lines = [note.index_line() for note in notes]
+        return "\n".join(lines) + ("\n" if lines else "")
+
+    def refresh(self) -> None:
+        """Regenerate both indexes from the notes, e.g. after the user edited one by hand."""
+        with self._lock:
+            for scope in SCOPES:
+                self._write_index(scope)
+
+    def _write_index(self, scope: str) -> None:
+        path = self.dirs[scope] / INDEX_FILE
+        text = self.render_index(scope)
+        try:
+            current = path.read_text(encoding="utf-8")
+        except (OSError, UnicodeError):
+            current = None
+        if current == text or (current is None and not text):
+            return
+        atomic_write(path, text)
+
+    def index_section(self, limit: int = INDEX_TOKENS, lines: int = INDEX_LINES) -> str:
+        """Both indexes for the system prompt, oldest entries dropped first beyond the limits."""
+        entries = {scope: [n for n in self.load(scope) if not n.error] for scope in SCOPES}
+        shown = {scope: notes[:lines] for scope, notes in entries.items()}
+
+        def render():
+            parts = []
+            for scope in SCOPES:
+                body = [note.index_line() for note in shown[scope]] or ["（暂无）"]
+                omitted = len(entries[scope]) - len(shown[scope])
+                if omitted:
+                    body.append(f"另有 {omitted} 条较旧的笔记未列出，可用 glob 查看目录")
+                parts.append(f"### {SCOPE_LABELS[scope]}笔记（目录：{self.dirs[scope]}）\n" + "\n".join(body))
+            return "\n\n".join(parts)
+
+        text = render()
+        while estimate_text(text) > limit and any(shown.values()):
+            # Drop the oldest entry across both scopes, then re-measure.
+            oldest = min((scope for scope in SCOPES if shown[scope]), key=lambda s: (shown[s][-1].updated, s == "user"))
+            shown[oldest] = shown[oldest][:-1]
+            text = render()
+        return text
+
+    # Writing ----------------------------------------------------------------------------------
+
+    def save(self, scope, name, type_, description, body, *, today: str | None = None) -> tuple[Note, bool]:
+        validate(scope, name, type_, description, body)
+        updated = today or date.today().isoformat()
+        path = self.dirs[scope] / f"{name}.md"
+        note = Note(scope, name, type_, description.strip(), updated, body.strip(), path)
+        with self._lock:
+            created = not path.exists()
+            atomic_write(path, note.text())
+            self._write_index(scope)
+        return note, created
+
+    def delete(self, scope, name) -> Path:
+        if scope not in SCOPES:
+            raise MemoryFailure("invalid_scope", "scope 只能是 user 或 project。")
+        if not isinstance(name, str) or not SLUG.fullmatch(name):
+            raise MemoryFailure("invalid_name", "name 只能用小写字母、数字和连字符，以字母或数字开头，最长 60 字符。")
+        path = self.dirs[scope] / f"{name}.md"
+        with self._lock:
+            if not path.is_file():
+                other = "project" if scope == "user" else "user"
+                hint = f"；{SCOPE_LABELS[other]}有同名笔记" if (self.dirs[other] / f"{name}.md").is_file() else ""
+                raise MemoryFailure("not_found", f"{SCOPE_LABELS[scope]}没有名为 {name} 的笔记{hint}。")
+            path.unlink()
+            self._write_index(scope)
+        return path
+
+    def apply(self, operations) -> tuple[list[tuple[str, Note | Path, str]], list[tuple[object, str]]]:
+        """At most five operations, each checked on its own; returns (applied, rejected).
+
+        applied items are (op, note or deleted path, name); rejected items are (operation, reason)."""
+        applied, rejected = [], []
+        if not isinstance(operations, list):
+            return applied, [(operations, "操作列表必须是 JSON 数组。")]
+        for operation in operations[:MAX_OPERATIONS]:
+            if not isinstance(operation, dict):
+                rejected.append((operation, "操作必须是 JSON 对象。"))
+                continue
+            op = operation.get("op")
+            try:
+                if op == "save":
+                    note, _ = self.save(
+                        operation.get("scope"),
+                        operation.get("name"),
+                        operation.get("type"),
+                        operation.get("description"),
+                        operation.get("body"),
+                    )
+                    applied.append(("save", note, note.name))
+                elif op == "delete":
+                    path = self.delete(operation.get("scope"), operation.get("name"))
+                    applied.append(("delete", path, path.stem))
+                else:
+                    rejected.append((operation, "op 只能是 save 或 delete。"))
+            except MemoryFailure as exc:
+                rejected.append((operation, f"{exc.code}: {exc}"))
+            except OSError as exc:
+                rejected.append((operation, f"写入失败：{exc.strerror or exc}"))
+        rejected += [(operation, "超过一次最多 5 个操作的限制。") for operation in operations[MAX_OPERATIONS:]]
+        return applied, rejected