@grifhinz/logics-manager 2.1.2 → 2.3.0

package/logics_manager/sync.py

@@ -10,6 +10,7 @@ from pathlib import Path
 
 from .config import find_repo_root
 from .lint import expected_workflow_mermaid_signature
+from .path_utils import resolve_repo_output_path
 from .termstyle import colorize_help
 
 
@@ -576,9 +577,10 @@ def append_workflow_note_payload(repo_root: Path, source: str, *, note_kind: str
             changed = False
         else:
             lines.insert(insert_at, bullet)
+    mermaid_signature_refreshed = False
     if changed and not dry_run:
         path.write_text("\n".join(lines).rstrip() + "\n", encoding="utf-8")
-        refresh_workflow_mermaid_signature_file(path, kind, dry_run=False, repo_root=repo_root)
+        mermaid_signature_refreshed = refresh_workflow_mermaid_signature_file(path, kind, dry_run=False, repo_root=repo_root)
     return {
         "path": path.relative_to(repo_root).as_posix(),
         "ref": path.stem,
@@ -586,6 +588,7 @@ def append_workflow_note_payload(repo_root: Path, source: str, *, note_kind: str
         "section": section,
         "text": cleaned,
         "changed": changed,
+        "mermaid_signature_refreshed": mermaid_signature_refreshed,
         "dry_run": dry_run,
     }
 
@@ -689,7 +692,7 @@ def refresh_workflow_mermaid_signature_file(path: Path, kind: str, dry_run: bool
     return True
 
 
-def _close_eligible_requests(repo_root: Path, dry_run: bool) -> tuple[int, int]:
+def _close_eligible_requests(repo_root: Path, dry_run: bool, *, quiet: bool = False) -> tuple[int, int]:
     request_dir = repo_root / DOC_KINDS["request"]["directory"]
     closed = 0
     scanned = 0
@@ -703,7 +706,8 @@ def _close_eligible_requests(repo_root: Path, dry_run: bool) -> tuple[int, int]:
             continue
         if all(_is_doc_done(item_path, "backlog") for item_path in linked_items):
             _close_doc(request_path, "request", dry_run)
-            print(f"Auto-closed request {request_ref} (all linked backlog items are done).")
+            if not quiet:
+                print(f"Auto-closed request {request_ref} (all linked backlog items are done).")
             closed += 1
     return scanned, closed
 
@@ -1030,7 +1034,7 @@ def _print_help(text: str) -> None:
 
 def cmd_close_eligible_requests(args: argparse.Namespace) -> dict[str, object]:
     repo_root = _find_repo_root(Path.cwd())
-    scanned, closed = _close_eligible_requests(repo_root, args.dry_run)
+    scanned, closed = _close_eligible_requests(repo_root, args.dry_run, quiet=args.format == "json")
     payload = {
         "command": "sync",
         "kind": "close-eligible-requests",
@@ -1161,6 +1165,8 @@ def cmd_append_note(args: argparse.Namespace) -> dict[str, object]:
         print(json.dumps(payload, indent=2, sort_keys=True))
     else:
         print(f"Appended {args.section} note to {payload['path']} (changed: {payload['changed']}).")
+        if payload.get("mermaid_signature_refreshed"):
+            print("- Mermaid signature refreshed.")
     return {"command": "sync", "kind": "append-note", "repo_root": repo_root.as_posix(), **payload}
 
 
@@ -1168,13 +1174,16 @@ def cmd_context_pack(args: argparse.Namespace) -> dict[str, object]:
     repo_root = _find_repo_root(Path.cwd())
     payload = _build_context_pack(repo_root, args.ref, mode=args.mode, profile=args.profile, config=None)
     if args.out:
-        out_path = (repo_root / args.out).resolve()
+        out_path, output_path = resolve_repo_output_path(repo_root, args.out)
         serialized = json.dumps(payload, indent=2, sort_keys=True) + "\n"
-        out_path.parent.mkdir(parents=True, exist_ok=True)
         if not args.dry_run:
+            out_path.parent.mkdir(parents=True, exist_ok=True)
             out_path.write_text(serialized, encoding="utf-8")
-        print(f"Wrote {out_path.relative_to(repo_root)}")
-        payload["output_path"] = out_path.relative_to(repo_root).as_posix()
+        payload["output_path"] = output_path
+        if args.format == "json":
+            print(json.dumps(payload, indent=2, sort_keys=True))
+        else:
+            print(f"Wrote {output_path}")
     else:
         if args.format == "json":
             print(json.dumps(payload, indent=2, sort_keys=True))
@@ -1189,13 +1198,16 @@ def cmd_export_graph(args: argparse.Namespace) -> dict[str, object]:
     payload = _graph_payload(repo_root, config=None)
     payload["repo_root"] = repo_root.as_posix()
     if args.out:
-        out_path = (repo_root / args.out).resolve()
+        out_path, output_path = resolve_repo_output_path(repo_root, args.out)
         serialized = json.dumps(payload, indent=2, sort_keys=True) + "\n"
-        out_path.parent.mkdir(parents=True, exist_ok=True)
         if not args.dry_run:
+            out_path.parent.mkdir(parents=True, exist_ok=True)
             out_path.write_text(serialized, encoding="utf-8")
-        print(f"Wrote {out_path.relative_to(repo_root)}")
-        payload["output_path"] = out_path.relative_to(repo_root).as_posix()
+        payload["output_path"] = output_path
+        if args.format == "json":
+            print(json.dumps(payload, indent=2, sort_keys=True))
+        else:
+            print(f"Wrote {output_path}")
     else:
         if args.format == "json":
             print(json.dumps(payload, indent=2, sort_keys=True))

package/logics_manager/update_check.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+import os
+from pathlib import Path
+import time
+from typing import Any, Callable
+from urllib.error import URLError
+from urllib.request import urlopen
+
+
+NPM_LATEST_URL = "https://registry.npmjs.org/@grifhinz%2Flogics-manager/latest"
+DISABLE_ENV = "LOGICS_MANAGER_NO_UPDATE_CHECK"
+CHECK_INTERVAL_SECONDS = 24 * 60 * 60
+
+
+@dataclass(frozen=True)
+class UpdateInfo:
+    current_version: str
+    latest_version: str | None
+    update_available: bool
+    checked_at: int | None
+    update_command: str
+    source: str
+
+    def to_payload(self) -> dict[str, Any]:
+        return {
+            "currentVersion": self.current_version,
+            "latestVersion": self.latest_version,
+            "updateAvailable": self.update_available,
+            "checkedAt": self.checked_at,
+            "updateCommand": self.update_command,
+            "source": self.source,
+        }
+
+
+def _parse_version(value: str | None) -> tuple[int, int, int, str]:
+    raw = (value or "").strip().lstrip("v")
+    parts = raw.split(".", 3)
+    numeric: list[int] = []
+    suffix = ""
+    for index, part in enumerate(parts[:3]):
+        digits = ""
+        rest = ""
+        for char in part:
+            if char.isdigit() and not rest:
+                digits += char
+            else:
+                rest += char
+        numeric.append(int(digits or "0"))
+        if rest:
+            suffix = ".".join([rest, *parts[index + 1 :]])
+            break
+    while len(numeric) < 3:
+        numeric.append(0)
+    return numeric[0], numeric[1], numeric[2], suffix
+
+
+def is_newer_version(latest: str | None, current: str | None) -> bool:
+    latest_tuple = _parse_version(latest)
+    current_tuple = _parse_version(current)
+    return latest_tuple[:3] > current_tuple[:3]
+
+
+def update_cache_path() -> Path:
+    override = os.environ.get("LOGICS_MANAGER_UPDATE_CACHE")
+    if override:
+        return Path(override)
+    cache_root = os.environ.get("XDG_CACHE_HOME")
+    if cache_root:
+        return Path(cache_root) / "logics-manager" / "update-check.json"
+    return Path.home() / ".cache" / "logics-manager" / "update-check.json"
+
+
+def _read_cache(path: Path, now: int) -> dict[str, Any] | None:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    checked_at = int(payload.get("checked_at") or 0)
+    if checked_at <= 0 or now - checked_at > CHECK_INTERVAL_SECONDS:
+        return None
+    return payload if isinstance(payload, dict) else None
+
+
+def _write_cache(path: Path, payload: dict[str, Any]) -> None:
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(payload, sort_keys=True), encoding="utf-8")
+    except OSError:
+        return
+
+
+def fetch_latest_npm_version(*, timeout: float = 0.75, opener: Callable[..., Any] = urlopen) -> str | None:
+    try:
+        with opener(NPM_LATEST_URL, timeout=timeout) as response:
+            payload = json.loads(response.read().decode("utf-8"))
+    except (OSError, URLError, TimeoutError, json.JSONDecodeError, ValueError):
+        return None
+    version = payload.get("version") if isinstance(payload, dict) else None
+    return version.strip() if isinstance(version, str) and version.strip() else None
+
+
+def get_update_info(
+    current_version: str,
+    *,
+    cache_path: Path | None = None,
+    now: int | None = None,
+    fetch_latest: Callable[[], str | None] | None = None,
+) -> UpdateInfo:
+    now_value = int(time.time() if now is None else now)
+    path = cache_path or update_cache_path()
+    cached = _read_cache(path, now_value)
+    latest = str(cached.get("latest_version") or "") if cached else ""
+    if not latest:
+        latest = (fetch_latest or fetch_latest_npm_version)() or ""
+        _write_cache(path, {"checked_at": now_value, "latest_version": latest})
+    return UpdateInfo(
+        current_version=current_version,
+        latest_version=latest or None,
+        update_available=is_newer_version(latest, current_version),
+        checked_at=now_value,
+        update_command="logics-manager self-update",
+        source="npm",
+    )
+
+
+def get_update_notice(current_version: str) -> str | None:
+    if os.environ.get(DISABLE_ENV):
+        return None
+    info = get_update_info(current_version)
+    if not info.update_available or not info.latest_version:
+        return None
+    return (
+        f"logics-manager {info.latest_version} is available "
+        f"(current {info.current_version}). Run `{info.update_command}` to update."
+    )