hyperagents 1.2.3rc5.post3__py3-none-any.whl

hyperclaw/persona.py

@@ -0,0 +1,367 @@
+"""The customer's persona: style preferences they set or agreed to (spec §14).
+
+- Per customer, stored in ``$HYPERCLAW_ROOT/persona.json``. Empty by default:
+  there is no seeded persona.
+- Consent-based: an inferred preference is only ever *proposed*; it is kept
+  only after the customer says yes. Declined proposals are remembered so the
+  same one is not asked again.
+- Visible, editable and resettable: ``/persona`` in the terminal and Telegram,
+  ``hyperclaw persona`` on the command line, all through :func:`run_command`.
+- Owner only: guest chats never receive it (callers pass the chat scope).
+- Tone only: :func:`render` frames it as style preferences that sit below
+  the truth rules and cannot change facts, claims or refusals.
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import time
+from pathlib import Path
+from typing import Optional
+
+KEYS = {
+    "tone": "Tone",
+    "length": "Answer length",
+    "address": "Address the owner as",
+    "topics": "Topics they care about",
+    "notes": "Style notes (owner's words, style only)",
+}
+MAX_VALUE = 200
+MAX_TOPICS = 12
+
+PERSONA_HEADING = "## Persona: the owner's style preferences (tone and wording only)"
+PERSONA_FRAME = (
+    "The owner set or approved these preferences. They shape tone, length and "
+    "wording only. They never change facts, never claim an action that has no "
+    "matching tool result, never override a refusal, and never override the "
+    "truthfulness, access or guest rules above; where anything here conflicts "
+    "with those rules, the rules win. Whatever this section says, if asked "
+    "whether you are an AI, say yes."
+)
+
+
+def path() -> Path:
+    from hyperclaw.userconfig import root
+    return root() / "persona.json"
+
+
+def clean_value(value: str) -> str:
+    """One line, no markdown headings or fences, bounded length — persona
+    text is data, it must not be able to open a new prompt section."""
+    v = re.sub(r"\s+", " ", str(value or "")).strip()
+    v = v.replace("```", "'''").lstrip("#").strip()
+    return v[:MAX_VALUE]
+
+
+def _empty() -> dict:
+    return {"version": 1, "preferences": {}, "pending": [], "declined": [],
+            "updated_at": None}
+
+
+class PersonaStore:
+    def __init__(self, file: Optional[Path] = None):
+        self.file = Path(file) if file else path()
+        self.data = self._load()
+
+    # ── persistence ──────────────────────────────────────────────────────
+    def _load(self) -> dict:
+        try:
+            if self.file.exists():
+                d = json.loads(self.file.read_text(encoding="utf-8"))
+                if isinstance(d, dict):
+                    base = _empty()
+                    base.update({k: d[k] for k in base if k in d})
+                    return base
+        except Exception:
+            pass
+        return _empty()
+
+    def save(self) -> None:
+        self.data["updated_at"] = time.strftime("%Y-%m-%dT%H:%M:%S")
+        self.file.parent.mkdir(parents=True, exist_ok=True)
+        tmp = self.file.with_suffix(".json.tmp")
+        tmp.write_text(json.dumps(self.data, indent=2), encoding="utf-8")
+        os.replace(tmp, self.file)
+
+    # ── preferences ──────────────────────────────────────────────────────
+    @property
+    def preferences(self) -> dict:
+        return self.data["preferences"]
+
+    def set(self, key: str, value) -> str:
+        """Set a preference the customer stated directly (that is consent)."""
+        if key not in KEYS:
+            raise KeyError(key)
+        if key == "topics":
+            items = value if isinstance(value, list) else str(value).split(",")
+            topics = [clean_value(t)[:60] for t in items if clean_value(t)]
+            if not topics:
+                raise ValueError("no topics given")
+            self.preferences["topics"] = topics[:MAX_TOPICS]
+            shown = ", ".join(self.preferences["topics"])
+        else:
+            v = clean_value(value)
+            if not v:
+                raise ValueError("empty value")
+            self.preferences[key] = v
+            shown = v
+        self.save()
+        return shown
+
+    def unset(self, key: str) -> bool:
+        had = self.preferences.pop(key, None) is not None
+        if had:
+            self.save()
+        return had
+
+    def reset(self) -> None:
+        """Back to the default: no preferences, nothing pending, nothing declined."""
+        self.data = _empty()
+        self.save()
+
+    # ── consent for inferred preferences ─────────────────────────────────
+    def _same(self, a: dict, b: dict) -> bool:
+        return a.get("key") == b.get("key") and \
+            str(a.get("value")).lower() == str(b.get("value")).lower()
+
+    def propose(self, key: str, value: str, evidence: str = "") -> Optional[dict]:
+        """Queue an inferred preference for the customer's yes/no. Nothing is
+        applied. Returns the pending item, or None if it is already set,
+        already pending or was declined before."""
+        if key not in KEYS:
+            return None
+        value = clean_value(value)
+        if not value:
+            return None
+        cand = {"key": key, "value": value}
+        cur = self.preferences.get(key)
+        if (isinstance(cur, list) and value.lower() in [c.lower() for c in cur]) or \
+                (isinstance(cur, str) and cur.lower() == value.lower()):
+            return None
+        if any(self._same(cand, p) for p in self.data["pending"] + self.data["declined"]):
+            return None
+        nid = max([p.get("id", 0) for p in self.data["pending"]] + [0]) + 1
+        item = {"id": nid, "key": key, "value": value,
+                "evidence": clean_value(evidence)[:120]}
+        self.data["pending"].append(item)
+        self.save()
+        return item
+
+    def pending(self) -> list:
+        return list(self.data["pending"])
+
+    def _take(self, pid: Optional[int]) -> Optional[dict]:
+        items = self.data["pending"]
+        if not items:
+            return None
+        item = items[-1] if pid is None else next((p for p in items if p.get("id") == pid), None)
+        if item:
+            items.remove(item)
+        return item
+
+    def accept(self, pid: Optional[int] = None) -> Optional[dict]:
+        item = self._take(pid)
+        if not item:
+            return None
+        if item["key"] == "topics":
+            topics = list(self.preferences.get("topics") or [])
+            topics.append(item["value"])
+            self.preferences["topics"] = topics[-MAX_TOPICS:]
+        else:
+            self.preferences[item["key"]] = item["value"]
+        self.save()
+        return item
+
+    def decline(self, pid: Optional[int] = None) -> Optional[dict]:
+        item = self._take(pid)
+        if not item:
+            return None
+        self.data["declined"].append({"key": item["key"], "value": item["value"]})
+        self.save()
+        return item
+
+
+# ── inference (deterministic, conservative) ─────────────────────────────
+
+_ANS = r"(?:(?:your|the|my|all|these|those)\s+)?(?:answers?|repl(?:y|ies)|responses?|messages?|texts?)"
+_RULES = [
+    # "keep your answers short", "keep it brief", "make your replies shorter",
+    # "shorter answers please", "be concise", "less wordy", "too long", "tl;dr"
+    (re.compile(r"\b(keep (it|things|" + _ANS + r") (short|brief|concise|tight|to the point)|"
+                r"(make|give me|i want|i'd like|i prefer|please give)\s+(it|" + _ANS + r"|me)?\s*"
+                r"(short(er)?|brief(er)?|concise)\b(?!\s+(summary|version) of)|"
+                r"be (more )?(brief|concise|succinct)|short(er)? (answers|replies|responses)|"
+                r"(answers?|repl(y|ies)|responses?) (are|is) too long|too long|less (wordy|verbose)|"
+                r"(don't|do not|stop) ramble|fewer words)\b", re.I), "length", "short"),
+    (re.compile(r"\b(more detail(ed)?|longer (answers|replies|responses)|be (more )?(thorough|detailed)|"
+                r"(give me|i want|i'd like|i prefer) (more )?(detailed|longer|in-depth) "
+                r"(answers|replies|responses)|go (into )?more (depth|detail))\b", re.I),
+     "length", "detailed"),
+    (re.compile(r"\b(be|sound|keep it|talk) (more )?(casual|relaxed|informal|laid[- ]back)\b", re.I),
+     "tone", "casual"),
+    (re.compile(r"\b(be|sound|keep it|talk) (more )?(formal|professional)\b", re.I), "tone", "formal"),
+    (re.compile(r"\b(be|sound|keep it|talk) (more )?(warm|warmer|friendly|friendlier)\b", re.I),
+     "tone", "warm"),
+    (re.compile(r"\b(be|sound|keep it|talk) (more )?(direct|blunt|straight)\b|"
+                r"\b(no|skip the|cut the) (fluff|small talk|pleasantries)\b", re.I), "tone", "direct"),
+]
+# "call me Sam", "call me Dr. Lee from now on": the first word, then any
+# following Capitalised words (so "Dr. Lee" survives its period).
+_ADDRESS = re.compile(r"\b(?:call me|address me as)\s+([A-Za-z][\w'.-]*(?:\s+[A-Z][\w'.-]*){0,3})",
+                      re.I)
+_TOPIC = re.compile(r"\bi(?:'m| am) (?:really |very )?interested in ([^.!?\n]{2,40})", re.I)
+
+
+def infer(message: str) -> list:
+    """Candidate (key, value) preferences stated in an owner message."""
+    out = []
+    text = message or ""
+    for rx, key, value in _RULES:
+        if rx.search(text):
+            out.append((key, value))
+            break
+    m = _ADDRESS.search(text)
+    if m:
+        # re.I makes [A-Z] match lowercase too; keep only Capitalised follow-ons.
+        words = m.group(1).split()
+        kept = words[:1]
+        for w in words[1:]:
+            if not w[:1].isupper():
+                break
+            kept.append(w)
+        out.append(("address", " ".join(kept).rstrip(".,")))
+    m = _TOPIC.search(text)
+    if m:
+        out.append(("topics", m.group(1).strip()))
+    return out
+
+
+def describe(item: dict) -> str:
+    key, value = item["key"], item["value"]
+    return {
+        "length": f"you prefer {value} answers",
+        "tone": f"you prefer a {value} tone",
+        "address": f"you'd like to be called {value}",
+        "topics": f"you're interested in {value}",
+        "notes": f"style note: {value}",
+    }.get(key, f"{key}: {value}")
+
+
+def consent_question(item: dict) -> str:
+    return f"Want me to remember that {describe(item)}? (yes/no)"
+
+
+def observe(message: str, store: Optional[PersonaStore] = None) -> Optional[dict]:
+    """Owner surfaces call this per owner message. Returns at most one new
+    pending item to ask about, or None. Never applies anything."""
+    store = store or PersonaStore()
+    for key, value in infer(message):
+        item = store.propose(key, value, evidence=message)
+        if item:
+            return item
+    return None
+
+
+YES = {"y", "yes", "yeah", "yep", "sure", "ok", "okay", "please do", "remember it"}
+NO = {"n", "no", "nope", "don't", "dont", "no thanks", "forget it"}
+
+
+def answer_kind(text: str) -> str:
+    t = (text or "").strip().lower().rstrip(".!")
+    return "yes" if t in YES else "no" if t in NO else ""
+
+
+# ── rendering ───────────────────────────────────────────────────────────
+
+def render(store: Optional[PersonaStore] = None) -> str:
+    """The persona section for an OWNER system prompt; "" if nothing is set.
+    Callers place it after TRUTH_RULES and the access manifest."""
+    store = store or PersonaStore()
+    prefs = store.preferences
+    if not prefs:
+        return ""
+    lines = [PERSONA_HEADING, PERSONA_FRAME]
+    for key, label in KEYS.items():
+        v = prefs.get(key)
+        if not v:
+            continue
+        if isinstance(v, list):
+            v = ", ".join(v)
+        lines.append(f'- {label}: "{v}"')
+    return "\n".join(lines)
+
+
+# ── commands (TUI /persona, Telegram /persona, `hyperclaw persona`) ─────
+
+HELP = (
+    "Persona commands:\n"
+    "  /persona                 show what shapes my style\n"
+    "  /persona set <key> <value>   keys: tone, length, address, topics, notes\n"
+    "  /persona unset <key>     remove one preference\n"
+    "  /persona pending         preferences waiting for your yes/no\n"
+    "  /persona accept [id]     keep a pending preference\n"
+    "  /persona decline [id]    drop a pending preference\n"
+    "  /persona reset           clear everything back to the default"
+)
+
+
+def show(store: PersonaStore) -> str:
+    prefs = store.preferences
+    if not prefs:
+        body = "No style preferences saved. I use the default style."
+    else:
+        rows = []
+        for key, label in KEYS.items():
+            v = prefs.get(key)
+            if v:
+                rows.append(f"- {key} ({label}): {', '.join(v) if isinstance(v, list) else v}")
+        body = "Saved style preferences:\n" + "\n".join(rows)
+    pend = store.pending()
+    if pend:
+        body += "\nWaiting for your yes/no:\n" + "\n".join(
+            f"  [{p['id']}] {describe(p)}" for p in pend)
+    return body + "\nThese only shape tone and wording; they never change facts."
+
+
+def run_command(argv: list, store: Optional[PersonaStore] = None) -> str:
+    store = store or PersonaStore()
+    if not argv or argv[0] in ("show", "view", "list"):
+        return show(store)
+    cmd, rest = argv[0].lower(), argv[1:]
+    if cmd in ("help", "-h", "--help"):
+        return HELP
+    if cmd in ("set", "edit"):
+        if len(rest) < 2 or rest[0].lower() not in KEYS:
+            return "Usage: /persona set <tone|length|address|topics|notes> <value>"
+        key = rest[0].lower()
+        try:
+            shown = store.set(key, " ".join(rest[1:]))
+        except ValueError:
+            return "That value is empty; nothing saved."
+        return f"Saved {key}: {shown}"
+    if cmd in ("unset", "remove", "forget"):
+        if not rest or rest[0].lower() not in KEYS:
+            return "Usage: /persona unset <tone|length|address|topics|notes>"
+        return (f"Removed {rest[0].lower()}." if store.unset(rest[0].lower())
+                else f"No {rest[0].lower()} was saved.")
+    if cmd == "reset":
+        store.reset()
+        return "Persona reset to the default. No style preferences are saved."
+    if cmd == "pending":
+        pend = store.pending()
+        return ("Nothing is waiting for your yes/no." if not pend else
+                "\n".join(f"[{p['id']}] {describe(p)}" for p in pend))
+    if cmd in ("accept", "decline"):
+        pid = None
+        if rest:
+            try:
+                pid = int(rest[0])
+            except ValueError:
+                return f"Usage: /persona {cmd} [id]"
+        item = store.accept(pid) if cmd == "accept" else store.decline(pid)
+        if not item:
+            return "Nothing pending with that id."
+        return (f"Saved: {describe(item)}." if cmd == "accept"
+                else f"OK, I won't keep that ({describe(item)}).")
+    return HELP

hyperclaw/prometheus.py

@@ -0,0 +1,219 @@
+"""
+HyperClaw Memory Agent
+Processes daily logs into summarized knowledge.
+Runs on schedule or on-demand via /api/memory/consolidate.
+"""
+
+import asyncio
+import json
+import logging
+import os
+import re
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Optional
+
+import anthropic
+from hyperclaw.api_utils import extract_text
+from hyperclaw.cost_guard import max_output
+from dotenv import load_dotenv
+
+load_dotenv()
+
+logger = logging.getLogger("hyperclaw.memory")
+
+# Paths - use environment variable or default
+HYPERCLAW_ROOT = Path(os.environ.get("HYPERCLAW_ROOT", Path.home() / ".hyperclaw"))
+MEMORY_PATH = HYPERCLAW_ROOT / "memory"
+WORKSPACE_PATH = HYPERCLAW_ROOT / "workspace"
+KNOWLEDGE_FILE = MEMORY_PATH / "KNOWLEDGE.md"
+SUMMARY_FILE = MEMORY_PATH / "summary.md"
+
+MODEL = os.environ.get("HYPERCLAW_MODEL", "claude-sonnet-4-6")
+MAX_TOKENS = 4096   # default of cost_guard path "memory" (config: max_output_tokens_per_path)
+
+
+class MemoryAgent:
+    """Memory consolidation engine - summarizes daily logs."""
+
+    def __init__(self):
+        from hyperclaw.cost_guard import guard_client
+        self.client = guard_client(
+            anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY", "")), "anthropic")
+        self._last_run: Optional[datetime] = None
+
+    async def consolidate(self, days_back: int = 1) -> dict:
+        """
+        Main consolidation routine.
+        1. Read recent daily logs
+        2. Extract key facts and decisions
+        3. Update knowledge file
+        """
+        logger.info(f"Memory consolidation starting (days_back={days_back})")
+
+        results = {
+            "logs_processed": 0,
+            "facts_extracted": 0,
+            "errors": [],
+        }
+
+        try:
+            logs = self._gather_logs(days_back)
+            results["logs_processed"] = len(logs)
+
+            if not logs:
+                logger.info("No logs to process")
+                return results
+
+            facts = await self._extract_facts(logs)
+            if facts:
+                self._append_knowledge(facts)
+                results["facts_extracted"] = len(facts)
+
+            self._last_run = datetime.now()
+            logger.info(f"Memory consolidation complete: {results}")
+
+        except Exception as e:
+            logger.error(f"Consolidation error: {e}", exc_info=True)
+            results["errors"].append(str(e))
+
+        return results
+
+    def _gather_logs(self, days_back: int) -> list[dict]:
+        """Read recent daily logs."""
+        logs = []
+        today = datetime.now()
+
+        for i in range(days_back):
+            date = today - timedelta(days=i)
+            date_str = date.strftime("%Y-%m-%d")
+
+            for base in [MEMORY_PATH, WORKSPACE_PATH / "memory"]:
+                log_path = base / f"{date_str}.md"
+                if log_path.exists():
+                    try:
+                        content = log_path.read_text(encoding="utf-8")
+                        if content.strip():
+                            logs.append({
+                                "date": date_str,
+                                "path": str(log_path),
+                                "content": content[:50000],
+                            })
+                    except Exception as e:
+                        logger.warning(f"Failed to read {log_path}: {e}")
+
+        return logs
+
+    async def _extract_facts(self, logs: list[dict]) -> list[str]:
+        """Extract key facts and decisions from logs."""
+        combined = "\n\n---\n\n".join(
+            f"## {log['date']}\n{log['content']}" for log in logs
+        )
+
+        prompt = f"""Analyze these daily logs and extract KEY FACTS that should be remembered.
+
+Extract:
+- Decisions made
+- New information learned
+- Completed tasks
+- Important changes
+
+Format each as:
+[YYYY-MM-DD] Brief description
+
+Do NOT include:
+- Routine tasks
+- In-progress work
+- Technical debugging
+
+Return only extracted facts, one per line. If none, return "NONE".
+
+LOGS:
+{combined}"""
+
+        try:
+            response = await asyncio.to_thread(
+                self.client.messages.create,
+                model=MODEL,
+                max_tokens=max_output("memory", "anthropic", MODEL),
+                messages=[{"role": "user", "content": prompt}],
+            )
+            text = extract_text(response)
+
+            if text == "NONE":
+                return []
+
+            facts = [
+                line.strip() for line in text.split("\n")
+                if line.strip() and line.strip().startswith("[")
+            ]
+            return facts
+        except Exception as e:
+            logger.error(f"Fact extraction failed: {e}")
+            return []
+
+    def _append_knowledge(self, facts: list[str]) -> None:
+        """Append new facts to knowledge file."""
+        if not facts:
+            return
+
+        KNOWLEDGE_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+        existing = ""
+        if KNOWLEDGE_FILE.exists():
+            existing = KNOWLEDGE_FILE.read_text(encoding="utf-8")
+
+        new_facts = []
+        for fact in facts:
+            match = re.match(r"\[(\d{4}-\d{2}-\d{2})\]\s*(.+)", fact)
+            if match:
+                content = match.group(2).lower()
+                if content not in existing.lower():
+                    new_facts.append(fact)
+
+        if new_facts:
+            with open(KNOWLEDGE_FILE, "a", encoding="utf-8") as f:
+                f.write("\n")
+                for fact in new_facts:
+                    f.write(f"- {fact}\n")
+            logger.info(f"Added {len(new_facts)} facts to KNOWLEDGE.md")
+
+    def status(self) -> dict:
+        """Get agent status."""
+        return {
+            "name": "memory_agent",
+            "status": "active",
+            "last_run": self._last_run.isoformat() if self._last_run else None,
+            "knowledge_file": str(KNOWLEDGE_FILE),
+        }
+
+
+# Singleton
+_agent: Optional[MemoryAgent] = None
+
+
+def get_memory_agent() -> MemoryAgent:
+    """Get or create memory agent singleton."""
+    global _agent
+    if _agent is None:
+        _agent = MemoryAgent()
+    return _agent
+
+
+async def run_consolidation(days_back: int = 1) -> dict:
+    """Run memory consolidation."""
+    agent = get_memory_agent()
+    return await agent.consolidate(days_back)
+
+
+# Backwards compatibility
+Prometheus = MemoryAgent
+get_prometheus = get_memory_agent
+
+
+if __name__ == "__main__":
+    import sys
+    logging.basicConfig(level=logging.INFO)
+    days = int(sys.argv[1]) if len(sys.argv) > 1 else 1
+    result = asyncio.run(run_consolidation(days))
+    print(json.dumps(result, indent=2))