substratum-cli 0.2.0__tar.gz → 0.2.2__tar.gz

{substratum_cli-0.2.0 → substratum_cli-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: substratum-cli
-Version: 0.2.0
+Version: 0.2.2
 Summary: Substratum: verified-or-refused code, with provenance. The terminal over the comprehension engine.
 Author: Substratum
 License: LicenseRef-Proprietary

{substratum_cli-0.2.0 → substratum_cli-0.2.2}/substratum_cli/__init__.py

@@ -5,4 +5,4 @@ Import budget: this package is stdlib-only; the ONLY module reaching into backen
 """
 # SINGLE SOURCE OF TRUTH for the release version. pyproject reads this (dynamic version), the boot shows
 # it, and the update-check compares against it. To cut a release, bump ONLY this line, then publish.
-__version__ = "0.2.0"
+__version__ = "0.2.2"

{substratum_cli-0.2.0 → substratum_cli-0.2.2}/substratum_cli/_boot.py

@@ -13,9 +13,11 @@ from __future__ import annotations
 
 import hashlib
 
-# The PUBLIC substrate release name -- what the product shows, like a model version (GPT-5.2, Opus 4.8).
-# Decoupled from the internal mining tag (pattern_library_scaled_v15): that tag still drives the seal
-# hash (the seal must certify the ACTUAL build), but users see this. Bump only on a real public release.
+# The PUBLIC name of the first intelligence library -- a model version, like GPT-5.2 or Opus 4.8. Shown
+# ONLY when this library actually backs the session: in AIRGAPPED-LOCAL mode (the engine + library shipped
+# on-prem, present on this machine), or reported by the HOSTED engine once the full corpus is live on it.
+# The boot NEVER shows this from a hardcoded local path -- the label must be a real representation of the
+# intelligence serving the user. The internal mining tag (pattern_library_scaled_v15) stays internal.
 RELEASE = "Substrate 1.0 Preview"
 
 L = "\033[38;5;154m"      # brand lime
@@ -53,18 +55,21 @@ def seal(lib_name: str, version: str) -> tuple[str, str]:
     return sigil, digest
 
 
-def render(name, census, langs, libname, patterns, warm, standing, version,
-           color=True, ascii_mode=False, logged_in=True, update_to="") -> list[str]:
-    """Return the boot lines. `standing` is build_state.standing() (may be {})."""
+def render(name, census, langs, substrate, substrate_note, substrate_ok, standing, version,
+           color=True, ascii_mode=False, logged_in=True, update_to="", seal_key="") -> list[str]:
+    """Return the boot lines. `substrate` is the HONEST name of the intelligence serving this session
+    (the hosted engine version, or 'not connected') -- NEVER a local path. `substrate_note`/`_ok` render
+    the connection state. `seal_key` is the stable identity the self-certificate hashes."""
     def c(code, s):
         return f"{code}{s}{R}" if color else s
 
-    sig, dig = seal(libname, version)
+    sig, dig = seal(seal_key or substrate, version)
     if ascii_mode:
         sig = "#" + dig.split()[0]
     dot = "-" if ascii_mode else "·"          # separators degrade with the glyph set
     if ascii_mode:                            # the renderer guarantees ascii output regardless of input
-        name, census, langs, libname = (str(s).replace("·", "-") for s in (name, census, langs, libname))
+        name, census, langs, substrate, substrate_note = (
+            str(s).replace("·", "-") for s in (name, census, langs, substrate, substrate_note))
     W = 78                                    # certificate inner width
     out = ["", ""]
 
@@ -99,8 +104,9 @@ def render(name, census, langs, libname, patterns, warm, standing, version,
         pad = " " * max(0, W - 1 - _vis(inner_plain))
         return c(CH, v_) + " " + inner_colored + pad + c(CH, v_)
 
-    lamp = (("*" if ascii_mode else "●") + " ready") if warm else (dot + " loading")
-    lampc = c(GR, lamp) if warm else c(CH, lamp)
+    glyph = ("*" if ascii_mode else "●") if substrate_ok else dot
+    lamp = f"{glyph} {substrate_note}"
+    lampc = c(GR if substrate_ok else CH, lamp)
     st = standing or {}
     runs, ver = st.get("runs", 0), st.get("verified", 0)
     unsaved = st.get("unapplied_total", 0)
@@ -114,8 +120,8 @@ def render(name, census, langs, libname, patterns, warm, standing, version,
     box.append(c(CH, v_) + " " + seal_inner_c + pad + right_c + c(CH, v_))
 
     box.append(bar(label="SUBSTRATE"))
-    box.append(rowline(f"  release   {RELEASE}      {lamp}",
-                       c(LAB, "  release   ") + c(DAT, RELEASE) + "      " + lampc))
+    box.append(rowline(f"  engine    {substrate}      {lamp}",
+                       c(LAB, "  engine    ") + c(DAT, substrate) + "      " + lampc))
     box.append(rowline(f"  covers    {langs}", c(LAB, "  covers    ") + c(DAT, langs)))
     box.append(bar(label="REPO"))
     box.append(rowline(f"  project   {name}", c(LAB, "  project   ") + c(DAT, name)))
@@ -145,16 +151,18 @@ def render(name, census, langs, libname, patterns, warm, standing, version,
     # fix + write run on the hosted engine; summarize/failing/verify run offline. Say so BEFORE they hit
     # a NO_ENGINE refusal, and pick an ask-example that actually works in their current state.
     ask_ex = '"fix the failing test"' if logged_in else '"what does this codebase do?"'
+    # the signpost text aligns at col 4 -- the same column as the welcome-back text -- so the whole bottom
+    # "here is what you can do" region reads as one clean left edge instead of jutting out under the box.
     out += [""]
     if update_to:                           # a pip package cannot self-update; hand over the one command
         arrow = "^" if ascii_mode else "↑"
-        out += ["  " + c(GO, f"{arrow} update") + c(LAB, f"  Substratum {update_to} is available")
+        out += ["    " + c(GO, f"{arrow} update") + c(LAB, f"  Substratum {update_to} is available")
                 + c(CH, f"   {dot}   ") + c(GO, "pip install --upgrade substratum-cli")]
     if not logged_in:
-        out += ["  " + c(GO, "login") + c(LAB, "  to ") + c(DAT, "fix") + c(LAB, " and ") + c(DAT, "write")
+        out += ["    " + c(GO, "login") + c(LAB, "  to ") + c(DAT, "fix") + c(LAB, " and ") + c(DAT, "write")
                 + c(LAB, " code (connects the engine)")
                 + c(CH, f"   {dot}   ") + c(LAB, "summarize, failing, verify work offline")]
-    out += ["  " + c(GO, "help") + c(LAB, "  see everything you can do")
+    out += ["    " + c(GO, "help") + c(LAB, "  see everything you can do")
             + c(CH, f"   {dot}   ") + c(LAB, "or just ask: ") + c(GO, ask_ex)]
     return out
 

{substratum_cli-0.2.0 → substratum_cli-0.2.2}/substratum_cli/_update.py

@@ -27,15 +27,25 @@ def _version_tuple(s: str) -> tuple:
     return tuple(out)
 
 
-def available(current: str) -> str:
-    """The newer published version if the cache knows of one, else "". Pure, instant, no network."""
+def _cache() -> dict:
     try:
-        latest = str(json.load(open(_cache_path(), encoding="utf-8")).get("latest") or "")
+        return json.load(open(_cache_path(), encoding="utf-8")) or {}
     except Exception:
-        return ""
+        return {}
+
+
+def available(current: str) -> str:
+    """The newer published version if the cache knows of one, else "". Pure, instant, no network."""
+    latest = str(_cache().get("latest") or "")
     return latest if latest and _version_tuple(latest) > _version_tuple(current) else ""
 
 
+def engine_version() -> str:
+    """The HOSTED engine's substrate version from the last check (cached), or "". This is what actually
+    serves fix/write for a thin client, so the boot shows THIS -- never a local path."""
+    return str(_cache().get("engine") or "")
+
+
 def refresh_async() -> None:
     """Fire-and-forget: ask the server for the latest published client and cache it for next session.
     The server sources this from PyPI, so publishing is all it takes -- no redeploy, no constant to bump."""
@@ -44,12 +54,16 @@ def refresh_async() -> None:
             from . import remote
             info = remote.server_info() or {}
             latest = str(info.get("latest_client") or "")
-            if not latest:
+            engine = str(info.get("engine_version") or "")
+            if not (latest or engine):
                 return
             path = _cache_path()
             os.makedirs(os.path.dirname(path), exist_ok=True)
+            cur = _cache()
+            cur.update({"latest": latest or cur.get("latest", ""),
+                        "engine": engine or cur.get("engine", ""), "t": int(time.time())})
             with open(path, "w", encoding="utf-8") as fh:
-                json.dump({"latest": latest, "t": int(time.time())}, fh)
+                json.dump(cur, fh)
         except Exception:
             pass
     try:

{substratum_cli-0.2.0 → substratum_cli-0.2.2}/substratum_cli/session.py

@@ -12,6 +12,7 @@ model, the run store, and the gate are all identical. The session adds no new en
 from __future__ import annotations
 
 import os
+import re
 import shlex
 import sys
 import threading
@@ -107,33 +108,50 @@ class Session:
         pn = S.Painter(self.color)
         name = os.path.basename(self.repo) or self.repo
         langs, files = self._repo_summary()
-        lib = engine.lib_roots.py_library_root()
-        libname = os.path.basename(lib) if lib else "none"
         census = f"{files} files" + ((" · " + langs.replace("  ", " · ")) if langs else "")
         st = build_state.standing(self.repo)
         ascii_mode = S.use_ascii()
         logged_in = account.is_logged_in()
         _update.refresh_async()                    # refresh the update cache in the background (next session)
         update_to = _update.available(_cver)       # instant read from cache; "" if none or unknown
+
+        # HONEST substrate: which intelligence actually serves fix/write this session, and in which mode.
+        # Two real deployment modes: HOSTED (thin client -> engine on Fly) and AIRGAPPED-LOCAL (engine +
+        # library shipped on-prem). Never claim a substrate that is not backing this session.
+        local_present = False
+        try:
+            _p = engine.lib_roots.py_library_root()
+            local_present = bool(_p) and os.path.exists(_p)
+        except Exception:
+            local_present = False                  # a thin client has no local library -- that is fine
+        ev = _update.engine_version()              # hosted engine's reported version (cached), "" if unknown
+        if logged_in:                              # hosted mode: write/fix reach the engine on the server
+            substrate = ev or "hosted engine"
+            sub_note, sub_ok, seal_key = (("hosted · connected", True, ev) if ev else ("connecting", False, "hosted"))
+        elif local_present:                        # airgapped / self-hosted: the on-disk library serves it
+            _warm = engine.is_warm()
+            substrate = _boot.RELEASE
+            sub_note, sub_ok, seal_key = (("local · ready" if _warm else "local · loading"), _warm, _boot.RELEASE)
+        else:                                       # thin client, not connected -> claim nothing
+            substrate, sub_note, sub_ok, seal_key = "not connected", "login to connect", False, "offline"
         # THE PROOF SEAL -- a self-certifying certificate boot: a byte-identical determinism seal (a real
         # hash of engine + substrate + scheme, no time/session input), the struck-plane emblem (the logo),
         # and a structured ledger. The sameness of the seal every boot IS the proof of determinism -- a
         # token-streaming tool cannot draw a stable self-certificate. Needs a wide pane; compact below.
         if S.seal_cols() >= 84:
-            for ln in _boot.render(name, census, "py · go · ts", libname, "", engine.is_warm(),
+            for ln in _boot.render(name, census, "py · go · ts", substrate, sub_note, sub_ok,
                                    st, "0.1.0", color=self.color, ascii_mode=ascii_mode,
-                                   logged_in=logged_in, update_to=update_to):
+                                   logged_in=logged_in, update_to=update_to, seal_key=seal_key):
                 self._say(ln)
             return
         # compact identity (narrow pane): the mark + a lime-railed status
-        state = (pn(S.g("lamp") + " ready", S.PROVEN) if engine.is_warm()
-                 else pn(S.g("dot") + " loading", S.CHROME))
+        state = pn(sub_note, S.PROVEN if sub_ok else S.CHROME)
         rail = ("\033[38;5;154m▌\033[0m" if (self.color and not ascii_mode) else "|")
         brand = (f"\033[38;5;154m{S.g('brand')}\033[0m" if (self.color and not ascii_mode)
                  else pn(S.g("brand"), S.PROVEN))
         self._say(brand + " " + pn("SUBSTRATUM", S.BOLD) + pn("   proof-carrying · deterministic", S.LABEL))
         self._say(f"  {rail} " + pn(name, S.BOLD) + "  " + pn(census, S.LABEL))
-        self._say(f"  {rail} " + pn(_boot.RELEASE, S.LABEL) + "  " + state)
+        self._say(f"  {rail} " + pn(substrate, S.LABEL) + "  " + state)
         if st:
             bits = pn(f"{st['runs']} runs", S.LABEL)
             if st.get("verified"):
@@ -179,6 +197,15 @@ class Session:
                 return None, True
             self._say("  " + self._paint(recalled, _DIM))       # echo what is being re-run
             line = recalled
+        # plain-language re-run: "run 12" replays history line 12 (clearer than the cryptic "!" syntax)
+        _rm = re.match(r"^run\s+(-?\d+)$", line)
+        if _rm:
+            recalled = self._recall(_rm.group(1))
+            if recalled is None:
+                self._say(f"  no history line {_rm.group(1)}  --  type  history  to see them", _CYAN)
+                return None, True
+            self._say("  " + self._paint(recalled, _DIM))
+            line = recalled
         try:
             parts = shlex.split(line)
         except ValueError:
@@ -254,7 +281,7 @@ class Session:
             {"login": auth.cmd_login, "logout": auth.cmd_logout, "whoami": auth.cmd_whoami}[cmd]()
             return None, True
         if cmd in ("history", "hist"):
-            self._history_cmd()
+            self._history_cmd(" ".join(args))
             return None, True
         if cmd in ("runs", "log"):
             from .commands.history import cmd_runs
@@ -302,15 +329,46 @@ class Session:
                 return c
         return None
 
-    def _history_cmd(self):
-        if not self._history:
-            self._say("  no commands yet this session", _DIM)
+    def _history_cmd(self, arg=""):
+        # The trail is PERSISTENT (grows across sessions, can be hundreds), so never dump it all: show a
+        # recent window with the total, let `history <word>` search and `history all` widen. Re-run is a
+        # plain verb -- `run <n>` -- not the cryptic bash `!` (which still works for shell muscle memory).
+        from . import style as S
+        pn = S.Painter(self.color)
+        h = self._history
+        if not h:
+            self._say("  " + pn("no commands yet", S.CHROME))
+            return
+        arg = (arg or "").strip()
+        total = len(h)
+        indexed = list(enumerate(h, 1))
+        if arg == "all":
+            items = indexed[-60:]
+            head = f"showing last {len(items)} of {total}"
+        elif arg:
+            hits = [(i, c) for i, c in indexed if arg.lower() in c.lower()]
+            items = hits[-40:]
+            head = (f"{len(hits)} match" + ("" if len(hits) == 1 else "es") + f' for "{arg}"'
+                    + (" (last 40)" if len(hits) > 40 else ""))
+        else:
+            items = indexed[-15:]
+            head = (f"last {len(items)} of {total}" if total > len(items)
+                    else f"{total} command" + ("" if total == 1 else "s"))
+        self._say("  " + pn("history", S.BOLD) + "   " + pn(head, S.LABEL))
+        w = len(str(total))
+        for i, c in items:
+            self._say("    " + pn(str(i).rjust(w), S.CHROME) + "   "
+                      + pn(S.ellipsize(c, S.read_width() - w - 8), S.LABEL))
+        if not items:
+            self._say("    " + pn(f'nothing matches "{arg}"  --  try another word', S.CHROME))
             return
-        self._say(self._paint("  session history", _BOLD))
-        start = max(1, len(self._history) - 29)
-        for i, c in enumerate(self._history[-30:], start):
-            self._say(f"  {self._paint(str(i).rjust(3), _DIM)}  {c}")
-        self._say(self._paint("  re-run:  !<n>  ·  !!  ·  !<prefix>", _DIM))
+        eg = items[-1][0]                                  # a concrete number the user can copy
+        bits = [pn("run " + str(eg), S.GOLD) + pn("  replays that line", S.CHROME)]
+        if not arg:
+            bits.append(pn("history <word>", S.GOLD) + pn("  searches", S.CHROME))
+            if total > len(items):
+                bits.append(pn("history all", S.GOLD) + pn("  shows more", S.CHROME))
+        self._say("  " + pn("   ·   ", S.CHROME).join(bits))
 
     # ---- natural-language router (closed-class, deterministic, no LLM) ----
     def _route_nl(self, line: str):

{substratum_cli-0.2.0 → substratum_cli-0.2.2}/substratum_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: substratum-cli
-Version: 0.2.0
+Version: 0.2.2
 Summary: Substratum: verified-or-refused code, with provenance. The terminal over the comprehension engine.
 Author: Substratum
 License: LicenseRef-Proprietary