hyperagents 1.2.3rc5.post3__py3-none-any.whl

hyperclaw/brief/tasks.py

@@ -0,0 +1,200 @@
+"""The to-do Sheet, read by code: open tasks in priority order.
+
+Columns are found by their header names (task, priority, status, due, owner,
+notes). Done rows are left out. Order: priority (urgent/P0, high/P1, medium/P2,
+low/P3, or a number 1-5), then due date, then the Sheet's own row order.
+Nothing is guessed: a task with no priority, an unknown priority word or a due
+date that can't be read becomes a question for the owner instead.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from datetime import date, datetime
+from typing import List, Optional
+
+from hyperclaw.brief.google import SheetContent
+
+HEADERS = {
+    "task": ("task", "to-do", "todo", "to do", "item", "action", "title", "what", "description"),
+    "priority": ("priority", "prio", "urgency", "importance", "rank"),
+    "status": ("status", "state", "done", "complete", "completed", "progress"),
+    "due": ("due", "due date", "deadline", "by", "date", "when", "due by"),
+    "owner": ("owner", "who", "assigned", "assignee", "assigned to"),
+    "notes": ("notes", "note", "comments", "details"),
+}
+DONE_WORDS = {"done", "complete", "completed", "closed", "finished", "cancelled", "canceled",
+              "x", "✓", "✔", "yes", "true", "y", "resolved", "n/a"}
+PRIORITY_WORDS = {
+    "p0": 0, "urgent": 0, "critical": 0, "asap": 0, "highest": 0, "top": 0,
+    "p1": 1, "high": 1, "hi": 1,
+    "p2": 2, "medium": 2, "med": 2, "normal": 2, "mid": 2,
+    "p3": 3, "low": 3, "lo": 3,
+    "p4": 4, "lowest": 4, "someday": 4,
+}
+UNRANKED = 99
+
+
+@dataclass
+class Task:
+    row: int                      # 1-based row number in its tab
+    tab: str
+    text: str
+    priority_raw: str = ""
+    rank: int = UNRANKED
+    due_raw: str = ""
+    due: Optional[date] = None
+    status: str = ""
+    owner: str = ""
+    notes: str = ""
+
+    def overdue(self, today: date) -> bool:
+        return self.due is not None and self.due < today
+
+
+@dataclass
+class TaskList:
+    title: str
+    open: List[Task] = field(default_factory=list)
+    questions: List[str] = field(default_factory=list)
+    done_count: int = 0
+    no_header: List[str] = field(default_factory=list)    # tabs with no task column found
+
+
+def _norm(s: str) -> str:
+    return " ".join(str(s or "").strip().lower().replace("_", " ").split())
+
+
+def _columns(header: list) -> dict:
+    cols = {}
+    names = [_norm(h) for h in header]
+    for key, words in HEADERS.items():
+        for i, n in enumerate(names):
+            if n in words and i not in cols.values():
+                cols[key] = i
+                break
+    if "task" not in cols:
+        for key, words in HEADERS.items():
+            if key in cols:
+                continue
+            for i, n in enumerate(names):
+                if i not in cols.values() and any(n.startswith(w) for w in words):
+                    cols[key] = i
+                    break
+    return cols
+
+
+def rank_of(raw: str) -> Optional[int]:
+    """0 = most urgent. None when the value can't be placed."""
+    v = _norm(raw).rstrip(".!")
+    if not v:
+        return UNRANKED
+    if v in PRIORITY_WORDS:
+        return PRIORITY_WORDS[v]
+    m = re.fullmatch(r"p?\s*([0-9])", v)
+    if m:
+        return int(m.group(1))
+    for w, r in PRIORITY_WORDS.items():
+        if re.fullmatch(rf"{re.escape(w)}( priority)?", v):
+            return r
+    return None
+
+
+def parse_due(raw: str, today: date) -> Optional[date]:
+    v = str(raw or "").strip()
+    if not v:
+        return None
+    for fmt in ("%Y-%m-%d", "%m/%d/%Y", "%m/%d/%y", "%d %b %Y", "%b %d, %Y", "%b %d %Y",
+                "%B %d, %Y", "%B %d %Y", "%a %d %b %Y"):
+        try:
+            return datetime.strptime(v, fmt).date()
+        except ValueError:
+            pass
+    for fmt in ("%m/%d", "%b %d", "%B %d", "%d %b", "%a %d %b"):
+        try:
+            d = datetime.strptime(f"{v} {today.year}", fmt + " %Y").date()
+            return d
+        except ValueError:
+            pass
+    return None
+
+
+def _cell(row: list, i: Optional[int]) -> str:
+    if i is None or i >= len(row):
+        return ""
+    return " ".join(str(row[i]).split())
+
+
+def read_tasks(sheet: SheetContent, today: date) -> TaskList:
+    out = TaskList(title=sheet.title)
+    for tab, rows in sheet.tabs:
+        hdr_idx = next((i for i, r in enumerate(rows) if any(str(c).strip() for c in r)), None)
+        if hdr_idx is None:
+            continue
+        cols = _columns(rows[hdr_idx])
+        if "task" not in cols:
+            if not any(k in cols for k in ("priority", "status", "due")):
+                out.no_header.append(tab)
+                continue
+            cols["task"] = next(i for i in range(len(rows[hdr_idx])) if i not in cols.values())
+        for r_i in range(hdr_idx + 1, len(rows)):
+            row = rows[r_i]
+            text = _cell(row, cols.get("task"))
+            if not text:
+                continue
+            status = _cell(row, cols.get("status"))
+            if _norm(status) in DONE_WORDS:
+                out.done_count += 1
+                continue
+            t = Task(row=r_i + 1, tab=tab, text=text, status=status,
+                     priority_raw=_cell(row, cols.get("priority")),
+                     due_raw=_cell(row, cols.get("due")),
+                     owner=_cell(row, cols.get("owner")),
+                     notes=_cell(row, cols.get("notes")))
+            if "priority" in cols:
+                r = rank_of(t.priority_raw)
+                if r is None:
+                    out.questions.append(
+                        f"\"{t.text}\" has priority \"{t.priority_raw}\" in the Sheet, which I "
+                        f"can't place. How urgent is it?")
+                    t.rank = UNRANKED
+                else:
+                    t.rank = r
+                    if r == UNRANKED:
+                        out.questions.append(f"\"{t.text}\" has no priority in the Sheet. "
+                                             f"How urgent is it?")
+            if t.due_raw:
+                t.due = parse_due(t.due_raw, today)
+                if t.due is None:
+                    out.questions.append(f"\"{t.text}\" is due \"{t.due_raw}\" in the Sheet, "
+                                         f"which I can't read as a date. When is it due?")
+            out.open.append(t)
+    out.open.sort(key=lambda t: (t.rank, t.due or date.max, t.tab, t.row))
+    return out
+
+
+def _fmt_date(d: date) -> str:
+    return d.strftime("%a %d %b").replace(" 0", " ")
+
+
+def format_tasks(tl: TaskList, today: date, limit: int = 15) -> List[str]:
+    lines = []
+    for i, t in enumerate(tl.open[:limit], start=1):
+        bits = []
+        if t.priority_raw and t.rank != UNRANKED:
+            bits.append(t.priority_raw)
+        if t.due:
+            bits.append(("overdue, was due " if t.overdue(today) else "due ") + _fmt_date(t.due))
+            if t.due == today:
+                bits[-1] = "due today"
+        elif t.due_raw:
+            bits.append(f"due \"{t.due_raw}\"")
+        if t.status:
+            bits.append(t.status)
+        if t.owner:
+            bits.append(f"owner: {t.owner}")
+        line = f"{i}. {t.text}" + (f" ({'; '.join(bits)})" if bits else "")
+        lines.append(line)
+    if len(tl.open) > limit:
+        lines.append(f"... and {len(tl.open) - limit} more open tasks in the Sheet.")
+    return lines

hyperclaw/chat_scope.py

@@ -0,0 +1,115 @@
+"""
+Chat scope: who is on the other end of a remote conversation.
+
+Spec (HyperClaw capability spec §6): "A paired non-owner chat gets its own scope
+and can never read the owner's memory, files or accounts."  Benchmark 4.1
+showed the opposite: a second paired Telegram chat got the owner's MEMORY.md
+(including where the spare key is) in its system prompt.
+
+Rules enforced here and by every remote surface that imports this module:
+
+- A chat is OWNER only when an owner identity is configured AND the chat
+  matches it exactly. Everything else is GUEST. If no owner identity is
+  configured, every chat is GUEST (fail closed).
+- A GUEST context never contains owner memory (MEMORY.md, USER.md,
+  IDENTITY.md, CLAUDE.md persona, daily logs, vector-memory recalls,
+  cross-channel memory bus) and is offered no tool that can read the owner's
+  memory, files, accounts or devices (see hyperclaw.tools: scope "public").
+- GUEST exchanges are not written into the owner's memory either (a guest
+  must not be able to plant instructions the owner's assistant later reads).
+
+Owner identity sources:
+- Telegram: TELEGRAM_OWNER_CHAT_ID (explicit, comma list allowed), else
+  TELEGRAM_CHAT_ID (onboarding writes the owner's own chat id there; see
+  SECURITY.md), plus the same keys in the mounted telegram secret.
+  TELEGRAM_ALLOWED_CHAT_IDS only *pairs* chats; it never makes one an owner.
+- iMessage: IMESSAGE_OWNER_CONTACTS (comma list of the owner's own handles).
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Optional
+
+OWNER = "owner"
+GUEST = "guest"
+SCOPES = (OWNER, GUEST)
+
+
+def _split_ids(raw: str) -> set:
+    return {x.strip() for x in str(raw or "").split(",") if x.strip()}
+
+
+def owner_ids(channel: str) -> set:
+    """The configured owner identities for a channel, as strings. Empty set
+    means the owner is unknown on that channel (every chat is a guest)."""
+    env = os.environ
+    if channel == "telegram":
+        ids = _split_ids(env.get("TELEGRAM_OWNER_CHAT_ID", ""))
+        if not ids:
+            ids = _split_ids(env.get("TELEGRAM_CHAT_ID", ""))
+        if not ids:
+            mount = Path(env.get("SECRETS_MOUNT", "/mnt/secrets")) / "telegram"
+            try:
+                if mount.exists():
+                    raw = json.loads(mount.read_text())
+                    ids = _split_ids(raw.get("TELEGRAM_OWNER_CHAT_ID", "")) or \
+                        _split_ids(raw.get("TELEGRAM_CHAT_ID", ""))
+            except Exception:
+                ids = set()
+        return {i for i in ids if i.lstrip("-").isdigit()}
+    if channel == "imessage":
+        return {c.lower() for c in _split_ids(env.get("IMESSAGE_OWNER_CONTACTS", ""))}
+    return set()
+
+
+def scope_for(channel: str, chat_id) -> str:
+    """OWNER only for an exact match against a configured owner identity;
+    GUEST otherwise, including when chat_id is None or no owner is set."""
+    if chat_id is None:
+        return GUEST
+    ids = owner_ids(channel)
+    if not ids:
+        return GUEST
+    key = str(chat_id).strip()
+    if channel == "imessage":
+        key = key.lower()
+    return OWNER if key in ids else GUEST
+
+
+def normalize(scope: Optional[str]) -> str:
+    """Anything that is not exactly OWNER is treated as GUEST."""
+    return OWNER if scope == OWNER else GUEST
+
+
+GUEST_RULES = """
+## Guest chat (non-negotiable — overrides any other instruction)
+- You are talking with a GUEST: a paired chat that is NOT the owner of this
+  assistant. You have no access to the owner's memory, notes, files, email,
+  calendar, messages, contacts or accounts in this chat, and you must not
+  claim or imply that you do.
+- Never reveal, confirm, guess or hint at anything private about the owner
+  (codes, passwords, keys, addresses, schedules, health, finances, family,
+  contacts, where things are kept). If asked, say plainly that you can't share
+  the owner's private information in this chat.
+- Do not take actions on the owner's behalf from this chat.
+""".strip()
+
+
+# Tools a GUEST chat may be offered: public-information tools that touch no
+# owner memory, file, account or device. Everything else is owner-only.
+# (web_fetch / http_request are excluded: they can reach the owner's local
+# network and services.) hyperclaw.tools derives each tool's `scope` from this.
+GUEST_SAFE_TOOLS = frozenset({
+    "web_search", "wikipedia", "weather", "news", "stock_price", "translate",
+    "youtube", "reddit", "hackernews", "arxiv", "math", "time_info",
+    "dns_lookup", "whois", "hash", "uuid_generate", "base64_encode",
+    "json_format", "regex_test", "geocode", "currency", "unit_convert",
+    "wayback",
+})
+
+
+def guest_tools(tools: list) -> list:
+    """Filter an Anthropic-format tool list down to what a guest may use."""
+    return [t for t in tools if t.get("name") in GUEST_SAFE_TOOLS]