@grifhinz/logics-manager 2.4.0 → 2.5.1

package/logics_manager/mcp.py

@@ -427,7 +427,7 @@ def _markdown_file_path(repo_root: Path, raw_path: str, allowed_dirs: tuple[str,
 
 def _run_command(repo_root: Path, args: list[str]) -> subprocess.CompletedProcess[str]:
     command = [sys.executable, "-m", "logics_manager", *args]
-    result = subprocess.run(command, cwd=repo_root, check=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    result = subprocess.run(command, cwd=repo_root, check=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, env=_subprocess_env())
     if result.returncode != 0:
         raise McpToolError(
             "command_failed",
@@ -439,7 +439,7 @@ def _run_command(repo_root: Path, args: list[str]) -> subprocess.CompletedProces
 
 def _run_json_command(repo_root: Path, args: list[str]) -> dict[str, Any]:
     command = [sys.executable, "-m", "logics_manager", *args]
-    result = subprocess.run(command, cwd=repo_root, check=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    result = subprocess.run(command, cwd=repo_root, check=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, env=_subprocess_env())
     payload = _json_from_stdout_or_none(result.stdout)
     if payload is None:
         raise McpToolError(
@@ -450,6 +450,14 @@ def _run_json_command(repo_root: Path, args: list[str]) -> dict[str, Any]:
     return payload
 
 
+def _subprocess_env() -> dict[str, str]:
+    env = os.environ.copy()
+    source_root = str(Path(__file__).resolve().parents[1])
+    existing = env.get("PYTHONPATH")
+    env["PYTHONPATH"] = source_root if not existing else os.pathsep.join([source_root, existing])
+    return env
+
+
 def _json_from_stdout(stdout: str) -> dict[str, Any]:
     start = stdout.find("{")
     end = stdout.rfind("}")

package/logics_manager/viewer.py

@@ -14,6 +14,7 @@ from dataclasses import dataclass
 from datetime import datetime
 from http import HTTPStatus
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from importlib import metadata
 from pathlib import Path
 from typing import Any
 from urllib.parse import parse_qs, quote, unquote, urlencode, urlparse
@@ -56,8 +57,14 @@ NODE_MERMAID_ROOT = REPO_ROOT / "node_modules" / "mermaid" / "dist"
 
 def _current_version() -> str:
     try:
-        return (REPO_ROOT / "VERSION").read_text(encoding="utf-8").strip() or "0.0.0"
+        version = (REPO_ROOT / "VERSION").read_text(encoding="utf-8").strip()
     except OSError:
+        version = ""
+    if version:
+        return version
+    try:
+        return metadata.version("logics-manager")
+    except metadata.PackageNotFoundError:
         return "0.0.0"
 
 
@@ -334,7 +341,7 @@ def viewer_data_payload(
     repo_root: Path,
     selected_id: str | None = None,
     *,
-    auto_refresh_interval_seconds: int = 60,
+    auto_refresh_interval_seconds: int = 15,
 ) -> dict[str, Any]:
     return {
         "root": str(repo_root.resolve()),
@@ -399,6 +406,20 @@ def _run_read_only_git(repo_root: Path, args: list[str], *, runner: Any | None =
     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)
@@ -410,7 +431,8 @@ 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()}
+        path = line[3:].strip()
+        return "untracked", {"path": path, "logicsType": _logics_doc_type(path)}
     if len(line) < 4:
         return None
     staged = line[0]
@@ -418,15 +440,16 @@ def _classify_porcelain_entry(line: str) -> tuple[str, dict[str, str]] | None:
     raw_path = line[3:].strip()
     if " -> " in raw_path:
         before, after = raw_path.split(" -> ", 1)
-        return "renamed", {"path": after.strip(), "from": before.strip()}
+        path = after.strip()
+        return "renamed", {"path": path, "from": before.strip(), "logicsType": _logics_doc_type(path)}
     if staged == "R":
-        return "renamed", {"path": raw_path}
+        return "renamed", {"path": raw_path, "logicsType": _logics_doc_type(raw_path)}
     if staged not in {" ", "?", "!"}:
-        return "staged", {"path": raw_path, "code": staged}
+        return "staged", {"path": raw_path, "code": staged, "logicsType": _logics_doc_type(raw_path)}
     if worktree == "D":
-        return "deleted", {"path": raw_path, "code": worktree}
+        return "deleted", {"path": raw_path, "code": worktree, "logicsType": _logics_doc_type(raw_path)}
     if worktree not in {" ", "?", "!"}:
-        return "modified", {"path": raw_path, "code": worktree}
+        return "modified", {"path": raw_path, "code": worktree, "logicsType": _logics_doc_type(raw_path)}
     return None
 
 
@@ -454,6 +477,59 @@ def _parse_git_branch_line(line: str) -> dict[str, Any]:
     }
 
 
+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"):
@@ -468,6 +544,12 @@ def git_status_payload(repo_root: Path, *, runner: Any | None = None, which: Any
     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:
@@ -483,6 +565,7 @@ def git_status_payload(repo_root: Path, *, runner: Any | None = None, which: Any
             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",
@@ -490,11 +573,98 @@ def git_status_payload(repo_root: Path, *, runner: Any | None = None, which: Any
         "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")
 
@@ -505,7 +675,7 @@ class LogicsViewerServer(ThreadingHTTPServer):
         server_address: tuple[str, int],
         repo_root: Path,
         *,
-        auto_refresh_interval_seconds: int = 60,
+        auto_refresh_interval_seconds: int = 15,
     ):
         self.repo_root = repo_root.resolve()
         self.auto_refresh_interval_seconds = auto_refresh_interval_seconds
@@ -597,6 +767,15 @@ class LogicsViewerRequestHandler(BaseHTTPRequestHandler):
         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:
@@ -629,7 +808,7 @@ def create_viewer_server(
     host: str = "127.0.0.1",
     port: int = 8765,
     *,
-    auto_refresh_interval_seconds: int = 60,
+    auto_refresh_interval_seconds: int = 15,
 ) -> LogicsViewerServer:
     return LogicsViewerServer(
         (host, port),
@@ -657,7 +836,7 @@ def render_start_status(
     focus: str | None = None,
     network_url: str | None = None,
     bind_host: str = "localhost",
-    auto_refresh_interval_seconds: int = 60,
+    auto_refresh_interval_seconds: int = 15,
 ) -> str:
     lines = [
         "Logics viewer running:",
@@ -682,8 +861,8 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument(
         "--refresh-interval",
         type=int,
-        default=60,
-        help="Automatic refresh interval in seconds. Defaults to 60; positive shorter intervals are allowed.",
+        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.")

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.4.0",
+  "version": "2.5.1",
   "publisher": "cdx-logics",
   "icon": "clients/shared-web/media/icon.png",
   "repository": {

package/pyproject.toml

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