lambda-watcher 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

lambda_watcher/__init__.py

@@ -1,4 +1,4 @@
 """Watch a downloads folder for AWS Lambda deployment packages and version them."""
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 __all__ = ["__version__"]

lambda_watcher/cli.py

@@ -11,7 +11,7 @@ import sys
 import webbrowser
 import zipfile
 from datetime import datetime, timezone
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from typing import NoReturn, Optional
 
 import typer
@@ -36,7 +36,7 @@ from .service import (
     install_service,
     stop_service,
 )
-from .store import Store
+from .store import Store, posix_stored_dir
 from .utils import format_ts, human_size, relative_ts, rmtree, setup_logging, slugify
 
 #: Index connections opened by the running command; see `_close_open_dbs`.
@@ -187,6 +187,19 @@ def _version_or_fail(db: Database, function_id: int, seq: int):
     return row
 
 
+def _stored_dirname(stored_dir: str) -> str:
+    """The last segment of a version's stored path: ``0007-a1b2c3d4``.
+
+    Goes through :func:`~lambda_watcher.store.posix_stored_dir` first, so it
+    reads the same answer out of a value an older release wrote on Windows —
+    where ``Path(...).name`` on Linux returns the whole backslash-joined string
+    instead of the directory name, and the caller then builds a path to nothing.
+    """
+    # back-compat: `posix_stored_dir` is the whole point of this helper existing
+    # rather than callers reaching for `Path(...).name` themselves.
+    return PurePosixPath(posix_stored_dir(stored_dir)).name
+
+
 def _build_diff(db: Database, store: Store, cfg: Config, function_row, a_seq: int, b_seq: int,
                 include_vendor: bool | None, compute_diffs: bool = True):
     """Resolve two versions and build the diff between them.
@@ -194,7 +207,10 @@ def _build_diff(db: Database, store: Store, cfg: Config, function_row, a_seq: in
     Warns, rather than fails, when a version's extracted code is missing from
     disk: the index still knows what changed at the file level, so the summary
     and dependency layers are worth printing even though the line diffs come out
-    empty. Deleting an archive directory by hand is the usual cause.
+    empty. Deleting an archive directory by hand is one cause; an index pointing
+    somewhere the directory no longer is, after the archive was moved or copied
+    from another machine, is the other — which is why the warning names
+    ``lw reindex``, the command that rebuilds the index from what is on disk.
     """
     a = _version_or_fail(db, function_row["id"], a_seq)
     b = _version_or_fail(db, function_row["id"], b_seq)
@@ -203,7 +219,8 @@ def _build_diff(db: Database, store: Store, cfg: Config, function_row, a_seq: in
         if not path.exists():
             err_console.print(
                 f"[yellow]warning:[/yellow] code for v{seq:04d} is missing at {path}; "
-                "line diffs for it will be empty"
+                "line diffs for it will be empty. If the archive was moved or copied "
+                "here, `lw reindex` re-points the index at what is on disk."
             )
     return diff_from_index(db, store, cfg.diff, function_row["name"], a, b,
                            include_vendor=include_vendor, compute_diffs=compute_diffs)
@@ -1128,8 +1145,15 @@ def rename(
         if new_dir.exists():
             _fail(f"{new_dir} already exists on disk; move it aside first")
         old_dir.rename(new_dir)
+        # back-compat: re-point the index by rebuilding each path from where the
+        # directory now is, rather than by patching the stored string. A
+        # `functions/<old slug>/` replacement silently matched nothing in an
+        # archive an older release wrote on Windows, where the separator is a
+        # backslash — and a version left pointing at the pre-rename path reads
+        # as missing from then on, which is a diff with no lines in it.
+        new_versions = store.versions_dir(new_slug)
         for version in db.list_versions(int(row["id"])):
-            updated = version["dir"].replace(f"functions/{old_slug}/", f"functions/{new_slug}/", 1)
+            updated = store.relative(new_versions / _stored_dirname(version["dir"]))
             db.conn.execute("UPDATE versions SET dir = ? WHERE id = ?", (updated, version["id"]))
     if old_slug != new_slug:
         # The mirror lives outside the function directory, so it does not move
@@ -1209,7 +1233,7 @@ def merge(
         stored = store.resolve_version_dir(version["dir"])
         if stored.exists():
             continue
-        candidate = dst_versions / Path(version["dir"]).name
+        candidate = dst_versions / _stored_dirname(version["dir"])
         if candidate.exists():
             db.conn.execute(
                 "UPDATE versions SET dir = ? WHERE id = ?",

lambda_watcher/diffing/compare.py

@@ -38,7 +38,15 @@ class FileRecord:
 
     @classmethod
     def from_row(cls, row: Any) -> FileRecord:
-        """Build a record from an index row, filling in defaults for null columns."""
+        """Build a record from an index row, filling in defaults for null columns.
+
+        The defaults are not decoration: a row reindexed from a manifest written
+        before ``lang`` and ``mode`` were recorded has NULL in those columns, and
+        the diff would rather call the file ``text`` at 644 than fail on it.
+        """
+        # back-compat: `or "text"` / `or 0o644` cover columns an older manifest
+        # cannot fill. Drop them and reindexing an old archive builds rows that
+        # crash the diff instead of one that is merely vaguer than it could be.
         return cls(
             path=row["path"], size=int(row["size"]), sha256=row["sha256"],
             is_text=bool(row["is_text"]), is_vendor=bool(row["is_vendor"]),
@@ -56,8 +64,9 @@ class FileChange:
 
     ``diff_lines`` may be empty even for a real modification —
     ``skipped_reason`` then says why (binary, too large, ignored by config,
-    whitespace only), so the renderer can explain the absence rather than imply
-    nothing changed. Two of those absences are not refusals but better answers:
+    whitespace only, missing from the archive), so the renderer can explain the
+    absence rather than imply nothing changed. Two of those absences are not
+    refusals but better answers:
     a whitespace-only change is fully described by its label, and a file with no
     usable lines is described by ``word_edits`` instead. See :func:`_fill_diff`.
     """
@@ -87,6 +96,12 @@ class FileChange:
     #: The changed runs of a ``long_lines`` file, with enough text either side to
     #: place them. Empty for every ordinary file.
     word_edits: list[WordEdit] = field(default_factory=list)
+    #: True when the index lists the file but the archived version directory does
+    #: not hold it, so there was nothing to diff. Unlike every other reason a
+    #: hunk is absent, this one is not about the file at all — the archive is
+    #: incomplete, or the index is pointing at the wrong place — so the
+    #: renderers say what to do about it rather than only what happened.
+    missing: bool = False
 
     @property
     def is_vendor(self) -> bool:
@@ -146,6 +161,7 @@ class FileChange:
             "is_vendor": self.is_vendor,
             "whitespace_only": self.whitespace_only,
             "long_lines": self.long_lines,
+            "missing": self.missing,
             "word_edits": [e.as_dict() for e in self.word_edits],
         }
 
@@ -764,6 +780,21 @@ def _whitespace_key(text: str) -> tuple[str, ...]:
     return tuple(" ".join(line.split()) for line in text.splitlines() if line.strip())
 
 
+def _absent(root: Path, record: FileRecord | None) -> bool:
+    """True when the index lists this file but the archive no longer holds it.
+
+    :func:`~lambda_watcher.utils.read_text` answers None both for bytes that are
+    not text and for a file it could not open at all, and the second is by far
+    the likelier of the two here: the index is derived from disk, so a file it
+    lists was readable when it was written. A version directory that has been
+    deleted, moved, or restored under a path the index does not know about is
+    what actually produces it — see :meth:`lambda_watcher.store.Store.relative`.
+    Telling the reader "not decodable as text" for that sends them looking for an
+    encoding problem in a file that is simply not there.
+    """
+    return record is not None and not (root / record.path).is_file()
+
+
 def _fill_diff(change: FileChange, old_root: Path, new_root: Path, cfg: DiffConfig) -> None:
     """Work out what changed inside one file and write it onto the change.
 
@@ -792,7 +823,10 @@ def _fill_diff(change: FileChange, old_root: Path, new_root: Path, cfg: DiffConf
         Everything else, from :func:`difflib.unified_diff`.
 
     Before any of that, a file can be refused outright — binary, over
-    ``max_diff_file_kb``, or not decodable — and ``skipped_reason`` says which.
+    ``max_diff_file_kb``, not decodable, or missing from the archive — and
+    ``skipped_reason`` says which. The last of those is not a property of the
+    file's bytes but of the archive around it, so it is told apart by
+    :func:`_absent` rather than lumped in with the encodings.
     Line counts stay at zero on every route but the last: the counts describe a
     hunk, and where there is no hunk ``+3/-3`` is the noise the route exists to
     remove.
@@ -813,7 +847,10 @@ def _fill_diff(change: FileChange, old_root: Path, new_root: Path, cfg: DiffConf
     old_text = read_text(old_root / old.path) if old else ""
     new_text = read_text(new_root / new.path) if new else ""
     if old_text is None or new_text is None:
-        change.skipped_reason = "not decodable as text"
+        change.missing = _absent(old_root, old) or _absent(new_root, new)
+        change.skipped_reason = (
+            "missing from the archive" if change.missing else "not decodable as text"
+        )
         return
 
     if old_text and new_text and old_text != new_text:

lambda_watcher/diffing/render_html.py

@@ -130,44 +130,52 @@ table.grid td.label { width: 210px; color: var(--muted); }
 .tok.removed { background: var(--del-bg); border-color: var(--del-gutter); color: var(--del-fg); }
 
 /* ---- toolbar --------------------------------------------------------- */
-.toolbar { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; margin-bottom: 12px;
-  position: sticky; top: 0; background: var(--bg); padding: 10px 0; z-index: 5;
+.toolbar { display: flex; gap: 10px; align-items: center; flex-wrap: wrap; margin-bottom: 10px;
+  position: sticky; top: 0; background: var(--bg); padding: 10px 0; z-index: 6;
   box-shadow: 0 1px 0 var(--border); }
 .toolbar #shown-count { margin-left: auto; white-space: nowrap; flex: 0 0 auto; color: var(--faint); }
-.toolbar input[type=search] { flex: 1 1 220px; min-width: 140px; padding: 6px 10px; border-radius: 6px;
+.toolbar input[type=search] { flex: 1 1 240px; min-width: 150px; padding: 7px 11px; border-radius: 7px;
   border: 1px solid var(--border); background: var(--panel); color: var(--text); font-size: 13px; }
-.toolbar input[type=search]:focus { outline: none; border-color: var(--accent); }
+.toolbar input[type=search]:focus { outline: none; border-color: var(--accent);
+  box-shadow: 0 0 0 3px var(--accent-wash); }
 .toolbar label { color: var(--muted); font-size: 13px; display: inline-flex; gap: 6px;
   align-items: center; cursor: pointer; user-select: none; }
-.toolbar button { padding: 6px 11px; border-radius: 6px; border: 1px solid var(--border);
-  background: var(--panel); color: var(--muted); font-size: 13px; cursor: pointer; }
-.toolbar button:hover { border-color: var(--faint); color: var(--text); }
 
-/* ---- one file -------------------------------------------------------- */
-details.file { border: 1px solid var(--border); border-radius: 8px; margin-bottom: 8px;
+/* ---- the file list --------------------------------------------------- */
+/* One panel of rows rather than a stack of cards, because the list is an index
+   now: the diff it points at opens beside it instead of pushing the rest of
+   the list down the page. A row is a button, since that is what it does. */
+.files { border: 1px solid var(--border); border-radius: 10px; overflow: hidden;
   background: var(--panel); }
-details.file[open] { background: var(--bg); }
-details.file > summary { cursor: pointer; padding: 8px 12px; display: flex; gap: 10px;
-  align-items: center; list-style: none; font-size: 13px; border-radius: 7px; }
-details.file > summary::-webkit-details-marker { display: none; }
-details.file > summary:hover { background: var(--panel); }
-/* The header stays put while a long file scrolls past, so the path is still
-   readable eighty lines into its own diff. */
-details.file[open] > summary { position: sticky; top: var(--toolbar-h, 54px); z-index: 3;
-  background: var(--panel);
-  border-bottom: 1px solid var(--border); border-radius: 7px 7px 0 0; }
-summary .path { display: flex; align-items: center; gap: 8px; flex: 1; min-width: 0; }
-summary .path .p { font-family: var(--mono); font-size: 12.5px; overflow-wrap: anywhere; }
+.file { border-top: 1px solid var(--rule); }
+/* Transparent rather than absent so every row is the same height, whichever
+   one the filter left at the top. */
+.file:first-child, .file.first-shown { border-top-color: transparent; }
+.row { display: flex; gap: 10px; align-items: center; width: 100%; padding: 9px 14px;
+  font: inherit; color: var(--text); text-align: left; background: none; border: 0;
+  cursor: pointer; }
+.row:hover { background: var(--sunken); }
+.row:focus-visible { outline: 2px solid var(--accent); outline-offset: -3px; }
+/* The chevron points where the diff will appear: to the side, not downwards.
+   Drawn in CSS because a vendored diff runs to thousands of rows, and each one
+   would otherwise carry its own copy of the glyph. */
+.row::after { content: ""; flex: 0 0 auto; width: 6px; height: 6px; margin-left: 2px;
+  border: 1.6px solid var(--faint); border-left: 0; border-bottom: 0;
+  transform: rotate(45deg); transition: transform .15s ease, border-color .15s ease; }
+.row:hover::after { border-color: var(--accent); transform: translateX(2px) rotate(45deg); }
+.file.active .row { background: var(--accent-wash); box-shadow: inset 3px 0 0 var(--accent); }
+.file.active .row::after { border-color: var(--accent); transform: translateX(2px) rotate(45deg); }
+.row .path { display: flex; align-items: center; gap: 8px; flex: 1; min-width: 0; }
+.row .path .p { font-family: var(--mono); font-size: 12.5px; overflow-wrap: anywhere; }
 /* The tint hugs the changed part exactly — padding here would open a gap in
    the middle of a path and read as though the name contained a space. */
-summary .path .ren { background: var(--sunken); border-radius: 3px; }
-summary .path .was { color: var(--faint); }
-summary .stat-line { font-variant-numeric: tabular-nums; font-size: 12px; white-space: nowrap;
+.path .ren { background: var(--sunken); border-radius: 3px; }
+.path .was { color: var(--faint); }
+.stat-line { font-variant-numeric: tabular-nums; font-size: 12px; white-space: nowrap;
   display: flex; gap: 8px; align-items: baseline; color: var(--faint); }
 
 /* ---- the diff itself ------------------------------------------------- */
 .diff { overflow-x: auto; border-top: 1px solid var(--border); }
-details.file[open] > .diff { border-top: none; }
 .diff table { border-collapse: collapse; width: 100%; font-family: var(--mono);
   font-size: 12.5px; line-height: 1.5; }
 .diff td { padding: 0 8px; white-space: pre; vertical-align: top; }
@@ -224,49 +232,273 @@ footer { margin-top: 48px; padding-top: 16px; border-top: 1px solid var(--border
 .moved-list { margin: 0; padding: 10px 16px 12px 34px; list-style: disc;
   color: var(--muted); font-size: 12px; line-height: 1.9; }
 .moved-list .hint { color: var(--faint); }
+/* ---- the sheet ------------------------------------------------------- */
+/* Where the diff lands when a row is clicked. Code wants width, and a block
+   that opened downwards spent the page's widest dimension on the file list it
+   had just pushed out of view; this keeps the list where it was, so the next
+   file is one click away rather than one scroll back.
+
+   A wide window docks the sheet and the page makes room beside it. A narrow
+   one slides it over the page with a scrim, because a laptop in portrait has
+   no room to dock and half a diff is worse than a covered list. */
+:root { --sheet-w: 760px; }
+.scrim { position: fixed; inset: 0; z-index: 30; background: rgba(8, 13, 20, .44);
+  opacity: 0; visibility: hidden; transition: opacity .26s ease, visibility 0s linear .26s; }
+body.sheet-open .scrim { opacity: 1; visibility: visible; transition: opacity .26s ease; }
+.sheet { position: fixed; top: 0; right: 0; bottom: 0; z-index: 40;
+  width: min(100%, var(--sheet-w)); display: flex; flex-direction: column;
+  background: var(--bg); border-left: 1px solid var(--border);
+  box-shadow: -24px 0 60px -30px rgba(6, 11, 18, .5);
+  /* `visibility` rather than `display`, so the sheet can animate out and still
+     leave nothing behind for the keyboard to land on while it is shut. It turns
+     visible on the same frame it is asked to — a transition would leave it
+     unfocusable for the length of the slide, which is exactly when the script
+     is moving focus into it — and back to hidden only once the slide is over. */
+  transform: translateX(100%); visibility: hidden;
+  transition: transform .26s cubic-bezier(.22, .61, .36, 1), visibility 0s linear .26s; }
+body.sheet-open .sheet { transform: none; visibility: visible;
+  transition: transform .26s cubic-bezier(.22, .61, .36, 1); }
+.sheet-head { padding: 12px 14px 11px; border-bottom: 1px solid var(--border);
+  background: var(--panel); display: flex; flex-direction: column; gap: 7px; }
+.sheet-bar { display: flex; align-items: center; gap: 10px; }
+.sheet-title { display: flex; align-items: center; gap: 10px; flex: 1; min-width: 0; }
+.sheet-title .path { display: flex; align-items: center; gap: 8px; min-width: 0; }
+.sheet-title .p { font-family: var(--mono); font-size: 13px; font-weight: 600;
+  overflow-wrap: anywhere; }
+/* Wrapping rather than clipping: a file whose counts are a sentence — "missing
+   from the archive" — is exactly the one whose reader needs to read them. */
+.sheet-sub { display: flex; align-items: baseline; gap: 12px; min-height: 18px;
+  flex-wrap: wrap; color: var(--faint); font-size: 12px; }
+.sheet-sub .ver { margin-left: auto; font-family: var(--mono); white-space: nowrap; }
+.sheet-nav { display: flex; align-items: center; gap: 2px; flex: 0 0 auto; }
+.sheet-nav .pos { color: var(--faint); font-size: 12px; padding: 0 3px;
+  font-variant-numeric: tabular-nums; white-space: nowrap; }
+.iconbtn { display: inline-flex; align-items: center; justify-content: center;
+  width: 28px; height: 28px; padding: 0; border-radius: 7px; border: 1px solid transparent;
+  background: none; color: var(--muted); cursor: pointer; }
+.iconbtn:hover:not(:disabled) { background: var(--sunken); border-color: var(--border);
+  color: var(--text); }
+.iconbtn:disabled { opacity: .3; cursor: default; }
+.iconbtn:focus-visible { outline: 2px solid var(--accent); outline-offset: 1px; }
+.iconbtn svg { width: 16px; height: 16px; fill: none; stroke: currentColor;
+  stroke-width: 1.7; stroke-linecap: round; stroke-linejoin: round; }
+.iconbtn.close { margin-left: 5px; }
+.sheet-body { flex: 1; overflow: auto; overscroll-behavior: contain; }
+.sheet-body:focus { outline: none; }
+/* The panel's own top rule would double the header's. */
+.sheet-body > .body > :first-child { border-top: none; }
+/* One file wants sixty columns and the next wants two hundred, and which one
+   is on screen is not something the page can know — so the edge is draggable
+   wherever there is a pointer and room to dock. */
+.grip { position: absolute; left: 0; top: 0; bottom: 0; width: 11px; display: none;
+  cursor: col-resize; }
+.grip::before { content: ""; position: absolute; left: 4px; top: 50%; width: 3px; height: 44px;
+  margin-top: -22px; border-radius: 3px; background: var(--border); transition: background .15s; }
+.grip:hover::before, body.dragging .grip::before { background: var(--accent); }
+body.dragging { user-select: none; cursor: col-resize; }
+body.dragging, body.dragging .sheet { transition: none; }
+
+@media (min-width: 1280px) {
+  :root { --sheet-w: min(50vw, 960px); }
+  .scrim { display: none; }
+  .grip { display: block; }
+  body { transition: padding-right .26s cubic-bezier(.22, .61, .36, 1); }
+  body.sheet-open { padding-right: min(var(--sheet-w), 76vw); }
+}
+/* Nothing to dock into: the sheet is over the page, so the page stops scrolling
+   underneath it. */
+@media (max-width: 1279.98px) {
+  body.sheet-open { overflow: hidden; }
+}
+@media (prefers-reduced-motion: reduce) {
+  body, .sheet, .scrim, .row::after { transition: none; }
+}
+/* On paper there is no clicking, so every diff is printed under its own row and
+   the chrome that only answers a pointer is left out. */
+@media print {
+  .toolbar, .scrim, .sheet-nav, .grip { display: none !important; }
+  .sheet { position: static; transform: none; visibility: visible; width: auto;
+    border-left: 0; box-shadow: none; }
+  body.sheet-open { padding-right: 0; overflow: visible; }
+  .file .body[hidden] { display: block; }
+}
 .hidden { display: none !important; }
 """
 
+#: What the page does once it is open: narrow the list, and move one file's diff
+#: into the sheet and back out again. Moving rather than copying is the whole
+#: design — the diff exists once, so the sheet cannot drift from the row, and
+#: closing it leaves the page exactly as it was rendered. One ``<script>`` at the
+#: end of the body, so everything it binds to is already parsed.
 JS = """
 (function () {
   var search = document.getElementById('filter');
   var vendorToggle = document.getElementById('vendor');
-  var files = Array.prototype.slice.call(document.querySelectorAll('details.file'));
+  var counter = document.getElementById('shown-count');
+  var files = Array.prototype.slice.call(document.querySelectorAll('.files .file'));
+  var scrim = document.getElementById('scrim');
+  var host = document.getElementById('sheet-body');
+  var titleBox = document.getElementById('sheet-title');
+  var statBox = document.getElementById('sheet-stat');
+  var posBox = document.getElementById('sheet-pos');
+  var prevBtn = document.getElementById('sheet-prev');
+  var nextBtn = document.getElementById('sheet-next');
+  var closeBtn = document.getElementById('sheet-close');
+  var grip = document.getElementById('sheet-grip');
+  var openFile = null;   // whose diff is sitting in the sheet right now
+  var opener = null;     // the row that put it there, to hand focus back to
+
+  function listed() {
+    return files.filter(function (el) { return !el.classList.contains('hidden'); });
+  }
+
+  function empty(node) {
+    while (node && node.firstChild) { node.removeChild(node.firstChild); }
+  }
+
+  // The sheet header says the same things the row does, so it is built from a
+  // copy of the row rather than from a second set of markup on every file.
+  function copyInto(node, source) {
+    empty(node);
+    if (node && source) { node.appendChild(source.cloneNode(true)); }
+  }
+
+  function position() {
+    var rows = listed();
+    var at = openFile ? rows.indexOf(openFile) : -1;
+    if (posBox) { posBox.textContent = at < 0 ? '' : (at + 1) + ' / ' + rows.length; }
+    if (prevBtn) { prevBtn.disabled = at <= 0; }
+    if (nextBtn) { nextBtn.disabled = at < 0 || at >= rows.length - 1; }
+  }
+
+  // The diff is moved into the sheet rather than copied, so this puts it back
+  // where it came from. One diff exists at a time, wherever it is showing.
+  function park() {
+    if (!openFile) { return; }
+    var body = host.firstElementChild;
+    if (body) { body.hidden = true; openFile.appendChild(body); }
+    openFile.classList.remove('active');
+    var row = openFile.querySelector('.row');
+    if (row) { row.setAttribute('aria-expanded', 'false'); }
+    openFile = null;
+  }
+
+  function show(file, takeFocus) {
+    var row = file && file.querySelector('.row');
+    if (!row || !host) { return; }
+    park();
+    openFile = file;
+    file.classList.add('active');
+    row.setAttribute('aria-expanded', 'true');
+    var body = file.querySelector('.body');
+    if (body) { body.hidden = false; host.appendChild(body); }
+    host.scrollTop = 0;
+    empty(titleBox);
+    ['.chip', '.path'].forEach(function (part) {
+      var found = row.querySelector(part);
+      if (found && titleBox) { titleBox.appendChild(found.cloneNode(true)); }
+    });
+    copyInto(statBox, row.querySelector('.stat-line'));
+    document.body.classList.add('sheet-open');
+    position();
+    if (takeFocus) { host.focus(); }
+  }
+
+  function close() {
+    park();
+    document.body.classList.remove('sheet-open');
+    empty(titleBox);
+    empty(statBox);
+    position();
+    if (opener) { opener.focus(); opener = null; }
+  }
+
+  function step(delta) {
+    var rows = listed();
+    var at = openFile ? rows.indexOf(openFile) : -1;
+    var next = at < 0 ? null : rows[at + delta];
+    if (next) {
+      // Focus stays on the button that is walking the list, so the next press
+      // lands on it too.
+      show(next, false);
+      opener = next.querySelector('.row');
+    }
+  }
 
   function apply() {
-    var term = (search.value || '').toLowerCase();
+    var term = (search ? search.value : '').toLowerCase();
     var showVendor = vendorToggle ? vendorToggle.checked : true;
     var shown = 0;
+    var total = 0;
+    var first = true;
     files.forEach(function (el) {
       var path = (el.getAttribute('data-path') || '').toLowerCase();
       var isVendor = el.getAttribute('data-vendor') === '1';
       var ok = (!term || path.indexOf(term) !== -1) && (showVendor || !isVendor);
+      // A move block stands for every file it folded up, so both halves of the
+      // count are sums of `data-files` rather than counts of rows.
+      var covers = parseInt(el.getAttribute('data-files') || '1', 10);
       el.classList.toggle('hidden', !ok);
-      if (ok) shown += parseInt(el.getAttribute('data-files') || '1', 10);
+      el.classList.toggle('first-shown', ok && first);
+      total += covers;
+      if (ok) { shown += covers; first = false; }
     });
-    var counter = document.getElementById('shown-count');
-    if (counter) counter.textContent = shown + ' of ' + files.length + ' files shown';
+    if (counter) { counter.textContent = shown + ' of ' + total + ' files shown'; }
+    // Leaving the sheet open on a file the filter just took off the list would
+    // show a diff with no row to close it from.
+    if (openFile && openFile.classList.contains('hidden')) { close(); } else { position(); }
   }
 
-  if (search) search.addEventListener('input', apply);
-  if (vendorToggle) vendorToggle.addEventListener('change', apply);
+  files.forEach(function (file) {
+    var row = file.querySelector('.row');
+    if (!row) { return; }
+    row.addEventListener('click', function () {
+      if (file === openFile) { close(); return; }
+      opener = row;
+      show(file, true);
+    });
+  });
+
+  if (search) { search.addEventListener('input', apply); }
+  if (vendorToggle) { vendorToggle.addEventListener('change', apply); }
+  if (closeBtn) { closeBtn.addEventListener('click', close); }
+  if (scrim) { scrim.addEventListener('click', close); }
+  if (prevBtn) { prevBtn.addEventListener('click', function () { step(-1); }); }
+  if (nextBtn) { nextBtn.addEventListener('click', function () { step(1); }); }
+
+  document.addEventListener('keydown', function (ev) {
+    if (!openFile || ev.ctrlKey || ev.metaKey || ev.altKey) { return; }
+    if (ev.key === 'Escape') { close(); return; }
+    var tag = (ev.target.tagName || '').toLowerCase();
+    if (tag === 'input' || tag === 'textarea') { return; }
+    if (ev.key === 'j') { step(1); ev.preventDefault(); }
+    if (ev.key === 'k') { step(-1); ev.preventDefault(); }
+  });
 
-  var toolbar = document.querySelector('.toolbar');
-  function measure() {
-    if (!toolbar) return;
-    document.documentElement.style.setProperty('--toolbar-h', toolbar.offsetHeight + 'px');
+  if (grip && window.PointerEvent) {
+    grip.addEventListener('pointerdown', function (down) {
+      down.preventDefault();
+      grip.setPointerCapture(down.pointerId);
+      document.body.classList.add('dragging');
+      function drag(move) {
+        // Clamped so a drag can neither shut the sheet nor bury the list
+        // behind it, whichever direction it is thrown in.
+        var width = Math.min(Math.max(window.innerWidth - move.clientX, 380),
+                             Math.max(window.innerWidth - 320, 380));
+        document.documentElement.style.setProperty('--sheet-w', Math.round(width) + 'px');
+      }
+      function drop() {
+        document.body.classList.remove('dragging');
+        grip.removeEventListener('pointermove', drag);
+        grip.removeEventListener('pointerup', drop);
+        grip.removeEventListener('pointercancel', drop);
+      }
+      grip.addEventListener('pointermove', drag);
+      grip.addEventListener('pointerup', drop);
+      grip.addEventListener('pointercancel', drop);
+    });
   }
-  window.addEventListener('resize', measure);
-  measure();
 
-  var expand = document.getElementById('expand-all');
-  var collapse = document.getElementById('collapse-all');
-  if (expand) expand.addEventListener('click', function () {
-    files.forEach(function (f) { if (!f.classList.contains('hidden')) f.open = true; });
-  });
-  if (collapse) collapse.addEventListener('click', function () {
-    files.forEach(function (f) { f.open = false; });
-  });
   apply();
 })();
 """
@@ -392,8 +624,46 @@ def _row_code(row: _Row, lang: str, old: _Painted, new: _Painted) -> str:
     return highlight(row.text, lang)
 
 
+def _file_block(
+    *,
+    path_key: str,
+    chip_class: str,
+    chip_text: str,
+    icon: str,
+    title: str,
+    stat: str,
+    body: str,
+    is_vendor: bool,
+    files: int | None = None,
+) -> str:
+    """One row of the file list, carrying the diff the sheet opens when it is clicked.
+
+    The row is what the reader scans — kind, icon, path, counts — and ``body``
+    is what opens beside it. The body ships inside the row's own element rather
+    than in a second list keyed by path, so a block stays one self-contained
+    thing to filter, hide or print; the script moves that element into the sheet
+    and back out again, which is why no diff is ever on the page twice.
+
+    ``path_key`` is what the filter box matches on: a file's own path and the
+    one it was renamed from, or every member path of a move. ``files`` is how
+    many files the block is the only entry for, left off when that is one.
+    """
+    extra = f' data-files="{files}"' if files is not None else ""
+    return (
+        f'<article class="file" data-path="{_esc(path_key)}" '
+        f'data-vendor="{1 if is_vendor else 0}"{extra}>'
+        '<button class="row" type="button" aria-expanded="false" aria-controls="sheet">'
+        f'<span class="chip {_esc(chip_class)}">{_esc(chip_text)}</span>'
+        f'<span class="path">{icon}<span class="p">{title}</span></span>'
+        f'<span class="stat-line">{stat}</span>'
+        "</button>"
+        f'<div class="body" hidden>{body}</div>'
+        "</article>"
+    )
+
+
 def _render_file(change: FileChange, a_root: Path | None = None, b_root: Path | None = None) -> str:
-    """Render one file's change as a titled block with its diff table.
+    """Render one file's change as a list row and the diff table behind it.
 
     A rename is titled as one file with only the moved part written twice
     (``boto3-{1.34.0 → 1.35.20}.dist-info/METADATA``), rather than as two
@@ -423,22 +693,12 @@ def _render_file(change: FileChange, a_root: Path | None = None, b_root: Path |
     if change.size_delta:
         stat += f"<span>{signed(change.size_delta)} B</span>"
     if note := change.line_count_note:
-        # The block is collapsed until someone opens it, so a summary row with
-        # no ``+`` and no ``−`` is all most readers ever see of this file. The
-        # note is the difference between "measured differently" and "unchanged".
+        # The diff is behind a click, so a row with no ``+`` and no ``−`` is all
+        # most readers ever see of this file. The note is the difference between
+        # "measured differently" and "unchanged".
         stat += f'<span class="skipped">{_esc(note)}</span>'
 
-    parts = [
-        f'<details class="file" data-path="{_esc(change.path)} {_esc(change.old_path or "")}" '
-        f'data-vendor="{1 if change.is_vendor else 0}">',
-        "<summary>",
-        f'<span class="chip {_esc(change.kind)}">{_esc(change.kind)}</span>',
-        f'<span class="path">{icons.file_icon(change.path, lang)}'
-        f'<span class="p">{title}</span></span>',
-        f'<span class="stat-line">{stat}</span>',
-        "</summary>",
-    ]
-
+    parts: list[str] = []
     if change.diff_lines:
         old = _paint(a_root, change.old_path or change.path, lang) if change.old else None
         new = _paint(b_root, change.path, lang) if change.new else None
@@ -450,7 +710,7 @@ def _render_file(change: FileChange, a_root: Path | None = None, b_root: Path |
                 parts.append(f'<tr class="hunk"><td colspan="4">{_esc(row.text)}</td></tr>')
                 continue
             css = f' class="{row.css}"' if row.css in ("add", "del") else ""
-            mark = {"add": "+", "del": "\u2212"}.get(row.css, "")
+            mark = {"add": "+", "del": "−"}.get(row.css, "")
             code = intraline.mark(_row_code(row, lang, old, new), marks.get(index, []))
             parts.append(
                 f"<tr{css}>"
@@ -482,10 +742,24 @@ def _render_file(change: FileChange, a_root: Path | None = None, b_root: Path |
             # check.
             note += (' Indentation, line endings or blank lines only — '
                      '<code>lw diff --whitespace</code> shows it anyway.')
+        elif change.missing:
+            # The one reason here that is not about the file: nothing is wrong
+            # with it, the archive just does not have it where the index says.
+            note += (' The index lists this file but the version directory does not '
+                     'hold it — <code>lw reindex</code> rebuilds the index from what '
+                     'is on disk.')
         parts.append(f'<div class="note">{note}</div>')
 
-    parts.append("</details>")
-    return "\n".join(parts)
+    return _file_block(
+        path_key=f'{change.path} {change.old_path or ""}',
+        chip_class=change.kind,
+        chip_text=change.kind,
+        icon=icons.file_icon(change.path, lang),
+        title=title,
+        stat=stat,
+        body="\n".join(parts),
+        is_vendor=change.is_vendor,
+    )
 
 
 def _render_word_edits(change: FileChange) -> str:
@@ -535,15 +809,14 @@ def _render_move(group: MoveGroup) -> str:
     files, so nothing is hidden that expanding will not show. The alternative
     is twenty blocks whose titles differ only in the filename at the end.
 
-    Kept searchable and filterable like any file block: ``data-path`` holds
-    every member path so the filter box still finds one by name, and
-    ``data-vendor`` is set only when the whole move is vendored, which is the
-    dependency-bump case (``boto3-1.{34.0 → 35.20}.dist-info/``).
+    Kept searchable and filterable like any file block: the filter box matches
+    on every member path, and the block counts as vendored only when the whole
+    move is, which is the dependency-bump case
+    (``boto3-1.{34.0 → 35.20}.dist-info/``).
 
-    ``data-files`` is how many files this block is the *only* entry for, so the
-    "N of M files shown" counter stays a count of files. The edited members are
-    left out of it because they follow as blocks of their own and would
-    otherwise be counted twice.
+    The file count it reports to :func:`_file_block` leaves out the edited
+    members, so the "N of M files shown" counter stays a count of files: those
+    members follow as blocks of their own and would otherwise be counted twice.
     """
     head, was, now, tail = rename_label(*group.display_dirs)
     title = (
@@ -573,18 +846,16 @@ def _render_move(group: MoveGroup) -> str:
         + "</li>"
         for c in group.members
     )
-    return (
-        f'<details class="file" data-path="{_esc(searchable)}" '
-        f'data-vendor="{1 if group.is_vendor else 0}" '
-        f'data-files="{group.moved - group.edited}">'
-        "<summary>"
-        '<span class="chip renamed">moved</span>'
-        f'<span class="path">{icons.file_icon(group.new_dir + "/", "text")}'
-        f'<span class="p">{title}</span></span>'
-        f'<span class="stat-line">{stat}</span>'
-        "</summary>"
-        f'<ul class="moved-list">{rows}</ul>'
-        "</details>"
+    return _file_block(
+        path_key=searchable,
+        chip_class="renamed",
+        chip_text="moved",
+        icon=icons.file_icon(group.new_dir + "/", "text"),
+        title=title,
+        stat=stat,
+        body=f'<ul class="moved-list">{rows}</ul>',
+        is_vendor=group.is_vendor,
+        files=group.moved - group.edited,
     )
 
 
@@ -767,8 +1038,68 @@ def _findings_section(diff: VersionDiff) -> str:
     return f"<h2>New findings</h2>{table}{resolved}"
 
 
+#: Without the script the sheet can never open, so the diffs sit under their own
+#: rows instead and the controls that would do nothing are taken off the page.
+NOSCRIPT = """
+.toolbar, .sheet, .scrim { display: none; }
+.row { cursor: default; }
+.row::after { display: none; }
+.file .body[hidden] { display: block; }
+"""
+
+
+def _nav_button(ident: str, label: str, glyph: str, extra: str = "") -> str:
+    """One of the sheet's three controls: a 16×16 stroked glyph with a spoken name.
+
+    ``label`` names the keystroke as well as the action (``Next file (j)``),
+    because a shortcut on a page with no menu has nowhere else to be found.
+    """
+    return (
+        f'<button type="button" class="iconbtn{extra}" id="{ident}" '
+        f'title="{_esc(label)}" aria-label="{_esc(label)}">'
+        f'<svg viewBox="0 0 16 16" aria-hidden="true"><path d="{glyph}"/></svg></button>'
+    )
+
+
+def _sheet(diff: VersionDiff) -> str:
+    """The panel a file's diff opens into, and the scrim behind it on a narrow window.
+
+    One frame per page rather than one per file: the script moves the clicked
+    file's diff into it, so what is written here is everything around that diff
+    — the path, its counts, which two versions are being compared, and the
+    controls that walk the list without going back to it.
+
+    The heading is left empty because it is filled from the row that was
+    clicked; see the ``show`` function in :data:`JS`.
+    """
+    return (
+        '<div class="scrim" id="scrim"></div>'
+        '<aside class="sheet" id="sheet" role="dialog" aria-labelledby="sheet-title">'
+        '<div class="grip" id="sheet-grip" title="Drag to resize"></div>'
+        '<header class="sheet-head"><div class="sheet-bar">'
+        '<div class="sheet-title" id="sheet-title"></div>'
+        '<div class="sheet-nav">'
+        + _nav_button("sheet-prev", "Previous file (k)", "m4.5 9.75 3.5-3.5 3.5 3.5")
+        + '<span class="pos" id="sheet-pos"></span>'
+        + _nav_button("sheet-next", "Next file (j)", "m4.5 6.25 3.5 3.5 3.5-3.5")
+        + _nav_button("sheet-close", "Close (Esc)", "m4.5 4.5 7 7m0-7-7 7", " close")
+        + "</div></div>"
+        '<div class="sheet-sub"><span id="sheet-stat"></span>'
+        f'<span class="ver">v{diff.a_seq:04d} → v{diff.b_seq:04d}</span>'
+        "</div></header>"
+        '<div class="sheet-body" id="sheet-body" tabindex="-1"></div>'
+        "</aside>"
+    )
+
+
 def render_html(diff: VersionDiff, generated_by: str = "lambda-watcher") -> str:
-    """Render the full report as a single HTML document."""
+    """Render the full report as a single HTML document.
+
+    What the reader gets is a summary they can take in without scrolling, then
+    a list of every changed file. Clicking one opens its diff in the sheet
+    beside the list rather than underneath it — see :func:`_sheet` — so the
+    list keeps its place and the code gets the width it wants.
+    """
     title = f"{diff.function_name} · v{diff.a_seq:04d} → v{diff.b_seq:04d}"
     a_when = format_ts(diff.a_meta.get("ingested_at"))
     b_when = format_ts(diff.b_meta.get("ingested_at"))
@@ -784,15 +1115,24 @@ def render_html(diff: VersionDiff, generated_by: str = "lambda-watcher") -> str:
         blocks.extend(
             _render_file(c, diff.a_root, diff.b_root) for c in row.edited_members
         )
-    file_blocks = "\n".join(blocks)
-    if not diff.files:
-        file_blocks = '<div class="empty">No file-level changes between these versions.</div>'
-
     vendor_toggle = (
         '<label><input type="checkbox" id="vendor" checked> show vendored files</label>'
         if any(c.is_vendor for c in diff.files)
         else ""
     )
+    # Two versions with the same tree have nothing to filter and nothing to
+    # open, so that page is one sentence: a search box above it would only
+    # offer to narrow an empty list.
+    toolbar = listing = ""
+    if diff.files:
+        toolbar = (
+            '<div class="toolbar">'
+            '<input type="search" id="filter" placeholder="Filter by path…" autocomplete="off">'
+            f'{vendor_toggle}<span class="sub" id="shown-count"></span></div>'
+        )
+        listing = '<div class="files">{}</div>'.format("\n".join(blocks))
+    else:
+        listing = '<div class="empty">No file-level changes between these versions.</div>'
 
     return f"""<!DOCTYPE html>
 <html lang="en">
@@ -801,6 +1141,7 @@ def render_html(diff: VersionDiff, generated_by: str = "lambda-watcher") -> str:
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>{_esc(title)}</title>
 <style>{CSS}{ICON_CSS}</style>
+<noscript><style>{NOSCRIPT}</style></noscript>
 </head>
 <body>
 {icons.sprite()}
@@ -820,20 +1161,15 @@ def render_html(diff: VersionDiff, generated_by: str = "lambda-watcher") -> str:
   {_findings_section(diff)}
 
   <h2>File changes</h2>
-  <div class="toolbar">
-    <input type="search" id="filter" placeholder="Filter by path…" autocomplete="off">
-    {vendor_toggle}
-    <button type="button" id="expand-all">Expand all</button>
-    <button type="button" id="collapse-all">Collapse all</button>
-    <span class="sub" id="shown-count"></span>
-  </div>
-  {file_blocks}
+  {toolbar}
+  {listing}
 
   <footer>
     Generated by {_esc(generated_by)} on {_esc(datetime.now().strftime('%Y-%m-%d %H:%M'))}.
     Content hashes ignore zip timestamps, so re-downloading unchanged code does not create a new version.
   </footer>
 </div>
+{_sheet(diff)}
 <script>{JS}</script>
 </body>
 </html>

lambda_watcher/gitmirror.py

@@ -4,8 +4,9 @@ This is the shortest path to a review workflow you already know: every version
 is a commit tagged ``v0007``, so ``git diff v0002 v0010``, ``git log -p``, VS
 Code's diff viewer and any git GUI all work on a single function's history
 without ten unrelated Lambdas mixed into the same repo. It lives at
-``functions/<slug>/repo/``, and ``lambda-watcher open`` hands that folder to an
-editor.
+``repos/<slug>/`` — see :meth:`lambda_watcher.store.Store.repo_dir`, which also
+moves the mirrors older releases kept inside the function directory — and
+``lw open`` hands that folder to an editor.
 """
 
 from __future__ import annotations
@@ -17,7 +18,7 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from .config import GitMirrorConfig
-from .utils import LOG, matches_any, rmtree
+from .utils import LOG, matches_any, no_window_kwargs, rmtree
 
 
 class GitUnavailable(RuntimeError):
@@ -83,6 +84,7 @@ def _run(repo: Path, *args: str, check: bool = True, env_extra: dict[str, str] |
         text=True,
         env=_git_env(env_extra),
         timeout=300,
+        **no_window_kwargs(),
     )
     if check and proc.returncode != 0:
         raise RuntimeError(f"git {' '.join(args)} failed: {proc.stderr.strip() or proc.stdout.strip()}")

lambda_watcher/notify.py

@@ -6,7 +6,7 @@ import shutil
 import subprocess
 import sys
 
-from .utils import LOG
+from .utils import LOG, no_window_kwargs
 
 
 def notify(title: str, message: str, enabled: bool = True) -> bool:
@@ -37,6 +37,7 @@ def notify(title: str, message: str, enabled: bool = True) -> bool:
                 ["powershell", "-NoProfile", "-NonInteractive", "-Command", ps],
                 capture_output=True,
                 timeout=15,
+                **no_window_kwargs(),
             )
             return True
         if shutil.which("notify-send"):

lambda_watcher/reindex.py

@@ -95,6 +95,10 @@ def _insert(db: Database, store: Store, function_id: int, manifest: dict[str, An
     with no recorded sequence number falls back to the numeric prefix of its
     directory name, which is where the sequence came from in the first place.
     """
+    # back-compat: every section is fetched with a default rather than indexed,
+    # so a manifest written before that section existed rebuilds as a version
+    # missing one facet instead of raising and costing the whole archive its
+    # index. Each analyser added since shipped is one more reason this stays.
     version_meta = manifest.get("version") or {}
     source = manifest.get("source") or {}
     runtime = manifest.get("runtime") or {}
@@ -103,7 +107,10 @@ def _insert(db: Database, store: Store, function_id: int, manifest: dict[str, An
 
     seq = int(version_meta.get("seq") or 0)
     if not seq:
-        # Fall back to the numeric prefix of the directory name.
+        # back-compat: a manifest from before the sequence number was recorded
+        # in it. The number is still in the directory name it was used to build
+        # (`0007-a1b2c3d4`), so recover it there rather than skipping the
+        # version and silently rebuilding a shorter history than the archive has.
         seq = int(version_dir.name.split("-")[0])
 
     with db.transaction():

lambda_watcher/service.py

@@ -30,7 +30,7 @@ from pathlib import Path
 from typing import TypedDict
 
 from .config import Config
-from .utils import LOG
+from .utils import LOG, no_window_kwargs
 
 #: Identifiers registered with the OS. Changing either of these orphans the
 #: service someone already installed, so they are constants, not config.
@@ -120,6 +120,11 @@ def _python_for_service() -> str:
 
     A scheduled task pointed at ``python.exe`` flashes a console window at every
     logon; ``pythonw.exe`` is the same interpreter without one.
+
+    This settles the watcher's own window and nothing else. Having no console is
+    exactly what makes Windows give a *new* one to each ``git`` and
+    ``powershell`` the watcher then spawns, which is
+    :func:`lambda_watcher.utils.no_window_kwargs`' problem.
     """
     executable = Path(sys.executable)
     if sys.platform.startswith("win"):
@@ -157,7 +162,8 @@ def _run(argv: list[str], check: bool = False) -> subprocess.CompletedProcess[st
     LOG.debug("service: %s", " ".join(argv))
     try:
         proc = subprocess.run(
-            argv, capture_output=True, text=True, timeout=_TIMEOUT, check=False
+            argv, capture_output=True, text=True, timeout=_TIMEOUT, check=False,
+            **no_window_kwargs(),
         )
     except FileNotFoundError as exc:
         raise ServiceError(f"{argv[0]} is not installed") from exc
@@ -628,6 +634,9 @@ class _DetachKwargs(TypedDict, total=False):
     annotation. Naming the two keys costs a class and buys a checked call.
 
     ``total=False`` because each platform returns exactly one of them.
+
+    :class:`lambda_watcher.utils.NoWindowKwargs` is the same trick for the
+    keyword that keeps a *captured* child from opening a console window.
     """
 
     creationflags: int

lambda_watcher/store.py

@@ -33,11 +33,41 @@ from .config import Config
 from .utils import LOG, rmtree, short_hash
 
 
-#: Where the mirror used to sit, inside the function directory. Both spellings
-#: are migrated: ``git/`` shipped, ``repo/`` was a brief step on the way here.
+#: back-compat: where the mirror used to sit, inside the function directory.
+#: Both spellings are migrated by :meth:`Store.repo_dir`: ``git/`` shipped,
+#: ``repo/`` was a brief step on the way here. Goes when no archive written
+#: before the move to ``repos/<slug>/`` can still be opened, which for a tool
+#: people leave running unattended is not a date anyone can name.
 LEGACY_REPO_DIRNAMES = ("git", "repo")
 
 
+def posix_stored_dir(stored_dir: str) -> str:
+    """A stored version-directory path with its separators made posix.
+
+    ``functions\\order-processor\\versions\\0001-a1b2c3d4`` →
+    ``functions/order-processor/versions/0001-a1b2c3d4``. Releases before this
+    one built the value with :func:`str` on a :class:`~pathlib.Path`, so an
+    archive first written on Windows holds backslashes — four directories there,
+    one oddly-named file anywhere else. Reading such an archive on Linux or macOS
+    finds no version directory at all, and every file in every diff comes back
+    missing.
+
+    The translation is unambiguous rather than a guess: these paths are built
+    from ``functions/``, a :func:`~lambda_watcher.utils.slugify` output (only
+    ``A-Za-z0-9._-`` survives it), ``versions/`` and
+    :meth:`Store.version_dirname`'s ``NNNN-`` plus hex, so no segment can
+    legitimately contain a backslash. Written by :meth:`Store.relative`, read by
+    :meth:`Store.resolve_version_dir`.
+
+    Goes when no index written by a release that stored the platform's own
+    separator can still be in use — so, in practice, it stays.
+    """
+    # back-compat: an index written on Windows before `Store.relative` wrote
+    # posix. Drop this and such an archive resolves no version at all: the diff
+    # still prints, with no lines in it and every file blamed for its encoding.
+    return stored_dir.replace("\\", "/")
+
+
 @dataclass
 class VersionPaths:
     """The three paths that make up one archived version directory.
@@ -108,6 +138,10 @@ class Store:
         repo = self.cfg.repos_dir / slug
         if repo.exists():
             return repo
+        # back-compat: relocate a mirror an older release left inside the
+        # function directory. Without this the mirror reads as missing, and
+        # `lw open`, `lw git` and `lw diff --mirror` all report there is no
+        # history to show for a function that has one.
         for name in LEGACY_REPO_DIRNAMES:
             legacy = self.function_dir(slug) / name
             if not (legacy / ".git").is_dir():
@@ -136,18 +170,32 @@ class Store:
         return VersionPaths(self.versions_dir(slug) / self.version_dirname(seq, tree_hash))
 
     def resolve_version_dir(self, stored_dir: str) -> Path:
-        """Version dirs are stored relative to the root so the store can move."""
-        path = Path(stored_dir)
+        """Version dirs are stored relative to the root so the store can move.
+
+        Separators are normalised on the way in by :func:`posix_stored_dir`, so
+        an archive an older release wrote on Windows still resolves after it is
+        copied to another machine — without that, every version reads as missing
+        and every file in a diff comes back unreadable.
+        """
+        path = Path(posix_stored_dir(stored_dir))
         return path if path.is_absolute() else self.cfg.root / path
 
     def relative(self, path: Path) -> str:
         """A path rewritten relative to the archive root, for storing and display.
 
+        Posix-separated on every platform — ``functions/order-processor/versions/
+        0001-a1b2c3d4``, never ``functions\\order-processor\\...`` — because this
+        is what goes into ``index.db`` and into ``manifest.json``, and both are
+        meant to survive the archive being copied to another machine. Windows
+        reads a ``/``-separated path perfectly well; Linux and macOS do not read
+        a ``\\``-separated one at all. :func:`posix_stored_dir` translates what
+        earlier releases already wrote.
+
         Falls back to the absolute path when it lies outside the root, which is
         better than raising in the middle of writing a manifest.
         """
         try:
-            return str(path.relative_to(self.cfg.root))
+            return path.relative_to(self.cfg.root).as_posix()
         except ValueError:
             return str(path)
 

lambda_watcher/utils.py

@@ -7,9 +7,11 @@ import hashlib
 import logging
 import os
 import re
+import subprocess
 import unicodedata
 from datetime import datetime, timezone
 from pathlib import Path, PurePosixPath
+from typing import TypedDict
 
 LOG = logging.getLogger("lambda_watcher")
 
@@ -362,6 +364,50 @@ def rmtree(path: Path) -> None:
         shutil.rmtree(path, onerror=_onerror)
 
 
+class NoWindowKwargs(TypedDict, total=False):
+    """The ``subprocess`` keyword that suppresses a child's console window.
+
+    A ``dict[str, int]`` would say the same thing at runtime and nothing at all
+    to a type checker: splatting one into ``subprocess.run`` makes every keyword
+    it accepts look like it might be receiving an ``int``. Naming the one key
+    costs a class and buys a checked call — the same trade, and the same shape,
+    as :class:`lambda_watcher.service._DetachKwargs`.
+
+    ``total=False`` because every platform but Windows contributes no keys.
+    """
+
+    creationflags: int
+
+
+def no_window_kwargs() -> NoWindowKwargs:
+    """``subprocess`` keywords that stop a child flashing a console window open.
+
+    On Windows a console program inherits its parent's console, and is handed a
+    brand new one when the parent has none. The watcher deliberately has none —
+    ``pythonw.exe``, ``DETACHED_PROCESS``, a hidden scheduled task; see
+    :func:`lambda_watcher.service.watch_argv` — so every ``git`` and
+    ``powershell`` it shells out to during an ingest opens a console window on
+    screen for as long as it runs. Archiving one new version fires five git
+    commands and a notification, so a single downloaded zip reads to the user as
+    a burst of black rectangles flickering over whatever they were doing.
+
+    ``CREATE_NO_WINDOW`` is what suppresses that. Capturing the child's output
+    does not: the console is allocated at process creation whatever the handles
+    later point at, which is why ``capture_output=True`` at every one of those
+    call sites never helped.
+
+    Empty on every other platform, since the flag is Windows-only, so callers
+    splat it unconditionally rather than branching on the platform themselves.
+
+    Only for children whose output is captured. A command that inherits the
+    user's terminal on purpose — :func:`lambda_watcher.gitmirror.passthrough`,
+    which backs ``lw git my-fn log`` — must *not* pass this: no window means no
+    pager and no colour for a command the user typed and is watching.
+    """
+    flag = getattr(subprocess, "CREATE_NO_WINDOW", 0)
+    return {"creationflags": flag} if flag else {}
+
+
 def setup_logging(level: str = "INFO", log_file: Path | None = None) -> logging.Logger:
     """Point the shared ``lambda_watcher`` logger at a level and optional file.
 

{lambda_watcher-0.2.0.dist-info → lambda_watcher-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lambda-watcher
-Version: 0.2.0
+Version: 0.3.0
 Summary: Watch your Downloads folder for AWS Lambda deployment zips, archive them as versions, analyse them, and diff any two versions.
 Author: Lambda Watcher contributors
 License: Apache-2.0

{lambda_watcher-0.2.0.dist-info → lambda_watcher-0.3.0.dist-info}/RECORD

@@ -1,18 +1,18 @@
-lambda_watcher/__init__.py,sha256=tT0uJbE-dB70mE8yUOIcaFOfw2siK2GZzoi8sB2koLY,133
+lambda_watcher/__init__.py,sha256=_mZZjOdLL-dBMHCC3OYWDP0nYkLcuzgdBW9PdgOvEs0,133
 lambda_watcher/__main__.py,sha256=vsLRaYJej6D2A1T-YVbqSoA3fnvOUkJo7YmPWQLesO0,95
-lambda_watcher/cli.py,sha256=Z2d6qMnt141yTKPI3PhGGELWdmZjYb9u_Vd-tH2ZQ5g,65266
+lambda_watcher/cli.py,sha256=KuZ8SfxRqP5yTVPEoEYi6Kux1NifGMnfmEQdXSDbn44,66815
 lambda_watcher/config.py,sha256=M5nVaR4pwvg25i1vRvowPsdwNNo8tyf0YiEeGBdUuIg,17048
 lambda_watcher/db.py,sha256=gJMmEhKIN4Gba26-u5blk7CydxiCqmUfBnpE6Jdy3Tk,25359
 lambda_watcher/extract.py,sha256=_xMyGEdprooleMI2i6uTcl7fpRkuJcu3916PGLlKAbQ,9094
-lambda_watcher/gitmirror.py,sha256=5BFLy5-it3p7R4mjOGLIWUhLYCeKwqy58COXShjNaUM,9755
+lambda_watcher/gitmirror.py,sha256=zuzOM3WDCfmWfs11GzqRMuvU1m1dP5xTaEw4ynFs2JM,9917
 lambda_watcher/identify.py,sha256=8YyMEq4tyb-ksQkbKuYKB53mcdcbnpcdm8L6CPuFmdQ,7903
 lambda_watcher/ingest.py,sha256=0fmlPfV4Pz6aMFyQLN_yi9fSPvEd6I4AJVK16Y2ClNQ,22813
-lambda_watcher/notify.py,sha256=bnsc8Gjs26GgMsPE_Nx13dvcRZDn3zdwjoRLoyKZo0g,2797
-lambda_watcher/reindex.py,sha256=YeQKSjVgMKvieLDZIUlMnkzCXHbVQ_wb_benXLCfq94,7200
-lambda_watcher/service.py,sha256=vZMZVWVaPcnr3LLnzB66MFtFB2o6CmUTCO8QU3YrZoQ,33901
-lambda_watcher/store.py,sha256=jmGn9mFxsim48TBcgeLJRGtRl7ReCbSO_qP4PtLCcE0,10168
+lambda_watcher/notify.py,sha256=VB_N4V1TNQhF9_71jq-FtVX9ydRms5FudAtT-ngFGpc,2853
+lambda_watcher/reindex.py,sha256=q24GYCL39UOwhy0SURCJO6PHYmVKI6XyZIMUVnfCHZ0,7763
+lambda_watcher/service.py,sha256=JaJr46Ep45u-Ix4gSG-FYYnavZHRuXf246rLbHpDcQE,34366
+lambda_watcher/store.py,sha256=keU3S9fsyLwyprCM_Xc3YAoe3vZkJBmg8UW7IlVo-5Y,12952
 lambda_watcher/templates.py,sha256=H65OWVZODnKGmD73BRg5FYQQ5t5b1coC2AuZ-mU1Oi4,6638
-lambda_watcher/utils.py,sha256=h7WuJs5TnOmBm7WxLsx0Wn8kNR2nzxcSikZ2F8wa10I,14409
+lambda_watcher/utils.py,sha256=CK7SF1YDuT5hHQnf636PUvGPyK1bwWjAdBEExpbL_0g,16655
 lambda_watcher/watcher.py,sha256=fdAiFRKqkJotlcrsVHhRmWjHKK1iL3duxtNTa3abyzU,13553
 lambda_watcher/analysis/__init__.py,sha256=eRlG_pwfHwNDgv0hi26YXOYTFX9cVO-zOKxwMFsz79E,6237
 lambda_watcher/analysis/deps.py,sha256=1UBwqfI8Ju4z8-orqVfCbhzc76fW-tCXNoYcNZZUrdo,15143
@@ -24,15 +24,15 @@ lambda_watcher/analysis/secrets.py,sha256=LPhC6vqSdoNYhk1erzeUi-l4m1jEbrFVbiMvz4
 lambda_watcher/analysis/services.py,sha256=O-j6pmx-RWUTCR5mIXT0Fm2svp3tbhjMXMi1sn4gdfQ,3452
 lambda_watcher/diffing/__init__.py,sha256=oAqyVDL7Qvl8ZwyU40XuC5jSEqe7S522YJrcm7khO9g,324
 lambda_watcher/diffing/build.py,sha256=DaznYxgpvtWrDvCTY2rLRkENsOzI7uIcFic3aqiCzPY,1938
-lambda_watcher/diffing/compare.py,sha256=arvcDdZjVpIJ3D38ksokxoAAkM-VFpTOBDRsM54or1s,45544
+lambda_watcher/diffing/compare.py,sha256=UThw2OrjlNxrMr3cjKPXUFJT7GrjWHcgNaDXmUwmtXY,47703
 lambda_watcher/diffing/highlight.py,sha256=-ez73AKhFG96YWKcwGReuaNWsDPnPQUJNkPR7Q48frU,14920
 lambda_watcher/diffing/icons.py,sha256=aPPHEmwC0SpiC_pIhhMVZ3hn9nlyz6kXf_2l7IKX8LA,6144
 lambda_watcher/diffing/intraline.py,sha256=xndL6x2zNY86xmdHLypKb3o31BwOJESMG5yK3nKvkXI,13954
-lambda_watcher/diffing/render_html.py,sha256=z57OIqT-td42ZYandzyzYVd8aNncXBmxIWcUhUG3YzQ,41933
+lambda_watcher/diffing/render_html.py,sha256=ls8Lk37iAVGY1BY-WTtm0c3IXxEL7KwoqKxgMC2pKIk,57898
 lambda_watcher/diffing/render_text.py,sha256=_zfILEMSAD3qU7nX2fKm7oJXS7AMxOnKqCt7YWWMrEc,16794
-lambda_watcher-0.2.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-lambda_watcher-0.2.0.dist-info/METADATA,sha256=UvbVE-tk9sON2nkHo2mkrLY4VkSN8ylyvQaMYxA9g78,20876
-lambda_watcher-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-lambda_watcher-0.2.0.dist-info/entry_points.txt,sha256=4I-7UgtYETyEeBYbQ2dl3iEQTsPotmJiCeaaxNf-hlA,88
-lambda_watcher-0.2.0.dist-info/top_level.txt,sha256=wBObv-hwzhX_dVP1bB4-2OAyUZ2oQM7ZNROzMyRhSnI,15
-lambda_watcher-0.2.0.dist-info/RECORD,,
+lambda_watcher-0.3.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+lambda_watcher-0.3.0.dist-info/METADATA,sha256=gXchMnwXprT3PMapEOdEIAZmr1eAlM2Ce1H_cZ_SuLI,20876
+lambda_watcher-0.3.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+lambda_watcher-0.3.0.dist-info/entry_points.txt,sha256=4I-7UgtYETyEeBYbQ2dl3iEQTsPotmJiCeaaxNf-hlA,88
+lambda_watcher-0.3.0.dist-info/top_level.txt,sha256=wBObv-hwzhX_dVP1bB4-2OAyUZ2oQM7ZNROzMyRhSnI,15
+lambda_watcher-0.3.0.dist-info/RECORD,,