calkit-python 0.35.4__tar.gz → 0.35.6__tar.gz

{calkit_python-0.35.4 → calkit_python-0.35.6}/Makefile

@@ -37,12 +37,17 @@ test-docs: sync-docs ## Test if documentation can be built without warnings or e
 	@uv run mkdocs build -s
 
 .PHONY: sync-docs
-sync-docs: ## Sync documentation content from docs/*.md into README.md.
+sync-docs: cli-reference ## Sync documentation content from docs/*.md into README.md.
 	@echo "🚀 Syncing documentation"
 	@uv run python scripts/sync-docs.py
 
+.PHONY: cli-reference
+cli-reference: ## Generate docs/cli-reference.md from CLI help output.
+	@echo "🚀 Generating CLI reference"
+	@uv run python scripts/generate-cli-reference.py
+
 .PHONY: docs
-docs: ## Build and serve the documentation.
+docs: sync-docs ## Build and serve the documentation.
 	@uv run mkdocs serve --livereload
 
 .PHONY: import-profile

{calkit_python-0.35.4 → calkit_python-0.35.6}/PKG-INFO

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

{calkit_python-0.35.4 → calkit_python-0.35.6}/calkit/conda.py

@@ -9,6 +9,7 @@ import shutil
 import subprocess
 import warnings
 from pathlib import Path
+from typing import cast
 
 import toml
 from packaging.specifiers import SpecifierSet
@@ -123,7 +124,13 @@ def _editable_package_name_from_dir(dir_path: str) -> str:
     elif os.path.isfile(os.path.join(dir_path, "pyproject.toml")):
         # Read pyproject.toml to get the package name
         with open(os.path.join(dir_path, "pyproject.toml")) as f:
-            pyproject = toml.load(f)
+            try:
+                pyproject = toml.load(f)
+            except Exception as e:
+                raise type(e)(
+                    f"Failed to load pyproject.toml from {dir_path}; "
+                    "check that it is valid TOML"
+                ) from e
         if "project" in pyproject:
             if "name" in pyproject["project"]:
                 return pyproject["project"]["name"]
@@ -139,6 +146,7 @@ def _check_single(
     """
     # If this is an editable install it needs to be handled specially
     # It also needs to be relative to the env spec dir
+    editable = False
     if req.startswith("-e ") or req.startswith("--editable "):
         req = req.split(" ", 1)[1]
         if "#" in req:
@@ -147,6 +155,7 @@ def _check_single(
         # Create path relative to env spec dir
         req = os.path.join(env_spec_dir, req)
         req = _editable_package_name_from_dir(req)
+        editable = True
     # If this is a Git version, we can't check it
     # TODO: Clone Git repos to check?
     if "@git" in req:
@@ -182,7 +191,7 @@ def _check_single(
         # TODO: Check exact version only
         return True
     spec = SpecifierSet(req_spec)
-    return spec.contains(version)
+    return spec.contains(version, prereleases=editable)
 
 
 def _check_list(
@@ -193,6 +202,10 @@ def _check_list(
     if "::" in req:
         req = req.split("::", 1)[1]
     for installed in actual:
+        if not isinstance(installed, str):
+            raise ValueError(
+                f"Expected installed package to be a string, got {installed}"
+            )
         if _check_single(
             req, installed, env_spec_dir=env_spec_dir, conda=conda
         ):
@@ -200,6 +213,46 @@ def _check_list(
     return False
 
 
+def _split_env_dependencies(
+    dependencies: list[str | dict[str, str | list[str]]],
+) -> tuple[list[str], list[str]]:
+    """Split an environment dependency list into conda and pip deps.
+
+    Conda environment files commonly include both the plain ``"pip"`` package
+    marker and a nested ``{"pip": [...]}`` section. This helper normalizes the
+    latter so callers do not need to assume it is the final list entry or that
+    the pip section is already represented as a list.
+    """
+    conda_deps = []
+    pip_deps = []
+    for dep in dependencies:
+        if isinstance(dep, dict):
+            dep_pip = dep.get("pip", [])
+            if isinstance(dep_pip, str):
+                dep_pip = [dep_pip]
+            elif dep_pip is None:
+                dep_pip = []
+            pip_deps.extend(dep_pip)
+        else:
+            conda_deps.append(dep)
+    return conda_deps, pip_deps
+
+
+def _get_pip_dependency_list(
+    dependencies: list[str | dict[str, str | list[str]]],
+) -> list[str]:
+    """Return a mutable pip dependency list from an env dependency list."""
+    for dep in dependencies:
+        if isinstance(dep, dict) and "pip" in dep:
+            dep_pip = dep["pip"]
+            if isinstance(dep_pip, str):
+                dep["pip"] = [dep_pip]
+            elif dep_pip is None:
+                dep["pip"] = []
+            return cast(list[str], dep["pip"])
+    return []
+
+
 class EnvCheckResult(BaseModel):
     env_exists: bool | None = None
     env_needs_export: bool | None = None
@@ -393,18 +446,12 @@ def check_env(
                 ryaml.dump(env_check, f)
         # Determine if the env matches
         env_needs_rebuild = False
-        if isinstance(env_check["dependencies"][-1], dict):
-            existing_conda_deps = env_check["dependencies"][:-1]
-            existing_pip_deps = env_check["dependencies"][-1]["pip"]
-        else:
-            existing_conda_deps = env_check["dependencies"]
-            existing_pip_deps = []
-        if isinstance(env_spec["dependencies"][-1], dict):
-            required_conda_deps = env_spec["dependencies"][:-1]
-            required_pip_deps = env_spec["dependencies"][-1]["pip"]
-        else:
-            required_conda_deps = env_spec["dependencies"]
-            required_pip_deps = []
+        existing_conda_deps, existing_pip_deps = _split_env_dependencies(
+            env_check["dependencies"]
+        )
+        required_conda_deps, required_pip_deps = _split_env_dependencies(
+            env_spec["dependencies"]
+        )
         if relaxed:
             log_func("Running in relaxed mode; combining pip and conda deps")
             for dep in existing_pip_deps:
@@ -516,20 +563,23 @@ def check_env(
         # Note that this needs to be relative to the env lock directory,
         # since that's how pip will interpret it
         editable_pip_deps = {}
-        if isinstance(env_spec["dependencies"][-1], dict):
-            # Map editable install dir to package name we'd see in lock
-            required_pip_deps = env_spec["dependencies"][-1]["pip"]
-            for dep in required_pip_deps:
-                if dep.startswith("-e ") or dep.startswith("--editable "):
-                    dir_path = dep.split(" ", 1)[1]
-                    if "#" in dir_path:
-                        dir_path = dir_path.split("#", 1)[0]
-                    dir_path = dir_path.strip()
-                    dir_path = os.path.join(env_spec_dir, dir_path)
-                    pkg_name = _editable_package_name_from_dir(dir_path)
-                    editable_pip_deps[pkg_name] = dir_path
-        if isinstance(env_export["dependencies"][-1], dict):
-            export_pip_deps = env_export["dependencies"][-1]["pip"]
+        required_pip_deps = _get_pip_dependency_list(env_spec["dependencies"])
+        for dep in required_pip_deps:
+            if dep.startswith("-e ") or dep.startswith("--editable "):
+                dir_path = dep.split(" ", 1)[1]
+                if "#" in dir_path:
+                    dir_path = dir_path.split("#", 1)[0]
+                dir_path = dir_path.strip()
+                dir_path = os.path.join(env_spec_dir, dir_path)
+                pkg_name = _editable_package_name_from_dir(dir_path)
+                if verbose:
+                    log_func(
+                        f"Found editable pip dependency '{pkg_name}' "
+                        f"at '{dir_path}'"
+                    )
+                editable_pip_deps[pkg_name] = dir_path
+        export_pip_deps = _get_pip_dependency_list(env_export["dependencies"])
+        if export_pip_deps:
             for i, dep in enumerate(export_pip_deps):
                 dep_name = re.split("[=<>]+", dep, maxsplit=1)[0]
                 if dep_name in editable_pip_deps:

calkit_python-0.35.6/calkit/git.py

@@ -0,0 +1,297 @@
+"""Git-related functionality."""
+
+from __future__ import annotations
+
+import os
+from os import PathLike
+from pathlib import Path
+
+import git
+
+
+def get_staged_files(
+    path: str | None = None, repo: git.Repo | None = None
+) -> list[str]:
+    """Get a list of staged files for the repo at ``path`` or the provided
+    repo.
+    """
+    if repo is None:
+        repo = git.Repo(path)
+    cmd = ["--staged", "--name-only"]
+    if path is not None:
+        cmd.append(path)
+    diff = repo.git.diff(cmd)
+    paths = diff.split("\n")
+    return [p for p in paths if p]
+
+
+def get_changed_files(
+    path: str | None = None, repo: git.Repo | None = None
+) -> list[str]:
+    """Get a list of files that have been changed but not staged."""
+    if repo is None:
+        repo = git.Repo(path)
+    return [
+        item.a_path
+        for item in repo.index.diff(None)
+        if item.a_path is not None
+    ]
+
+
+def get_untracked_files(
+    path: str | None = None, repo: git.Repo | None = None
+) -> list[str]:
+    """Get a list of untracked files."""
+    if repo is None:
+        repo = git.Repo(path)
+    return repo.untracked_files
+
+
+def get_staged_files_with_status(
+    path: str | None = None, repo: git.Repo | None = None
+) -> list[dict]:
+    if repo is None:
+        repo = git.Repo(path)
+    cmd = ["--staged", "--name-status"]
+    if path is not None:
+        cmd.append(path)
+    diff = repo.git.diff(cmd)
+    paths = diff.split("\n")
+    res = []
+    for pathi in paths:
+        # Make sure line is not empty, e.g., a trailing newline
+        if pathi:
+            status, p = pathi.split("\t")
+            res.append({"status": status, "path": p})
+    return res
+
+
+def ls_files(repo: git.Repo, *args, **kwargs) -> list[str]:
+    """Get a list of all files tracked by git."""
+    output = repo.git.ls_files(*args, **kwargs)
+    return [f for f in output.split("\n") if f]
+
+
+def _resolve_repo_and_ignore_path(
+    repo: git.Repo, path: str | PathLike
+) -> tuple[git.Repo, str]:
+    """Resolve which repo should own ignore rules for ``path``."""
+    # Normalize target path to absolute from the current repo root.
+    repo_root = Path(repo.working_dir).resolve()
+    path_obj = Path(path)
+    if path_obj.is_absolute():
+        abs_path = path_obj.resolve()
+    else:
+        abs_path = (repo_root / path_obj).resolve()
+    # If the path is inside a submodule, use that repo and relative path.
+    for submodule in repo.submodules:
+        submodule_root = (repo_root / submodule.path).resolve()
+        if abs_path == submodule_root:
+            continue
+        if abs_path.is_relative_to(submodule_root):
+            sub_repo = submodule.module()
+            rel_path = abs_path.relative_to(submodule_root).as_posix()
+            return sub_repo, rel_path
+    # Fall back to a repo-relative path when possible.
+    try:
+        rel_path = abs_path.relative_to(repo_root).as_posix()
+    except ValueError:
+        rel_path = path_obj.as_posix()
+    return repo, rel_path
+
+
+def _get_matching_gitignore_details(
+    repo: git.Repo, path: str
+) -> tuple[Path | None, str | None]:
+    """Return the repo-local gitignore file and pattern matching ``path``."""
+    try:
+        check_ignore = repo.git.check_ignore("-v", "--", path)
+    except git.GitCommandError:
+        return None, None
+    line = check_ignore.splitlines()[0]
+    try:
+        source_info, _ = line.split("\t", 1)
+        source_path, _, pattern = source_info.rsplit(":", 2)
+    except ValueError:
+        return None, None
+    if not source_path.endswith(".gitignore"):
+        return None, pattern
+    gitignore_path = (Path(repo.working_dir) / source_path).resolve()
+    try:
+        gitignore_path.relative_to(Path(repo.working_dir).resolve())
+    except ValueError:
+        return None, pattern
+    return gitignore_path, pattern
+
+
+def ensure_path_is_ignored(
+    repo: git.Repo, path: str | PathLike
+) -> None | bool:
+    """Ensure that the given path is ignored by Git.
+
+    Returns True if ``.gitignore`` was modified.
+    """
+    # Resolve whether the ignore rule belongs to this repo or a submodule.
+    target_repo, target_path = _resolve_repo_and_ignore_path(repo, path)
+    # No-op if Git already ignores this path.
+    if target_repo.ignored(target_path):
+        return
+    # Read gitignore first to check if the path is already ignored
+    # If not, we don't want to add a line for it since it was added
+    # TODO: Add an option to remove cached (`git rm --cached`)
+    gitignore_path = os.path.join(target_repo.working_dir, ".gitignore")
+    if os.path.isfile(gitignore_path):
+        with open(gitignore_path) as f:
+            gitignore_txt = f.read()
+        lines = gitignore_txt.splitlines()
+        if target_path in lines:
+            return
+    with open(gitignore_path, "a") as f:
+        if (
+            os.path.isfile(gitignore_path)
+            and os.path.getsize(gitignore_path) > 0
+        ):
+            f.write("\n")
+        f.write(f"{target_path}\n")
+        return True
+
+
+def ensure_path_is_not_ignored(
+    repo: git.Repo, path: str | PathLike
+) -> None | bool:
+    """Ensure a path is not ignored by Git."""
+    # Resolve whether the unignore rule belongs to this repo or a submodule.
+    target_repo, target_path = _resolve_repo_and_ignore_path(repo, path)
+    # No-op if Git does not ignore this path.
+    if not target_repo.ignored(target_path):
+        return
+    matching_gitignore_path, matched_pattern = _get_matching_gitignore_details(
+        target_repo, target_path
+    )
+    if matching_gitignore_path is not None:
+        gitignore_path = matching_gitignore_path.as_posix()
+        path_for_gitignore = (
+            (Path(target_repo.working_dir) / target_path)
+            .resolve()
+            .relative_to(matching_gitignore_path.parent.resolve())
+            .as_posix()
+        )
+    else:
+        gitignore_path = os.path.join(target_repo.working_dir, ".gitignore")
+        path_for_gitignore = target_path
+    if not os.path.isfile(gitignore_path):
+        with open(gitignore_path, "w") as f:
+            f.write(f"!{path_for_gitignore}\n")
+        return True
+    with open(gitignore_path) as f:
+        gitignore_txt = f.read()
+    lines = gitignore_txt.splitlines()
+    direct_rule_variants = [path_for_gitignore, f"/{path_for_gitignore}"]
+    if matched_pattern is not None and matched_pattern.startswith("/"):
+        no_ignore_line = f"!/{path_for_gitignore}"
+    else:
+        no_ignore_line = f"!{path_for_gitignore}"
+    path_parts = Path(path_for_gitignore).parts
+
+    def ancestor_requires_recursive_unignore() -> bool:
+        """Return True if any ancestor-level ignore rule would block this path.
+
+        This includes explicit directory ignores (e.g. 'dir/' or '/dir/')
+        as well as ancestor-based glob patterns like 'dir/*' or '/dir/*',
+        i.e., any rule that would prevent reaching the nested path without
+        adding recursive unignore patterns.
+        """
+        for i in range(1, len(path_parts)):
+            ancestor = "/".join(path_parts[:i])
+            if (
+                ancestor in lines
+                or f"/{ancestor}" in lines
+                or f"{ancestor}/" in lines
+                or f"/{ancestor}/" in lines
+                or f"{ancestor}/*" in lines
+                or f"/{ancestor}/*" in lines
+            ):
+                return True
+        return False
+
+    if len(path_parts) == 1:
+        # Simple (non-nested) path: remove the direct ignore rule, or add a
+        # negation if the ignore comes from a glob or other pattern
+        direct_rule = next(
+            (rule for rule in direct_rule_variants if rule in lines), None
+        )
+        if direct_rule is not None:
+            lines.remove(direct_rule)
+        else:
+            # Remove any stale negation and re-append at the end so it takes
+            # precedence over any later re-ignore rule
+            if no_ignore_line in lines:
+                lines.remove(no_ignore_line)
+            lines.append(no_ignore_line)
+    else:
+        # Nested path: only apply recursive un-ignore rules when an ancestor
+        # directory is explicitly ignored
+        # Otherwise, remove a direct ignore
+        # rule for this path or add a simple negation if needed
+        removed_direct_rule = False
+        direct_rule = next(
+            (rule for rule in direct_rule_variants if rule in lines), None
+        )
+        if direct_rule is not None:
+            lines.remove(direct_rule)
+            removed_direct_rule = True
+        if ancestor_requires_recursive_unignore():
+            # Git will not traverse into a directory excluded by a "dir/"
+            # pattern, so a bare "!dir/sub/file" negation has no effect.
+            # We need to:
+            #   1. Convert any "ancestor/" (or "ancestor") exclude to
+            #      "ancestor/*" so git traverses the directory while still
+            #      ignoring direct children by default.
+            #   2. Add "!ancestor/" rules for intermediate directories.
+            #   3. Add "ancestor/*" re-ignore rules for each intermediate dir.
+            #   4. Add "!target_path" for the specific file.
+            for i in range(1, len(path_parts)):
+                ancestor = "/".join(path_parts[:i])
+                reignore_glob = f"{ancestor}/*"
+                if f"{ancestor}/" in lines:
+                    idx = lines.index(f"{ancestor}/")
+                    lines[idx] = reignore_glob
+                elif f"/{ancestor}/" in lines:
+                    idx = lines.index(f"/{ancestor}/")
+                    lines[idx] = f"/{ancestor}/*"
+                elif ancestor in lines:
+                    idx = lines.index(ancestor)
+                    lines[idx] = reignore_glob
+                elif f"/{ancestor}" in lines:
+                    idx = lines.index(f"/{ancestor}")
+                    lines[idx] = f"/{ancestor}/*"
+                no_ignore_dir = f"!{ancestor}/"
+                anchored_no_ignore_dir = f"!/{ancestor}/"
+                # The first ancestor does not need an explicit un-ignore once
+                # converted to "ancestor/*". Deeper ancestors do.
+                if i > 1:
+                    # Remove stale entry and re-append so it takes precedence
+                    if no_ignore_dir in lines:
+                        lines.remove(no_ignore_dir)
+                    elif anchored_no_ignore_dir in lines:
+                        lines.remove(anchored_no_ignore_dir)
+                    lines.append(no_ignore_dir)
+                if (
+                    reignore_glob not in lines
+                    and f"/{ancestor}/*" not in lines
+                ):
+                    lines.append(reignore_glob)
+            # Remove stale negation and re-append at the end so it takes
+            # precedence over any later re-ignore rule
+            if no_ignore_line in lines:
+                lines.remove(no_ignore_line)
+            lines.append(no_ignore_line)
+        elif not removed_direct_rule:
+            # The path may be ignored by a non-directory pattern (e.g., glob);
+            # remove stale negation and append at end so it takes precedence
+            if no_ignore_line in lines:
+                lines.remove(no_ignore_line)
+            lines.append(no_ignore_line)
+    with open(gitignore_path, "w") as f:
+        f.write(os.linesep.join(lines))
+    return True

{calkit_python-0.35.4 → calkit_python-0.35.6}/calkit/overleaf.py

@@ -317,6 +317,32 @@ class OverleafSyncPaths:
             - self.files_in_overleaf_last_sync
         )
 
+    @cached_property
+    def dvc_files(self) -> set[str]:
+        """Files tracked by DVC within the Overleaf project folder.
+
+        These paths are relative to the project directory (i.e., relative to
+        the Overleaf repo root). Files tracked by DVC may not exist on disk if
+        they haven't been pulled, but should still be kept on Overleaf rather
+        than deleted.
+        """
+        try:
+            import calkit.dvc
+
+            dvc_paths = calkit.dvc.list_paths(
+                wdir=str(self.main_repo.working_dir), recursive=True
+            )
+        except Exception as e:
+            warnings.warn(f"Could not list DVC files: {e}")
+            return set()
+        prefix = Path(self.path_in_project).as_posix().rstrip("/") + "/"
+        result = set()
+        for p in dvc_paths:
+            p_posix = Path(p).as_posix()
+            if p_posix.startswith(prefix):
+                result.add(p_posix[len(prefix) :])
+        return result
+
     @cached_property
     def files_to_keep_on_overleaf(self) -> set[str]:
         """Files that should be preserved on Overleaf.
@@ -324,9 +350,14 @@ class OverleafSyncPaths:
         This includes:
         1. All files being copied from local
         2. Any files newly added on Overleaf since last sync
+        3. Any files tracked by DVC within the project path (these may not
+           exist on disk if not pulled, but should not be deleted from
+           Overleaf)
         """
         return (
-            set(self.files_to_copy_to_overleaf) | self.newly_added_on_overleaf
+            set(self.files_to_copy_to_overleaf)
+            | self.newly_added_on_overleaf
+            | self.dvc_files
         )
 
     @cached_property

{calkit_python-0.35.4 → calkit_python-0.35.6}/calkit/pipeline.py

@@ -117,6 +117,20 @@ def to_dvc(
     except Exception as e:
         raise ValueError(f"Pipeline is not defined properly: {e}")
     dvc_stages = {}
+    # Read existing dvc.yaml now so we can clean up stale .gitignore entries
+    # when stage outputs are renamed or removed
+    if write:
+        dvc_yaml_path = os.path.join(wdir, "dvc.yaml") if wdir else "dvc.yaml"
+        if os.path.isfile(dvc_yaml_path):
+            with open(dvc_yaml_path) as f:
+                existing_dvc_yaml = calkit.ryaml.load(f)
+        else:
+            existing_dvc_yaml = {}
+        if existing_dvc_yaml is None:
+            existing_dvc_yaml = {}
+        existing_dvc_stages = existing_dvc_yaml.get("stages", {})
+    else:
+        existing_dvc_stages = {}
     # First, gather up any env lock paths we might need for DVC deps
     used_envs = set(
         [stage.inner_environment for stage in pipeline.stages.values()]
@@ -227,6 +241,17 @@ def to_dvc(
                 outputs += stage.notebook_outputs
             elif stage.kind == "sbatch":
                 outputs.append(stage.log_output)
+            # Build the set of current DVC output paths so we can detect stale
+            # .gitignore entries from the previous version of the stage,
+            # including synthesized outputs like LaTeX PDFs
+            current_out_paths = set(calkit.dvc.out_paths_from_stage(dvc_stage))
+            # If this stage already existed, un-ignore any outputs that have
+            # been renamed or removed so .gitignore does not accumulate stale
+            # entries (e.g., after a capitalization change in the path)
+            old_stage = existing_dvc_stages.get(stage_name, {})
+            for old_path in calkit.dvc.out_paths_from_stage(old_stage):
+                if old_path not in current_out_paths:
+                    calkit.git.ensure_path_is_not_ignored(repo, path=old_path)
             # Deal with any gitignore changes necessary
             for out in outputs:
                 if isinstance(out, PathOutput) and out.storage is None:
@@ -268,14 +293,8 @@ def to_dvc(
                         else:
                             dvc_stages[stage_name]["deps"].append(out)
     if write:
-        if os.path.isfile("dvc.yaml"):
-            with open("dvc.yaml") as f:
-                dvc_yaml = calkit.ryaml.load(f)
-        else:
-            dvc_yaml = {}
-        if dvc_yaml is None:
-            dvc_yaml = {}
-        existing_stages = dvc_yaml.get("stages", {})
+        dvc_yaml = existing_dvc_yaml
+        existing_stages = existing_dvc_stages
         for stage_name, stage in existing_stages.items():
             # Skip private stages (ones whose names start with an underscore)
             # and stages that are automatically generated

{calkit_python-0.35.4 → calkit_python-0.35.6}/calkit/tests/cli/test_overleaf.py

@@ -181,6 +181,44 @@ def test_overleaf(tmp_dir):
     subprocess.run(["calkit", "overleaf", "sync", "--verbose"], check=True)
     print("Overleaf Git show after adding fig2 back:", ol_repo.git.show())
     assert "ol-project/figs/fig2.txt" in ls_files(repo)
+    # Test that if a file is deleted from Git but added to DVC, it is not
+    # deleted from Overleaf (the file still logically exists in the DVC repo)
+    with open(
+        os.path.join(repo.working_dir, "ol-project", "figs", "fig3.txt"), "w"
+    ) as f:
+        f.write("Fig3 created in main repo")
+    repo.git.add("ol-project/figs/fig3.txt")
+    repo.git.commit(["-m", "Add figure 3"])
+    assert "ol-project/figs/fig3.txt" in ls_files(repo)
+    subprocess.run(["calkit", "overleaf", "sync", "--verbose"], check=True)
+    ol_repo_git_show = ol_repo.git.show()
+    assert "diff --git a/figs/fig3.txt b/figs/fig3.txt" in ol_repo_git_show
+    # Now move from Git to DVC: first remove from Git index (keeping file on
+    # disk), then add to DVC so it gets moved to DVC cache
+    repo.git.rm(["--cached", "ol-project/figs/fig3.txt"])
+    subprocess.run(
+        ["dvc", "add", "ol-project/figs/fig3.txt"],
+        check=True,
+        cwd=repo.working_dir,
+    )
+    # Commit the DVC pointer file (fig3.txt is now tracked by DVC, not Git)
+    repo.git.add("ol-project/figs/fig3.txt.dvc", "ol-project/figs/.gitignore")
+    repo.git.commit(["-m", "Move figure 3 from git to DVC"])
+    assert "ol-project/figs/fig3.txt" not in ls_files(repo)
+    # Also remove the local file to simulate the file not being pulled from
+    # DVC (i.e., only the DVC pointer exists locally, not the actual file)
+    fig3_path = os.path.join(
+        repo.working_dir, "ol-project", "figs", "fig3.txt"
+    )
+    if os.path.exists(fig3_path):
+        os.remove(fig3_path)
+    assert not os.path.exists(fig3_path)
+    subprocess.run(["calkit", "overleaf", "sync", "--verbose"], check=True)
+    ol_repo_git_show = ol_repo.git.show()
+    print("Git show in OL repo after moving fig3 to DVC:\n", ol_repo_git_show)
+    # The file should not have been deleted from Overleaf
+    assert "deleted file mode" not in ol_repo_git_show
+    assert "--- a/figs/fig3.txt" not in ol_repo_git_show
 
 
 def test_extract_title_from_tex(tmp_dir):