hum-cli 0.0.1__py3-none-any.whl

hum/runtime/tools.py

@@ -0,0 +1,284 @@
+"""Native tools. Every tool is a JSON-schema function the model calls directly;
+MCP servers are mounted into the same registry so ``control`` and ``run-unit``
+look to the model exactly like ``bash`` does.
+"""
+from __future__ import annotations
+
+import asyncio
+import fnmatch
+import json
+import os
+import re
+import shlex
+import time
+from pathlib import Path
+from contextlib import AsyncExitStack
+from dataclasses import dataclass, field
+from typing import Any, Awaitable, Callable
+
+from .executor import Executor, decode
+from .models import ToolCall, ToolResult
+from .observe import shape
+
+Handler = Callable[[Executor, dict[str, Any]], Awaitable[str]]
+
+
+@dataclass
+class Tool:
+    name: str
+    description: str
+    parameters: dict[str, Any]
+    handler: Handler
+    mutating: bool = False  # used by autonomy gating: read-only tools may run ungated
+
+    def to_openai(self) -> dict[str, Any]:
+        return {"type": "function", "function": {"name": self.name, "description": self.description, "parameters": self.parameters}}
+
+
+@dataclass
+class ToolRegistry:
+    tools: dict[str, Tool] = field(default_factory=dict)
+    observation_max_bytes: int = 16_000
+
+    def add(self, tool: Tool) -> None:
+        if tool.name in self.tools:
+            raise ValueError(f"duplicate tool {tool.name}")
+        self.tools[tool.name] = tool
+
+    def extend(self, tools: list[Tool]) -> "ToolRegistry":
+        for t in tools:
+            self.add(t)
+        return self
+
+    def to_openai(self) -> list[dict[str, Any]]:
+        return [t.to_openai() for t in self.tools.values()]
+
+    def is_mutating(self, name: str) -> bool:
+        t = self.tools.get(name)
+        return True if t is None else t.mutating
+
+    async def call(self, call: ToolCall, executor: Executor) -> ToolResult:
+        t0 = time.monotonic()
+        tool = self.tools.get(call.name)
+        if tool is None:
+            return ToolResult(call_id=call.id, name=call.name, ok=False, content=f"unknown tool {call.name!r}; available: {sorted(self.tools)}")
+        try:
+            raw = await tool.handler(executor, call.arguments)
+            text, nbytes = shape(raw, self.observation_max_bytes)
+            return ToolResult(call_id=call.id, name=call.name, content=text, raw_bytes=nbytes, elapsed_s=time.monotonic() - t0)
+        except Exception as e:  # the model gets the error as an observation, never a crash
+            return ToolResult(call_id=call.id, name=call.name, ok=False, content=f"{type(e).__name__}: {e}", elapsed_s=time.monotonic() - t0)
+
+    async def call_many(self, calls: list[ToolCall], executor: Executor, parallel: bool = True) -> list[ToolResult]:
+        if parallel and len(calls) > 1 and all(not self.is_mutating(c.name) for c in calls):
+            return list(await asyncio.gather(*(self.call(c, executor) for c in calls)))
+        out = []
+        for c in calls:
+            out.append(await self.call(c, executor))
+        return out
+
+
+# --- builtins -----------------------------------------------------------------
+
+async def _bash(ex: Executor, a: dict[str, Any]) -> str:
+    r = await ex.exec(a["command"], timeout_sec=int(a.get("timeout_sec", 120)))
+    tail = f"\n[exit {r.returncode}{' (timed out)' if r.timed_out else ''}]"
+    return (r.text or "(no output)") + tail
+
+
+async def _read_file(ex: Executor, a: dict[str, Any]) -> str:
+    text = decode(await ex.read(a["path"]))
+    lines = text.splitlines()
+    off = max(int(a.get("offset", 1)), 1)
+    lim = int(a.get("limit", 400))
+    chunk = lines[off - 1 : off - 1 + lim]
+    width = len(str(off + len(chunk)))
+    body = "\n".join(f"{i:>{width}}\t{l}" for i, l in enumerate(chunk, start=off))
+    more = len(lines) - (off - 1 + len(chunk))
+    return body + (f"\n... ({more} more lines)" if more > 0 else "")
+
+
+async def _write_file(ex: Executor, a: dict[str, Any]) -> str:
+    data = a["content"].encode("utf-8")
+    await ex.write(a["path"], data)
+    return f"wrote {len(data)} bytes to {a['path']}"
+
+
+async def _edit_file(ex: Executor, a: dict[str, Any]) -> str:
+    raw = await ex.read(a["path"])
+    text = decode(raw)
+    old, new = a["old_string"], a["new_string"]
+    n = text.count(old)
+    if n == 0:
+        return "old_string not found; no change"
+    if n > 1 and not a.get("replace_all", False):
+        return f"old_string occurs {n} times; pass replace_all=true or make it unique; no change"
+    text = text.replace(old, new) if a.get("replace_all") else text.replace(old, new, 1)
+    enc = "utf-8"
+    try:
+        raw.decode("utf-8")
+    except UnicodeDecodeError:
+        enc = "latin-1"
+    await ex.write(a["path"], text.encode(enc))
+    return f"replaced {n if a.get('replace_all') else 1} occurrence(s) in {a['path']}"
+
+
+_SKIP_DIRS = {".git", "node_modules", ".venv", "venv", "__pycache__", ".hum", ".idea", ".vscode", "dist", "build"}
+
+
+def _walk(root: Path, max_files: int = 50_000):
+    n = 0
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d not in _SKIP_DIRS]
+        for f in filenames:
+            yield Path(dirpath) / f
+            n += 1
+            if n >= max_files:
+                return
+
+
+def _root_of(ex: Executor, path: str) -> Path:
+    base = Path(getattr(ex, "root", ex.cwd))
+    p = Path(path)
+    return p if p.is_absolute() else base / p
+
+
+async def _grep(ex: Executor, a: dict[str, Any]) -> str:
+    """Byte-wise search in Python: same results on macOS, Linux and Windows; latin-1 estate files are searchable."""
+    root = _root_of(ex, a.get("path", "."))
+    flags = re.IGNORECASE if a.get("ignore_case") else 0
+    try:
+        pat = re.compile(a["pattern"].encode("latin-1", errors="replace"), flags)
+    except re.error as e:
+        return f"bad pattern: {e}"
+    glob = a.get("glob")
+    limit = int(a.get("max_results", 200))
+    base = Path(getattr(ex, "root", ex.cwd))
+    out: list[str] = []
+
+    def run() -> list[str]:
+        files = [root] if root.is_file() else _walk(root)
+        for f in files:
+            if glob and not fnmatch.fnmatch(f.name, glob):
+                continue
+            try:
+                data = f.read_bytes()
+            except OSError:
+                continue
+            if b"\x00" in data[:8000]:
+                continue  # binary
+            for i, line in enumerate(data.splitlines(), 1):
+                if pat.search(line):
+                    rel = os.path.relpath(f, base).replace(os.sep, "/")  # one path style on every OS
+                    out.append(f"{rel}:{i}:{decode(line)[:400]}")
+                    if len(out) >= limit:
+                        return out
+        return out
+
+    res = await asyncio.to_thread(run)
+    return "\n".join(res) if res else "(no matches)"
+
+
+async def _glob(ex: Executor, a: dict[str, Any]) -> str:
+    root = _root_of(ex, a.get("path", "."))
+    pattern = a["pattern"]
+    limit = int(a.get("max_results", 500))
+    base = Path(getattr(ex, "root", ex.cwd))
+
+    # fnmatch has no '**': accept the pattern with '**/' meaning "zero or more directories".
+    cands = {pattern, pattern.replace("**/", ""), pattern.replace("/**", ""), "*/" + pattern.lstrip("*/")}
+
+    def match(rel: str, name: str) -> bool:
+        return any(fnmatch.fnmatch(rel, c) for c in cands) or fnmatch.fnmatch(name, pattern)
+
+    def run() -> list[str]:
+        out = []
+        for f in _walk(root):
+            rel = os.path.relpath(f, base).replace(os.sep, "/")
+            if match(rel, f.name):
+                out.append(rel)
+                if len(out) >= limit:
+                    break
+        return sorted(out)
+
+    res = await asyncio.to_thread(run)
+    return "\n".join(res) if res else "(no files)"
+
+
+def builtin_tools(shell: str = "bash") -> list[Tool]:
+    """``shell`` names the workspace shell ("bash" or "powershell") so the model writes the right syntax."""
+    S = lambda **p: {"type": "object", "properties": p, "required": [k for k, v in p.items() if v.pop("required", False)]}
+    shell_desc = ("Run a bash command in the workspace." if shell == "bash"
+                  else "Run a PowerShell command in the workspace (Windows; no bash available).")
+    return [
+        Tool(shell, shell_desc + " Output is returned; long output is head/tail trimmed.",
+             S(command={"type": "string", "required": True}, timeout_sec={"type": "integer", "default": 120}), _bash, mutating=True),
+        Tool("read_file", "Read a file with line numbers. Use offset/limit for large files.",
+             S(path={"type": "string", "required": True}, offset={"type": "integer", "default": 1}, limit={"type": "integer", "default": 400}), _read_file),
+        Tool("write_file", "Create or overwrite a file with the given content.",
+             S(path={"type": "string", "required": True}, content={"type": "string", "required": True}), _write_file, mutating=True),
+        Tool("edit_file", "Replace an exact string in a file. old_string must be unique unless replace_all.",
+             S(path={"type": "string", "required": True}, old_string={"type": "string", "required": True}, new_string={"type": "string", "required": True}, replace_all={"type": "boolean", "default": False}), _edit_file, mutating=True),
+        Tool("grep", "Search file contents recursively with a regex (byte-wise; latin-1 files are searchable).",
+             S(pattern={"type": "string", "required": True}, path={"type": "string", "default": "."}, glob={"type": "string"}, ignore_case={"type": "boolean", "default": False}, max_results={"type": "integer", "default": 200}), _grep),
+        Tool("glob", "Find files by name or path pattern, e.g. '*.cbl' or 'src/**/*.py'.",
+             S(pattern={"type": "string", "required": True}, path={"type": "string", "default": "."}, max_results={"type": "integer", "default": 500}), _glob),
+    ]
+
+
+# --- MCP bridge ----------------------------------------------------------------
+
+class MCPToolset:
+    """Mounts an MCP server's tools into a registry as native tools named
+    ``<server>__<tool>``. Transport: stdio or streamable-http."""
+
+    def __init__(self, name: str, *, url: str | None = None, command: str | None = None, args: list[str] | None = None, headers: dict[str, str] | None = None):
+        self.name, self.url, self.command, self.args, self.headers = name, url, command, args or [], headers or {}
+        self._stack: AsyncExitStack | None = None
+        self._session = None
+
+    async def connect(self) -> list[Tool]:
+        from mcp import ClientSession  # type: ignore
+
+        self._stack = AsyncExitStack()
+        if self.command:
+            from mcp import StdioServerParameters  # type: ignore
+            from mcp.client.stdio import stdio_client  # type: ignore
+            read, write = await self._stack.enter_async_context(stdio_client(StdioServerParameters(command=self.command, args=self.args)))
+        elif self.url:
+            from mcp.client.streamable_http import streamablehttp_client  # type: ignore
+            read, write, _ = await self._stack.enter_async_context(streamablehttp_client(self.url, headers=self.headers or None))
+        else:
+            raise ValueError("MCPToolset needs url or command")
+        self._session = await self._stack.enter_async_context(ClientSession(read, write))
+        await self._session.initialize()
+        listed = await self._session.list_tools()
+        tools: list[Tool] = []
+        for t in listed.tools:
+            tools.append(Tool(
+                name=f"{self.name}__{t.name}",
+                description=t.description or "",
+                parameters=t.inputSchema or {"type": "object", "properties": {}},
+                handler=self._make_handler(t.name),
+                mutating=not (getattr(t, "annotations", None) and getattr(t.annotations, "readOnlyHint", False)),
+            ))
+        return tools
+
+    def _make_handler(self, tool_name: str) -> Handler:
+        async def h(_ex: Executor, args: dict[str, Any]) -> str:
+            res = await self._session.call_tool(tool_name, args)  # type: ignore[union-attr]
+            parts = []
+            for c in res.content:
+                if getattr(c, "type", "") == "text":
+                    parts.append(c.text)
+                else:
+                    parts.append(json.dumps(c.model_dump(mode="json")))
+            out = "\n".join(parts)
+            if getattr(res, "isError", False):
+                out = f"[tool error]\n{out}"
+            return out
+        return h
+
+    async def close(self) -> None:
+        if self._stack:
+            await self._stack.aclose()

hum/runtime/trajectory.py

@@ -0,0 +1,68 @@
+"""ATIF export. The main branch becomes the trajectory; authorship,
+interventions, shadow branches and verdicts ride in ``extra`` so the file
+stays a valid ATIF-v1.7 document for every consumer that doesn't know us.
+"""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+from .session import Session
+
+
+def _ts(t: float) -> str:
+    return datetime.fromtimestamp(t, tz=timezone.utc).isoformat()
+
+
+def to_atif(session: Session, *, agent_name: str, agent_version: str, model_name: str | None, system_prompt: str,
+            branch: str = "main", tool_definitions: list[dict[str, Any]] | None = None) -> dict[str, Any]:
+    leaf = session.head(branch)
+    steps: list[dict[str, Any]] = [
+        {"step_id": 1, "source": "system", "message": system_prompt, "timestamp": _ts(leaf.at if leaf else 0)},
+        {"step_id": 2, "source": "user", "message": session.task["instruction"], "timestamp": _ts(leaf.at if leaf else 0)},
+    ]
+    tot_in = tot_out = tot_cache = 0
+    tot_cost = 0.0
+    for n in session.lineage(leaf.id if leaf else None):
+        t = n.turn
+        src = "agent" if t.author in ("policy", "shadow") else "user"
+        step: dict[str, Any] = {
+            "step_id": len(steps) + 1,
+            "timestamp": _ts(n.at),
+            "source": src,
+            "message": t.content or "",
+            "extra": {"node_id": n.id, "parent": n.parent, "branch": n.branch, "author": t.author,
+                      "intervention": n.intervention.model_dump() if n.intervention else None,
+                      "verdict": n.verdict.model_dump() if n.verdict else None},
+        }
+        if src == "agent":
+            step["model_name"] = t.model or model_name
+        if t.reasoning:
+            step["reasoning_content"] = t.reasoning
+        if t.tool_calls:
+            step["tool_calls"] = [{"tool_call_id": c.id, "function_name": c.name, "arguments": c.arguments} for c in t.tool_calls]
+        if n.results:
+            step["observation"] = {"results": [{"source_call_id": r.call_id, "content": r.content,
+                                                "extra": {"ok": r.ok, "elapsed_s": r.elapsed_s, "raw_bytes": r.raw_bytes}} for r in n.results]}
+        if t.usage:
+            step["metrics"] = {"prompt_tokens": t.usage.input_tokens, "completion_tokens": t.usage.output_tokens,
+                               "cached_tokens": t.usage.cache_tokens, "cost_usd": t.usage.cost_usd,
+                               "prompt_token_ids": t.prompt_token_ids, "completion_token_ids": t.completion_token_ids, "logprobs": t.logprobs}
+            tot_in += t.usage.input_tokens; tot_out += t.usage.output_tokens; tot_cache += t.usage.cache_tokens; tot_cost += t.usage.cost_usd
+        steps.append(step)
+    shadows = sorted({n.branch for n in session.nodes.values() if n.branch != branch})
+    return {
+        "schema_version": "ATIF-v1.7",
+        "session_id": session.id,
+        "agent": {"name": agent_name, "version": agent_version, "model_name": model_name, "tool_definitions": tool_definitions},
+        "steps": steps,
+        "final_metrics": {"total_prompt_tokens": tot_in, "total_completion_tokens": tot_out, "total_cached_tokens": tot_cache,
+                          "total_cost_usd": tot_cost, "total_steps": len(steps)},
+        "extra": {
+            "harness": agent_name,
+            "task": {k: v for k, v in session.task.items() if k != "instruction"},
+            "shadow_branches": {b: [n.id for n in session.branch_nodes(b)] for b in shadows},
+            "preference_pairs": [p.model_dump() for p in session.pairs],
+            "leaf_verdict": leaf.verdict.model_dump() if leaf and leaf.verdict else None,
+        },
+    }

hum/runtime/workspace.py

@@ -0,0 +1,48 @@
+"""Notice what the human changed with their own hands.
+
+Between two model turns, if files in the workspace changed and no tool call
+made the change, a person did. That is the most natural intervention there is
+and the SME never has to announce it. Uses git when the workspace is a repo
+(cheap, exact), otherwise an mtime scan.
+"""
+from __future__ import annotations
+
+import hashlib
+import os
+from pathlib import Path
+
+from .executor import Executor
+
+_SKIP = {".git", "node_modules", ".venv", "__pycache__", ".hum"}
+
+
+async def fingerprint(ex: Executor) -> str:
+    r = await ex.exec("git status --porcelain=v1 --untracked-files=all && git diff", timeout_sec=30)
+    if r.returncode == 0:
+        return hashlib.sha1(r.stdout.encode("utf-8", errors="replace")).hexdigest()
+    return await _mtime_scan(ex)
+
+
+async def _mtime_scan(ex: Executor) -> str:
+    root = Path(getattr(ex, "root", ex.cwd))
+    h = hashlib.sha1()
+    n = 0
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d not in _SKIP]
+        for f in filenames:
+            p = Path(dirpath) / f
+            try:
+                st = p.stat()
+            except OSError:
+                continue
+            h.update(f"{p.relative_to(root)}:{st.st_mtime_ns}:{st.st_size}".encode())
+            n += 1
+            if n > 20000:
+                break
+    return h.hexdigest()
+
+
+async def describe_change(ex: Executor) -> str:
+    r = await ex.exec("git status --porcelain=v1 && git diff --stat", timeout_sec=30)
+    lines = (r.stdout or "").strip().splitlines()
+    return "\n".join(lines[:60])

hum/sync.py

@@ -0,0 +1,56 @@
+"""Sessions go home. After a run, the session file is uploaded to the auth
+server (bearer = the person's Hum token). Best-effort and quick; ``hum sync``
+retries anything that didn't make it. A ledger in ~/.hum/synced.json records
+what has been sent.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from hum.auth import Credentials, load as load_creds
+from hum.runtime.store import home, list_sessions
+
+
+def _ledger() -> dict[str, Any]:
+    p = home() / "synced.json"
+    return json.loads(p.read_text()) if p.exists() else {}
+
+
+def _mark(name: str, info: dict[str, Any]) -> None:
+    p = home() / "synced.json"
+    d = _ledger()
+    d[name] = info
+    p.write_text(json.dumps(d, indent=1))
+
+
+def upload(path: Path, creds: Credentials | None = None, client: Any = None, timeout: float = 10.0) -> bool:
+    import httpx
+
+    c = creds or load_creds()
+    if not c.logged_in:
+        return False
+    http = client or httpx.Client(timeout=timeout)
+    size = path.stat().st_size
+    r = http.post(f"{c.auth_url}/sessions", content=path.read_bytes(),
+                  headers={"Authorization": f"Bearer {c.access_token}", "Content-Type": "application/x-ndjson", "X-Hum-Session": path.name})
+    if r.status_code in (200, 201):
+        _mark(path.name, {"size": size, "id": r.json().get("id")})
+        return True
+    return False
+
+
+def sync_all(client: Any = None) -> tuple[int, int]:
+    c = load_creds()
+    if not c.logged_in:
+        return 0, 0
+    done = _ledger()
+    sent = skipped = 0
+    for p in list_sessions():
+        if done.get(p.name, {}).get("size") == p.stat().st_size:
+            skipped += 1
+            continue
+        if upload(p, c, client=client):
+            sent += 1
+    return sent, skipped

hum/ui.py

@@ -0,0 +1,109 @@
+"""What the person sees. Rich for rendering; nothing here knows about training."""
+from __future__ import annotations
+
+import difflib
+import json
+import sys
+from typing import Any
+
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.syntax import Syntax
+from rich.text import Text
+
+from hum.runtime.models import ToolCall
+
+
+class UI:
+    def __init__(self, console: Console | None = None):
+        self.console = console or Console(highlight=False, soft_wrap=True)
+        self._streaming = False
+        self._buf = ""
+        self._status: Any = None
+
+    # -- lifecycle ------------------------------------------------------------------
+    def banner(self, model: str, tools: list[str], session: str, user: str | None = None) -> None:
+        who = f" · {user}" if user else ""
+        self.console.print(Text(f"hum · {model}{who} · tools: {', '.join(tools)} · {session}", style="dim"))
+
+    def thinking(self, on: bool) -> None:
+        """Spinner for unattended runs only; in chat the prompt owns the bottom line."""
+        if on and self._status is None:
+            self._status = self.console.status("[dim]thinking…", spinner="dots")
+            self._status.start()
+        elif not on and self._status is not None:
+            self._status.stop()
+            self._status = None
+
+    # -- model text -------------------------------------------------------------------
+    def text(self, delta: str) -> None:
+        self.thinking(False)
+        if not self._streaming:
+            self.console.print(Text("hum ", style="bold"), end="")
+            self._streaming = True
+        self._buf += delta
+        self.console.print(Text(delta), end="")
+        sys.stdout.flush()
+
+    def end_text(self) -> None:
+        if self._streaming:
+            self.console.print()
+            self._streaming = False
+        self._buf = ""
+
+    def final(self, content: str) -> None:
+        """Unattended runs: the whole answer at once, rendered."""
+        if content.strip():
+            self.console.print(Markdown(content))
+
+    # -- tools ---------------------------------------------------------------------------
+    def call(self, c: ToolCall) -> None:
+        self.thinking(False)
+        self.end_text()
+        a = c.arguments
+        if c.name in ("bash", "powershell"):
+            self.console.print(Text("  $ " if c.name == "bash" else "  PS> ", style="cyan") + Text(str(a.get("command", "")).replace("\n", " ⏎ ")[:300]))
+        elif c.name == "edit_file":
+            self.console.print(Text(f"  ✎ {a.get('path', '')}", style="cyan"))
+            old, new = str(a.get("old_string", "")), str(a.get("new_string", ""))
+            diff = "\n".join(difflib.unified_diff(old.splitlines(), new.splitlines(), lineterm="", n=1))
+            diff = "\n".join(l for l in diff.splitlines() if not l.startswith(("---", "+++")))
+            if diff:
+                self.console.print(Syntax(diff, "diff", theme="ansi_dark", word_wrap=True, padding=(0, 4)))
+        elif c.name == "write_file":
+            content = str(a.get("content", ""))
+            self.console.print(Text(f"  + {a.get('path', '')}", style="cyan") + Text(f"  ({len(content.splitlines())} lines)", style="dim"))
+        elif c.name == "read_file":
+            self.console.print(Text(f"  ◦ read {a.get('path', '')}", style="dim cyan"))
+        elif c.name in ("grep", "glob"):
+            self.console.print(Text(f"  ◦ {c.name} {a.get('pattern', '')}" + (f" in {a['path']}" if a.get("path") else ""), style="dim cyan"))
+        else:
+            self.console.print(Text(f"  ▸ {c.name} ", style="cyan") + Text(json.dumps(a, ensure_ascii=False)[:300], style="dim"))
+
+    def result(self, r: Any, max_lines: int = 10) -> None:
+        if r.name in ("read_file", "grep", "glob") and r.ok:
+            n = len(r.content.splitlines())
+            self.console.print(Text(f"    {n} lines", style="dim"))
+            return
+        lines = r.content.splitlines() or [""]
+        style = "dim" if r.ok else "red"
+        for l in lines[:max_lines]:
+            self.console.print(Text("    " + l[:220], style=style))
+        if len(lines) > max_lines:
+            self.console.print(Text(f"    … {len(lines) - max_lines} more lines", style="dim"))
+
+    # -- notes -------------------------------------------------------------------------------
+    def info(self, msg: str) -> None:
+        self.console.print(Text(msg, style="dim"))
+
+    def warn(self, msg: str) -> None:
+        self.console.print(Text(msg, style="yellow"))
+
+    def error(self, msg: str) -> None:
+        self.end_text()
+        self.console.print(Text(msg, style="red"))
+
+    def summary(self, turns: int, cost: float, verdict: Any) -> None:
+        v = "" if verdict is None else (" · [green]pass[/]" if verdict.passed else " · [red]fail[/]")
+        c = f"${cost:.2f}" if cost >= 0.01 else (f"${cost:.4f}" if cost > 0 else "$0")
+        self.console.print(f"[dim]— {turns} turns · {c}[/]{v}")

hum_cli-0.0.1.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.5
+Name: hum-cli
+Version: 0.0.1
+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
+Requires-Dist: litellm>=1.70
+Requires-Dist: mcp>=1.2
+Requires-Dist: prompt-toolkit>=3.0
+Requires-Dist: pydantic>=2
+Requires-Dist: rich>=13
+Provides-Extra: dev
+Requires-Dist: fastapi>=0.110; extra == 'dev'
+Requires-Dist: google-auth>=2; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: python-multipart; extra == 'dev'
+Provides-Extra: harbor
+Requires-Dist: harbor>=0.21; extra == 'harbor'
+Provides-Extra: server
+Requires-Dist: fastapi>=0.110; extra == 'server'
+Requires-Dist: google-auth>=2; extra == 'server'
+Requires-Dist: python-multipart; extra == 'server'
+Requires-Dist: uvicorn[standard]; extra == 'server'

hum_cli-0.0.1.dist-info/RECORD

@@ -0,0 +1,27 @@
+hum/__init__.py,sha256=lxYx2Ie0s5xhhxj3lKz_l2WR5vUOizJ8C8wRDTVyoQA,158
+hum/auth.py,sha256=bHn5PCf3zT_WtQBlhx63VNO4baPQsCRmaA2qDVQRLwM,3887
+hum/cli.py,sha256=VGldokS9Tr4qJSurValnN6bO_ksBGy8j9EgwOItb_js,17572
+hum/sync.py,sha256=Xuhbw6ndWxh-ikC82Qygg8_XQG84rzb8W_v44KhIZlU,1773
+hum/ui.py,sha256=m1so_szp1Fm6s2WLBmNvTJPzFQITs3Lpwd5P_AieT7g,4981
+hum/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hum/adapters/harbor.py,sha256=ofJKz54tcsWKzVUokHsb2Lfuhc3DVlR-V9JAlxxUQpQ,6286
+hum/runtime/__init__.py,sha256=PyyENODOaQUjj_Kiq_MnhadaOlN0XYgi-ovlnogTsgI,535
+hum/runtime/autonomy.py,sha256=ZNV5VlTeRkZAtJi-mp_T9DidVMD2hyL2IFVRKIRErac,2909
+hum/runtime/config.py,sha256=HZHpNDlRDFaRdjPyZjvWRm2tokwxujgDwRSdvlDanjw,4203
+hum/runtime/drivers.py,sha256=EJ9VzGPRs5HshEqwM8ulcoJ-mIlZmVQh0OmFuTD3EgI,2559
+hum/runtime/executor.py,sha256=JUArGC1obW8XVftPfi3kuZO-25n13LJqvXCXNjFO7g8,4552
+hum/runtime/grader.py,sha256=4rt1DmklCvqEKQWYMLQne7PAnSBIhOHul54EQ_2oEqc,1799
+hum/runtime/llm.py,sha256=HMERV01oBfkoyFDwzKH2jYO2JZlWVjgwYIu-7hYOBXk,11478
+hum/runtime/loop.py,sha256=kRbvabfji2VqlBrcp-3MhMnPYT-9wbQieNtcWko-bXU,13599
+hum/runtime/models.py,sha256=JU8dH9JJ36snqgBsq7Evc7olXa9_DJvosSy38XHtjqc,4125
+hum/runtime/observe.py,sha256=FRtkmIkRlqB17G6pN7V2goXAvJqdHLvqnc0Wb-Ujd0s,1186
+hum/runtime/prompt.py,sha256=NHiurSRiXysoxqp5KqNc5DGGcfBDdlQHigTXZWK8YrE,617
+hum/runtime/session.py,sha256=Q6dgHtGff58PdCZNiSgthMzErUGtarGXz-TzQ-yvsRo,5840
+hum/runtime/store.py,sha256=RKnyqW2O8H6DT7yuTMoq67EHxke5dkJKCOjCxo7jFtA,679
+hum/runtime/tools.py,sha256=6oTcSnsch4uo52UVPyNP38X7Vzr4ap5JiQfPl6DOy0o,12496
+hum/runtime/trajectory.py,sha256=IC13W5AgE43TzkRnMtjrskM-g5ef6MX02Hg3lLOUdyQ,3709
+hum/runtime/workspace.py,sha256=rb6ZBWDbtmU-hvUh43cQsfDIbLbessQjKtfDyo0d6TM,1605
+hum_cli-0.0.1.dist-info/METADATA,sha256=_O8E3Xv1uZDBqmPWVuGPWjgeIymLLDs2qZLgoTMbH-I,979
+hum_cli-0.0.1.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+hum_cli-0.0.1.dist-info/entry_points.txt,sha256=lCjo9VqrgXPe_0O_lMxEV73ZY91gqnI9mQ3WJKY4VH4,37
+hum_cli-0.0.1.dist-info/RECORD,,

hum_cli-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

hum_cli-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+hum = hum.cli:main