hum-cli 0.1.0__tar.gz → 0.1.2__tar.gz

{hum_cli-0.1.0 → hum_cli-0.1.2}/.github/workflows/publish.yml

@@ -14,6 +14,7 @@ jobs:
       - run: cd tui && npm ci && npm run build
       - uses: astral-sh/setup-uv@v5
       - run: uv build
+      - run: unzip -l dist/*.whl | grep -q "hum/tui/cli.mjs"   # the wheel must carry the terminal UI
       - uses: actions/upload-artifact@v4
         with: { name: dist, path: dist/ }
       - uses: actions/upload-artifact@v4

{hum_cli-0.1.0 → hum_cli-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hum-cli
-Version: 0.1.0
+Version: 0.1.2
 Summary: An agent harness built as an RL environment that humans can drive: session trees, interchangeable human/policy drivers, counterfactual shadow, earned autonomy, verifier in the loop.
 Requires-Python: >=3.12
 Requires-Dist: httpx>=0.27

{hum_cli-0.1.0 → hum_cli-0.1.2}/hum/__init__.py

@@ -1,4 +1,4 @@
 """Hum — an agent harness built as an RL environment that humans can drive.
 
 हम (Hindi): we, us. Human and model, one harness."""
-__version__ = "0.1.0"
+__version__ = "0.1.2"

hum_cli-0.1.2/hum/catalog.py

@@ -0,0 +1,64 @@
+"""What a person sees when they choose a session to pick up: when, what, how far,
+what it cost, where. Local files first; the server's list fills in sessions from
+other machines (pulled on demand when chosen)."""
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+from typing import Any
+
+from hum.runtime.store import list_sessions
+
+
+def _summary(path: Path) -> dict[str, Any]:
+    steps = 0
+    cost = 0.0
+    task: dict[str, Any] = {}
+    last = 0.0
+    try:
+        with path.open(encoding="utf-8") as f:
+            for line in f:
+                try:
+                    r = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                k = r.get("kind")
+                if k == "session":
+                    task = r.get("task") or {}
+                elif k == "meta":
+                    task.update({kk: v for kk, v in r.items() if kk != "kind"})
+                elif k == "node":
+                    if r.get("branch") == "main":
+                        steps += 1
+                    u = (r.get("turn") or {}).get("usage") or {}
+                    cost += float(u.get("cost_usd") or 0)
+                    last = max(last, float(r.get("at") or 0))
+    except OSError:
+        pass
+    return {"name": path.name, "instruction": (task.get("instruction") or "")[:200], "cwd": task.get("cwd"), "model": task.get("model"),
+            "steps": steps, "cost_usd": round(cost, 4), "at": last or path.stat().st_mtime, "local": True}
+
+
+def catalog(remote: list[dict[str, Any]] | None = None) -> list[dict[str, Any]]:
+    """Newest first. Remote entries not present locally are included with local=False."""
+    items = {p.name: _summary(p) for p in list_sessions()}
+    for r in remote or []:
+        n = r.get("name")
+        if n and n not in items:
+            items[n] = {"name": n, "instruction": (r.get("instruction") or "")[:200], "cwd": r.get("cwd"), "model": r.get("model"),
+                        "steps": None, "cost_usd": None, "at": float(r.get("created") or 0), "local": False}
+    return sorted(items.values(), key=lambda x: x["at"], reverse=True)
+
+
+def when(at: float, now: float | None = None) -> str:
+    d = (now or time.time()) - at
+    if d < 90:
+        return "just now"
+    if d < 3600:
+        return f"{int(d // 60)}m ago"
+    if d < 86400:
+        return f"{int(d // 3600)}h ago"
+    if d < 7 * 86400:
+        return f"{int(d // 86400)}d ago"
+    return time.strftime("%b %d", time.localtime(at))

{hum_cli-0.1.0 → hum_cli-0.1.2}/hum/cli.py

@@ -37,6 +37,7 @@ HELP = """/help          this
 /model [name]  show or switch the model for this session
 /tools         what's mounted
 /cost          tokens and cost so far
+/compact       summarise and restart the context now
 /quit          leave (Ctrl-D works too)
 !cmd           run a command yourself
 Ctrl-C         stop the current turn"""
@@ -336,6 +337,10 @@ class Client:
                 self.ui.info(f"model: {self.cfg.model}" + (f" via {self.cfg.api_base}" if self.cfg.api_base else ""))
         elif cmd == "tools":
             self.ui.info(", ".join(sorted(self.tools.tools)))
+        elif cmd == "compact":
+            head = session.head("main")
+            cid = asyncio.get_event_loop().run_until_complete(runner._compact(head.id if head else None, runner.policy, 0)) if False else None
+            self.ui.info("use /compact from the terminal UI; the plain client compacts automatically at the threshold")
         elif cmd == "cost":
             u = runner.usage + getattr(getattr(self, "delegation", None), "usage", u.__class__())
             self.ui.info(f"{u.input_tokens}+{u.output_tokens} tokens · ${u.cost_usd:.4f} · {runner.turns} turns" +
@@ -354,20 +359,20 @@ class Client:
 # --- commands -------------------------------------------------------------------------------------
 
 def cmd_sessions(ui: UI) -> None:
-    for p in list_sessions():
-        try:
-            s = Session.load(p)
-            hv = sum(1 for n in s.nodes.values() if n.intervention)
-            ui.console.print(f"[dim]{p.stem}[/]  {len(s.order):>3} turns  {hv:>2} yours  {s.task.get('instruction', '')[:70]}")
-        except Exception as e:  # noqa: BLE001
-            ui.console.print(f"[dim]{p.name}[/]  (unreadable: {e})")
+    from hum import sync
+    from hum.catalog import catalog, when
+    for it in catalog(sync.remote_list()):
+        steps = f"{it['steps']:>3} steps" if it["steps"] is not None else "  (on the server)"
+        cost = f"${it['cost_usd']:.2f}" if it["cost_usd"] else ""
+        ui.console.print(f"[dim]{when(it['at']):>9}[/]  {steps:<16} {cost:>6}  {it['instruction'][:60]}  [dim]{Path(it['cwd']).name if it.get('cwd') else ''}[/]")
 
 
 def _find(name: str) -> Path:
-    ms = [p for p in list_sessions() if name in p.name] if name and name != "last" else list_sessions()
-    if not ms:
+    from hum.engine import find_session
+    p = find_session(name or "last")
+    if p is None:
         sys.exit(f"no session matching {name!r}")
-    return ms[-1]
+    return p
 
 
 def cmd_show(ui: UI, name: str) -> None:
@@ -494,6 +499,7 @@ def main(argv: list[str] | None = None) -> int:
     cp = sub.add_parser("chat"); cp.add_argument("task", nargs="?"); cp.add_argument("-C", "--cwd", default="."); cp.add_argument("--plain", action="store_true", help="the Rich client, no Ink")
     rp = sub.add_parser("run"); rp.add_argument("task"); rp.add_argument("-C", "--cwd", default=".")
     rs = sub.add_parser("resume"); rs.add_argument("name", nargs="?", default="last"); rs.add_argument("--plain", action="store_true")
+    rs.add_argument("--last", dest="pick_last", action="store_true", help="skip the picker; continue the newest session")
     lg = sub.add_parser("login"); lg.add_argument("--auth-url")
     sub.add_parser("logout"); sub.add_parser("whoami"); sub.add_parser("sessions"); sub.add_parser("sync")
     mp = sub.add_parser("model"); mp.add_argument("name", nargs="?")
@@ -533,13 +539,12 @@ def main(argv: list[str] | None = None) -> int:
         if a.cmd == "run":
             return asyncio.run(Client(cfg, Path(a.cwd).resolve(), ui).one_shot(a.task))
         if a.cmd == "resume":
-            s = Session.load(_find(a.name))
-            cwd = Path(s.task.get("cwd", ".")).resolve()
             if not a.plain and sys.stdin.isatty():
-                rc = launch_tui(cfg, cwd, None, a.name)
+                rc = launch_tui(cfg, Path(a.cwd if hasattr(a, "cwd") else ".").resolve(), None, "pick" if a.name == "last" and not a.pick_last else a.name)
                 if rc >= 0:
                     return rc
-            return asyncio.run(Client(cfg, cwd, ui).chat(None, resume=s))
+            s = Session.load(_find(a.name))
+            return asyncio.run(Client(cfg, Path(s.task.get("cwd", ".")).resolve(), ui).chat(None, resume=s))
         if not a.plain and sys.stdin.isatty():
             rc = launch_tui(cfg, Path(a.cwd).resolve(), a.task, None)
             if rc >= 0:

{hum_cli-0.1.0 → hum_cli-0.1.2}/hum/engine.py

@@ -8,7 +8,9 @@ other way round (the front-end was spawned by Python and told where to connect).
 
 Front-end → engine (commands)
   {"cmd": "start", "task": "…"}             begin a session with this instruction
-  {"cmd": "resume", "name": "…"}            re-open a saved session (name or "last")
+  {"cmd": "resume", "name": "…"}            re-open a saved session (name or "last"); while idle, switches sessions
+  {"cmd": "sessions"}                        list sessions to pick from (local and on the server) → sessions {items}
+  {"cmd": "compact"}                         summarise and restart the context now (while idle)
   {"cmd": "message", "text": "…"}           steer (while busy) or a follow-up (while idle)
   {"cmd": "shell", "command": "…"}          the person runs a command themselves (!cmd)
   {"cmd": "interrupt"}                      stop the current turn; what it had so far is kept
@@ -22,7 +24,7 @@ Engine → front-end (events); every event has "type"
   human_edit {stat}                            compaction {prompt_tokens_before}
   turn_end {turns, cost_usd, input_tokens, output_tokens, elapsed_s, stop_reason}
   interrupted {kept}                           info {text} · warn {text} · error {text}
-  session {name, path}                         idle · busy {phase} · retry {attempt, text} · bye
+  session {name, path}                         idle · busy {phase} · retry {attempt, text} · bye · sessions {items}
 """
 from __future__ import annotations
 
@@ -38,7 +40,7 @@ from hum.cli import Client, Uploader, make_llm
 from hum.runtime import CURRENT_AGENT, HumanAction, HumanDriver, PolicyDriver, Session, StreamEvents, ToolCall, ToolRegistry, Turn
 from hum.runtime.config import Config
 from hum.runtime.llm import describe_partial_call, error_text
-from hum.runtime.store import list_sessions
+from hum.runtime.store import home, list_sessions
 from hum.ui import UI
 
 
@@ -200,15 +202,44 @@ class Engine:
                 self._open(self.client._session(str(cmd.get("task", "")).strip(), "chat"))
                 self._launch(None, None)
         elif kind == "resume":
-            if self.session is None:
-                name = str(cmd.get("name") or "last")
-                ms = [p for p in list_sessions() if name in p.name] if name != "last" else list_sessions()
-                if not ms:
-                    self.wire.send("error", text=f"no session matching {name!r}")
-                    return
-                s = Session.load(ms[-1])
-                self._open(s)
-                self.wire.send("idle")
+            if self.busy:
+                self.wire.send("warn", text="finish or stop the current turn first")
+                return
+            name = str(cmd.get("name") or "last")
+            path = await asyncio.to_thread(find_session, name)
+            if path is None:
+                self.wire.send("error", text=f"no session matching {name!r}")
+                return
+            if self.session is not None:
+                if self.uploader:
+                    await self.uploader.stop()
+                await self.client.close()
+            s = Session.load(path)
+            cwd = Path(s.task.get("cwd") or self.cwd).resolve()
+            if cwd != self.cwd:
+                # the session belongs to another directory: work there
+                self.cwd = cwd
+                self.client = Client(self.cfg, cwd, self.ui)
+                await self.client.mount()
+            self._open(s)
+            self.wire.send("idle")
+        elif kind == "sessions":
+            from hum import sync
+            from hum.catalog import catalog, when
+            remote = await asyncio.to_thread(sync.remote_list)
+            items = catalog(remote)
+            for it in items:
+                it["when"] = when(it["at"])
+            self.wire.send("sessions", items=items[:50])
+        elif kind == "compact":
+            if self.busy or self.runner is None or self.session is None:
+                self.wire.send("warn", text="nothing to compact yet" if self.session is None else "wait for the current turn to finish")
+                return
+            head = self.session.head("main")
+            self.wire.send("busy", phase="compacting")
+            cid = await self.runner._compact(head.id if head else None, self.runner.policy, 0)
+            self.wire.send("info", text="context summarised and restarted" if cid else "compaction failed; context unchanged")
+            self.wire.send("idle")
         elif kind == "message":
             text = str(cmd.get("text", "")).strip()
             if not text:
@@ -301,6 +332,18 @@ class Engine:
             pass
 
 
+def find_session(name: str) -> Path | None:
+    """A local session by name (substring; "last" = newest), else pull it from the server."""
+    from hum import sync
+    ms = [p for p in list_sessions() if name in p.name] if name != "last" else list_sessions()
+    if ms:
+        return ms[-1]
+    for r in sync.remote_list():
+        if name == "last" or name in r.get("name", ""):
+            return sync.pull(r["name"])
+    return None
+
+
 async def serve(cfg: Config, cwd: Path, *, listen: bool, port: int | None) -> int:
     """``listen``: bind an ephemeral localhost port, print it, accept one front-end.
     Otherwise connect to ``port`` (the front-end is listening)."""

{hum_cli-0.1.0 → hum_cli-0.1.2}/hum/sync.py

@@ -54,3 +54,38 @@ def sync_all(client: Any = None) -> tuple[int, int]:
         if upload(p, c, client=client):
             sent += 1
     return sent, skipped
+
+
+def remote_list(creds: Credentials | None = None, client: Any = None, timeout: float = 8.0) -> list[dict[str, Any]]:
+    """Sessions the server holds for this person (any machine). Empty on any failure."""
+    import httpx
+
+    c = creds or load_creds()
+    if not c.logged_in:
+        return []
+    try:
+        http = client or httpx.Client(timeout=timeout)
+        r = http.get(f"{c.auth_url}/sessions", headers={"Authorization": f"Bearer {c.access_token}"})
+        return list(r.json()) if r.status_code == 200 else []
+    except Exception:  # noqa: BLE001
+        return []
+
+
+def pull(name: str, creds: Credentials | None = None, client: Any = None, timeout: float = 30.0) -> Path | None:
+    """Fetch one session file from the server into ~/.hum/sessions (so it can be resumed here)."""
+    import httpx
+
+    c = creds or load_creds()
+    if not c.logged_in:
+        return None
+    try:
+        http = client or httpx.Client(timeout=timeout)
+        r = http.get(f"{c.auth_url}/sessions/{name}", headers={"Authorization": f"Bearer {c.access_token}"})
+        if r.status_code != 200 or not r.content:
+            return None
+        dest = home() / "sessions" / Path(name).name
+        dest.write_bytes(r.content)
+        _mark(dest.name, {"size": dest.stat().st_size, "id": None})
+        return dest
+    except Exception:  # noqa: BLE001
+        return None