@grifhinz/logics-manager 2.3.3 → 2.5.0

package/logics_manager/lint.py

@@ -25,8 +25,8 @@ KINDS = {
     "request": Kind("logics/request", "req", False, ("From version", "Understanding", "Confidence"), ("Draft", "Ready", "In progress", "Blocked", "Done", "Obsolete", "Archived")),
     "backlog": Kind("logics/backlog", "item", True, ("From version", "Understanding", "Confidence", "Progress"), ("Draft", "Ready", "In progress", "Blocked", "Done", "Obsolete", "Archived")),
     "task": Kind("logics/tasks", "task", True, ("From version", "Understanding", "Confidence", "Progress"), ("Draft", "Ready", "In progress", "Blocked", "Done", "Obsolete", "Archived")),
-    "product": Kind("logics/product", "prod", False, ("Date", "Status", "Related request", "Related backlog", "Related task", "Related architecture", "Reminder"), ("Draft", "Proposed", "Active", "Validated", "Rejected", "Superseded", "Archived")),
-    "architecture": Kind("logics/architecture", "adr", False, ("Date", "Status", "Drivers", "Related request", "Related backlog", "Related task", "Reminder"), ("Draft", "Proposed", "Accepted", "Rejected", "Superseded", "Archived")),
+    "product": Kind("logics/product", "prod", False, ("Date", "Status", "Related request", "Related backlog", "Related task", "Related architecture", "Reminder"), ("Draft", "Proposed", "Active", "Accepted", "Validated", "Rejected", "Superseded", "Settled", "Archived")),
+    "architecture": Kind("logics/architecture", "adr", False, ("Date", "Status", "Drivers", "Related request", "Related backlog", "Related task", "Reminder"), ("Draft", "Proposed", "Accepted", "Validated", "Rejected", "Superseded", "Settled", "Archived")),
 }
 
 WORKFLOW_KINDS = {"request", "backlog", "task"}

package/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
@@ -328,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 = 15,
+) -> 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,
@@ -384,13 +393,285 @@ 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 _run_read_only_cdx(repo_root: Path, args: list[str], *, runner: Any | None = None) -> subprocess.CompletedProcess[str]:
+    command = ["cdx", *args]
+    cdx_runner = runner or subprocess.run
+    return cdx_runner(command, cwd=repo_root, text=True, capture_output=True, timeout=5)
+
+
+def _logics_doc_type(rel_path: str) -> str:
+    normalized = rel_path.replace("\\", "/").lstrip("/")
+    for family in DOC_FAMILIES:
+        if normalized.startswith(f"{family.directory}/"):
+            return family.stage
+    return ""
+
+
+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("?? "):
+        path = line[3:].strip()
+        return "untracked", {"path": path, "logicsType": _logics_doc_type(path)}
+    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)
+        path = after.strip()
+        return "renamed", {"path": path, "from": before.strip(), "logicsType": _logics_doc_type(path)}
+    if staged == "R":
+        return "renamed", {"path": raw_path, "logicsType": _logics_doc_type(raw_path)}
+    if staged not in {" ", "?", "!"}:
+        return "staged", {"path": raw_path, "code": staged, "logicsType": _logics_doc_type(raw_path)}
+    if worktree == "D":
+        return "deleted", {"path": raw_path, "code": worktree, "logicsType": _logics_doc_type(raw_path)}
+    if worktree not in {" ", "?", "!"}:
+        return "modified", {"path": raw_path, "code": worktree, "logicsType": _logics_doc_type(raw_path)}
+    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 _parse_recent_git_commits(output: str) -> list[dict[str, str]]:
+    commits: list[dict[str, str]] = []
+    for line in output.splitlines():
+        parts = line.split("\x1f")
+        if len(parts) < 5:
+            continue
+        commit_hash, subject, author, date, refs = parts[:5]
+        commits.append(
+            {
+                "hash": _sanitize_git_ref(commit_hash),
+                "subject": subject.strip()[:240],
+                "author": author.strip()[:120],
+                "date": date.strip()[:40],
+                "refs": _sanitize_git_ref(refs),
+            }
+        )
+    return commits
+
+
+def _count_unique_git_status_paths(groups: dict[str, list[dict[str, str]]]) -> int:
+    paths: set[str] = set()
+    for entries in groups.values():
+        for entry in entries:
+            path = entry.get("path", "").strip()
+            if path:
+                paths.add(path)
+    return len(paths)
+
+
+def _git_unpushed_commit_count(repo_root: Path, *, runner: Any | None = None) -> dict[str, Any]:
+    try:
+        upstream = _run_read_only_git(repo_root, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], runner=runner)
+    except (OSError, subprocess.SubprocessError) as exc:
+        return {"available": False, "count": 0, "message": f"Unable to inspect upstream: {exc}"}
+    if upstream.returncode != 0:
+        return {"available": False, "count": 0, "message": "No upstream branch detected."}
+
+    tracking = _sanitize_git_ref(upstream.stdout.strip())
+    try:
+        unpushed = _run_read_only_git(repo_root, ["rev-list", "--count", "@{u}..HEAD"], runner=runner)
+    except (OSError, subprocess.SubprocessError) as exc:
+        return {"available": False, "count": 0, "tracking": tracking, "message": f"Unable to count unpushed commits: {exc}"}
+    if unpushed.returncode != 0:
+        message = (unpushed.stderr or unpushed.stdout or "Unable to count unpushed commits.").strip().splitlines()[0]
+        return {"available": False, "count": 0, "tracking": tracking, "message": message}
+
+    try:
+        count = max(0, int(unpushed.stdout.strip() or "0"))
+    except ValueError:
+        count = 0
+    return {"available": True, "count": count, "tracking": tracking, "message": ""}
+
+
+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)
+        recent_commits = _run_read_only_git(
+            repo_root,
+            ["log", "-8", "--date=short", "--pretty=format:%h%x1f%s%x1f%an%x1f%ad%x1f%D"],
+            runner=runner,
+        )
+        unpushed = _git_unpushed_commit_count(repo_root, 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()}
+    uncommitted_files = _count_unique_git_status_paths(groups)
+    dirty = any(counts.values())
+    return {
+        "state": "ok",
+        **branch_info,
+        "clean": not dirty,
+        "dirty": dirty,
+        "counts": counts,
+        "badgeCounts": {
+            "unpushedCommits": int(unpushed.get("count", 0)),
+            "uncommittedFiles": uncommitted_files,
+        },
+        "badgeAvailability": {
+            "unpushedCommits": bool(unpushed.get("available")),
+            "uncommittedFiles": True,
+        },
+        "badgeMessages": {
+            "unpushedCommits": str(unpushed.get("message", "")),
+            "uncommittedFiles": "",
+        },
+        "groups": groups,
+        "latestCommit": (commit.stdout.strip() if commit.returncode == 0 else "")[:300],
+        "recentCommits": _parse_recent_git_commits(recent_commits.stdout) if recent_commits.returncode == 0 else [],
+    }
+
+
+def git_diff_payload(
+    repo_root: Path,
+    rel_path: str,
+    *,
+    cached: bool = False,
+    max_chars: int = 20000,
+    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."}
+    normalized = unquote(rel_path).replace("\\", "/").lstrip("/")
+    if not normalized or normalized.startswith("~") or normalized.startswith("/") or ".." in normalized.split("/"):
+        return {"state": "error", "message": "Unsafe Git 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 diff: {exc}"}
+    if inside.returncode != 0 or inside.stdout.strip().lower() != "true":
+        return {"state": "not-repository", "message": "This folder is not inside a Git worktree."}
+
+    args = ["diff", "--no-ext-diff", "--unified=80"]
+    if cached:
+        args.append("--cached")
+    args.extend(["--", normalized])
+    try:
+        diff = _run_read_only_git(repo_root, args, runner=runner)
+    except (OSError, subprocess.SubprocessError) as exc:
+        return {"state": "error", "message": f"Unable to collect Git diff: {exc}"}
+    if diff.returncode != 0:
+        message = (diff.stderr or diff.stdout or "Git diff failed.").strip().splitlines()[0]
+        return {"state": "error", "message": message}
+    content = diff.stdout
+    truncated = len(content) > max_chars
+    if truncated:
+        content = content[:max_chars]
+    return {
+        "state": "ok",
+        "path": normalized,
+        "mode": "staged" if cached else "worktree",
+        "diff": content,
+        "truncated": truncated,
+        "logicsType": _logics_doc_type(normalized),
+        "message": "" if content else "No diff is available for this file in the selected mode.",
+    }
+
+
+def cdx_status_payload(repo_root: Path, *, runner: Any | None = None, which: Any | None = None) -> dict[str, Any]:
+    cdx_which = which or shutil.which
+    if not cdx_which("cdx"):
+        return {"state": "unavailable", "message": "CDX is not available on PATH.", "status": {}}
+
+    try:
+        status = _run_read_only_cdx(repo_root, ["status", "--json"], runner=runner)
+    except subprocess.TimeoutExpired:
+        return {"state": "timeout", "message": "CDX status timed out.", "status": {}}
+    except (OSError, subprocess.SubprocessError) as exc:
+        return {"state": "error", "message": f"Unable to run CDX status: {exc}", "status": {}}
+
+    if status.returncode != 0:
+        message = (status.stderr or status.stdout or "CDX status failed.").strip().splitlines()[0]
+        return {"state": "error", "message": message, "status": {}}
+
+    try:
+        parsed = json.loads(status.stdout or "{}")
+    except json.JSONDecodeError:
+        return {"state": "invalid-json", "message": "CDX status returned invalid JSON.", "status": {}}
+    if not isinstance(parsed, dict):
+        return {"state": "invalid-json", "message": "CDX status JSON must be an object.", "status": {}}
+
+    return {"state": "ok", "message": "", "status": parsed}
+
+
 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 = 15,
+    ):
         self.repo_root = repo_root.resolve()
+        self.auto_refresh_interval_seconds = auto_refresh_interval_seconds
         super().__init__(server_address, LogicsViewerRequestHandler)
 
 
@@ -453,7 +734,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]
@@ -468,12 +757,32 @@ 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
+        if route == "/api/cdx-status":
+            self._send_json({"ok": True, "payload": cdx_status_payload(self.server.repo_root)})
+            return
+        if route == "/api/git-diff":
+            params = parse_qs(parsed.query)
+            rel_path = params.get("path", [""])[0]
+            cached = params.get("cached", [""])[0].lower() in {"1", "true", "yes"}
+            self._send_json({"ok": True, "payload": git_diff_payload(self.server.repo_root, rel_path, cached=cached)})
+            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]
@@ -487,19 +796,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 = 15,
+) -> 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 = 15,
+) -> 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)
@@ -509,6 +851,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=15,
+        help="Automatic refresh interval in seconds. Defaults to 15; positive 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.")
@@ -519,16 +867,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)
 

package/package.json

@@ -2,7 +2,7 @@
   "name": "@grifhinz/logics-manager",
   "displayName": "Logics Orchestrator",
   "description": "Visual orchestration for Logics workflows inside VS Code.",
-  "version": "2.3.3",
+  "version": "2.5.0",
   "publisher": "cdx-logics",
   "icon": "clients/shared-web/media/icon.png",
   "repository": {
@@ -127,6 +127,7 @@
     "test:coverage:media": "node scripts/run-plugin-coverage.mjs media",
     "test:coverage": "npm run test:coverage:src && npm run test:coverage:media",
     "test:smoke": "node tests/run_extension_smoke_checks.mjs",
+    "test:viewer-smoke": "node tests/run_local_viewer_visual_smoke.mjs",
     "test:npm-cli": "node scripts/npm/logics-manager.mjs --help",
     "test:lifecycle": "node tests/run_plugin_lifecycle_checks.mjs",
     "test:watch": "vitest",
@@ -155,14 +156,15 @@
     "@types/vscode": "^1.86.0",
     "@typescript-eslint/eslint-plugin": "^8.58.1",
     "@typescript-eslint/parser": "^8.58.1",
-    "@vscode/vsce": "^3.9.1",
     "@vitest/coverage-v8": "^4.1.2",
+    "@vscode/vsce": "^3.9.1",
     "esbuild": "^0.25.10",
     "eslint": "^10.2.0",
     "jsdom": "^25.0.1",
     "mermaid": "^11.14.0",
     "typescript": "^5.3.3",
     "vitest": "^4.1.2",
+    "ws": "8.21.0",
     "yaml": "^2.8.3",
     "yauzl": "^3.2.0"
   },

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "logics-manager"
-version = "2.3.3"
+version = "2.5.0"
 description = "Canonical Logics CLI"
 requires-python = ">=3.10"