calkit-python 0.49.3__tar.gz → 0.49.5__tar.gz

{calkit_python-0.49.3 → calkit_python-0.49.5}/.calkit/stage-runs.json

@@ -38,18 +38,18 @@
     }
   },
   "find-calkit-papers": {
-    "start_time": "2026-10-22T02:33:03.151000",
-    "end_time": "2026-10-22T02:33:13.966000",
+    "start_time": "2026-10-24T01:16:02.141000",
+    "end_time": "2026-10-24T01:16:07.971000",
     "environment": "dev",
-    "git_rev": "2965496b66b48944fab7b03e19371886ae05a2a8",
+    "git_rev": "daae45c7f8364137254446ee39f0045ae1fb4191",
     "git_dirty": false,
-    "dvc_lock_hash": "sha256:45a249777a79aebf205a0c061fcf007b33d05a671bc57c29fcb1f21938446425",
-    "calkit_version": "0.49.3.dev39+g2965496b",
-    "calkit_git_rev": "2965496b66b48944fab7b03e19371886ae05a2a8",
+    "dvc_lock_hash": "sha256:ed1acb0f5f05f00a02b693c42cccf1e8bb1b500f497ab480c1f7370fb1770308",
+    "calkit_version": "0.49.4.dev43+gdaae45c7",
+    "calkit_git_rev": "daae45c7f8364137254446ee39f0045ae1fb4191",
     "system": {
-      "machine_id": "6b80cb66c24c4cf8ba62e40236d3cfda",
+      "machine_id": "2d791d5cce6240faa3c626058b1ffc7d",
       "os": "Linux",
-      "os_version": "7.0.0-1017-azure",
+      "os_version": "6.17.0-1022-azure",
       "machine": "x86_64",
       "processor": "x86_64",
       "cpu_count": 4,
@@ -57,18 +57,18 @@
     }
   },
   "find-calkit-projects": {
-    "start_time": "2026-10-22T02:32:01.006000",
-    "end_time": "2026-10-22T02:33:03.151000",
+    "start_time": "2026-10-24T01:15:00.963000",
+    "end_time": "2026-10-24T01:16:02.141000",
     "environment": "dev",
-    "git_rev": "2965496b66b48944fab7b03e19371886ae05a2a8",
+    "git_rev": "daae45c7f8364137254446ee39f0045ae1fb4191",
     "git_dirty": false,
-    "dvc_lock_hash": "sha256:ca096611f632a62330e433a0e4dbf11de8df6e2385c391205eadc02242945377",
-    "calkit_version": "0.49.3.dev39+g2965496b",
-    "calkit_git_rev": "2965496b66b48944fab7b03e19371886ae05a2a8",
+    "dvc_lock_hash": "sha256:301672e6a490f398eb70c7aee98495445266cdec96aba0cf263685b8e675c4c0",
+    "calkit_version": "0.49.4.dev43+gdaae45c7",
+    "calkit_git_rev": "daae45c7f8364137254446ee39f0045ae1fb4191",
     "system": {
-      "machine_id": "6b80cb66c24c4cf8ba62e40236d3cfda",
+      "machine_id": "2d791d5cce6240faa3c626058b1ffc7d",
       "os": "Linux",
-      "os_version": "7.0.0-1017-azure",
+      "os_version": "6.17.0-1022-azure",
       "machine": "x86_64",
       "processor": "x86_64",
       "cpu_count": 4,
@@ -132,17 +132,17 @@
     }
   },
   "one-pager/pdf": {
-    "start_time": "2026-10-22T02:33:15.906000",
-    "end_time": "2026-10-22T02:33:21.333000",
-    "git_rev": "2965496b66b48944fab7b03e19371886ae05a2a8",
+    "start_time": "2026-10-24T01:16:09.299000",
+    "end_time": "2026-10-24T01:16:13.252000",
+    "git_rev": "daae45c7f8364137254446ee39f0045ae1fb4191",
     "git_dirty": false,
-    "dvc_lock_hash": "sha256:1baf82191bd18d3f450c21417bd1550de1b0a9c195473f47667e3906e66f2fd4",
-    "calkit_version": "0.49.3.dev39+g2965496b",
-    "calkit_git_rev": "2965496b66b48944fab7b03e19371886ae05a2a8",
+    "dvc_lock_hash": "sha256:fc7b6c75e7f03baafcb74de4df99747695ea56f21c2f4ddec1129ec68c3959a0",
+    "calkit_version": "0.49.4.dev43+gdaae45c7",
+    "calkit_git_rev": "daae45c7f8364137254446ee39f0045ae1fb4191",
     "system": {
-      "machine_id": "6b80cb66c24c4cf8ba62e40236d3cfda",
+      "machine_id": "2d791d5cce6240faa3c626058b1ffc7d",
       "os": "Linux",
-      "os_version": "7.0.0-1017-azure",
+      "os_version": "6.17.0-1022-azure",
       "machine": "x86_64",
       "processor": "x86_64",
       "cpu_count": 4,
@@ -150,18 +150,18 @@
     }
   },
   "traction": {
-    "start_time": "2026-10-22T02:33:13.966000",
-    "end_time": "2026-10-22T02:33:15.906000",
+    "start_time": "2026-10-24T01:16:07.971000",
+    "end_time": "2026-10-24T01:16:09.299000",
     "environment": "dev",
-    "git_rev": "2965496b66b48944fab7b03e19371886ae05a2a8",
+    "git_rev": "daae45c7f8364137254446ee39f0045ae1fb4191",
     "git_dirty": false,
-    "dvc_lock_hash": "sha256:ee16ee8873750d7ab3bddccb4a2b0833217ef1b6641bf95ab8de9f867a794c6b",
-    "calkit_version": "0.49.3.dev39+g2965496b",
-    "calkit_git_rev": "2965496b66b48944fab7b03e19371886ae05a2a8",
+    "dvc_lock_hash": "sha256:3ac5e2633cbc17d07d9d1ae8740a42744dcb865f66dc2022eec0752994a82e5d",
+    "calkit_version": "0.49.4.dev43+gdaae45c7",
+    "calkit_git_rev": "daae45c7f8364137254446ee39f0045ae1fb4191",
     "system": {
-      "machine_id": "6b80cb66c24c4cf8ba62e40236d3cfda",
+      "machine_id": "2d791d5cce6240faa3c626058b1ffc7d",
       "os": "Linux",
-      "os_version": "7.0.0-1017-azure",
+      "os_version": "6.17.0-1022-azure",
       "machine": "x86_64",
       "processor": "x86_64",
       "cpu_count": 4,

{calkit_python-0.49.3 → calkit_python-0.49.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: calkit-python
-Version: 0.49.3
+Version: 0.49.5
 Summary: Reproducibility simplified.
 Project-URL: Homepage, https://calkit.org
 Project-URL: Issues, https://github.com/calkit/calkit/issues

{calkit_python-0.49.3 → calkit_python-0.49.5}/agent-plugin/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "calkit",
   "description": "Agent skills for working with Calkit projects.",
-  "version": "0.2.0"
+  "version": "0.3.0"
 }

calkit_python-0.49.5/agent-plugin/skills/resolve-merge-conflicts/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: resolve-merge-conflicts
+description: Resolve Git merge conflicts in a Calkit project, including
+  dvc.lock, stage run records, and pipeline outputs. Use when the user
+  invokes `/calkit:resolve-merge-conflicts`, asks to merge a branch, or a
+  merge, pull, or rebase stopped with conflicts.
+---
+
+# Resolve merge conflicts
+
+Some conflicted files record what the pipeline ran rather than what anyone
+wrote, so they're resolved per stage by Calkit, not by editing text.
+
+## Division of labor
+
+Done by Calkit, never by hand:
+
+- `dvc.lock` and `.calkit/stage-runs.json`, in the project and any
+  subproject. Don't edit them or take one side whole with
+  `git checkout --ours/--theirs`: that mixes stages, or drops the records of
+  stages that only ran on the other side.
+- Git-tracked pipeline outputs, which are checked out from the side each
+  stage's `dvc.lock` entry came from.
+- `dvc.yaml`, which is generated from `calkit.yaml`. Once `calkit.yaml` is
+  resolved, take either side (`git checkout --ours dvc.yaml`) and run
+  `calkit status`, which rewrites it.
+
+Done by you, with judgment: everything else, e.g., source code,
+`calkit.yaml`, and manuscripts. When the two sides disagree about intent,
+not just text, ask the user.
+
+## Starting a merge
+
+Prefer `calkit merge BRANCH` to `git merge`. It sets up the merge driver,
+resolves what it can, and checks out DVC-tracked outputs afterwards. Most
+stages merge without a conflict: one changed on one side only takes that
+side.
+
+## Stages changed on both sides
+
+Each needs one choice, which decides its `dvc.lock` entry, run record, and
+Git-tracked outputs together:
+
+- `ours` or `theirs`: keep that side's result.
+- `rerun`: keep neither, so `calkit run` reruns it.
+
+You have no terminal for the prompt, so pass choices as options:
+
+```sh
+calkit fix merge-conflicts --theirs fit --rerun figures
+calkit fix merge-conflicts --prefer rerun
+```
+
+Name subproject stages as `calkit check stage-runs` does, e.g.,
+`sub/dvc.yaml:stage`. Run it without options first to list the stages that
+need a choice.
+
+To choose, compare each side's inputs with the merged ones. If the merged
+inputs match one side, keep that side. If they match neither, e.g., both
+sides edited the code, the stage will rerun either way, so choose `rerun`.
+If a stage is expensive to run, or its result is shared with others, ask the
+user. During a rebase, "ours" is the branch being rebased onto, and
+"theirs" is the commit being replayed.
+
+## Finishing
+
+1. Resolve and `git add` the remaining files.
+2. For a merge, run `calkit merge --continue`, with any stage choices still
+   needed. For a rebase or cherry-pick, run `calkit fix merge-conflicts`,
+   then `git rebase --continue` or `git cherry-pick --continue`.
+3. Run `calkit status`, then `calkit run` if stages are stale.
+4. Run `calkit check stage-runs` to confirm every stage matches its run.

{calkit_python-0.49.3 → calkit_python-0.49.5}/browser-ext/public/manifest.json

@@ -25,11 +25,12 @@
     "service_worker": "background.js",
     "type": "module"
   },
-  "permissions": ["storage", "tabs", "scripting", "activeTab"],
+  "permissions": ["storage", "tabs", "scripting", "activeTab", "cookies"],
   "host_permissions": [
     "https://api.calkit.io/*",
     "https://api.staging.calkit.io/*",
     "http://api.localhost/*",
+    "https://www.overleaf.com/*",
     "https://storage.googleapis.com/*",
     "https://s3.amazonaws.com/*",
     "https://*.s3.amazonaws.com/*"

{calkit_python-0.49.3 → calkit_python-0.49.5}/browser-ext/src/background/index.ts

@@ -38,6 +38,11 @@ function projectPath(owner: string, project: string): string {
   )}`;
 }
 
+// The session Overleaf's web app signs in with, which lets the hub sync for
+// users without Overleaf Premium, whose Git integration needs a token
+const OVERLEAF_URL = "https://www.overleaf.com";
+const OVERLEAF_SESSION_COOKIE = "overleaf_session2";
+
 const MAX_PREVIEW_BYTES = 2_000_000;
 const MAX_VIEWER_BYTES = 25_000_000;
 
@@ -251,6 +256,21 @@ async function handle(message: Request): Promise<unknown> {
         method: "PUT",
         body: { token: message.token },
       });
+    case "overleaf.connectSession": {
+      // Read here, since Overleaf keeps the cookie from page scripts, and
+      // only when the user asks, so it's never held otherwise
+      const cookie = await chrome.cookies.get({
+        url: OVERLEAF_URL,
+        name: OVERLEAF_SESSION_COOKIE,
+      });
+      if (!cookie) {
+        throw new Error("Sign in to Overleaf first");
+      }
+      return request<{ message: string }>("/user/overleaf-session", {
+        method: "PUT",
+        body: { session: cookie.value },
+      });
+    }
     case "overleaf.import":
       return request<{ path: string; title: string }>(
         `${projectPath(message.owner, message.project)}/publications/overleaf`,

{calkit_python-0.49.3 → calkit_python-0.49.5}/browser-ext/src/content/overleaf.ts

@@ -35,6 +35,19 @@ const OVERLEAF_TOKEN_RE = /\bolp_[A-Za-z0-9]{20,}\b/;
 let panel: Panel | null = null;
 let currentProjectId: string | null = null;
 let hubWebUrl = "https://calkit.io";
+// The last status found for this page, so opening the panel shows it at
+// once instead of waiting for the hub to check Overleaf all over again
+let lastCheck: {
+  overleafProjectId: string;
+  hubWebUrl: string;
+  link: OverleafLinkPublic;
+  status: OverleafSyncStatus;
+  // What the last sync did, kept through the check that follows it
+  notice?: string;
+} | null = null;
+// Bumped by each load, each sync, and each sign-in change, so a check
+// that finishes after any of them doesn't draw over it
+let loadGeneration = 0;
 let tokenWatcher: MutationObserver | null = null;
 
 /**
@@ -50,12 +63,51 @@ function isOverleafTokenProblem(e: unknown): boolean {
   );
 }
 
-/** Ask for an Overleaf Git token, and save it to the hub. */
+/**
+ * Ask for an Overleaf Git token, and save it to the hub, or, without
+ * Overleaf Premium, connect the browser's Overleaf login instead.
+ */
 function renderTokenForm(
   container: HTMLElement,
-  rejected: boolean,
+  problem: string,
   reload: () => void,
 ): void {
+  const rejected = problem.includes("rejected");
+  const sessionRejected = rejected && problem.includes("session");
+  const connectMessage = el("div", { class: "small" });
+  const connect = el("button", {
+    class: sessionRejected ? "action" : "action secondary",
+    text: "Connect with Overleaf login",
+  });
+  connect.addEventListener("click", async () => {
+    connect.disabled = true;
+    clear(connectMessage).append(loading("Connecting"));
+    try {
+      await send({ type: "overleaf.connectSession" });
+      reload();
+    } catch (e) {
+      connect.disabled = false;
+      clear(connectMessage).append(
+        errorMessage(e instanceof Error ? e.message : String(e)),
+      );
+    }
+  });
+  const connectSection = el("div", { style: { marginTop: "12px" } }, [
+    el("div", {
+      class: "small",
+      text: sessionRejected
+        ? "Overleaf no longer accepts the Overleaf login Calkit saved. " +
+          "Connect it again to keep syncing."
+        : "No Overleaf Premium? Calkit can sync using your Overleaf " +
+          "login instead of a token.",
+    }),
+    el("div", { class: "actions" }, [connect]),
+    connectMessage,
+  ]);
+  if (sessionRejected) {
+    container.append(connectSection);
+    return;
+  }
   const input = textInput({ placeholder: "olp_..." });
   input.type = "password";
   const message = el("div", { class: "small" });
@@ -107,9 +159,27 @@ function renderTokenForm(
       }),
     ]),
     message,
+    connectSection,
   );
 }
 
+/**
+ * Show a failure, offering to connect Overleaf when that's what's missing,
+ * so a first link or import works without Premium too.
+ */
+function renderOverleafFailure(e: unknown, reload: () => void): HTMLElement {
+  if (isOverleafTokenProblem(e)) {
+    const container = el("div");
+    renderTokenForm(
+      container,
+      e instanceof Error ? e.message : String(e),
+      reload,
+    );
+    return container;
+  }
+  return renderFailure(e, { onSignedIn: reload });
+}
+
 /**
  * Offer to save an Overleaf Git token to Calkit as soon as Overleaf shows
  * one, which it only does once, right after it's generated.
@@ -309,6 +379,7 @@ function renderStatus(
   });
   const message = el("div", { class: "small" });
   syncButton.addEventListener("click", async () => {
+    loadGeneration++;
     syncButton.disabled = true;
     clear(message).append(loading("Syncing"));
     try {
@@ -318,16 +389,25 @@ function renderStatus(
         project: link.project_name,
         path: status.path,
       });
-      clear(message).append(
-        el("span", {
-          class: "dim",
-          text:
-            `Synced. ${result.commits_from_overleaf} change` +
-            `${
-              result.commits_from_overleaf === 1 ? "" : "s"
-            } came from Overleaf.`,
-        }),
-      );
+      // Shown as in sync straight away, since that's what a sync leaves,
+      // while the hub confirms it
+      lastSyncNeeded = false;
+      lastCheck = {
+        overleafProjectId: link.overleaf_project_id,
+        hubWebUrl,
+        link,
+        status: {
+          ...status,
+          in_sync: true,
+          files_to_push: [],
+          files_to_delete: [],
+          commits_from_overleaf: 0,
+        },
+        notice:
+          `Synced. ${result.commits_from_overleaf} change` +
+          `${result.commits_from_overleaf === 1 ? "" : "s"} came from ` +
+          "Overleaf.",
+      };
       reload();
     } catch (e) {
       syncButton.disabled = false;
@@ -396,9 +476,7 @@ async function renderPicker(
         ]),
       );
     } catch (e) {
-      clear(message).append(
-        errorMessage(e instanceof Error ? e.message : String(e)),
-      );
+      clear(message).append(renderOverleafFailure(e, reload));
     }
   };
   const runSearch = async () => {
@@ -616,7 +694,7 @@ async function renderAttachForm(
       reload();
     } catch (e) {
       attach.disabled = false;
-      clear(message).append(renderFailure(e, { onSignedIn: reload }));
+      clear(message).append(renderOverleafFailure(e, reload));
     }
   });
   container.append(
@@ -682,9 +760,7 @@ function renderImportForm(
       reload();
     } catch (e) {
       importButton.disabled = false;
-      clear(message).append(
-        errorMessage(e instanceof Error ? e.message : String(e)),
-      );
+      clear(message).append(renderOverleafFailure(e, reload));
     }
   });
   return [
@@ -702,6 +778,8 @@ async function load(overleafProjectId: string): Promise<void> {
     return;
   }
   const body = panel.body;
+  const generation = ++loadGeneration;
+  const current = () => generation === loadGeneration;
   clear(body).append(loading());
   const reload = () => void load(overleafProjectId);
   try {
@@ -718,7 +796,31 @@ async function load(overleafProjectId: string): Promise<void> {
         }),
       ],
     );
-    clear(body).append(pickers, loading("Looking for the linked project"));
+    const cached =
+      lastCheck?.overleafProjectId === overleafProjectId &&
+      lastCheck.hubWebUrl === hubWebUrl
+        ? lastCheck
+        : null;
+    const content = el("div");
+    clear(body).append(pickers, content);
+    const showNotice = () => {
+      if (cached?.notice) {
+        content.append(
+          el("div", {
+            class: "dim small",
+            style: { marginTop: "6px" },
+            text: cached.notice,
+          }),
+        );
+      }
+    };
+    if (cached) {
+      renderStatus(content, cached.link, cached.status, reload);
+      showNotice();
+      content.append(loading("Checking for changes"));
+    } else {
+      content.append(loading("Looking for the linked project"));
+    }
     // The index answers at once when this Overleaf project has been seen
     // before; otherwise the hub reads through the user's projects, active
     // one first, and remembers what it finds
@@ -727,6 +829,9 @@ async function load(overleafProjectId: string): Promise<void> {
       overleafProjectId,
       activeProject: settings.activeProject ?? undefined,
     });
+    if (!current()) {
+      return;
+    }
     const links = lookup.links;
     if (!links.length) {
       clear(body).append(pickers);
@@ -752,15 +857,14 @@ async function load(overleafProjectId: string): Promise<void> {
       await renderPicker(chooser, overleafProjectId, reload);
       return;
     }
-    clear(body).append(pickers);
-    const content = el("div");
-    body.append(content);
     // A folder in more than one project is rare, so the first link is the
     // one shown, with the rest offered as alternatives underneath
     const link = links[0];
-    clear(content).append(
-      loading(`Checking ${link.project_owner_name}/${link.project_name}`),
-    );
+    if (!cached) {
+      clear(content).append(
+        loading(`Checking ${link.project_owner_name}/${link.project_name}`),
+      );
+    }
     const statuses = await send({
       type: "overleaf.status",
       owner: link.project_owner_name,
@@ -768,6 +872,9 @@ async function load(overleafProjectId: string): Promise<void> {
       overleafProjectId,
       path: link.path,
     });
+    if (!current()) {
+      return;
+    }
     if (!statuses.length) {
       clear(content).append(
         el("div", {
@@ -781,7 +888,9 @@ async function load(overleafProjectId: string): Promise<void> {
     }
     lastTokenProblem = false;
     lastSyncNeeded = !statuses[0].in_sync;
+    lastCheck = { overleafProjectId, hubWebUrl, link, status: statuses[0] };
     renderStatus(content, link, statuses[0], reload);
+    showNotice();
     if (links.length > 1) {
       content.append(
         el("div", {
@@ -792,6 +901,9 @@ async function load(overleafProjectId: string): Promise<void> {
       );
     }
   } catch (e) {
+    if (!current()) {
+      return;
+    }
     clear(body);
     if (e instanceof RequestFailed && e.notSignedIn) {
       // With a hub picker alongside, since credentials are per hub and a
@@ -820,15 +932,20 @@ async function load(overleafProjectId: string): Promise<void> {
       );
       return;
     }
+    // The picker stays, since the problem may be with this hub, e.g., an
+    // Overleaf token only another hub has, and switching is the way out
+    const hubPicker = el("div", { style: { marginBottom: "8px" } }, [
+      await renderHubPicker(reload),
+    ]);
     if (isOverleafTokenProblem(e)) {
-      renderTokenForm(
-        body,
-        e instanceof Error && e.message.includes("rejected"),
-        reload,
-      );
+      body.append(hubPicker);
+      renderTokenForm(body, e instanceof Error ? e.message : String(e), reload);
       return;
     }
-    body.append(errorMessage(e instanceof Error ? e.message : String(e)));
+    body.append(
+      hubPicker,
+      errorMessage(e instanceof Error ? e.message : String(e)),
+    );
   }
 }
 
@@ -942,6 +1059,12 @@ function sync(): void {
  * shows: an amber button when a sync would do something.
  */
 async function checkSyncStatus(overleafProjectId: string): Promise<void> {
+  // An answer from a hub or sign-in that has since changed describes
+  // something else, so it's dropped rather than cached
+  const generation = loadGeneration;
+  const hub = await getHubWebUrl();
+  const current = async () =>
+    generation === loadGeneration && (await getHubWebUrl()) === hub;
   try {
     const settings = await send({ type: "settings.get" });
     const lookup = await send({
@@ -960,8 +1083,14 @@ async function checkSyncStatus(overleafProjectId: string): Promise<void> {
       overleafProjectId,
       path: link.path,
     });
+    if (!(await current())) {
+      return;
+    }
     lastTokenProblem = false;
     lastSyncNeeded = Boolean(statuses.length) && !statuses[0].in_sync;
+    lastCheck = statuses.length
+      ? { overleafProjectId, hubWebUrl: hub, link, status: statuses[0] }
+      : null;
     // Nothing to say if the panel was opened in the meantime, or if the
     // page moved on to another project
     if (panel || currentProjectId !== overleafProjectId) {
@@ -972,6 +1101,9 @@ async function checkSyncStatus(overleafProjectId: string): Promise<void> {
       lastSyncNeeded ? "attention" : "idle",
     );
   } catch (e) {
+    if (!(await current())) {
+      return;
+    }
     // A token problem is worth a nudge, since nothing works until it's
     // fixed; anything else the panel explains when opened
     lastTokenProblem = isOverleafTokenProblem(e);
@@ -1028,8 +1160,10 @@ runContentScript({
     }
     const overleafProjectId = currentProjectId;
     // What the last session found says nothing about this one
+    loadGeneration++;
     lastSyncNeeded = false;
     lastTokenProblem = false;
+    lastCheck = null;
     if (panel) {
       void load(overleafProjectId);
     } else {

{calkit_python-0.49.3 → calkit_python-0.49.5}/browser-ext/src/core/messages.ts

@@ -118,6 +118,7 @@ export type Request =
     }
   | { type: "overleaf.sync"; owner: string; project: string; path: string }
   | { type: "overleaf.setToken"; token: string }
+  | { type: "overleaf.connectSession" }
   | {
       type: "overleaf.import";
       owner: string;
@@ -183,6 +184,7 @@ export interface ResponseMap {
   "overleaf.status": OverleafSyncStatus[];
   "overleaf.sync": OverleafSyncResponse;
   "overleaf.setToken": { message: string };
+  "overleaf.connectSession": { message: string };
   "overleaf.import": { path: string; title: string };
   "references.list": References[];
   "references.search": ReferenceSearchMatch[];