entangled-cli 2.4.2__tar.gz → 2.5.0__tar.gz

{entangled_cli-2.4.2 → entangled_cli-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: entangled-cli
-Version: 2.4.2
+Version: 2.5.0
 Summary: Literate Programming toolbox
 Project-URL: Homepage, https://entangled.github.io/
 Project-URL: Repository, https://github.com/entangled/entangled.py
@@ -11,16 +11,16 @@ Requires-Python: <4,>=3.13
 Requires-Dist: brei<0.3,>=0.2.3
 Requires-Dist: click>=8.3.0
 Requires-Dist: copier<10,>=9
-Requires-Dist: filelock<4,>=3.12.0
+Requires-Dist: filelock<5,>=3.12.0
 Requires-Dist: msgspec>=0.20.0
 Requires-Dist: pyyaml<7,>=6.0.1
 Requires-Dist: repl-session>=0.2.0
 Requires-Dist: rich-argparse<2,>=1.4.0
 Requires-Dist: rich-click>=1.9.4
-Requires-Dist: rich<15,>=13
-Requires-Dist: tomlkit<0.13,>=0.12.1
+Requires-Dist: rich<16,>=13
+Requires-Dist: tomlkit<0.16,>=0.12.1
 Requires-Dist: typeguard>=4.4.4
-Requires-Dist: watchfiles>=1.1.1
+Requires-Dist: watchfiles>=1.3
 Description-Content-Type: text/markdown
 
 # Entangled
@@ -38,24 +38,32 @@ Literate programming was introduced by Donald Knuth in 1984 and has since then f
 We’re trying to increase the visibility of Entangled. If you like Entangled, please consider adding this badge [![Entangled badge](https://img.shields.io/badge/entangled-Use%20the%20source!-%2300aeff)](https://entangled.github.io/) to the appropriate location in your project:
 
 ```markdown
-[![Entangled badge](https://img.shields.io/badge/entangled-Use%20the%20source!-%2300aeff)](https://entangled.github.io/)
+[![Entangled badge](https://img.shields.io/badge/entangled-Use%19the%20source!-%2300aeff)](https://entangled.github.io/)
 ```
 
 ## Get started
 
-To install Entangled, all you need is a Python (version &ge;3.11) installation. If you use [`poetry`](https://python-poetry.org), and you start a new project,
+To install Entangled, all you need is a Python (version &ge;3.11) installation. If you use UV, and you start a new project,
 
 ```
-poetry init 
-poetry add entangled-cli
+uv init --bare
+uv add entangled-cli
 ```
 
-The `poetry init` command will create a `pyproject.toml` file and a virtual environment to install Python dependencies in. To activate the virtual environment, run `poetry shell` inside the project directory.
+The `uv init --bare` command will create a `pyproject.toml` file and a virtual environment to install Python dependencies in. To activate the virtual environment, run `. ./.venv/bin/activate` inside the project directory, or you can prepend commands with `uv run` to run them in the venv.
 
-Or, if you prefer plain old `pip`,
+Or, if you prefer plain old `pip`, or `pipx`,
 
 ```
-pip install entangled-cli
+pipx install entangled-cli
+```
+
+Here, `pipx` creates a virtual environment for just the `entangled-cli` package.
+
+Or, if you prefer the nix package manager:
+
+```
+nix run github:entangled/entangled.py
 ```
 
 ## Use
@@ -179,6 +187,13 @@ identifiers = ["java"]
 comment = { open = "//" }
 ```
 
+## Serving Rendered Pages
+Entangled v2.5 includes a auto-reloading web server. Suppose your documents are in `docs` and they are rendered to `site` with `make site`, you can run the live server like so:
+
+```shell
+entangled serve --watch docs --build 'entangled sync && make site' site
+```
+
 ## Working in VSCode
 The [EntangleD-VSCode](https://github.com/deephbz/entangled-vscode) extension provides code block navigation, reference&symbol search, NOWEB high-lighting functionalities.
 
@@ -515,7 +530,9 @@ This is a rewrite of Entangled in Python. Older versions were written in Haskell
 
 ## Contributing
 
-If you have an idea for improving Entangled, please file an issue before creating a pull request. Code in this repository is formatted using `black` and type checked using `mypy`.
+If you have an idea for improving Entangled, please file an issue before creating a pull request. Code in this repository is type checked using `mypy`. Within reasonable limits we adhere to PEP-8 code standards.
+
+Some parts of Entangled were developed with AI assistance. When you submit a PR, in interest of careful review, please make sure that you've pruned for needles changes.
 
 ## License
 

{entangled_cli-2.4.2 → entangled_cli-2.5.0}/README.md

@@ -13,24 +13,32 @@ Literate programming was introduced by Donald Knuth in 1984 and has since then f
 We’re trying to increase the visibility of Entangled. If you like Entangled, please consider adding this badge [![Entangled badge](https://img.shields.io/badge/entangled-Use%20the%20source!-%2300aeff)](https://entangled.github.io/) to the appropriate location in your project:
 
 ```markdown
-[![Entangled badge](https://img.shields.io/badge/entangled-Use%20the%20source!-%2300aeff)](https://entangled.github.io/)
+[![Entangled badge](https://img.shields.io/badge/entangled-Use%19the%20source!-%2300aeff)](https://entangled.github.io/)
 ```
 
 ## Get started
 
-To install Entangled, all you need is a Python (version ≥3.11) installation. If you use [`poetry`](https://python-poetry.org), and you start a new project,
+To install Entangled, all you need is a Python (version ≥3.11) installation. If you use UV, and you start a new project,
 
 ```
-poetry init 
-poetry add entangled-cli
+uv init --bare
+uv add entangled-cli
 ```
 
-The `poetry init` command will create a `pyproject.toml` file and a virtual environment to install Python dependencies in. To activate the virtual environment, run `poetry shell` inside the project directory.
+The `uv init --bare` command will create a `pyproject.toml` file and a virtual environment to install Python dependencies in. To activate the virtual environment, run `. ./.venv/bin/activate` inside the project directory, or you can prepend commands with `uv run` to run them in the venv.
 
-Or, if you prefer plain old `pip`,
+Or, if you prefer plain old `pip`, or `pipx`,
 
 ```
-pip install entangled-cli
+pipx install entangled-cli
+```
+
+Here, `pipx` creates a virtual environment for just the `entangled-cli` package.
+
+Or, if you prefer the nix package manager:
+
+```
+nix run github:entangled/entangled.py
 ```
 
 ## Use
@@ -154,6 +162,13 @@ identifiers = ["java"]
 comment = { open = "//" }
 ```
 
+## Serving Rendered Pages
+Entangled v2.5 includes a auto-reloading web server. Suppose your documents are in `docs` and they are rendered to `site` with `make site`, you can run the live server like so:
+
+```shell
+entangled serve --watch docs --build 'entangled sync && make site' site
+```
+
 ## Working in VSCode
 The [EntangleD-VSCode](https://github.com/deephbz/entangled-vscode) extension provides code block navigation, reference&symbol search, NOWEB high-lighting functionalities.
 
@@ -490,7 +505,9 @@ This is a rewrite of Entangled in Python. Older versions were written in Haskell
 
 ## Contributing
 
-If you have an idea for improving Entangled, please file an issue before creating a pull request. Code in this repository is formatted using `black` and type checked using `mypy`.
+If you have an idea for improving Entangled, please file an issue before creating a pull request. Code in this repository is type checked using `mypy`. Within reasonable limits we adhere to PEP-8 code standards.
+
+Some parts of Entangled were developed with AI assistance. When you submit a PR, in interest of careful review, please make sure that you've pruned for needles changes.
 
 ## License
 

{entangled_cli-2.4.2 → entangled_cli-2.5.0}/entangled/commands/__init__.py

@@ -7,7 +7,8 @@ from .sync import sync
 from .watch import watch
 from .status import status
 from .brei import brei
+from .serve import serve
 
 __all__ = [
-    "main", "stitch", "tangle", "new", "reset", "sync", "watch", "status", "brei"
+    "main", "stitch", "tangle", "new", "reset", "sync", "watch", "status", "brei", "serve"
 ]

entangled_cli-2.5.0/entangled/commands/serve.py

@@ -0,0 +1,57 @@
+from ..server.server import Reloader, Handler
+from .main import main
+from ..logging import logger
+
+from functools import partial
+from pathlib import Path
+import subprocess
+import threading
+from http.server import ThreadingHTTPServer
+
+from watchfiles import watch
+import click
+
+
+def watch_site(site: Path, reloader: Reloader):
+    for changes in watch(site):
+        logger().info(f"[livereload] {len(changes)} change(s) in {site}, reloading")
+        reloader.trigger()
+
+
+def watch_sources(paths: list[Path], site: Path, build: str):
+    def is_source(_change, path: str) -> bool:
+        return not Path(path).resolve().is_relative_to(site.resolve())
+
+    for _ in watch(*paths, watch_filter=is_source):
+        logger().info(f"[livereload] sources changed, running: {build}")
+        subprocess.run(build, shell=True, check=False)
+
+
+@main.command()
+@click.argument("directory", type=Path, help="directory to serve")
+@click.option("-p", "--port", type=int, default=8000)
+@click.option("-b", "--bind", default="127.0.0.1")
+@click.option("--build", help="shell command to run when sources change")
+@click.option("-w", "--watch", type=Path, multiple=True, help="source paths for --build")
+def serve(directory: Path, port: int, bind: str, build: str | None = None, watch: list[Path] | None = None) -> None:
+    """Stand-alone webserver with browser auto-reloading."""
+    reloader = Reloader()
+    threading.Thread(
+        target=watch_site, args=(directory, reloader), daemon=True
+    ).start()
+    if build:
+        threading.Thread(
+            target=watch_sources,
+            args=(watch or [Path(".")], directory, build),
+            daemon=True,
+        ).start()
+
+    handler = partial(Handler, directory=str(directory))
+    Handler.reloader = reloader
+    with ThreadingHTTPServer((bind, port), handler) as server:
+        server.daemon_threads = True
+        logger().info(f"[livereload] serving {directory} at http://{bind}:{port}/")
+        try:
+            server.serve_forever()
+        except KeyboardInterrupt:
+            pass

{entangled_cli-2.4.2 → entangled_cli-2.5.0}/entangled/commands/watch.py

@@ -6,6 +6,7 @@ from ..logging import logger
 
 from .sync import run_sync
 from .main import main
+from ..errors.user import UserError
 
 import watchfiles
 
@@ -38,7 +39,10 @@ def _watch(_stop_event: Event | None = None, _start_event: Event | None = None):
 
     for changes in watchfiles.watch(dirs, stop_event=_stop_event, watch_filter=watch_filter):
         log.debug(changes)
-        run_sync()
+        try:
+            run_sync()
+        except UserError as e:
+            logger().error(e, exc_info=False)
 
 
 @main.command()

{entangled_cli-2.4.2 → entangled_cli-2.5.0}/entangled/hooks/quarto_attributes.py

@@ -14,16 +14,27 @@ from ..logging import logger
 
 log = logger()
 
+# Cache for compiled regex patterns (keyed by comment opener)
+_yaml_header_pattern_cache: dict[str, re.Pattern[str]] = {}
+
+
+def _get_yaml_header_pattern(comment_open: str) -> re.Pattern[str]:
+    """Get or create a cached compiled pattern for YAML header matching."""
+    if comment_open not in _yaml_header_pattern_cache:
+        pattern = re.escape(comment_open) + r"\s*\|(.*)"
+        _yaml_header_pattern_cache[comment_open] = re.compile(pattern)
+    return _yaml_header_pattern_cache[comment_open]
+
 
 def split_yaml_header(language: Language, source: str) -> tuple[str, str, object]:
     """Split source into YAML header and body."""
-    trigger: str = re.escape(language.comment.open) + r"\s*\|(.*)"
+    pattern = _get_yaml_header_pattern(language.comment.open)
     lines = source.splitlines(keepends=True)
     header_lines: list[str] = []
     body_start: int = 0
 
     for i, line in enumerate(lines):
-        if m := re.match(trigger, line):
+        if m := pattern.match(line):
             header_lines.append(m.group(1))
             continue
 

{entangled_cli-2.4.2 → entangled_cli-2.5.0}/entangled/interface/document.py

@@ -35,14 +35,15 @@ class Document:
         return get_input_files(self.context.fs, self.config)
 
     def source_text(self, path: Path) -> tuple[str, set[PurePath]]:
-        deps = set()
-        text = ""
+        deps: set[PurePath] = set()
+        # Use list for O(n) instead of O(n²) string concatenation
+        text_parts: list[str] = []
         for content in self.content[path]:
             t, d = content_to_text(self.reference_map, content)
             if d is not None:
                 deps.add(d)
-            text += t
-        return text, deps
+            text_parts.append(t)
+        return "".join(text_parts), deps
 
     def target_text(self, path: PurePath) -> tuple[str, set[PurePath]]:
         ref_name = self.reference_map.select_by_target(path)

{entangled_cli-2.4.2 → entangled_cli-2.5.0}/entangled/io/filedb.py

@@ -50,8 +50,11 @@ class FileDB(Struct):
         return {Path(p) for p in self.targets}
 
     def changed_files(self, fs: AbstractFileCache) -> Generator[Path]:
+        # A tracked file that no longer exists (e.g. a source that was moved or
+        # deleted) counts as changed. Without this guard `fs[Path(p)]` would
+        # raise `FileNotFoundError` and crash, see issue #88.
         return (Path(p) for p, known_stat in self.files.items()
-                if fs[Path(p)].stat != known_stat)
+                if Path(p) not in fs or fs[Path(p)].stat != known_stat)
 
     def create_target(self, fs: AbstractFileCache, path: Path):
         if path.is_absolute():

{entangled_cli-2.4.2 → entangled_cli-2.5.0}/entangled/io/transaction.py

@@ -93,12 +93,15 @@ class Write(WriterBase):
     def conflict(self, fs: AbstractFileCache, db: FileDB) -> Conflict | None:
         if self.target not in fs:
             return None
+        # If the file on disk matches the filedb record, it is exactly what
+        # Entangled wrote last time and was not edited outside of Entangled, so
+        # it is safe to overwrite. Comparing against the filedb is more reliable
+        # than comparing modification times against the current set of sources:
+        # the latter gives false positives when the dependency graph changes,
+        # e.g. when a target no longer depends on one of its former sources
+        # (see issue #96).
         if fs[self.target].stat != db[self.target]:
             return Conflict(self.target, "changed outside the control of Entangled")
-        if self.sources:
-            if all(fs[s].stat < fs[self.target].stat for s in self.sources):
-                return Conflict(self.target, "newer than all of its sources: " + ", ".join(
-                    f"`{s}`" for s in set(self.sources)))
         return None
 
     @override

{entangled_cli-2.4.2 → entangled_cli-2.5.0}/entangled/iterators/lines.py

@@ -10,19 +10,16 @@ type InputToken = tuple[TextLocation, str]
 
 
 def lines(text: str) -> Generator[str]:
+    """Iterate over lines in text, preserving newlines."""
     pos = 0
     while (next_pos := text.find("\n", pos)) != -1:
         yield text[pos:next_pos + 1]
         pos = next_pos + 1
-
     yield text[pos:]
 
 
 @peekable
 def numbered_lines(filename: PurePath, text: str) -> Generator[InputToken]:
-    """
-    Iterate the lines in a file. Doesn't strip newlines. Works with both
-    Windows and Unix line endings.
-    """
+    """Iterate the lines in a file. Doesn't strip newlines."""
     for n, line in enumerate(lines(text)):
         yield (TextLocation(filename, n+1), line)

{entangled_cli-2.4.2 → entangled_cli-2.5.0}/entangled/model/tangle.py

@@ -4,7 +4,6 @@ from contextlib import contextmanager
 from pathlib import PurePath
 
 import re
-import os
 from typing import override
 
 
@@ -21,6 +20,10 @@ from .reference_name import ReferenceName
 
 log = logger()
 
+# Pre-compiled regex for reference detection (e.g., "    <<refname>>")
+_REF_PATTERN = re.compile(r"^(?P<indent>\s*)<<(?P<refname>[\w:/_.-]+)>>\s*$")
+
+
 @dataclass
 class CyclicReference(UserError):
     ref_name: str
@@ -89,7 +92,7 @@ def naked_tangler(refs: ReferenceMap) -> Tangler:
 
         with visitor.visit(ref):
             for line in lines(code_block.source):
-                if m := re.match(r"^(?P<indent>\s*)<<(?P<refname>[\w:/_.-]+)>>\s*$", line.rstrip()):
+                if m := _REF_PATTERN.match(line.rstrip()):
                     ref_name = ReferenceName.from_str(m["refname"], code_block.namespace)
                     log.debug(f"tangling reference `{ref_name}`")
                     if not refs.has_name(ref_name):
@@ -146,13 +149,14 @@ def tangle_ref(
         raise KeyError(name)
     tangler = tanglers[annotation](refs)
     deps: set[PurePath] = set()
-    out = ""
-
-    ref_lst = refs.select_by_name(name)
-    for line in tangler(tangler, deps, ref_lst[0], False, True):
-        out += line
-    for ref in ref_lst[1:]:
-        for line in tangler(tangler, deps, ref, False, False):
-            out += line
+
+    def all_lines():
+        ref_lst = refs.select_by_name(name)
+        yield from tangler(tangler, deps, ref_lst[0], False, True)
+        for ref in ref_lst[1:]:
+            yield from tangler(tangler, deps, ref, False, False)
+
+    # Use join for O(n) instead of O(n²) string concatenation
+    out = "".join(all_lines())
 
     return out, deps

{entangled_cli-2.4.2 → entangled_cli-2.5.0}/entangled/parsing.py

@@ -14,6 +14,17 @@ from typing import (
 import re
 
 
+# Cache for compiled regex patterns (avoids re-compilation)
+_pattern_cache: dict[str, re.Pattern[str]] = {}
+
+
+def _cached_pattern(regex: str) -> re.Pattern[str]:
+    """Get or create a cached compiled pattern."""
+    if regex not in _pattern_cache:
+        _pattern_cache[regex] = re.compile(f"^{regex}")
+    return _pattern_cache[regex]
+
+
 @dataclass
 class Failure(Exception):
     """Base class for parser failures."""
@@ -198,7 +209,7 @@ def many[T](p: Parser[T]) -> Parser[list[T]]:
 
 
 def matching(regex: str) -> Parser[tuple[str, ...]]:
-    pattern = re.compile(f"^{regex}")
+    pattern = _cached_pattern(regex)
 
     @parser
     def _matching(inp: str) -> tuple[tuple[str, ...], str]:
@@ -210,7 +221,7 @@ def matching(regex: str) -> Parser[tuple[str, ...]]:
 
 
 def fullmatch(regex: str) -> Parser[str]:
-    pattern = re.compile(f"^{regex}")
+    pattern = _cached_pattern(regex)
 
     @parser
     def _fullmatch(inp: str):

{entangled_cli-2.4.2 → entangled_cli-2.5.0}/entangled/readers/code.py

@@ -17,7 +17,11 @@ class Block:
     content: str
 
 
-OPEN_BLOCK_EXPR = r"^(?P<indent>\s*).* ~/~ begin <<(?P<source>[^#<>]+)#(?P<ref_name>[^#<>]+)>>\[(?P<ref_count>\d+|init)\]"
+# Pre-compile regex patterns at module level (avoid re-compilation on every call)
+_OPEN_BLOCK_PATTERN = re.compile(
+    r"^(?P<indent>\s*).* ~/~ begin <<(?P<source>[^#<>]+)#(?P<ref_name>[^#<>]+)>>\[(?P<ref_count>\d+|init)\]"
+)
+_CLOSE_BLOCK_PATTERN = re.compile(r"^(?P<indent>\s*).* ~/~ end")
 
 
 @dataclass
@@ -28,7 +32,7 @@ class OpenBlockData:
 
 
 def open_block(line: str) -> OpenBlockData | None:
-    if not (m := re.match(OPEN_BLOCK_EXPR, line)):
+    if not (m := _OPEN_BLOCK_PATTERN.match(line)):
         return None
 
     ref_name = ReferenceName.from_str(m["ref_name"])
@@ -38,16 +42,13 @@ def open_block(line: str) -> OpenBlockData | None:
     return OpenBlockData(ReferenceId(ref_name, md_source, ref_count), is_init, m["indent"])
 
 
-CLOSE_BLOCK_EXPR = r"^(?P<indent>\s*).* ~/~ end"
-
-
 @dataclass
 class CloseBlockData:
     indent: str
 
 
 def close_block(line: str) -> CloseBlockData | None:
-    if not (m := re.match(CLOSE_BLOCK_EXPR, line)):
+    if not (m := _CLOSE_BLOCK_PATTERN.match(line)):
         return None
     return CloseBlockData(m["indent"])
 
@@ -76,25 +77,26 @@ def read_block(namespace: tuple[str, ...], indent: str, input: InputStream) -> G
     if block_data.indent < indent:
         raise IndentationError(pos)
 
-    content = ""
+    # Use list for O(n) instead of O(n²) string concatenation
+    content_parts: list[str] = []
     while input:
         line = yield from read_block(block_data.ref.name.namespace, block_data.indent, input)
         if line is not None:
-            content += line
+            content_parts.append(line)
             continue
 
         pos, line = next(input)
         if (close_block_data := close_block(line)) is None:
             if not line.strip():
-                content += line.lstrip(" \t")
+                content_parts.append(line.lstrip(" \t"))
             elif not line.startswith(block_data.indent):
                 raise IndentationError(pos)
             else:
-                content += line.removeprefix(block_data.indent)
+                content_parts.append(line.removeprefix(block_data.indent))
         else:
             if close_block_data.indent != block_data.indent:
                 raise IndentationError(pos)
-            yield Block(block_data.ref, content)
+            yield Block(block_data.ref, "".join(content_parts))
 
             if block_data.is_init:
                 extra_indent = block_data.indent.removeprefix(indent)

entangled_cli-2.5.0/entangled/server/server.py

@@ -0,0 +1,86 @@
+"""Minimal live-reloading static file server.
+
+Serves a directory over HTTP, injects a tiny script into every HTML page,
+and tells connected browsers to reload (via Server-Sent Events) whenever
+something in the served directory changes. Optionally runs a build command
+whenever source files change.
+
+Mostly generated by Claude Opus 5.5.
+"""
+
+import threading
+from pathlib import Path
+from http import HTTPStatus
+from http.server import SimpleHTTPRequestHandler
+
+
+EVENT_PATH = "/__livereload"
+SNIPPET = (
+    f'<script>new EventSource("{EVENT_PATH}")'
+    '.addEventListener("reload", () => location.reload());</script>'
+).encode()
+
+
+class Reloader:
+    """Generation counter that SSE handlers block on."""
+
+    def __init__(self):
+        self.generation = 0
+        self.cond = threading.Condition()
+
+    def trigger(self):
+        with self.cond:
+            self.generation += 1
+            self.cond.notify_all()
+
+    def wait(self, generation: int, timeout: float) -> int:
+        with self.cond:
+            self.cond.wait_for(lambda: self.generation != generation, timeout)
+            return self.generation
+
+
+class Handler(SimpleHTTPRequestHandler):
+    reloader: Reloader
+
+    def do_GET(self):
+        if self.path == EVENT_PATH:
+            return self.serve_events()
+        path = Path(self.translate_path(self.path))
+        if path.is_dir():
+            path = path / "index.html"
+        if path.suffix == ".html" and path.is_file():
+            return self.serve_html(path)
+        return super().do_GET()
+
+    def serve_html(self, path: Path):
+        body = path.read_bytes()
+        i = body.rfind(b"</body>")
+        body = body[:i] + SNIPPET + body[i:] if i >= 0 else body + SNIPPET
+        self.send_response(HTTPStatus.OK)
+        self.send_header("Content-Type", "text/html; charset=utf-8")
+        self.send_header("Content-Length", str(len(body)))
+        self.send_header("Cache-Control", "no-store")
+        self.end_headers()
+        self.wfile.write(body)
+
+    def serve_events(self):
+        self.send_response(HTTPStatus.OK)
+        self.send_header("Content-Type", "text/event-stream")
+        self.send_header("Cache-Control", "no-store")
+        self.end_headers()
+        generation = self.reloader.generation
+        try:
+            while True:
+                new = self.reloader.wait(generation, timeout=15)
+                if new != generation:
+                    generation = new
+                    self.wfile.write(b"event: reload\ndata: \n\n")
+                else:
+                    self.wfile.write(b": keepalive\n\n")  # detects closed tabs
+                self.wfile.flush()
+        except (BrokenPipeError, ConnectionResetError):
+            pass
+
+    def log_message(self, format, *args):
+        if self.path != EVENT_PATH:
+            super().log_message(format, *args)

{entangled_cli-2.4.2 → entangled_cli-2.5.0}/pyproject.toml

@@ -1,15 +1,15 @@
 [project]
 name = "entangled-cli"
-version = "2.4.2"
+version = "2.5.0"
 description = "Literate Programming toolbox"
 authors = [{ name = "Johan Hidding", email = "j.hidding@esciencecenter.nl" }]
 requires-python = ">=3.13,<4"
 readme = "README.md"
 license = "Apache-2.0"
 dependencies = [
-        "filelock>=3.12.0,<4",
-        "rich>=13,<15",
-        "tomlkit>=0.12.1,<0.13",
+        "filelock>=3.12.0,<5",
+        "rich>=13,<16",
+        "tomlkit>=0.12.1,<0.16",
         "copier>=9,<10",
         "brei>=0.2.3,<0.3",
         "rich-argparse>=1.4.0,<2",
@@ -19,7 +19,7 @@ dependencies = [
         "click>=8.3.0",
         "rich-click>=1.9.4",
         "typeguard>=4.4.4",
-        "watchfiles>=1.1.1",
+        "watchfiles>=1.3",
 ]
 
 [project.urls]
@@ -32,8 +32,7 @@ entangled = "entangled.main:cli"
 [dependency-groups]
 dev = [
         "pytest>=9.0,<10",
-        "mypy>=1.18,<2",
-        "black>=23.3.0,<24",
+        "mypy>=2.4.0",
         "pytest-cov>=4.0.0,<5",
         "mkdocs>=1.4.3,<2",
         "mkdocs-material>=9.7,<10",
@@ -48,7 +47,6 @@ dev = [
         "types-pexpect>=4.9.0.20250916",
         "types-PyYAML>=6.0.1,<7",
         "pytest-timeout>=2.4.0",
-        "ty>=0.0.1a24",
 ]
 
 [tool.hatch.build.targets.sdist]
@@ -70,5 +68,10 @@ testpaths = ["test"]
 [tool.mypy]
 packages = ["entangled"]
 
+[tool.uv.workspace]
+members = [
+    ".",
+]
+
 [tool.uv.sources]
-watchdog = { git = "https://github.com/gorakhargosh/watchdog" }
+entangled-cli = { workspace = true, editable = true }