tithon 0.2.2__tar.gz → 0.2.3__tar.gz

tithon-0.2.3/.git-blame-ignore-revs

@@ -0,0 +1,9 @@
+# Commits that only reformat. `git blame` skips these so it lands on the
+# commit that last changed the code, not the one that moved the whitespace.
+#
+# Enable locally with:
+#   git config blame.ignoreRevsFile .git-blame-ignore-revs
+# (GitHub honours this file automatically.)
+
+# style: format the tree with ruff and biome
+f6c1838afe7dc977d6f08e8b65f548db1f1091d3

tithon-0.2.3/.release-please-manifest.json

@@ -0,0 +1,4 @@
+{
+  ".": "0.2.3",
+  "extension": "0.2.3"
+}

tithon-0.2.3/.vscode/extensions.json

@@ -0,0 +1,3 @@
+{
+  "recommendations": ["charliermarsh.ruff", "biomejs.biome"]
+}

tithon-0.2.3/.vscode/settings.json

@@ -0,0 +1,28 @@
+{
+  "[python]": {
+    "editor.defaultFormatter": "charliermarsh.ruff",
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+      "source.organizeImports.ruff": "explicit"
+    }
+  },
+  "[typescript]": {
+    "editor.defaultFormatter": "biomejs.biome",
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+      "source.organizeImports.biome": "explicit"
+    }
+  },
+  "[javascript]": {
+    "editor.defaultFormatter": "biomejs.biome",
+    "editor.formatOnSave": true
+  },
+  "[json]": {
+    "editor.defaultFormatter": "biomejs.biome",
+    "editor.formatOnSave": true
+  },
+  "[jsonc]": {
+    "editor.defaultFormatter": "biomejs.biome",
+    "editor.formatOnSave": true
+  }
+}

{tithon-0.2.2 → tithon-0.2.3}/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.2.3](https://github.com/rnoro/tithon/compare/v0.2.2...v0.2.3) (2026-08-16)
+
+
+### Features
+
+* **extension:** let "open as Notebook" stick, per file ([08ba8c1](https://github.com/rnoro/tithon/commit/08ba8c157988a027edcdd71ee5be831b703ed48b))
+* share cell outputs through the project, not the journal ([1ba9d24](https://github.com/rnoro/tithon/commit/1ba9d24a7612bbc530a40da007517d4315be7651))
+
+
+### Bug Fixes
+
+* clear the lint backlog and undo two formatter regressions ([7cd4e10](https://github.com/rnoro/tithon/commit/7cd4e107269ca735d145cb9e2cf8b6b51346ff68))
+
+
+### Documentation
+
+* fix guide for Windows in readme ([bd77e14](https://github.com/rnoro/tithon/commit/bd77e14dd4a39c871a476d1139fc5191736c475e))
+* state invariants instead of naming the ledger ([35e4913](https://github.com/rnoro/tithon/commit/35e4913e696817d4bddd67ff8c7861bf54401aea))
+
 ## [0.2.2](https://github.com/rnoro/tithon/compare/v0.2.1...v0.2.2) (2026-08-12)
 
 

{tithon-0.2.2 → tithon-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tithon
-Version: 0.2.2
+Version: 0.2.3
 Summary: Tithon - The immortal Python REPL that will set you free.
 Project-URL: Homepage, https://github.com/rnoro/tithon
 Project-URL: Documentation, https://tithon.readthedocs.io/
@@ -105,7 +105,8 @@ moves it to the host.
   remote, connect over a Tunnel or Remote-SSH — the notebook then works exactly
   as it does locally.
 
-> Windows is not currently supported.
+> On Windows, we recommend running Tithon inside WSL and connecting with VS Code using the WSL extension.  
+> Native Windows is not currently supported.
 
 ## Install
 
@@ -241,6 +242,32 @@ Outputs live in `$TITHON_HOME/sessions/<session>/journal.db` (raw messages plus
 folded snapshots), with rich outputs written as files under
 `<workdir>/.tithon/outputs/` and referenced from the journal.
 
+### Sharing a notebook's outputs
+
+A percent-format `.py` holds only code, and the journal above is machine-local
+(binary, unbounded, unmergeable). So alongside it the daemon keeps the _folded_
+output state as text in your project:
+
+```
+<project>/.tithon/
+  cells/<relpath>.json   # what each cell currently shows
+  outputs/               # its images, sha256-deduplicated
+```
+
+Commit that directory and whoever clones the repository opens the file with your
+results already in it — what `.ipynb` gives you, without the outputs living in
+the `.py`. Images are referenced rather than embedded, so a plot redrawn every
+step of a training loop still commits one file, not one per frame. Leave the
+directory uncommitted (or `.gitignore` it) to keep your outputs to yourself;
+nothing else depends on it, and your own session restores from the journal
+either way.
+
+Terminating a kernel yourself (`tithon kill`, or **Tithon: Terminate Kernel…**)
+means you are done with that session, so reopening the file no longer restores
+its cells. The history is kept — **Tithon: Restore Previous Outputs** brings it
+back. Every involuntary loss (daemon restart, host reboot, dropped tunnel, idle
+GC) still restores automatically.
+
 ## License
 
 [MIT](LICENSE).

{tithon-0.2.2 → tithon-0.2.3}/README.md

@@ -53,7 +53,8 @@ moves it to the host.
   remote, connect over a Tunnel or Remote-SSH — the notebook then works exactly
   as it does locally.
 
-> Windows is not currently supported.
+> On Windows, we recommend running Tithon inside WSL and connecting with VS Code using the WSL extension.  
+> Native Windows is not currently supported.
 
 ## Install
 
@@ -189,6 +190,32 @@ Outputs live in `$TITHON_HOME/sessions/<session>/journal.db` (raw messages plus
 folded snapshots), with rich outputs written as files under
 `<workdir>/.tithon/outputs/` and referenced from the journal.
 
+### Sharing a notebook's outputs
+
+A percent-format `.py` holds only code, and the journal above is machine-local
+(binary, unbounded, unmergeable). So alongside it the daemon keeps the _folded_
+output state as text in your project:
+
+```
+<project>/.tithon/
+  cells/<relpath>.json   # what each cell currently shows
+  outputs/               # its images, sha256-deduplicated
+```
+
+Commit that directory and whoever clones the repository opens the file with your
+results already in it — what `.ipynb` gives you, without the outputs living in
+the `.py`. Images are referenced rather than embedded, so a plot redrawn every
+step of a training loop still commits one file, not one per frame. Leave the
+directory uncommitted (or `.gitignore` it) to keep your outputs to yourself;
+nothing else depends on it, and your own session restores from the journal
+either way.
+
+Terminating a kernel yourself (`tithon kill`, or **Tithon: Terminate Kernel…**)
+means you are done with that session, so reopening the file no longer restores
+its cells. The history is kept — **Tithon: Restore Previous Outputs** brings it
+back. Every involuntary loss (daemon restart, host reboot, dropped tunnel, idle
+GC) still restores automatically.
+
 ## License
 
 [MIT](LICENSE).

{tithon-0.2.2 → tithon-0.2.3}/docs/SPEC.md

@@ -261,7 +261,9 @@ image / widget / text output below it as native notebook rendering. Outputs come
 from the journal and are attached to cells, so the `.py` is never polluted.
 
 `.py` files open as **plain text by default**; Notebook is opt-in (command
-_Open as Notebook_), and you can flip back with _Open as Text Editor_.
+_Open as Notebook_), and you can flip back with _Open as Text Editor_. For a
+durable per-file choice, _Always Open With…_ offers exactly _Text Editor_ and
+_Notebook_ from the Explorer context menu and both editor representations.
 
 - **Byte-exact round-trip is mandatory.** Serialization preserves the user's
   formatting, whitespace, and comments to the byte — no auto-reformat
@@ -342,20 +344,57 @@ drives the same daemon over the socket:
 ## 6. On-disk layout
 
 ```
-$TITHON_HOME (default ~/.tithon)/
+$TITHON_HOME (default ~/.tithon)/          # machine-local; never in a repo
   daemon.sock                  # unix socket (0600)
   daemon.pid
   daemon.log
   sessions/<session-dir>/
     meta.json
+    kernel.json                # carries an hmac-sha256 key
     journal.db                 # SQLite (WAL): executions, messages, artifacts
 
-<workdir>/.tithon/outputs/     # rich-output files, sha256-deduplicated
-  exec{N}_{idx}_{sha8}.png
+<workdir>/.tithon/             # the document's output state; shareable
+  outputs/                     # rich-output files, sha256-deduplicated
+    exec{N}_{idx}_{sha8}.png
+  cells/<relpath>.json         # folded snapshot per source file
 ```
 
 The `.tithon/outputs/` location is configurable (default: inside the workspace).
 
+**What lives where, and why.** The journal is this machine's verbatim
+write-ahead record — binary, WAL, unbounded, rewritten on every run — so it can
+neither be committed nor merged, and it sits in `$TITHON_HOME` beside the kernel
+connection file whose hmac key must never reach a repository.
+
+What a *reader* of a shared notebook needs is not that record but the **fold**:
+the current output state per execution. The daemon projects it onto
+`.tithon/cells/<relpath>.json` (stable key order, one field per line). Cloning
+the project therefore restores the outputs — the one property `.ipynb` has that
+a percent-format `.py` does not — while images stay as deduplicated files rather
+than one base64 blob per frame, so a live-updating plot commits **one** file.
+
+It is published once per **user action** — when a submitted batch drains, or a
+clear lands — not once per cell: rebuilding it re-serializes every execution's
+fold, so per-cell writes would make a Run All quadratic in the notebook's
+length. The shared file therefore lags a running batch by design; that is sound
+because it is a projection of a journal that already holds everything, and a
+daemon that dies mid-batch republishes when `_recover_inflight` terminalizes the
+cell it was on. A publish that fails (read-only checkout, full disk) also
+suppresses the artifact reclaim that would otherwise follow a clear, so the
+shared file never names an image that has already been deleted.
+
+The journal stays authoritative for the machine that ran the cells: a sidecar is
+imported only into a session with no local executions of its own, and an imported
+execution is terminal, message-less, and has its fold hydrated from the stored
+snapshot (`ExecutionFold.hydrate`) so the startup artifact sweep counts its
+images as live instead of reclaiming them.
+
+Nothing machine-specific is written. A cell's origin carries its index and range
+but no uri, and execution ids are renumbered on import — the file is tracked,
+hand-editable and merge-prone, so its ids are data rather than keys, and each row
+is rebound to the reading file's own uri (which the sidecar's location already
+implies) so that per-file restore scoping keeps it.
+
 ---
 
 ## 7. Tricky points & how they are handled
@@ -479,7 +518,7 @@ make core        # v1–v4 v47 v49 v50 v57 core journal / daemon lifecycle
 make serializer  # v6       percent <-> notebook round-trip
 make backpressure# v9       slow-client host protection
 make widgets     # v5 v29 v30           ipywidget mirror + render + live animation
-make restore     # v7 v8 v15 v16 v22 v38 reconnect: output + cell-state restore, orphan
+make restore     # v7 v8 v15 v16 v22 v38 v61 v62 v63 reconnect restore, orphan, cloned repo, closed session
 make livesync    # v10–v14 v33 v37       live streaming into cells
 make kernels     # v17–v21 v23 v24 v26 v40 v45   per-file kernels + lifecycle + idle-GC
 make richoutputs # v27 v28 v31 v34 v35   matplotlib/tqdm images, live-plot GC, clear, storage
@@ -506,6 +545,8 @@ Capability → what it guarantees → how it is verified:
 | Bounded render cost      | Coalescing caps UI updates                          | `liveSync.test.ts` (50k events → 1 sink call)      |
 | Host protection          | Slow client can't grow memory or block others       | `test_backpressure.py`, `v9`                       |
 | Widget rendering         | Widgets render in VSCode, restore, and animate live | `v29` (static + restore), `v30` (live)             |
+| Shared outputs           | A cloned repo restores outputs + images              | `v61` (real `git clone`), `test_sidecar.py`        |
+| Deliberate close         | A killed session is not re-seeded; history kept     | `v62` (daemon), `v63` (real VSCode seed gate)      |
 
 `make vscode` downloads VSCode and needs system libraries (Debian/Ubuntu):
 

{tithon-0.2.2 → tithon-0.2.3}/extension/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.2.3](https://github.com/rnoro/tithon/compare/vscode-v0.2.2...vscode-v0.2.3) (2026-08-16)
+
+
+### Features
+
+* **extension:** confirm destructive kernel actions; notify outcomes ([73c6d13](https://github.com/rnoro/tithon/commit/73c6d13fcece4630b675cb28d0e5d6e34a317527))
+* **extension:** let "open as Notebook" stick, per file ([08ba8c1](https://github.com/rnoro/tithon/commit/08ba8c157988a027edcdd71ee5be831b703ed48b))
+* **extension:** let "open as Notebook" stick, per file ([d921f52](https://github.com/rnoro/tithon/commit/d921f52e6a0a9f7033adea41b110c5ecc8c10c5f))
+* share cell outputs through the project, not the journal ([1ba9d24](https://github.com/rnoro/tithon/commit/1ba9d24a7612bbc530a40da007517d4315be7651))
+
+
+### Bug Fixes
+
+* clear the lint backlog and undo two formatter regressions ([7cd4e10](https://github.com/rnoro/tithon/commit/7cd4e107269ca735d145cb9e2cf8b6b51346ff68))
+* **extension:** serialize durable editor choice ([376ae78](https://github.com/rnoro/tithon/commit/376ae786c296d71b3473dba9efdc04c637bc9854))
+
 ## [0.2.2](https://github.com/rnoro/tithon/compare/vscode-v0.2.1...vscode-v0.2.2) (2026-08-12)
 
 

{tithon-0.2.2 → tithon-0.2.3}/extension/README.md

@@ -107,6 +107,10 @@ stays pure source — outputs never touch the file, so diffs stay clean.
   time, with no manual command.
 - **ipywidgets** — `tqdm` bars and interactive widgets render through a bundled
   widget renderer and come back at their real state, not their initial value.
+- **Shareable outputs** — the folded output state is kept as text in
+  `<project>/.tithon/` (images referenced as deduplicated files, not embedded).
+  Commit it and whoever clones the repository opens the file with your results
+  already in it; leave it uncommitted to keep them to yourself.
 
 ## Commands
 
@@ -115,15 +119,27 @@ The rest are run from the command palette or the notebook's kernel toolbar:
 
 | Command | What it does |
 | --- | --- |
-| `Tithon: Open as Notebook` / `Open as Text Editor` | Toggle a `.py` between notebook and plain text. |
+| `Tithon: Open as Notebook` / `Open as Text Editor` | Toggle a `.py` between notebook and plain text, once. |
+| `Tithon: Always Open With…` | Choose Text Editor or Notebook for this one file, permanently in this workspace. |
 | `Tithon: Restart Kernel` | Restart the session's kernel. |
 | `Tithon: Interrupt Kernel` | Interrupt the running cell. |
 | `Tithon: Select Python Interpreter` | Choose the interpreter the daemon runs the kernel as. |
 | `Tithon: Restart Daemon` | Restart the host daemon. |
-| `Tithon: Terminate Kernel…` | Kill the session's kernel. |
+| `Tithon: Terminate Kernel…` | Kill the session's kernel. Reopening the file then leaves the cells empty — terminating means you are done with that session. |
+| `Tithon: Restore Previous Outputs` | Put a terminated session's outputs back into the cells. |
 
 `Run Cell` is offered as a CodeLens above each `# %%` cell.
 
+A `.py` opens as a normal text editor unless you say otherwise. Use `Tithon:
+Always Open With…` from the Explorer context menu, editor title, or Notebook
+toolbar to choose `Text Editor` or `Notebook`. Tithon records the choice as one
+`workbench.editorAssociations` entry in the workspace's `.vscode/settings.json`,
+so it survives reloads and can be committed for the team. If you want *every*
+`.py` in a workspace to open as a notebook, that is VSCode's own setting rather
+than a Tithon command — `Reopen With…` → `Configure default editor…` on a `.py`,
+choosing `Notebook - Tithon`. It writes `"*.py": "tithon-py"`, which applies to
+every Python file in scope, `setup.py` and `conftest.py` included.
+
 ## Settings
 
 | Setting | Default | Purpose |
@@ -131,6 +147,7 @@ The rest are run from the command palette or the notebook's kernel toolbar:
 | `tithon.autoStartDaemon` | `true` | Start the daemon on the host when it isn't already running (spawned detached, so it survives reconnects). |
 | `tithon.daemonCommand` | `tithon` | Command used to launch the daemon (run as `<command> daemon`). Set an absolute path if `tithon` isn't on `PATH`. |
 | `tithon.pythonPath` | `""` | Run the daemon as `<python> -m tithon daemon`. Leave empty to use the Python extension's selected interpreter. |
+| `tithon.confirmDestructiveActions` | `true` | Ask in a modal dialog before Restart Kernel, Terminate Kernel and Restart Daemon. Set to `false` if you restart often and accept losing the namespace to a mis-click. |
 | `tithon.kernelIdleTimeout` | `0` | Reap a kernel after this many seconds idle (no attached notebook, nothing running or queued). Outputs stay restorable from the journal; only the in-memory variables are lost. `0` = never. Applied when the extension (re)starts the daemon. |
 
 ## How it works

tithon-0.2.3/extension/biome.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "https://biomejs.dev/schemas/2.5.8/schema.json",
+  "files": {
+    "includes": ["**", "!dist", "!out-int", "!.vscode-test", "!**/*.vsix", "!test/fixtures"]
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 100
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "double",
+      "semicolons": "always",
+      "trailingCommas": "all",
+      "arrowParentheses": "always"
+    }
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "preset": "recommended",
+      "suspicious": {
+        "noExplicitAny": "off"
+      },
+      "style": {
+        "noNonNullAssertion": "off"
+      }
+    }
+  },
+  "assist": {
+    "actions": {
+      "source": {
+        "organizeImports": "on"
+      }
+    }
+  }
+}

{tithon-0.2.2 → tithon-0.2.3}/extension/integration/runTest.ts

@@ -12,7 +12,8 @@
  * notebook/LSP guard suites against the insiders build as an early warning, so a
  * breaking change is caught before it reaches users on stable.
  */
-import * as path from "path";
+
+import * as path from "node:path";
 import { runTests } from "@vscode/test-electron";
 
 async function main(): Promise<void> {
@@ -41,9 +42,7 @@ async function main(): Promise<void> {
   // Python language servers (ruff/ty) live, so it passes TITHON_LSP_EXT_DIR — a
   // curated extensions dir — and we drop --disable-extensions for that run.
   const lspExtDir = process.env.TITHON_LSP_EXT_DIR;
-  const extArgs = lspExtDir
-    ? [`--extensions-dir=${lspExtDir}`]
-    : ["--disable-extensions"];
+  const extArgs = lspExtDir ? [`--extensions-dir=${lspExtDir}`] : ["--disable-extensions"];
 
   // Default "stable" matches @vscode/test-electron's own default (latest stable),
   // so the existing bundles are unchanged; the insiders bundle overrides it.
@@ -74,6 +73,11 @@ async function main(): Promise<void> {
       TITHON_FIXTURE: process.env.TITHON_FIXTURE ?? "",
       TITHON_HELPER: process.env.TITHON_HELPER ?? "",
       TITHON_SUITE: process.env.TITHON_SUITE ?? "",
+      // "1" leaves `tithon.confirmDestructiveActions` at its shipped default, so
+      // the suite that verifies the modal gate sees what a user sees. Every other
+      // suite drives restart/terminate unattended, so the bootstrap turns it off.
+      TITHON_CONFIRM_DESTRUCTIVE: process.env.TITHON_CONFIRM_DESTRUCTIVE ?? "",
+      TITHON_CONFIRM_TARGET: process.env.TITHON_CONFIRM_TARGET ?? "",
     },
   });
 }

{tithon-0.2.2 → tithon-0.2.3}/extension/integration/seed.ts

@@ -4,10 +4,10 @@
  * source via the verified SessionClient so daemon cell_hash == the extension's
  * computeCellHash(cellSource), and waits until every execution is terminal.
  */
-import { readFileSync } from "fs";
-import { parse, cellSource } from "../src/serializer";
-import { SessionClient } from "../src/sessionClient";
+import { readFileSync } from "node:fs";
 import { computeCellHash } from "../src/cellAttach";
+import { cellSource, parse } from "../src/serializer";
+import { SessionClient } from "../src/sessionClient";
 
 async function main(): Promise<void> {
   const file = process.argv[2];

{tithon-0.2.2 → tithon-0.2.3}/extension/integration/suite/addcell.test.ts

@@ -8,7 +8,7 @@
  * Flow: run cell 0 (starts live), then insert a new cell and run it, and assert
  * the new cell shows its output WITHOUT any manual restore step.
  */
-import * as assert from "assert";
+import * as assert from "node:assert";
 import * as vscode from "vscode";
 
 const dec = new TextDecoder();
@@ -64,7 +64,10 @@ describe("Tithon streams output for a cell added after live started (v14)", () =
     const nb = await vscode.workspace.openNotebookDocument(uri);
     await vscode.window.showNotebookDocument(nb);
     await waitFor(() => nb.cellCount >= 1, 15000, "cells");
-    await vscode.commands.executeCommand("notebook.selectKernel", { id: "tithon", extension: ext.id });
+    await vscode.commands.executeCommand("notebook.selectKernel", {
+      id: "tithon",
+      extension: ext.id,
+    });
 
     // Run the first cell — this starts live sync (index has only cell 0).
     await runCell(uri, 0);

{tithon-0.2.2 → tithon-0.2.3}/extension/integration/suite/autoopen.test.ts

@@ -8,30 +8,41 @@
  * command. Auto-open must (a) restore the lines already produced and (b) keep
  * appending new lines as the loop runs.
  */
-import * as assert from "assert";
+import * as assert from "node:assert";
+import { readFileSync } from "node:fs";
 import * as vscode from "vscode";
-import { readFileSync } from "fs";
-import { parse, cellSource } from "../../src/serializer";
-import { SessionClient } from "../../src/sessionClient";
 import { computeCellHash } from "../../src/cellAttach";
+import { cellSource, parse } from "../../src/serializer";
+import { SessionClient } from "../../src/sessionClient";
 
 const dec = new TextDecoder();
 function cellText(cell: vscode.NotebookCell): string {
   let s = "";
-  for (const o of cell.outputs) for (const it of o.items)
-    if (it.mime.includes("stdout") || it.mime === "text/plain") s += dec.decode(it.data);
+  for (const o of cell.outputs)
+    for (const it of o.items)
+      if (it.mime.includes("stdout") || it.mime === "text/plain") s += dec.decode(it.data);
   return s;
 }
 function lines(t: string): number[] {
-  return t.split("\n").map((x) => x.trim()).filter((x) => /^\d+$/.test(x)).map(Number);
+  return t
+    .split("\n")
+    .map((x) => x.trim())
+    .filter((x) => /^\d+$/.test(x))
+    .map(Number);
 }
 async function waitFor(pred: () => boolean, ms: number, label: string): Promise<void> {
   const deadline = Date.now() + ms;
-  while (!pred()) { if (Date.now() > deadline) throw new Error(`timed out: ${label}`); await new Promise((r) => setTimeout(r, 50)); }
+  while (!pred()) {
+    if (Date.now() > deadline) throw new Error(`timed out: ${label}`);
+    await new Promise((r) => setTimeout(r, 50));
+  }
 }
 function ext(): vscode.Extension<unknown> {
   const e = vscode.extensions.all.find((x) =>
-    (x.packageJSON?.contributes?.commands ?? []).some((c: { command?: string }) => c.command === "tithon.restartKernel"));
+    (x.packageJSON?.contributes?.commands ?? []).some(
+      (c: { command?: string }) => c.command === "tithon.restartKernel",
+    ),
+  );
   if (!e) throw new Error("Tithon extension not found");
   return e;
 }
@@ -43,12 +54,17 @@ describe("Tithon auto-restore + live on open, no command (v22)", () => {
 
     // Driver starts the long loop on this file's kernel (independent of the UI).
     const cells = parse(readFileSync(uri.fsPath, "utf8")).cells;
-    const loopIdx = cells.findIndex((c) => c.kind === "code" && c.body.some((l) => l.text.includes("range(30)")));
+    const loopIdx = cells.findIndex(
+      (c) => c.kind === "code" && c.body.some((l) => l.text.includes("range(30)")),
+    );
     assert.ok(loopIdx >= 0, "fixture needs the range(30) loop");
     const src = cellSource(cells[loopIdx]);
     const driver = new SessionClient(undefined, uri.toString());
     await driver.execute(src, {
-      uri: uri.toString(), range: { start: 0, end: 0 }, cell_hash: computeCellHash(src), index: loopIdx,
+      uri: uri.toString(),
+      range: { start: 0, end: 0 },
+      cell_hash: computeCellHash(src),
+      index: loopIdx,
     });
 
     // Let a few lines accumulate so there is real prior output to auto-restore.
@@ -66,15 +82,25 @@ describe("Tithon auto-restore + live on open, no command (v22)", () => {
     const nb = await vscode.workspace.openNotebookDocument(uri);
     await vscode.window.showNotebookDocument(nb);
     await waitFor(() => nb.cellCount >= 1, 15000, "cells");
-    await vscode.commands.executeCommand("notebook.selectKernel", { id: "tithon", extension: ext().id });
+    await vscode.commands.executeCommand("notebook.selectKernel", {
+      id: "tithon",
+      extension: ext().id,
+    });
 
     // (a) prior output restored: at least the early lines show up.
-    await waitFor(() => lines(cellText(nb.cellAt(loopIdx))).length >= 4, 20000, "auto-restored prior output");
+    await waitFor(
+      () => lines(cellText(nb.cellAt(loopIdx))).length >= 4,
+      20000,
+      "auto-restored prior output",
+    );
     const restoredMax = Math.max(...lines(cellText(nb.cellAt(loopIdx))));
 
     // (b) live continues: the cell keeps growing past what was there at open.
-    await waitFor(() => Math.max(...lines(cellText(nb.cellAt(loopIdx))), -1) > restoredMax,
-      25000, "live output continued after open");
+    await waitFor(
+      () => Math.max(...lines(cellText(nb.cellAt(loopIdx))), -1) > restoredMax,
+      25000,
+      "live output continued after open",
+    );
 
     const final = lines(cellText(nb.cellAt(loopIdx)));
     assert.ok(final.length >= 5, `expected continuous output, got ${JSON.stringify(final)}`);

{tithon-0.2.2 → tithon-0.2.3}/extension/integration/suite/autostart.test.ts

@@ -4,26 +4,33 @@
  * (tithon.autoStartDaemon) and stream output — "pip install tithon, then just
  * use it". Also asserts the kernel reports its Python version (label plumbing).
  */
-import * as assert from "assert";
+import * as assert from "node:assert";
+import * as fs from "node:fs";
+import * as path from "node:path";
 import * as vscode from "vscode";
-import * as fs from "fs";
-import * as path from "path";
 import { SessionClient } from "../../src/sessionClient";
 
 const dec = new TextDecoder();
 function cellText(cell: vscode.NotebookCell): string {
   let s = "";
-  for (const o of cell.outputs) for (const it of o.items)
-    if (it.mime.includes("stdout") || it.mime === "text/plain") s += dec.decode(it.data);
+  for (const o of cell.outputs)
+    for (const it of o.items)
+      if (it.mime.includes("stdout") || it.mime === "text/plain") s += dec.decode(it.data);
   return s;
 }
 async function waitFor(pred: () => boolean, ms: number, label: string): Promise<void> {
   const deadline = Date.now() + ms;
-  while (!pred()) { if (Date.now() > deadline) throw new Error(`timed out: ${label}`); await new Promise((r) => setTimeout(r, 50)); }
+  while (!pred()) {
+    if (Date.now() > deadline) throw new Error(`timed out: ${label}`);
+    await new Promise((r) => setTimeout(r, 50));
+  }
 }
 function ext(): vscode.Extension<unknown> {
   const e = vscode.extensions.all.find((x) =>
-    (x.packageJSON?.contributes?.commands ?? []).some((c: { command?: string }) => c.command === "tithon.restartKernel"));
+    (x.packageJSON?.contributes?.commands ?? []).some(
+      (c: { command?: string }) => c.command === "tithon.restartKernel",
+    ),
+  );
   if (!e) throw new Error("Tithon extension not found");
   return e;
 }
@@ -39,20 +46,29 @@ describe("Tithon daemon auto-start (v23)", () => {
     // Use the interpreter path (Jupyter-style `<python> -m tithon`) — no venv
     // activation, no `tithon` on PATH. daemonCommand stays default "tithon"
     // (absent here) to prove the interpreter candidate is what starts it.
-    await vscode.workspace.getConfiguration("tithon")
+    await vscode.workspace
+      .getConfiguration("tithon")
       .update("pythonPath", process.env.TITHON_PYTHON!, vscode.ConfigurationTarget.Global);
 
     const nb = await vscode.workspace.openNotebookDocument(uri);
     await vscode.window.showNotebookDocument(nb);
     await waitFor(() => nb.cellCount >= 1, 15000, "cells");
     // Selecting the kernel triggers ensureLive -> ensureDaemon (auto-start).
-    await vscode.commands.executeCommand("notebook.selectKernel", { id: "tithon", extension: ext().id });
+    await vscode.commands.executeCommand("notebook.selectKernel", {
+      id: "tithon",
+      extension: ext().id,
+    });
     await vscode.commands.executeCommand("notebook.cell.execute", {
-      ranges: [new vscode.NotebookRange(0, 1)], document: uri,
+      ranges: [new vscode.NotebookRange(0, 1)],
+      document: uri,
     });
 
     // Output only appears if the daemon was actually auto-started.
-    await waitFor(() => cellText(nb.cellAt(0)).includes("AUTO_OK"), 40000, "auto-started daemon streamed output");
+    await waitFor(
+      () => cellText(nb.cellAt(0)).includes("AUTO_OK"),
+      40000,
+      "auto-started daemon streamed output",
+    );
     assert.ok(fs.existsSync(pidFile), "daemon.pid should exist after auto-start");
 
     // Kernel reports its Python version (for the "Tithon · Python x.y" label).
@@ -60,7 +76,10 @@ describe("Tithon daemon auto-start (v23)", () => {
     await c.attach(0);
     const py = c.kernelInfo()?.python ?? "";
     c.close();
-    assert.ok(/^\d+\.\d+/.test(py), `kernel should report a python version, got ${JSON.stringify(py)}`);
+    assert.ok(
+      /^\d+\.\d+/.test(py),
+      `kernel should report a python version, got ${JSON.stringify(py)}`,
+    );
     console.log(`[v23] daemon auto-started; kernel python = ${py}`);
   });
 });