logics-manager 2.3.2__tar.gz → 2.4.0__tar.gz

{logics_manager-2.3.2 → logics_manager-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logics-manager
-Version: 2.3.2
+Version: 2.4.0
 Summary: Canonical Logics CLI
 Requires-Python: >=3.10
 License-File: LICENSE

{logics_manager-2.3.2 → logics_manager-2.4.0}/README.md

@@ -2,7 +2,7 @@
 
 [![CI](https://github.com/AlexAgo83/logics-manager/actions/workflows/ci.yml/badge.svg)](https://github.com/AlexAgo83/logics-manager/actions/workflows/ci.yml)
 [![License](https://img.shields.io/github/license/AlexAgo83/logics-manager)](LICENSE)
-![Version](https://img.shields.io/badge/version-v2.3.2-4C8BF5)
+![Version](https://img.shields.io/badge/version-v2.4.0-4C8BF5)
 ![VS Code](https://img.shields.io/badge/VS%20Code-1.86.0-007ACC?logo=visualstudiocode&logoColor=white)
 ![TypeScript](https://img.shields.io/badge/TypeScript-5.3.3-3178C6?logo=typescript&logoColor=white)
 ![Vitest](https://img.shields.io/badge/Vitest-2.1.8-6E9F18?logo=vitest&logoColor=white)

{logics_manager-2.3.2 → logics_manager-2.4.0}/logics_manager/viewer.py

@@ -5,6 +5,8 @@ import json
 import mimetypes
 import os
 import re
+import shutil
+import socket
 import subprocess
 import sys
 import webbrowser
@@ -40,9 +42,15 @@ DOC_FAMILIES = (
 
 STAGE_ORDER = {family.stage: index for index, family in enumerate(DOC_FAMILIES)}
 REPO_ROOT = Path(__file__).resolve().parents[1]
+PACKAGE_VIEWER_ASSETS_ROOT = Path(__file__).resolve().parent / "viewer_assets"
 VIEWER_ROOT = REPO_ROOT / "clients" / "viewer"
+if not (VIEWER_ROOT / "index.html").is_file():
+    VIEWER_ROOT = PACKAGE_VIEWER_ASSETS_ROOT / "viewer"
 SHARED_MEDIA_ROOT = REPO_ROOT / "clients" / "shared-web" / "media"
+if not SHARED_MEDIA_ROOT.is_dir():
+    SHARED_MEDIA_ROOT = PACKAGE_VIEWER_ASSETS_ROOT / "media"
 DIST_VENDOR_ROOT = REPO_ROOT / "dist" / "vendor"
+PACKAGE_VENDOR_ROOT = PACKAGE_VIEWER_ASSETS_ROOT / "vendor"
 NODE_MERMAID_ROOT = REPO_ROOT / "node_modules" / "mermaid" / "dist"
 
 
@@ -322,9 +330,16 @@ def collect_viewer_items(repo_root: Path) -> list[dict[str, Any]]:
     return items
 
 
-def viewer_data_payload(repo_root: Path, selected_id: str | None = None) -> dict[str, Any]:
+def viewer_data_payload(
+    repo_root: Path,
+    selected_id: str | None = None,
+    *,
+    auto_refresh_interval_seconds: int = 60,
+) -> dict[str, Any]:
     return {
         "root": str(repo_root.resolve()),
+        "repoName": repo_root.resolve().name,
+        "autoRefreshIntervalSeconds": auto_refresh_interval_seconds,
         "items": collect_viewer_items(repo_root),
         "updateInfo": get_update_info(_current_version()).to_payload(),
         "selectedId": selected_id,
@@ -378,13 +393,122 @@ def _system_editor_command(path: Path) -> list[str]:
     return ["xdg-open", str(path)]
 
 
+def _run_read_only_git(repo_root: Path, args: list[str], *, runner: Any | None = None) -> subprocess.CompletedProcess[str]:
+    command = ["git", *args]
+    git_runner = runner or subprocess.run
+    return git_runner(command, cwd=repo_root, text=True, capture_output=True, timeout=5)
+
+
+def _sanitize_git_ref(value: str) -> str:
+    ref = value.strip()
+    ref = re.sub(r"://[^/@\s]+@", "://", ref)
+    ref = re.sub(r"^[^/@\s]+@", "", ref)
+    return ref[:200]
+
+
+def _classify_porcelain_entry(line: str) -> tuple[str, dict[str, str]] | None:
+    if not line or line.startswith("## "):
+        return None
+    if line.startswith("?? "):
+        return "untracked", {"path": line[3:].strip()}
+    if len(line) < 4:
+        return None
+    staged = line[0]
+    worktree = line[1]
+    raw_path = line[3:].strip()
+    if " -> " in raw_path:
+        before, after = raw_path.split(" -> ", 1)
+        return "renamed", {"path": after.strip(), "from": before.strip()}
+    if staged == "R":
+        return "renamed", {"path": raw_path}
+    if staged not in {" ", "?", "!"}:
+        return "staged", {"path": raw_path, "code": staged}
+    if worktree == "D":
+        return "deleted", {"path": raw_path, "code": worktree}
+    if worktree not in {" ", "?", "!"}:
+        return "modified", {"path": raw_path, "code": worktree}
+    return None
+
+
+def _parse_git_branch_line(line: str) -> dict[str, Any]:
+    branch = line[3:].strip() if line.startswith("## ") else ""
+    tracking = ""
+    ahead = 0
+    behind = 0
+    if "..." in branch:
+        branch, tracking_part = branch.split("...", 1)
+        if " [" in tracking_part:
+            tracking, details = tracking_part.split(" [", 1)
+            for detail in details.rstrip("]").split(", "):
+                if detail.startswith("ahead "):
+                    ahead = int(detail.removeprefix("ahead ") or "0")
+                if detail.startswith("behind "):
+                    behind = int(detail.removeprefix("behind ") or "0")
+        else:
+            tracking = tracking_part
+    return {
+        "branch": _sanitize_git_ref(branch or "HEAD"),
+        "tracking": _sanitize_git_ref(tracking),
+        "ahead": ahead,
+        "behind": behind,
+    }
+
+
+def git_status_payload(repo_root: Path, *, runner: Any | None = None, which: Any | None = None) -> dict[str, Any]:
+    git_which = which or shutil.which
+    if not git_which("git"):
+        return {"state": "unavailable", "message": "Git is not available on PATH."}
+    try:
+        inside = _run_read_only_git(repo_root, ["rev-parse", "--is-inside-work-tree"], runner=runner)
+    except (OSError, subprocess.SubprocessError) as exc:
+        return {"state": "error", "message": f"Unable to run Git status: {exc}"}
+    if inside.returncode != 0 or inside.stdout.strip().lower() != "true":
+        return {"state": "not-repository", "message": "This folder is not inside a Git worktree."}
+
+    try:
+        status = _run_read_only_git(repo_root, ["status", "--porcelain=v1", "-b"], runner=runner)
+        commit = _run_read_only_git(repo_root, ["log", "-1", "--pretty=format:%h %s"], runner=runner)
+    except (OSError, subprocess.SubprocessError) as exc:
+        return {"state": "error", "message": f"Unable to collect Git status: {exc}"}
+    if status.returncode != 0:
+        message = (status.stderr or status.stdout or "Git status failed.").strip().splitlines()[0]
+        return {"state": "error", "message": message}
+
+    lines = status.stdout.splitlines()
+    branch_info = _parse_git_branch_line(lines[0]) if lines else {"branch": "HEAD", "tracking": "", "ahead": 0, "behind": 0}
+    groups: dict[str, list[dict[str, str]]] = {key: [] for key in ("staged", "modified", "deleted", "renamed", "untracked")}
+    for line in lines[1:]:
+        classified = _classify_porcelain_entry(line)
+        if classified:
+            group, entry = classified
+            groups[group].append(entry)
+    counts = {key: len(value) for key, value in groups.items()}
+    dirty = any(counts.values())
+    return {
+        "state": "ok",
+        **branch_info,
+        "clean": not dirty,
+        "dirty": dirty,
+        "counts": counts,
+        "groups": groups,
+        "latestCommit": (commit.stdout.strip() if commit.returncode == 0 else "")[:300],
+    }
+
+
 def _json_bytes(payload: Any) -> bytes:
     return json.dumps(payload, indent=2, sort_keys=True).encode("utf-8")
 
 
 class LogicsViewerServer(ThreadingHTTPServer):
-    def __init__(self, server_address: tuple[str, int], repo_root: Path):
+    def __init__(
+        self,
+        server_address: tuple[str, int],
+        repo_root: Path,
+        *,
+        auto_refresh_interval_seconds: int = 60,
+    ):
         self.repo_root = repo_root.resolve()
+        self.auto_refresh_interval_seconds = auto_refresh_interval_seconds
         super().__init__(server_address, LogicsViewerRequestHandler)
 
 
@@ -435,6 +559,8 @@ class LogicsViewerRequestHandler(BaseHTTPRequestHandler):
             vendor_path = DIST_VENDOR_ROOT / "mermaid.min.js"
             if not vendor_path.is_file():
                 vendor_path = NODE_MERMAID_ROOT / "mermaid.min.js"
+            if not vendor_path.is_file():
+                vendor_path = PACKAGE_VENDOR_ROOT / "mermaid.min.js"
             self._serve_file(vendor_path)
             return
         if route.startswith("/media/"):
@@ -445,7 +571,15 @@ class LogicsViewerRequestHandler(BaseHTTPRequestHandler):
             self._serve_file(media_path)
             return
         if route == "/api/items":
-            self._send_json({"ok": True, "payload": viewer_data_payload(self.server.repo_root)})
+            self._send_json(
+                {
+                    "ok": True,
+                    "payload": viewer_data_payload(
+                        self.server.repo_root,
+                        auto_refresh_interval_seconds=self.server.auto_refresh_interval_seconds,
+                    ),
+                }
+            )
             return
         if route == "/api/doc":
             rel_path = parse_qs(parsed.query).get("path", [""])[0]
@@ -460,12 +594,23 @@ class LogicsViewerRequestHandler(BaseHTTPRequestHandler):
         if route == "/api/audit":
             self._send_json({"ok": True, "payload": audit_payload(self.server.repo_root)})
             return
+        if route == "/api/git-status":
+            self._send_json({"ok": True, "payload": git_status_payload(self.server.repo_root)})
+            return
         self._send_error_json(HTTPStatus.NOT_FOUND, "Not found")
 
     def do_POST(self) -> None:
         parsed = urlparse(self.path)
         if parsed.path == "/api/refresh":
-            self._send_json({"ok": True, "payload": viewer_data_payload(self.server.repo_root)})
+            self._send_json(
+                {
+                    "ok": True,
+                    "payload": viewer_data_payload(
+                        self.server.repo_root,
+                        auto_refresh_interval_seconds=self.server.auto_refresh_interval_seconds,
+                    ),
+                }
+            )
             return
         if parsed.path == "/api/edit":
             rel_path = parse_qs(parsed.query).get("path", [""])[0]
@@ -479,19 +624,52 @@ class LogicsViewerRequestHandler(BaseHTTPRequestHandler):
         self._send_error_json(HTTPStatus.NOT_FOUND, "Not found")
 
 
-def create_viewer_server(repo_root: Path, host: str = "127.0.0.1", port: int = 8765) -> LogicsViewerServer:
-    return LogicsViewerServer((host, port), repo_root)
+def create_viewer_server(
+    repo_root: Path,
+    host: str = "127.0.0.1",
+    port: int = 8765,
+    *,
+    auto_refresh_interval_seconds: int = 60,
+) -> LogicsViewerServer:
+    return LogicsViewerServer(
+        (host, port),
+        repo_root,
+        auto_refresh_interval_seconds=auto_refresh_interval_seconds,
+    )
 
 
-def render_start_status(url: str, repo_root: Path, *, focus: str | None = None) -> str:
+def _network_viewer_url(host: str, port: int, *, focus: str | None = None, read: bool = False) -> str | None:
+    if host not in {"0.0.0.0", "::", ""}:
+        return None
+    try:
+        candidate = socket.gethostbyname(socket.gethostname())
+    except OSError:
+        return None
+    if not candidate or candidate.startswith("127."):
+        return None
+    return build_viewer_url(candidate, port, focus=focus, read=read)
+
+
+def render_start_status(
+    url: str,
+    repo_root: Path,
+    *,
+    focus: str | None = None,
+    network_url: str | None = None,
+    bind_host: str = "localhost",
+    auto_refresh_interval_seconds: int = 60,
+) -> str:
     lines = [
         "Logics viewer running:",
-        url,
+        f"Local: {url}",
         "",
         f"Repo: {repo_root.name}",
         "Mode: read-only",
-        "Bind: localhost",
+        f"Bind: {bind_host}",
+        f"Auto refresh: {auto_refresh_interval_seconds}s",
     ]
+    if network_url:
+        lines.insert(2, f"Network: {network_url}")
     if focus:
         lines.append(f"Focus: {focus}")
     return "\n".join(lines)
@@ -501,6 +679,12 @@ def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(prog="logics-manager view", description="Start the local read-only Logics browser viewer.")
     parser.add_argument("--host", default="127.0.0.1", help="Bind host. Defaults to 127.0.0.1.")
     parser.add_argument("--port", type=int, default=8765, help="Bind port. Use 0 to select an available port.")
+    parser.add_argument(
+        "--refresh-interval",
+        type=int,
+        default=60,
+        help="Automatic refresh interval in seconds. Defaults to 60; positive shorter intervals are allowed.",
+    )
     parser.add_argument("--focus", help="Open the viewer focused on a workflow ref or repo-relative Logics Markdown path.")
     parser.add_argument("--read", action="store_true", help="Open the focused item in the read preview. Requires --focus.")
     parser.add_argument("--open", action="store_true", help="Open the viewer in the default browser.")
@@ -511,16 +695,34 @@ def build_parser() -> argparse.ArgumentParser:
 def main(argv: list[str]) -> int:
     args = build_parser().parse_args(argv)
     repo_root = find_repo_root(Path.cwd())
+    if args.refresh_interval <= 0:
+        raise SystemExit("--refresh-interval must be a positive number of seconds.")
     if args.read and not args.focus:
         raise SystemExit("--read requires --focus.")
     try:
         focus = normalize_viewer_focus_target(repo_root, args.focus) if args.focus else None
     except ValueError as exc:
         raise SystemExit(str(exc)) from exc
-    server = create_viewer_server(repo_root, host=args.host, port=args.port)
+    server = create_viewer_server(
+        repo_root,
+        host=args.host,
+        port=args.port,
+        auto_refresh_interval_seconds=args.refresh_interval,
+    )
     host, port = server.server_address[:2]
     url = build_viewer_url(str(host), int(port), focus=focus, read=bool(args.read))
-    print(render_start_status(url, repo_root, focus=focus), flush=True)
+    network_url = _network_viewer_url(str(host), int(port), focus=focus, read=bool(args.read))
+    print(
+        render_start_status(
+            url,
+            repo_root,
+            focus=focus,
+            network_url=network_url,
+            bind_host=str(host),
+            auto_refresh_interval_seconds=args.refresh_interval,
+        ),
+        flush=True,
+    )
     if args.open and not args.no_open:
         webbrowser.open(url)