calkit-python 0.45.1__tar.gz → 0.45.2__tar.gz

{calkit_python-0.45.1 → calkit_python-0.45.2}/PKG-INFO

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

{calkit_python-0.45.1 → calkit_python-0.45.2}/calkit/cli/main/core.py

@@ -286,9 +286,18 @@ def init(
         needs_own_repo = True
     if needs_own_repo:
         subprocess.run(["git", "init"])
-    result = calkit.dvc.init(force=force)
-    if result != 0:
-        raise_error("Failed to initialize DVC")
+    # A DVC repo can already exist here without a calkit.yaml, e.g., on
+    # platforms that set one up for us, so leave it alone rather than
+    # failing on DVC's refusal to initialize over an existing .dvc. The
+    # marker is .dvc/config, as elsewhere: a .dvc directory without one is
+    # an interrupted initialization, which has nothing worth keeping and
+    # which DVC will only initialize over with --force.
+    if os.path.isfile(os.path.join(".dvc", "config")) and not force:
+        typer.echo("DVC is already initialized")
+    else:
+        result = calkit.dvc.init(force=force or os.path.isdir(".dvc"))
+        if result != 0:
+            raise_error("Failed to initialize DVC")
     # Ensure autostage is enabled for DVC
     result = calkit.dvc.run_dvc_command(["config", "core.autostage", "true"])
     if result != 0:

{calkit_python-0.45.1 → calkit_python-0.45.2}/calkit/dvc/core.py

@@ -98,6 +98,60 @@ if sys.platform == "win32":
     _tolerate_lock_release_failures()
 
 
+def _hash_dirs_inside_nested_repos() -> None:
+    """Make DVC hash directories that live inside nested DVC repos.
+
+    DVC's ``DvcIgnoreFilter`` prunes nested DVC repos (e.g. isolated
+    subprojects) when walking, so the parent never indexes a subproject's
+    ``dvc.yaml`` and ``.dvc`` files as its own. The same walk hashes directory
+    deps and outs, though, and the subrepo check is order-dependent:
+    ``_get_trie_pattern`` hands the starting directory's ``dnames`` to every
+    ancestor it visits, so a walk that starts inside the nested repo never
+    registers it, while the root-level index walk does. Whichever touches the
+    ignore trie first wins for the rest of the process. In practice a parent
+    stage depending on a directory inside an isolated subproject hashes it as
+    *empty* on ``status`` but not always on ``repro``, so ``dvc.lock`` and
+    ``dvc status`` disagree and the stage is forever stale (or, worse, changes
+    in the subproject go unnoticed).
+
+    A walk that starts at or below a nested repo can only be a caller hashing
+    that path (the index walk always starts at the repo root), and the caller
+    named the path deliberately, so its contents must be hashed. Such walks
+    are routed through DVC's ``ignore_subrepos=False`` trie, which is built
+    separately, is deterministic, and still honors every ``.dvcignore`` on
+    the way down, including the nested repo's own.
+    """
+    from dvc.ignore import DvcIgnoreFilter
+    from dvc.repo import Repo
+
+    original_walk = DvcIgnoreFilter.walk
+
+    def in_nested_repo(dvcignore: Any, path: str) -> bool:
+        fs = dvcignore.fs
+        root_dir = dvcignore.root_dir
+        current = fs.abspath(path)
+        if not fs.isin(current, root_dir):
+            return False
+        while current != root_dir:
+            if fs.exists(fs.join(current, Repo.DVC_DIR)):
+                return True
+            parent = fs.parent(current)
+            if parent == current:
+                return False
+            current = parent
+        return False
+
+    def walk(self: Any, fs: Any, path: str, **kwargs: Any) -> Any:
+        if "ignore_subrepos" not in kwargs and in_nested_repo(self, path):
+            kwargs["ignore_subrepos"] = False
+        return original_walk(self, fs, path, **kwargs)
+
+    DvcIgnoreFilter.walk = walk
+
+
+_hash_dirs_inside_nested_repos()
+
+
 # Default seconds to wait for DVC's repo-level lock during a pipeline run.
 #
 # DVC's own default is only 3 seconds (``dvc.lock.DEFAULT_TIMEOUT``), after

{calkit_python-0.45.1 → calkit_python-0.45.2}/calkit/tests/cli/main/test_core.py

@@ -149,6 +149,25 @@ def test_init(tmp_dir):
     # --force allows re-initialization without clobbering calkit.yaml
     subprocess.check_call(["calkit", "init", "--force"], cwd="sub")
     assert calkit.load_calkit_info(wdir="sub") == ck_info
+    # An existing DVC repo with no calkit.yaml is left alone rather than
+    # failing on DVC's refusal to initialize over an existing .dvc (#1013)
+    os.remove(os.path.join("sub", "calkit.yaml"))
+    assert os.path.isdir(os.path.join("sub", ".dvc"))
+    result = subprocess.run(
+        ["calkit", "init"],
+        cwd="sub",
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode == 0
+    assert "already initialized" in result.stdout.lower()
+    assert os.path.isfile(os.path.join("sub", "calkit.yaml"))
+    assert calkit.load_calkit_info(wdir="sub") == {}
+    # A .dvc directory left behind by an interrupted init has no config in
+    # it, so it is re-initialized rather than taken for a working repo
+    os.remove(os.path.join("sub", ".dvc", "config"))
+    subprocess.check_call(["calkit", "init"], cwd="sub")
+    assert os.path.isfile(os.path.join("sub", ".dvc", "config"))
     # --no-commit stages the initial files without committing, so a
     # bootstrap (as run by xr) can be rolled back by restoring files
     os.makedirs("nocommit")

{calkit_python-0.45.1 → calkit_python-0.45.2}/calkit/tests/cli/main/test_subprojects.py

@@ -4,6 +4,7 @@ import os
 import subprocess
 
 import calkit
+import calkit.dvc
 import calkit.pipeline
 
 
@@ -375,6 +376,106 @@ def test_isolated_subproject_external_dep(tmp_dir):
     assert not status.is_stale
 
 
+def test_isolated_subproject_dir_dep(tmp_dir):
+    # A parent stage depending on a *directory* inside an isolated
+    # subproject: DVC prunes nested repos when walking, so without calkit's
+    # workaround the directory hashes as empty on status (but not always on
+    # repro), leaving the stage forever stale and blind to subproject changes.
+    def write_sub(b_content):
+        # Create the output directory here, since mkdir -p doesn't work in
+        # cmd.exe on Windows
+        os.makedirs("sub/figs", exist_ok=True)
+        write_ck_info(
+            "sub/calkit.yaml",
+            {
+                "pipeline": {
+                    "stages": {
+                        "make-figs": make_stage(
+                            "echo a > figs/a.txt && "
+                            f"echo {b_content} > figs/b.txt",
+                            outputs=[
+                                {"path": "figs/a.txt", "storage": "git"},
+                                {"path": "figs/b.txt", "storage": "git"},
+                            ],
+                        )
+                    }
+                }
+            },
+        )
+        calkit.pipeline.to_dvc(wdir="sub", write=True, manage_gitignore=False)
+
+    subprocess.check_call(["calkit", "init"])
+    init_isolated_subproject("sub", {})
+    write_sub("b")
+    write_ck_info(
+        "calkit.yaml",
+        {
+            "subprojects": [{"path": "sub"}],
+            "pipeline": {
+                "stages": {
+                    "consume": make_stage(
+                        "cat sub/figs/* > parent.txt",
+                        inputs=["sub/figs/"],
+                        outputs=[{"path": "parent.txt", "storage": "git"}],
+                    )
+                }
+            },
+        },
+    )
+    subprocess.check_call(["calkit", "run"])
+    # Windows' echo leaves trailing spaces, so compare tokens
+    with open("parent.txt") as f:
+        assert f.read().split() == ["a", "b"]
+    # The lock must record the directory's real contents, not an empty dir
+    with open("dvc.lock") as f:
+        lock = calkit.ryaml.load(f)
+    figs_dep = [
+        d
+        for d in lock["stages"]["consume"]["deps"]
+        if d["path"] == "sub/figs/"
+    ][0]
+    assert figs_dep["nfiles"] == 2
+    # And status must agree with the lock
+    status = calkit.pipeline.get_status(
+        check_environments=False, compile_to_dvc=False
+    )
+    assert not status.is_stale
+    # Hashing must not depend on whether the index walk (which registers the
+    # subrepo in DVC's ignore trie) ran first
+    repo = calkit.dvc.get_dvc_repo()
+    list(repo.index.stages)
+    found = sorted(
+        os.path.relpath(p)
+        for p in repo.dvcignore.find(repo.fs, os.path.abspath("sub/figs"))
+    )
+    assert found == [
+        os.path.join("sub", "figs", "a.txt"),
+        os.path.join("sub", "figs", "b.txt"),
+    ]
+    # The index walk still keeps the subproject's own pipeline out of the
+    # parent's index
+    assert {s.addressing for s in repo.index.stages} == {"sub", "consume"}
+    # A change inside the subproject propagates to the parent stage
+    write_sub("c")
+    subprocess.check_call(["calkit", "run"])
+    with open("parent.txt") as f:
+        assert f.read().split() == ["a", "c"]
+    status = calkit.pipeline.get_status(
+        check_environments=False, compile_to_dvc=False
+    )
+    assert not status.is_stale
+    # Editing a file in the directory makes the parent stage stale
+    with open("sub/figs/a.txt", "w") as f:
+        f.write("z\n")
+    status = calkit.pipeline.get_status(
+        check_environments=False, compile_to_dvc=False
+    )
+    assert status.is_stale
+    assert [
+        p.rstrip("/") for p in status.stale_stages["consume"].modified_inputs
+    ] == ["sub/figs"]
+
+
 def test_targeted_status_uses_full_subproject_status_for_stage_targets(
     tmp_dir, monkeypatch
 ):

{calkit_python-0.45.1 → calkit_python-0.45.2}/hub/frontend/src/components/Onboarding/AccountSetupCard.tsx

@@ -32,7 +32,7 @@ const CHROME_EXT_URL =
 const AccountSetupCard = ({ projectCount }: { projectCount: number }) => {
   const showToast = useCustomToast()
   const overleafModal = useDisclosure()
-  const { accountFlags, setFlag } = useOnboardingFlags()
+  const { accountFlags, setFlag, flagsLoading } = useOnboardingFlags()
   const connectedAccountsQuery = useQuery({
     queryKey: ["user", "connected-accounts"],
     queryFn: () =>
@@ -60,7 +60,10 @@ const AccountSetupCard = ({ projectCount }: { projectCount: number }) => {
     projectCount,
     flags: accountFlags,
   })
-  if (connectedAccountsQuery.isPending) {
+  // Nothing shows until both the connected accounts and the user's flags
+  // are in hand: a card rendered on either one alone flashes a full
+  // checklist at a user who finished or dismissed it long ago.
+  if (connectedAccountsQuery.isPending || flagsLoading) {
     return null
   }
   const actions: Record<string, React.ReactNode> = {

{calkit_python-0.45.1 → calkit_python-0.45.2}/hub/frontend/src/components/Onboarding/ProjectChecklist.tsx

@@ -41,7 +41,7 @@ const ProjectChecklist = ({
   projectName,
   projectId,
 }: ProjectChecklistProps) => {
-  const { projectFlags, setFlag } = useOnboardingFlags(projectId)
+  const { projectFlags, setFlag, flagsLoading } = useOnboardingFlags(projectId)
   const { questionsRequest } = useProjectQuestions(accountName, projectName)
   // Both of these read the project's repo, which the page has already had
   // cloned and cached for the README and showcase, so they're cheap here
@@ -86,7 +86,9 @@ const ProjectChecklist = ({
   // someone whose project is already in good shape, which is the worst
   // first impression this card can make. A read that failed outright says
   // nothing about the project either, so that's no reason to show one.
-  if (reproCheckQuery.isPending || reproCheckQuery.isError) {
+  // The flags say whether this list was dismissed, so they have to land
+  // before anything renders for the same reason.
+  if (reproCheckQuery.isPending || reproCheckQuery.isError || flagsLoading) {
     return null
   }
   const actions: Record<string, React.ReactNode> = {

{calkit_python-0.45.1 → calkit_python-0.45.2}/hub/frontend/src/hooks/useOnboarding.ts

@@ -72,6 +72,10 @@ const useOnboardingFlags = (projectId?: string | null) => {
     )
   return {
     flagsQuery,
+    // Whether the flags are still on their way. A checklist rendered before
+    // they land reads as undismissed and unchecked, which flashes a fresh
+    // user's checklist at someone who put it away months ago.
+    flagsLoading: flagsQuery.isLoading,
     accountFlags,
     projectFlags,
     setFlag,

calkit_python-0.45.2/scripts/install.ps1

@@ -0,0 +1,26 @@
+# Install Calkit with uv (installing the latter if it isn't yet)
+
+# Every statement below is kept on a single line so the script still does the
+# right thing when a shell feeds it to `iex` one line at a time, which is what
+# happens if the quoting around `irm ... | iex` is lost and the outer shell,
+# rather than the inner one, ends up handling the pipe (see issue #1569)
+
+# Check if uv is installed
+if (-not (Get-Command uv -ErrorAction SilentlyContinue)) { Write-Host "Installing uv"; powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex" } else { Write-Host "uv is already installed" }
+
+# uv and the tools it installs go in ~\.local\bin, which this process won't
+# have on its PATH, since it started before uv put it there
+$env:Path = "$env:USERPROFILE\.local\bin;$env:Path"
+
+if (-not (Get-Command uv -ErrorAction SilentlyContinue)) { throw "Failed to install uv; please install it manually from https://docs.astral.sh/uv/getting-started/installation/" }
+
+# Install Calkit using uv
+Write-Host "Installing Calkit"
+uv tool install --upgrade calkit-python --python=3.14
+if ($LASTEXITCODE -ne 0) { throw "Failed to install Calkit; please check your uv installation" }
+
+# Install shell completion, per command name, so the `ck` alias gets it too
+Write-Host "Installing shell completion"
+foreach ($cmd in @("calkit", "ck")) { & $cmd --install-completion; if ($LASTEXITCODE -ne 0) { Write-Warning "Failed to install shell completion for '$cmd'; run '$cmd --install-completion' manually" } }
+
+Write-Host "Success! Restart your shell to pick up Calkit on your PATH."

{calkit_python-0.45.1 → calkit_python-0.45.2}/scripts/install.sh

@@ -22,11 +22,14 @@ if ! uv tool install --upgrade calkit-python --python=3.14; then
     exit 1
 fi
 
+# Completion is installed per command name, so the `ck` alias gets it too
 echo "Installing shell completion"
-if ! calkit --install-completion; then
-    echo "⚠️ Failed to install shell completion; run 'calkit --install-completion' manually"
-else
-    echo "✅ Shell completion installed"
-fi
+for cmd in calkit ck; do
+    if ! $cmd --install-completion; then
+        echo "⚠️ Failed to install shell completion for '$cmd'; run '$cmd --install-completion' manually"
+    else
+        echo "✅ Shell completion installed for '$cmd'"
+    fi
+done
 
 echo "✅ Success! 🚀"

{calkit_python-0.45.1 → calkit_python-0.45.2}/vscode-ext/src/extension.ts

@@ -31,6 +31,11 @@ import type {
   StaleStageDetail,
 } from "./types";
 import { dvcStageOutputPaths } from "./pipeline/core";
+import {
+  formatYamlSyntaxError,
+  yamlSyntaxError,
+  type YamlSyntaxError,
+} from "./yaml";
 import { CalkitSidebarProvider } from "./sidebar";
 import {
   resolveFigureRefStage,
@@ -138,6 +143,9 @@ const execFileAsync = promisify(execFile);
 const DEFAULT_MIN_CALKIT_VERSION = "0.41.15";
 const DEFAULT_NOTEBOOK_SLURM_TIME = "120";
 const CALKIT_INSTALL_DOCS_URL = "https://docs.calkit.org/installation";
+const WINDOWS_INSTALL_SCRIPT = "irm install-ps1.calkit.org | iex";
+const WINDOWS_INSTALL_COMMAND = `powershell -ExecutionPolicy ByPass -c "${WINDOWS_INSTALL_SCRIPT}"`;
+const UNIX_INSTALL_COMMAND = "curl -LsSf install.calkit.org | sh";
 const MISSING_IJULIA_ERROR_TEXT =
   "IJulia is not installed in this Julia environment";
 
@@ -1531,32 +1539,54 @@ async function promptCalkitInstallOrUpgrade(options: {
     return;
   }
 
-  const command = await pickCalkitSetupCommand(options.mode);
-  if (!command) {
+  const selected = await pickCalkitSetupCommand(options.mode);
+  if (!selected) {
     return;
   }
-
-  const terminal = vscode.window.createTerminal("Calkit Setup");
+  // The PowerShell installer runs as the terminal's own shell rather than as
+  // text typed into one. VS Code hands these arguments to the process
+  // directly, so nothing can strip the quotes that keep `irm ... | iex`
+  // inside -Command; when they were stripped, the outer shell took the pipe
+  // and fed the script to `iex` a line at a time, which fails (issue #1569).
+  const terminal = selected.powershell
+    ? vscode.window.createTerminal({
+        name: "Calkit Setup",
+        shellPath: "powershell.exe",
+        shellArgs: [
+          "-NoExit",
+          "-ExecutionPolicy",
+          "ByPass",
+          "-Command",
+          WINDOWS_INSTALL_SCRIPT,
+        ],
+      })
+    : vscode.window.createTerminal("Calkit Setup");
   terminal.show(true);
-  terminal.sendText(command, true);
+  if (!selected.powershell) {
+    terminal.sendText(selected.command, true);
+  }
   void vscode.window.showInformationMessage(
     "Started Calkit setup command in terminal. After it finishes, reload VS Code.",
   );
 }
 
+interface CalkitSetupCommand extends vscode.QuickPickItem {
+  /** The command line, as documented. */
+  command: string;
+  /** Run it as a PowerShell process instead of typing it into a terminal. */
+  powershell?: boolean;
+}
+
 async function pickCalkitSetupCommand(
   mode: "install" | "upgrade",
-): Promise<string | undefined> {
+): Promise<CalkitSetupCommand | undefined> {
   const isWindows = process.platform === "win32";
-  const installItems = [
+  const installItems: CalkitSetupCommand[] = [
     {
       label: "Official installer (recommended)",
-      description: isWindows
-        ? 'powershell -ExecutionPolicy ByPass -c "irm install-ps1.calkit.org | iex"'
-        : "curl -LsSf install.calkit.org | sh",
-      command: isWindows
-        ? 'powershell -ExecutionPolicy ByPass -c "irm install-ps1.calkit.org | iex"'
-        : "curl -LsSf install.calkit.org | sh",
+      description: isWindows ? WINDOWS_INSTALL_COMMAND : UNIX_INSTALL_COMMAND,
+      command: isWindows ? WINDOWS_INSTALL_COMMAND : UNIX_INSTALL_COMMAND,
+      powershell: isWindows,
     },
     {
       label: "uv tool",
@@ -1576,15 +1606,14 @@ async function pickCalkitSetupCommand(
     },
     {
       label: "Windows PowerShell installer",
-      description:
-        'powershell -ExecutionPolicy ByPass -c "irm install-ps1.calkit.org | iex"',
-      command:
-        'powershell -ExecutionPolicy ByPass -c "irm install-ps1.calkit.org | iex"',
+      description: WINDOWS_INSTALL_COMMAND,
+      command: WINDOWS_INSTALL_COMMAND,
+      powershell: true,
     },
     {
       label: "Linux/macOS installer",
-      description: "curl -LsSf install.calkit.org | sh",
-      command: "curl -LsSf install.calkit.org | sh",
+      description: UNIX_INSTALL_COMMAND,
+      command: UNIX_INSTALL_COMMAND,
     },
   ];
 
@@ -1593,7 +1622,7 @@ async function pickCalkitSetupCommand(
     placeHolder: "Choose an installation command to run in terminal",
     matchOnDescription: true,
   });
-  return selected?.command;
+  return selected;
 }
 
 export function deactivate(): void {
@@ -1628,7 +1657,15 @@ async function readDvcYaml(
     if (isFileNotFoundError(error)) {
       return {};
     }
-    log(`Failed to read dvc.yaml: ${String(error)}`);
+    // Logged rather than shown: dvc.yaml is generated from calkit.yaml, so a
+    // syntax error in it is already being reported against its source, and a
+    // read that lands mid-write shouldn't raise a notification.
+    const syntaxError = yamlSyntaxError(error);
+    log(
+      syntaxError
+        ? formatYamlSyntaxError("dvc.yaml", syntaxError)
+        : `Failed to read dvc.yaml: ${String(error)}`,
+    );
     return undefined;
   }
 }
@@ -4099,18 +4136,80 @@ async function readCalkitConfig(
     const bytes = await vscode.workspace.fs.readFile(fileUri);
     const raw = Buffer.from(bytes).toString("utf8");
     const parsed = YAML.parse(raw) as CalkitInfo | undefined;
+    clearYamlProblem(fileUri);
     return parsed ?? {};
   } catch (error) {
     if (isFileNotFoundError(error)) {
+      clearYamlProblem(fileUri);
       return {};
     }
-    void vscode.window.showErrorMessage(
-      `Failed to read calkit.yaml: ${String(error)}`,
-    );
+    reportYamlProblem(fileUri, error);
     return undefined;
   }
 }
 
+// A file we can't read is reported once per distinct problem: the config is
+// re-read on every refresh, so a broken file would otherwise stack up an
+// unbounded pile of identical notifications.
+const reportedYamlProblems = new Map<string, string>();
+
+function clearYamlProblem(fileUri: vscode.Uri): void {
+  reportedYamlProblems.delete(fileUri.fsPath);
+}
+
+function reportYamlProblem(fileUri: vscode.Uri, error: unknown): void {
+  const fileName = path.basename(fileUri.fsPath);
+  const syntaxError = yamlSyntaxError(error);
+  const message = syntaxError
+    ? formatYamlSyntaxError(fileName, syntaxError)
+    : `Failed to read ${fileName}: ${String(error)}`;
+  log(message);
+  if (reportedYamlProblems.get(fileUri.fsPath) === message) {
+    return;
+  }
+  reportedYamlProblems.set(fileUri.fsPath, message);
+  // Not awaited: reads happen during refreshes that shouldn't block on the
+  // user dismissing a notification.
+  void (async () => {
+    const openAction = `Open ${fileName}`;
+    const choice = await vscode.window.showErrorMessage(message, openAction);
+    if (choice === openAction) {
+      await revealYamlProblem(fileUri, syntaxError);
+    }
+  })().catch((openError: unknown) => {
+    // The file can be deleted, or lose read permission, between the
+    // notification and the click, so opening it is allowed to fail.
+    const failure = `Failed to open ${fileName}: ${String(openError)}`;
+    log(failure);
+    void vscode.window.showErrorMessage(failure);
+  });
+}
+
+async function revealYamlProblem(
+  fileUri: vscode.Uri,
+  syntaxError: YamlSyntaxError | undefined,
+): Promise<void> {
+  const document = await vscode.workspace.openTextDocument(fileUri);
+  const editor = await vscode.window.showTextDocument(document);
+  if (syntaxError?.line === undefined) {
+    return;
+  }
+  // The parser reports one-based positions, and it can point past the end of
+  // the file, so clamp before jumping there.
+  const line = Math.min(syntaxError.line - 1, document.lineCount - 1);
+  const position = document.validatePosition(
+    new vscode.Position(
+      Math.max(line, 0),
+      Math.max((syntaxError.column ?? 1) - 1, 0),
+    ),
+  );
+  editor.selection = new vscode.Selection(position, position);
+  editor.revealRange(
+    new vscode.Range(position, position),
+    vscode.TextEditorRevealType.InCenter,
+  );
+}
+
 async function fileExists(fsPath: string): Promise<boolean> {
   try {
     await vscode.workspace.fs.stat(vscode.Uri.file(fsPath));

calkit_python-0.45.2/vscode-ext/src/test/yaml.test.ts

@@ -0,0 +1,54 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import YAML from "yaml";
+
+import { formatYamlSyntaxError, yamlSyntaxError } from "../yaml";
+
+test("yamlSyntaxError describes parse failures and ignores other errors", () => {
+  // A block sequence used as an implicit map key, as reported in issue #1567
+  const raw = [
+    "stages:",
+    "  build:",
+    "    cmd: echo hi",
+    "- --export=ALL",
+  ].join("\n");
+  let caught: unknown;
+  try {
+    YAML.parse(raw);
+  } catch (error) {
+    caught = error;
+  }
+  assert.ok(caught, "expected malformed YAML to throw");
+  const described = yamlSyntaxError(caught);
+  assert.ok(described);
+  // The parser's " at line L, column C:" suffix and source snippet are
+  // stripped, since the position is rendered separately
+  assert.ok(!described.message.includes("at line"));
+  assert.ok(!described.message.includes("\n"));
+  assert.equal(typeof described.line, "number");
+  assert.equal(typeof described.column, "number");
+  // Non-parse errors are left for the caller to handle
+  assert.equal(yamlSyntaxError(new Error("EACCES")), undefined);
+  assert.equal(yamlSyntaxError(undefined), undefined);
+  // Valid YAML doesn't throw at all
+  assert.deepEqual(YAML.parse("a: 1"), { a: 1 });
+});
+
+test("formatYamlSyntaxError names the file and whatever position is known", () => {
+  assert.equal(
+    formatYamlSyntaxError("calkit.yaml", {
+      message: "Bad indent",
+      line: 368,
+      column: 1,
+    }),
+    "calkit.yaml has a YAML syntax error at line 368, column 1: Bad indent",
+  );
+  assert.equal(
+    formatYamlSyntaxError("dvc.yaml", { message: "Bad indent", line: 2 }),
+    "dvc.yaml has a YAML syntax error at line 2: Bad indent",
+  );
+  assert.equal(
+    formatYamlSyntaxError("dvc.yaml", { message: "Bad indent" }),
+    "dvc.yaml has a YAML syntax error: Bad indent",
+  );
+});

calkit_python-0.45.2/vscode-ext/src/yaml.ts

@@ -0,0 +1,47 @@
+import { YAMLParseError } from "yaml";
+
+export interface YamlSyntaxError {
+  /** Parser message, with its trailing position and source snippet removed. */
+  message: string;
+  /** One-based line the parser flagged, if it reported one. */
+  line?: number;
+  /** One-based column the parser flagged, if it reported one. */
+  column?: number;
+}
+
+// The `yaml` package appends " at line L, column C:" plus a snippet of the
+// offending source to every parse error message. That reads poorly in a
+// notification, and we render the position ourselves.
+const POSITION_SUFFIX = / at line \d+, column \d+:?[\s\S]*$/;
+
+/**
+ * Describe a YAML parse failure, or return undefined for other errors.
+ *
+ * Errors from reading the file (missing, unreadable) are not syntax errors,
+ * so callers can keep handling those separately.
+ */
+export function yamlSyntaxError(error: unknown): YamlSyntaxError | undefined {
+  if (!(error instanceof YAMLParseError)) {
+    return undefined;
+  }
+  const pos = error.linePos?.[0];
+  return {
+    message: error.message.replace(POSITION_SUFFIX, "").trim(),
+    line: pos?.line,
+    column: pos?.col,
+  };
+}
+
+/** Render a syntax error as a single line naming the file and position. */
+export function formatYamlSyntaxError(
+  fileName: string,
+  error: YamlSyntaxError,
+): string {
+  const where =
+    error.line === undefined
+      ? ""
+      : error.column === undefined
+      ? ` at line ${error.line}`
+      : ` at line ${error.line}, column ${error.column}`;
+  return `${fileName} has a YAML syntax error${where}: ${error.message}`;
+}

calkit_python-0.45.1/scripts/install.ps1

@@ -1,11 +0,0 @@
-# First, check if uv is installed
-if (-not (Get-Command uv -ErrorAction SilentlyContinue)) {
-    # Install uv
-    powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
-}
-
-# Install Calkit using uv
-uv tool install --upgrade calkit-python --python=3.14
-
-# Install shell completion
-calkit --install-completion