town 0.1.0__py3-none-any.whl

town/__init__.py

@@ -0,0 +1,5 @@
+"""morph: experimental morphing agent harness."""
+from .config import Config
+from .organism import Organism, Town
+
+__all__ = ["Config", "Organism", "Town"]

town/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

town/auth.py

@@ -0,0 +1,73 @@
+"""`town auth`: interactive onboarding. Asks for the API base URL and key, validates them against the
+models endpoint, and stores them in the user config file. `town auth status` shows what is in effect."""
+from __future__ import annotations
+
+import getpass
+import os
+import sys
+
+from .config import ANTHROPIC_URL, CONFIG_FILE, Config, load_user_config, save_user_config
+
+
+def _models(base_url: str, api_key: str) -> list[str]:
+    import anthropic
+
+    client = anthropic.Anthropic(api_key=api_key, base_url=base_url, max_retries=1, timeout=30)
+    return [m.id for m in client.models.list()]
+
+
+def status() -> int:
+    cfg = Config()
+    src = "env" if os.environ.get("TOWN_API_KEY") or os.environ.get("ANTHROPIC_API_KEY") else "unset"
+    if src == "env" and load_user_config().get("TOWN_API_KEY") == os.environ.get("TOWN_API_KEY"):
+        src = str(CONFIG_FILE)
+    print(f"base url : {cfg.base_url}")
+    print(f"api key  : {'set (' + cfg.api_key[:8] + '…) from ' + src if cfg.api_key else 'not set'}")
+    print(f"model    : {cfg.model}   helper: {cfg.helper_model}")
+    print(f"config   : {CONFIG_FILE}{'' if CONFIG_FILE.exists() else ' (absent)'}")
+    if not cfg.api_key:
+        print("run `town auth` to set up")
+        return 1
+    try:
+        ms = _models(cfg.base_url, cfg.api_key)
+        print(f"gateway  : ok, {len(ms)} models ({', '.join(ms[:6])}{'…' if len(ms) > 6 else ''})")
+        return 0
+    except Exception as e:  # noqa: BLE001
+        print(f"gateway  : FAILED ({type(e).__name__}: {str(e)[:160]})")
+        return 1
+
+
+def onboard(non_interactive: bool = False) -> int:
+    print("town setup")
+    print("Every citizen calls the Claude API. Tell me where and with which key; env vars override this later.")
+    print()
+    if non_interactive or not sys.stdin.isatty():
+        print("No terminal to ask on. Set TOWN_API_KEY (and TOWN_BASE_URL for a gateway), or run `town auth` in a terminal.")
+        return 1
+    current = Config()
+    default_url = current.base_url or ANTHROPIC_URL
+    url = input(f"API base URL [{default_url}] (Anthropic directly, or a gateway such as LiteLLM): ").strip() or default_url
+    url = url.rstrip("/")
+    key = getpass.getpass("API key (input hidden; sk-ant-… for Anthropic, or your gateway key): ").strip()
+    if not key:
+        print("no key given; nothing saved")
+        return 1
+    print("checking…", end=" ", flush=True)
+    try:
+        ms = _models(url, key)
+    except Exception as e:  # noqa: BLE001
+        print(f"failed: {type(e).__name__}: {str(e)[:200]}")
+        print("Nothing saved. Check the URL and key (a LiteLLM gateway takes its own key, not an Anthropic one).")
+        return 1
+    print(f"ok, {len(ms)} models available")
+    default_model = "claude-opus-5" if "claude-opus-5" in ms else (ms[0] if ms else "claude-opus-5")
+    model = input(f"default model for citizens [{default_model}]: ").strip() or default_model
+    if model not in ms:
+        print(f"note: {model!r} is not in the gateway's list; keeping it anyway")
+    path = save_user_config({"TOWN_BASE_URL": url, "TOWN_API_KEY": key, "TOWN_MODEL": model, "TOWN_HELPER_MODEL": model})
+    print(f"saved to {path} (mode 600)")
+    print()
+    print("try:  town run \"Find out which stdlib module has the most public names. Tell me once.\"")
+    print("      town preset fork_merge      # one of the built-in experiments")
+    print("      town watch traces/<run>.jsonl   in a second terminal, to watch it live")
+    return 0

town/blocks.py

@@ -0,0 +1,73 @@
+"""The context data model.
+
+A cell's context is NOT a chat transcript. It is an ordered, mutable list of Blocks that gets
+re-rendered into a single document on every model call. Because we do not care about prompt
+caching, every call can see a freshly rewritten context: blocks can be dropped, rewritten,
+pinned, compressed into engrams, recalled from the memory store, or copied into forks.
+"""
+from __future__ import annotations
+
+import itertools
+import time
+from dataclasses import dataclass, field
+
+_ids = itertools.count(1)
+
+# Default salience per kind. 5 = pinned (never auto-compressed), 1 = first to go.
+DEFAULT_SALIENCE = {
+    "task": 5,      # the originating task / focus statement
+    "user": 5,      # something the human said
+    "ask": 4,       # a question we surfaced to the human
+    "msg": 4,       # a message from another cell
+    "merge": 4,     # synthesized result of merging other cells
+    "recall": 3,    # an engram recalled from memory
+    "note": 3,      # explicit note written by the cell via ctx.note()
+    "system": 3,    # harness notices
+    "thought": 2,   # visible text the model wrote (its monologue)
+    "result": 2,    # python stdout/stderr/value
+    "code": 1,      # python code executed
+    "think": 1,     # summarized thinking (continuous inner voice)
+    "stub": 3,      # compressed-block placeholder pointing at an engram
+    "rewind": 4,    # record of a rewind: where from, where to, and why
+}
+
+
+@dataclass
+class Block:
+    kind: str
+    text: str
+    salience: int = 0
+    id: int = field(default_factory=lambda: next(_ids))
+    t: float = field(default_factory=time.time)
+    step: int = 0
+    meta: dict = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if not self.salience:
+            self.salience = DEFAULT_SALIENCE.get(self.kind, 3)
+
+    @property
+    def pinned(self) -> bool:
+        return self.salience >= 5
+
+    def copy(self) -> "Block":
+        return Block(kind=self.kind, text=self.text, salience=self.salience, step=self.step, meta=dict(self.meta))
+
+    def copy_with_id(self) -> "Block":
+        b = self.copy()
+        b.id, b.t = self.id, self.t
+        return b
+
+    def render(self) -> str:
+        attrs = [f"id={self.id}", f"kind={self.kind}", f"s={self.salience}", f"step={self.step}"]
+        for k, v in self.meta.items():
+            if k in ("from", "engram", "cell", "to", "kept_from"):
+                attrs.append(f"{k}={v}")
+        return f"<b {' '.join(attrs)}>\n{self.text}\n</b>"
+
+    def to_json(self) -> dict:
+        return {"id": self.id, "kind": self.kind, "s": self.salience, "step": self.step, "text": self.text, "meta": self.meta}
+
+
+def estimate_tokens(text: str, chars_per_token: float = 3.6) -> int:
+    return int(len(text) / chars_per_token) + 1