ipygraph 1.14.2__tar.gz → 1.15.0__tar.gz

ipygraph-1.15.0/.claude/launch.json

@@ -0,0 +1,20 @@
+{
+  "version": "0.0.1",
+  "configurations": [
+    {
+      "name": "jupyterlab",
+      "runtimeExecutable": "python3",
+      "runtimeArgs": [
+        "-m",
+        "jupyter",
+        "lab",
+        "--no-browser",
+        "--ServerApp.token=",
+        "--ServerApp.password=",
+        "--port=8901",
+        "--notebook-dir=/Users/muruga/Projects/ipycopilot/jupyterlab-ipygb"
+      ],
+      "port": 8901
+    }
+  ]
+}

{ipygraph-1.14.2 → ipygraph-1.15.0}/.gitignore

@@ -131,3 +131,82 @@ dmypy.json
 Untitled*.ipynb
 untitled*.ipygb
 *.ipygb
+
+# --- mac-mini-sync: generated, secrets, heavy binaries (kept local, see SYNC-NOTES.md) ---
+.DS_Store
+# dependencies & build output
+node_modules/
+.venv*/
+venv/
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+.build/
+.next/
+.gradle/
+.kotlin/
+DerivedData/
+Pods/
+xcuserdata/
+target/
+.cache/
+.ipynb_checkpoints/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.turbo/
+.parcel-cache/
+coverage/
+# local state & secrets
+.env
+.env.*
+!.env.example
+!.env.sample
+*.pem
+*.key
+*.p12
+*.jks
+*.keystore
+credentials*.json
+service-account*
+token.json
+local.properties
+.jupyter_ystore.db*
+.claude/settings.local.json
+.claude/worktrees/
+# heavy media & archives & model weights
+*.mp4
+*.mov
+*.mkv
+*.webm
+*.avi
+*.m4v
+*.wav
+*.mp3
+*.m4a
+*.aac
+*.flac
+*.ogg
+*.aiff
+*.zip
+*.tar
+*.gz
+*.tgz
+*.7z
+*.rar
+*.pt
+*.pth
+*.ckpt
+*.safetensors
+*.onnx
+*.h5
+*.gguf
+*.npz
+# project-specific
+/demo/instagram/reel-ai-era.mp4
+/demo/instagram/reel-day6-merge.mp4
+/demo/instagram/reel-notebook-chaos.mp4
+/demo/ipygraph-demo.mp4
+/demo/ipygraph-story.mp4

ipygraph-1.15.0/.jupyter/collaboration_sessions.json

@@ -0,0 +1,52 @@
+{
+  "0cc729d6-c09c-4594-8930-44612bc72185": {
+    "version": "3.0.0.a0",
+    "created_at": "2026-08-23T15:08:06.652307+00:00",
+    "document_version": "2.0.0"
+  },
+  "dd3b6181-cbfd-4039-93eb-6db2b0246ebd": {
+    "version": "3.0.0.a0",
+    "created_at": "2026-08-23T15:23:43.147711+00:00",
+    "document_version": "2.0.0"
+  },
+  "f30795eb-41c1-4e74-8d3d-9a803ae9a738": {
+    "version": "3.0.0.a0",
+    "created_at": "2026-09-18T03:40:58.005128+00:00",
+    "document_version": "1.0.0"
+  },
+  "e3034965-30b6-49aa-98ef-9a85416a7f2e": {
+    "version": "3.0.0.a0",
+    "created_at": "2026-09-18T03:43:06.459902+00:00",
+    "document_version": "2.0.0"
+  },
+  "1c8cf52b-76a7-4375-add1-1cdafd83fe22": {
+    "version": "3.0.0.a0",
+    "created_at": "2026-09-18T04:28:13.453173+00:00",
+    "document_version": "2.0.0"
+  },
+  "9d8f9246-4d22-431b-8367-16433fcf4ef7": {
+    "version": "3.0.0.a0",
+    "created_at": "2026-09-18T09:49:32.246067+00:00",
+    "document_version": "2.0.0"
+  },
+  "37564caf-d4cd-4ad6-91ef-8126414c7141": {
+    "version": "3.0.0.a0",
+    "created_at": "2026-11-08T07:23:25.129911+00:00",
+    "document_version": "2.0.0"
+  },
+  "cb5a2cbf-7a0a-4537-b52c-5524a382d3dc": {
+    "version": "3.0.0.a0",
+    "created_at": "2026-11-08T07:24:30.394928+00:00",
+    "document_version": "2.0.0"
+  },
+  "fe954943-09f8-404f-906e-e38f4000fa1e": {
+    "version": "3.0.0.a0",
+    "created_at": "2026-11-08T07:50:42.939301+00:00",
+    "document_version": "1.0.0"
+  },
+  "08924082-5c22-47a5-9f0c-11c82a5e7fac": {
+    "version": "3.0.0.a0",
+    "created_at": "2026-11-08T07:50:16.946795+00:00",
+    "document_version": "1.0.0"
+  }
+}

ipygraph-1.15.0/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+<!-- <START NEW CHANGELOG ENTRY> -->
+
+## 1.15.0
+
+- **`.ipydag` — DAG of notebooks**: a second document type wiring whole `.ipynb` files into a pipeline. Data flows through saved artifact files (`IPYDAG_INPUTS` / `IPYDAG_OUTPUTS` injected per run); ◆ decision (if/else) and ⬡ case (switch) nodes route the flow from values in upstream JSON artifacts. Visual editor with inspector, per-node and full-DAG runs (server-side via nbclient), and a DAG-node header inside member notebooks for editing inputs/outputs in place.
+- **🧪 Experiments view**: a live leaderboard + journal of the whole experiment campaign, derived from the graph — metrics parsed from branch annotations and run outputs, Δ vs the baseline branch, winner highlighted, one-click markdown report.
+- **Streaming agent**: new `/ipygb/agent/stream` endpoint streams model tokens into the panel as they generate (Anthropic, OpenAI, Gemini, claude CLI/SDK); Anthropic prompt caching and a bigger token budget cut turn latency; light sub-agent roles auto-route to fast models; Stop now cancels mid-request.
+- **Agentic UX**: pinned live mission-plan checklist, per-step activity timelines with per-action status/duration and expandable full observations, live sub-agent task rows (branch workers, design debate, Kaggle, validators).
+- Modernized assistant panel UI; verified against JupyterLab 4.6.6.
+
+<!-- <END NEW CHANGELOG ENTRY> -->

{ipygraph-1.14.2 → ipygraph-1.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: ipygraph
-Version: 1.14.2
+Version: 1.15.0
 Summary: Turn your Jupyter notebook into a branching graph of experiments — a JupyterLab extension with a plan-first AI copilot, branch isolation, and fork-join parallel execution.
 Project-URL: Homepage, https://github.com/jupyterlab/jupyterlab-ipygb
 Project-URL: Bug Tracker, https://github.com/jupyterlab/jupyterlab-ipygb/issues
@@ -222,6 +222,8 @@ Requires-Python: >=3.10
 Requires-Dist: dill
 Requires-Dist: jupyter-server<3,>=2.0.0
 Requires-Dist: jupyterlab<5,>=4.0.0
+Requires-Dist: nbclient>=0.7
+Requires-Dist: nbformat>=5.7
 Description-Content-Type: text/markdown
 
 <p align="center">
@@ -275,6 +277,27 @@ ipyGraph adds a new document type: **`.ipygb`** (a "Graphbook"). It's a **supers
 
 Because it's a superset, the kernel, outputs, and rendering are ordinary Jupyter — nothing proprietary about how your code runs. And you can always **export any root→tip path back to a plain `.ipynb`** to share or hand off.
 
+## The `.ipydag` file format
+
+Where `.ipygb` branches **cells inside one notebook**, **`.ipydag`** wires **whole notebooks** into a DAG. Each node is an ordinary `.ipynb`; data moves between them through **saved files** ("artifacts") — an upstream notebook writes a file, the downstream notebook reloads it, and the files that support the flow stay on disk next to the `.ipydag`.
+
+Three node types:
+
+- **📓 Notebook** — runs a `.ipynb`. It declares the artifact files it *writes* (outputs) and the upstream artifacts it *reads* (inputs). When the DAG runs, an injected parameters cell (tagged `ipydag-parameters`) defines `IPYDAG_INPUTS` / `IPYDAG_OUTPUTS` dicts mapping those names to file paths — so notebooks stay ordinary, runnable Jupyter:
+
+  ```python
+  import json, pandas as pd
+  df = pd.read_parquet(IPYDAG_INPUTS["raw"])
+  ...
+  df.to_parquet(IPYDAG_OUTPUTS["clean"])
+  json.dump({"use_nn": True}, open(IPYDAG_OUTPUTS["flags"], "w"))
+  ```
+
+- **◆ Decision (if/else)** — reads a **boolean** key out of a JSON artifact written upstream and routes the flow along its `true` or `false` edge.
+- **⬡ Case (switch)** — reads a **string** the same way and takes the edge whose label matches (or the `default` edge).
+
+The file itself is plain JSON (`nodes` + `edges` + layout). A run walks the DAG in topological order, executes each notebook server-side (saving its outputs in place — the executed notebooks are the run's record), evaluates gates, and **skips everything reachable only through untaken branches**. Create one from the Launcher ("Notebook DAG") or try the demo at `demo/dag/pipeline.ipydag`.
+
 ---
 
 ## See it

{ipygraph-1.14.2 → ipygraph-1.15.0}/README.md

@@ -49,6 +49,27 @@ ipyGraph adds a new document type: **`.ipygb`** (a "Graphbook"). It's a **supers
 
 Because it's a superset, the kernel, outputs, and rendering are ordinary Jupyter — nothing proprietary about how your code runs. And you can always **export any root→tip path back to a plain `.ipynb`** to share or hand off.
 
+## The `.ipydag` file format
+
+Where `.ipygb` branches **cells inside one notebook**, **`.ipydag`** wires **whole notebooks** into a DAG. Each node is an ordinary `.ipynb`; data moves between them through **saved files** ("artifacts") — an upstream notebook writes a file, the downstream notebook reloads it, and the files that support the flow stay on disk next to the `.ipydag`.
+
+Three node types:
+
+- **📓 Notebook** — runs a `.ipynb`. It declares the artifact files it *writes* (outputs) and the upstream artifacts it *reads* (inputs). When the DAG runs, an injected parameters cell (tagged `ipydag-parameters`) defines `IPYDAG_INPUTS` / `IPYDAG_OUTPUTS` dicts mapping those names to file paths — so notebooks stay ordinary, runnable Jupyter:
+
+  ```python
+  import json, pandas as pd
+  df = pd.read_parquet(IPYDAG_INPUTS["raw"])
+  ...
+  df.to_parquet(IPYDAG_OUTPUTS["clean"])
+  json.dump({"use_nn": True}, open(IPYDAG_OUTPUTS["flags"], "w"))
+  ```
+
+- **◆ Decision (if/else)** — reads a **boolean** key out of a JSON artifact written upstream and routes the flow along its `true` or `false` edge.
+- **⬡ Case (switch)** — reads a **string** the same way and takes the edge whose label matches (or the `default` edge).
+
+The file itself is plain JSON (`nodes` + `edges` + layout). A run walks the DAG in topological order, executes each notebook server-side (saving its outputs in place — the executed notebooks are the run's record), evaluates gates, and **skips everything reachable only through untaken branches**. Create one from the Launcher ("Notebook DAG") or try the demo at `demo/dag/pipeline.ipydag`.
+
 ---
 
 ## See it

ipygraph-1.15.0/junit.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<testsuites name="jest tests" tests="1" failures="0" errors="0" time="1.16">
+  <testsuite name="myextension" errors="0" failures="0" skipped="0" timestamp="2026-11-08T07:40:34" time="0.722" tests="1">
+    <testcase classname="myextension should be tested" name="myextension should be tested" time="0.001">
+    </testcase>
+  </testsuite>
+</testsuites>

{ipygraph-1.14.2 → ipygraph-1.15.0}/myextension/_version.py

@@ -1,4 +1,4 @@
 # This file is auto-generated by Hatchling. As such, do not:
 #   - modify
 #   - track in version control e.g. be sure to add to .gitignore
-__version__ = VERSION = '1.14.2'
+__version__ = VERSION = '1.15.0'

{ipygraph-1.14.2 → ipygraph-1.15.0}/myextension/agent.py

@@ -81,10 +81,18 @@ ALWAYS respond with a single JSON object, no prose outside it:
 
 {
   "reply": "<natural-language explanation + your assumptions>",
+  "plan": [ {"step": "<= 8 words>", "status": "pending"|"doing"|"done"} ],
   "actions": [ <zero or more action objects, empty if you are asking> ],
   "questions": [ {"question": "<short question>", "options": ["<opt>", ...]} ]
 }
 
+"plan" is your LIVE MISSION CHECKLIST, shown pinned in the panel. Include it \
+in EVERY turn of a multi-step mission: 3-8 steps covering the WHOLE mission \
+(not just this turn), each with its current status — keep step wording \
+STABLE across turns and only flip statuses as work progresses, so the user \
+watches the same list fill in. Put the step you are doing RIGHT NOW as \
+"doing". Omit "plan" only for trivial single-action asks.
+
 "questions" is optional; include it only when you genuinely need input. When \
 you ask questions, keep "actions" empty and wait for the user's answer.
 
@@ -344,8 +352,11 @@ sklearn/GBM branches; run heavy neural-net training SEQUENTIALLY with \
 run_cells (parallel torch trainings starve each other and a kernel gets \
 killed mid-backward). Then in your reflection compare their metrics \
 against the current best. Keep the \
-winner as the new BEST; annotate every branch with set_comment (its metric + \
-a one-line takeaway) so the graph tells the story.
+winner as the new BEST; annotate every branch with set_comment so the graph \
+tells the story. FORMAT these annotations machine-readably — start with the \
+metric, then the takeaway: "accuracy=0.913 — +embeddings beat the baseline \
+by 2pts" — because the 🧪 Experiments view parses them into the live \
+leaderboard (branch · metric · Δ vs baseline · winner) the user watches.
 5. ITERATE. Repeat BRANCH→EVALUATE from the new best, going DEEPER — e.g. \
 linear → MLP → +embeddings → +self-attention → multi-head → deeper/residual \
 — until the metric plateaus for two rounds or you reach a genuinely strong \
@@ -533,30 +544,62 @@ _FORMAT_RETRY_MSG = (
 )
 
 
+def _prepare_turn(body: dict):
+    """Shared request parsing for the blocking and streaming handlers."""
+    provider = body.get("provider", "claude-cli")
+    role = body.get("role", "master")
+    # Light roles (dataset curation, Kaggle picking) run on the provider's
+    # fast model unless the caller pinned one — several-fold latency cut.
+    model = providers.pick_model(provider, body.get("model", ""), role)
+    messages = body.get("messages", [])
+    if not messages:
+        raise tornado.web.HTTPError(400, reason="No messages")
+
+    # Prepend the graph context to the latest user turn.
+    convo = [dict(m) for m in messages]
+    context = _graph_summary(body.get("graph", {}))
+    for m in reversed(convo):
+        if m.get("role") == "user":
+            m["content"] = f"Current graph:\n{context}\n\nRequest: {m['content']}"
+            break
+    return (
+        provider,
+        model,
+        role,
+        convo,
+        body.get("key", ""),
+        body.get("base_url", ""),
+    )
+
+
+def _final_payload(parsed: dict, raw: str) -> dict:
+    """Normalize a parsed model reply into the response the frontend expects."""
+    actions = parsed.get("actions", [])
+    if not isinstance(actions, list):
+        actions = []
+    questions = parsed.get("questions", [])
+    if not isinstance(questions, list):
+        questions = []
+    plan = parsed.get("plan", [])
+    if not isinstance(plan, list):
+        plan = []
+    return {
+        "reply": parsed.get("reply", ""),
+        "plan": plan,
+        "actions": actions,
+        "questions": questions,
+        "done": bool(parsed.get("done", False)),
+        "raw": raw,
+    }
+
+
 class AgentHandler(APIHandler):
     """POST /ipygb/agent — run one assistant turn."""
 
     @tornado.web.authenticated
     async def post(self):
         body = self.get_json_body() or {}
-        provider = body.get("provider", "claude-cli")
-        model = body.get("model", "")
-        messages = body.get("messages", [])
-        graph = body.get("graph", {})
-        key = body.get("key", "")
-        base_url = body.get("base_url", "")
-        role = body.get("role", "master")
-
-        if not messages:
-            raise tornado.web.HTTPError(400, reason="No messages")
-
-        # Prepend the graph context to the latest user turn.
-        convo = [dict(m) for m in messages]
-        context = _graph_summary(graph)
-        for m in reversed(convo):
-            if m.get("role") == "user":
-                m["content"] = f"Current graph:\n{context}\n\nRequest: {m['content']}"
-                break
+        provider, model, role, convo, key, base_url = _prepare_turn(body)
 
         try:
             raw = await tornado.ioloop.IOLoop.current().run_in_executor(
@@ -594,24 +637,98 @@ class AgentHandler(APIHandler):
                     parsed, raw = parsed2, raw2
             except Exception:
                 self.log.exception("ipygb agent: format retry failed")
-        reply = parsed.get("reply", "")
-        actions = parsed.get("actions", [])
-        if not isinstance(actions, list):
-            actions = []
-        questions = parsed.get("questions", [])
-        if not isinstance(questions, list):
-            questions = []
-        self.finish(
-            json.dumps(
-                {
-                    "reply": reply,
-                    "actions": actions,
-                    "questions": questions,
-                    "done": bool(parsed.get("done", False)),
-                    "raw": raw,
-                }
-            )
-        )
+        self.finish(json.dumps(_final_payload(parsed, raw)))
+
+
+class AgentStreamHandler(APIHandler):
+    """
+    POST /ipygb/agent/stream — one assistant turn, streamed.
+
+    The response is a server-sent-event style chunked body; each event is a
+    line `data: {...}` followed by a blank line:
+      {"delta": "<text>"}   model tokens as they are generated
+      {"note": "<text>"}    progress notes (e.g. a format retry)
+      {"result": {...}}     the final parsed turn (same shape as /agent)
+      {"error": "<text>"}   fatal failure (no result follows)
+    """
+
+    @tornado.web.authenticated
+    async def post(self):
+        import asyncio
+
+        body = self.get_json_body() or {}
+        provider, model, role, convo, key, base_url = _prepare_turn(body)
+
+        self.set_header("Content-Type", "text/event-stream")
+        self.set_header("Cache-Control", "no-cache")
+        self.set_header("X-Accel-Buffering", "no")
+
+        loop = tornado.ioloop.IOLoop.current()
+        q: asyncio.Queue = asyncio.Queue()
+
+        def produce():
+            try:
+                for chunk in providers.stream_generate(
+                    provider, model, get_prompt(role), convo, key, base_url
+                ):
+                    loop.add_callback(q.put_nowait, ("delta", chunk))
+                loop.add_callback(q.put_nowait, ("end", None))
+            except Exception as e:  # surfaced as an SSE error event
+                loop.add_callback(q.put_nowait, ("error", str(e)))
+
+        loop.run_in_executor(None, produce)
+
+        async def emit(obj) -> bool:
+            try:
+                self.write(f"data: {json.dumps(obj)}\n\n")
+                await self.flush()
+                return True
+            except Exception:
+                return False  # client went away — drain quietly
+
+        chunks = []
+        failed = None
+        while True:
+            kind, payload = await q.get()
+            if kind == "delta":
+                chunks.append(payload)
+                await emit({"delta": payload})
+            elif kind == "error":
+                failed = payload
+                break
+            else:
+                break
+
+        raw = "".join(chunks)
+        if failed is not None and not raw:
+            self.log.error("ipygb agent stream failed: %s", failed)
+            await emit({"error": failed})
+            self.finish()
+            return
+
+        parsed, parsed_ok = _extract_json(raw)
+        if not parsed_ok:
+            # Same one-shot format correction as the blocking endpoint.
+            await emit({"note": "Reply was not valid JSON — retrying once…"})
+            retry_convo = convo + [
+                {"role": "assistant", "content": raw[-4000:]},
+                {"role": "user", "content": _FORMAT_RETRY_MSG},
+            ]
+            try:
+                raw2 = await loop.run_in_executor(
+                    None,
+                    lambda: providers.generate(
+                        provider, model, get_prompt(role), retry_convo,
+                        key, base_url
+                    ),
+                )
+                parsed2, ok2 = _extract_json(raw2)
+                if ok2:
+                    parsed, raw = parsed2, raw2
+            except Exception:
+                self.log.exception("ipygb agent: stream format retry failed")
+        await emit({"result": _final_payload(parsed, raw)})
+        self.finish()
 
 
 class AgentProvidersHandler(APIHandler):
@@ -692,6 +809,10 @@ def setup_agent_handlers(web_app):
         host_pattern,
         [
             (url_path_join(base_url, "ipygb", "agent"), AgentHandler),
+            (
+                url_path_join(base_url, "ipygb", "agent", "stream"),
+                AgentStreamHandler,
+            ),
             (
                 url_path_join(base_url, "ipygb", "agent", "providers"),
                 AgentProvidersHandler,