nuspace 0.3.0__tar.gz → 0.3.1__tar.gz

{nuspace-0.3.0 → nuspace-0.3.1}/CHANGELOG.md

@@ -2,13 +2,24 @@
 
 ## Packages shipped from this repo
 
-- **nuspace** (the runtime, the `nuspace` command) — 0.3.0
+- **nuspace** (the runtime, the `nuspace` command) — 0.3.1
 - **nuspace-ui** (the compiled web bundle) — 0.3.0
 
 Below is the changelog for **nuspace** - the full commit stream. Newest first.
 The `nuspace-ui` wheel is the same source tree's vite output and is not tracked
 separately here.
 
+## 0.3.1 — 2026-09-23
+
+- Opening a page no longer slows down with each extra cell on it
+- Navigating away clears the old page at once instead of blinking through it
+- Keep workers ready in advance, so opening a plane no longer waits for one to start
+- Draw a page without a web server loaded behind it, so it opens much sooner
+- Let a chat work as long as the work takes, and stop it only when it is stuck
+- Always get a way to say something else, whatever a turn drew
+- Watch a chat work step by step, and never get a broken answer
+- Ask a chat for something and it draws the answer and how you reply
+
 ## 0.3.0 — 2026-09-21
 
 - Make a chat, ask it for something, and watch it work the space

{nuspace-0.3.0 → nuspace-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: nuspace
-Version: 0.3.0
+Version: 0.3.1
 Summary: Nu runtime built on Nu. A self-hosted programmable space that runs Nu apps in a tree of containers and applications.
 Project-URL: Repository, https://github.com/nustackdev/nuspace
 Author-email: Gor Arakelyan <gorarkln@gmail.com>
@@ -16,7 +16,6 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Requires-Dist: click>=8.0
-Requires-Dist: nuagent>=0.1.3
 Requires-Dist: nucore>=0.5.2
 Requires-Dist: nuspace-ui>=0.3.0
 Requires-Dist: nustd[all]>=0.5.2

{nuspace-0.3.0 → nuspace-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nuspace"
-version = "0.3.0"
+version = "0.3.1"
 description = "Nu runtime built on Nu. A self-hosted programmable space that runs Nu apps in a tree of containers and applications."
 readme = "README.md"
 license = "AGPL-3.0-or-later"
@@ -22,7 +22,6 @@ dependencies = [
     # project size and a SPA rebuilt on every UI tweak would eat the quota --
     # not optional. `pip install nuspace` gives you the browser.
     "nuspace-ui>=0.3.0",
-    "nuagent>=0.1.3",
     "typing-extensions>=4.7.0",
     "click>=8.0",
     "rich>=10.7",
@@ -55,6 +54,12 @@ Repository = "https://github.com/nustackdev/nuspace"
 nuspace = "nuspace.cli:main"
 
 [tool.hatch.build.targets.wheel]
+# Whole directories, not python files: the agent's system prompt is prose in
+# `nuspace/agent/prompt/text/*.md`, read at runtime through
+# importlib.resources. hatchling ships every file under a listed package, so
+# this needs no data entry of its own -- but adding an `include` or
+# `only-include` here would drop the prose and leave a wheel whose chats
+# raise on their first message. Don't.
 packages = ["src/nuspace"]
 
 [tool.hatch.build.targets.sdist]
@@ -68,7 +73,6 @@ nuspace-ui = { path = "./ts" }
 nucore = { path = "../nu", editable = true }
 nustd = { path = "../nu/pkgs/nustd", editable = true }
 nucli = { path = "../nu/pkgs/nucli", editable = true }
-nuagent = { path = "../nuagent", editable = true }
 
 [tool.uv]
 default-groups = ["dev"]

nuspace-0.3.1/src/nuspace/agent/__init__.py

@@ -0,0 +1,233 @@
+"""The agent a chat runs: it answers by drawing, and the host checks the drawing.
+
+A chat is two Planes. One runs, and the Cell on it is this package. One draws,
+and what is on it is whatever this turn and the turns before it put there.
+Every turn leaves three Cells on the Plane that draws. Two of them are the
+host's: the panel, appended the moment somebody presses send, and the escape
+hatch, a folded box appended under the answer so that a person always has a
+way to say something. The third is the answer itself, which is the response
+and the next input form in one. The reply box is not chrome any more, it is a
+Cell a model wrote, so it can just as well be three buttons, a form, a slider,
+or a diff with approve and reject on it.
+
+What stays uniform is the **record**. Whatever the person does through whatever
+was drawn lands in the conversation as an ordinary ``{role, text}`` message,
+and that list is what wakes the agent for the next turn. Cells are
+presentation; the conversation is the truth.
+
+That is natural here and awkward anywhere else, because a Cell's program is
+Nu: what the model generates is a live program bound to the store rather than
+a dead render of a payload. It also persists as an ordinary Cell, so a person
+can open what the agent made and edit it.
+
+The structure, and every word of it is load bearing::
+
+    chat        the conversation. one input runs a turn
+     turn       one input, looped until done
+      cycle     a phase of the turn. exactly two: work, then answer
+       pass     one model call plus the program it wrote
+
+The modules::
+
+    conversation    the chat loop and the turn: heard, work, answer
+    cycles          the two cycles, and the check before an answer lands
+    passes          one pass, composed, with the host's rows between the links
+    trace           those rows: the fixed machine, and where it is written
+    session         a turn's working memory, in the store, under the chat
+    shapes          the slots it runs on, and the one slot the model writes
+    source          fenced extraction, one attempt, and the Cell check
+    panel           display(): the trace of one turn, hardcoded, drawn live
+    cc              Claude Code. one session for as long as the chat
+    llm             a served model over the OpenAI wire. one call per pass
+    prompt          what the model reads, as markdown on disk
+
+**The pass is composed here rather than taken from nuagent, and that is the
+whole point of the move.** nuagent's ``turn`` is one opaque composed Flow, so
+there is nowhere to stand between the model call going out and the program
+coming back, and a chat wearing it showed a person a blank panel for a minute
+and then everything at once. Composing it here buys six places to stand.
+nuagent stays where it is and keeps working; we stopped importing it.
+
+**Two entry points onto one core.** :func:`converse` is a chat: two cycles,
+a conversation, a drawn answer. :func:`perform` is a job agent: the work cycle
+with a fixed task and no drawing. Splitting them later is cheap and nothing
+about the core would have to move.
+
+**Three names are not imported until somebody asks for one**, and that is not
+tidiness, it is what the two kinds of Cell in here cost each other. The Cell
+that draws a chat's panel wants :func:`display` and no model; the Cell that
+talks wants an endpoint and draws nothing. Imported eagerly, each pays for the
+other: ``nustd.cc`` pulls the Claude Code SDK, which is most of a second, and
+``nuspace.agent.panel`` pulls ``nustd.ui``, which is a third of one. A panel
+Cell is launched in a fresh worker every time somebody navigates to a chat, so
+that is a third of a second of Claude Code SDK on every navigation for a Cell
+that will never speak. :data:`DEFERRED` is the table and the module
+``__getattr__`` below is the whole of the mechanism.
+
+**This package is where the behaviour lives, not the template.** A chat's
+talking Cell holds ten lines that call :func:`converse`, so installing a newer
+nuspace upgrades every chat already in the store. Templates are seeds and a
+seed has no migration; for a prompt that gets tuned daily, seeding is the
+wrong shape.
+"""
+
+from __future__ import annotations
+
+from importlib import import_module
+from typing import TYPE_CHECKING
+
+import nustd.kv
+from nuspace.agent import conversation, cycles, passes, prompt, session, source, trace
+from nuspace.agent.shapes import Run, Session
+from nuspace.shapes import Space
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    import nu
+    from nuspace.agent.panel import display
+
+
+__all__ = [
+    "DEFERRED",
+    "Run",
+    "Session",
+    "claude_code",
+    "conversation",
+    "converse",
+    "cycles",
+    "display",
+    "passes",
+    "perform",
+    "prompt",
+    "served_model",
+    "session",
+    "source",
+    "trace",
+]
+
+
+#: The names that cost an import nobody else here needs, by the module each
+#: lives in. Read by :func:`__getattr__`, so ``nuspace.agent.display`` still
+#: resolves and the import it costs is paid by whoever asked for it.
+DEFERRED = {"claude_code": "cc", "display": "panel", "served_model": "llm"}
+
+
+def __getattr__(name: str) -> object:
+    """Resolve one of :data:`DEFERRED` by importing the module it lives in.
+
+    Python calls this only for names the module does not already have, so it
+    costs nothing on any other attribute, and the result is cached by the
+    ordinary import machinery rather than by anything here.
+    """
+    if name in DEFERRED:
+        return getattr(import_module(f"{__name__}.{DEFERRED[name]}"), name)
+    msg = f"module {__name__!r} has no attribute {name!r}"
+    raise AttributeError(msg)
+
+
+def converse(
+    plane_id: nu.StrArg,
+    cell_id: nu.StrArg,
+    *,
+    ui_plane_id: nu.StrArg,
+    root: type[Space] = Space,
+    talk: Callable[..., nu.Nu] | None = None,
+) -> nu.Nu:
+    """The whole term a chat's talking Cell runs.
+
+    Answer whatever is outstanding, then wait for more, forever, with the
+    endpoint held open around all of it.
+
+    Args:
+        plane_id: the Plane the chat runs on. The Cell's own ``plane``.
+        cell_id: the Cell on it that talks and holds the conversation. The
+            Cell's own ``cell``.
+        ui_plane_id: the Plane the agent draws its answers onto. The other
+            half of the pair a chat is, and the one the person is looking at.
+        root: the Space shape class. It decides the store the agent writes to
+            and the surface it is shown, so a subclassed Space gets a prompt
+            about itself.
+        talk: the endpoint, ``endpoint(loop, *, system)``. ``None`` means
+            Claude Code with its defaults, which is what a chat made by
+            pressing ``+`` gets. Pass
+            :func:`~nuspace.agent.llm.served_model` or
+            :func:`~nuspace.agent.cc.claude_code` with arguments of your own
+            for anything else.
+
+    Returns:
+        A Flow that never ends on its own.
+
+    Notes:
+        - The bracket over the store is here rather than in the template,
+          because a program owns its own atomicity and this *is* the program.
+          Nothing brackets it on the way in: the host cannot see inside a
+          program it evaluates.
+        - The endpoint goes up once, outside the wait, so a session lasts as
+          long as the chat rather than as long as a turn.
+    """
+
+    def loop(ask: Callable[..., nu.Nu]) -> nu.Nu:
+        return conversation.answering(
+            plane_id, cell_id, ui_plane_id=ui_plane_id, ask=ask, root=root
+        )
+
+    return _under(talk, loop, prompt.system_prompt(root=root), root)
+
+
+def perform(
+    plane_id: nu.StrArg,
+    cell_id: nu.StrArg,
+    task: str,
+    *,
+    root: type[Space] = Space,
+    talk: Callable[..., nu.Nu] | None = None,
+) -> nu.Nu:
+    """One job agent: the work cycle, a fixed task, and no drawing.
+
+    The narrow half of the same core. Nobody is talking to a job agent, so
+    there is nothing to hear and nothing to answer, and what is left is the
+    cycle that changes the space. It narrates into its own Cell's state, so
+    :func:`display` over that Cell shows a job doing its work exactly the way
+    it shows a chat doing a turn.
+
+    Args:
+        plane_id: the Plane the job runs on. The Cell's own ``plane``.
+        cell_id: the Cell doing the work. The Cell's own ``cell``.
+        task: what to do, in prose. It goes in the prompt and again as the
+            first message, because a prompt is what a model is told once and
+            a message is what it is looking at.
+        root: the Space shape class.
+        talk: the endpoint, as for :func:`converse`.
+
+    Returns:
+        A Flow that runs the work cycle once and ends.
+    """
+
+    def once(ask: Callable[..., nu.Nu]) -> nu.Nu:
+        return conversation.performing(plane_id, cell_id, task, ask=ask, root=root)
+
+    system = prompt.system_prompt(root=root, task=task, drawing=False)
+    return _under(talk, once, system, root)
+
+
+def _under(
+    talk: Callable[..., nu.Nu] | None,
+    body: Callable[..., nu.Nu],
+    system: str,
+    root: type[Space],
+) -> nu.Nu:
+    """``body`` with an endpoint up around it and the store bracketed once.
+
+    Claude Code is imported here rather than at the top of the module, so a
+    Cell that reads this package for :func:`display` and talks to no model
+    never pays for the SDK.
+    """
+    if talk is None:
+        from nuspace.agent.cc import claude_code
+
+        endpoint = claude_code()
+    else:
+        endpoint = talk
+    return nustd.kv.auto_flow_atomic(endpoint(body, system=system), scope=root)

nuspace-0.3.1/src/nuspace/agent/cc.py

@@ -0,0 +1,105 @@
+"""Claude Code, and one session for as long as the chat is up.
+
+A space is a thing you run on the machine you are sitting at, so the endpoint
+a chat talks to by default is the Claude Code already installed on it rather
+than an api key somebody has to find.
+
+**The session is the whole point of this file.** ``nustd.cc.Session`` is a
+bracket: the first prompt inside it starts a conversation, every later prompt
+resumes it. Opened around the chat's whole loop rather than around a pass, so
+the model keeps its own context from one pass of a turn to the next and a
+prompt carries only what is new. Without it every call is a cold start, the
+entire transcript has to ride in every prompt, and pass eight re-sends seven
+passes of code and diagnostics to be told one line.
+
+So :func:`ask` sends the newest message and nothing before it. That is right
+cold as well as warm: the first message of a turn is the opening, which
+carries the conversation whole, and every message after it is an observation
+about the pass that just ran.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import nu
+import nustd.cc
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+
+
+__all__ = ["MODEL", "Bot", "ask", "claude_code"]
+
+
+#: What a chat talks to when nobody says otherwise.
+MODEL = "claude-opus-5"
+
+
+class Bot(nu.Service):
+    """The Claude Code endpoint a chat runs against."""
+
+    ask = nustd.cc.PromptRef.method()
+
+
+def ask(*, messages: nu.Nu) -> nu.Nu:
+    """One pass's prompt: the newest message, and nothing before it.
+
+    What one pass calls. It hands over the whole transcript and this
+    takes the last of it, because the rest is already in the session.
+
+    Args:
+        messages: the working memory's message list, oldest first.
+
+    Returns:
+        The prompt interaction, yielding a dict with ``text`` in it.
+    """
+    newest = nu.Dict(nu.List(messages)[nu.Int(-1)])
+    return Bot.ask(prompt=nu.ToStr(newest.get_item(nu.Str("content"), nu.Str(""))))
+
+
+def claude_code(
+    *,
+    model: str = MODEL,
+    allowed_tools: Sequence[str] = (),
+    permission_mode: str = "default",
+) -> Callable[..., nu.Nu]:
+    """The endpoint a chat runs against: Claude Code, in one session.
+
+    Args:
+        model: which model to ask.
+        allowed_tools: the tools Claude Code may use. Empty on purpose: the
+            model's action here is the Nu program it writes, and a model that
+            can edit files as well has two ways to change the world and only
+            one of them is in the transcript.
+        permission_mode: what Claude Code does when something needs
+            permission. Nobody is at the terminal to answer, so this only
+            matters once tools are allowed.
+
+    Returns:
+        A callable ``endpoint(loop, *, system)``. ``loop`` is what to run
+        once the endpoint is up, as a function of :func:`ask`; ``system`` is
+        the system prompt. It yields whatever ``loop`` yields.
+
+    Notes:
+        - The bracket is the lifetime. The client opens when the ``With`` is
+          entered and closes when it exits, so everything the chat will ever
+          do has to be inside it.
+        - Reach is by Context rather than by ownership, so a prompt inside a
+          nested ``With`` the loop opens still joins the session.
+    """
+
+    def endpoint(loop: Callable[..., nu.Nu], *, system: str) -> nu.Nu:
+        return nu.With(
+            nustd.cc.bind(
+                Bot,
+                model=model,
+                system_prompt=system,
+                allowed_tools=list(allowed_tools),
+                permission_mode=permission_mode,
+            ),
+            body=nustd.cc.Session(loop(ask)),
+        )
+
+    return endpoint