@grifhinz/logics-manager 2.5.1 → 2.6.0

package/logics_manager/viewer.py

@@ -346,6 +346,10 @@ def viewer_data_payload(
     return {
         "root": str(repo_root.resolve()),
         "repoName": repo_root.resolve().name,
+        "repository": {
+            "root": str(repo_root.resolve()),
+            "githubUrl": github_repo_url(repo_root),
+        },
         "autoRefreshIntervalSeconds": auto_refresh_interval_seconds,
         "items": collect_viewer_items(repo_root),
         "updateInfo": get_update_info(_current_version()).to_payload(),
@@ -392,6 +396,17 @@ def edit_doc_payload(repo_root: Path, rel_path: str, *, launcher: Any | None = N
     }
 
 
+def open_repo_folder_payload(repo_root: Path, *, launcher: Any | None = None) -> dict[str, str]:
+    root = repo_root.resolve()
+    command = _system_editor_command(root)
+    runner = launcher or subprocess.Popen
+    runner(command)
+    return {
+        "path": str(root),
+        "command": command[0],
+    }
+
+
 def _system_editor_command(path: Path) -> list[str]:
     if sys.platform == "darwin":
         return ["open", str(path)]
@@ -412,6 +427,12 @@ def _run_read_only_cdx(repo_root: Path, args: list[str], *, runner: Any | None =
     return cdx_runner(command, cwd=repo_root, text=True, capture_output=True, timeout=5)
 
 
+def _run_read_only_gh(repo_root: Path, args: list[str], *, runner: Any | None = None) -> subprocess.CompletedProcess[str]:
+    command = ["gh", *args]
+    gh_runner = runner or subprocess.run
+    return gh_runner(command, cwd=repo_root, text=True, capture_output=True, timeout=8)
+
+
 def _logics_doc_type(rel_path: str) -> str:
     normalized = rel_path.replace("\\", "/").lstrip("/")
     for family in DOC_FAMILIES:
@@ -427,6 +448,62 @@ def _sanitize_git_ref(value: str) -> str:
     return ref[:200]
 
 
+def _github_web_url_from_remote(value: str) -> str:
+    remote = value.strip()
+    if not remote:
+        return ""
+    remote = re.sub(r"^git\+", "", remote)
+    match = re.match(r"^(?:https://|http://)(?:[^/@\s]+@)?github\.com[:/]+([^/\s]+)/([^/\s]+?)(?:\.git)?/?$", remote)
+    if not match:
+        match = re.match(r"^(?:ssh://)?git@github\.com[:/]+([^/\s]+)/([^/\s]+?)(?:\.git)?/?$", remote)
+    if not match:
+        return ""
+    owner, repo = match.groups()
+    if not owner or not repo:
+        return ""
+    return f"https://github.com/{owner}/{repo}"
+
+
+def _github_owner_repo_from_web_url(value: str) -> tuple[str, str] | None:
+    match = re.match(r"^https://github\.com/([^/\s]+)/([^/\s]+?)/?$", value.strip())
+    if not match:
+        return None
+    owner, repo = match.groups()
+    return owner, repo
+
+
+def github_repo_url(repo_root: Path, *, runner: Any | None = None, which: Any | None = None) -> str:
+    git_which = which or shutil.which
+    if not git_which("git"):
+        return ""
+    try:
+        remotes = _run_read_only_git(repo_root, ["remote", "-v"], runner=runner)
+    except (OSError, subprocess.SubprocessError):
+        return ""
+    if remotes.returncode != 0:
+        return ""
+
+    candidates: list[tuple[int, str]] = []
+    for line in remotes.stdout.splitlines():
+        parts = line.split()
+        if len(parts) < 2:
+            continue
+        name, url = parts[0], parts[1]
+        web_url = _github_web_url_from_remote(url)
+        if web_url:
+            candidates.append((0 if name == "origin" else 1, web_url))
+    if not candidates:
+        return ""
+    return sorted(candidates, key=lambda entry: entry[0])[0][1]
+
+
+def _has_github_actions_workflows(repo_root: Path) -> bool:
+    workflows_dir = repo_root / ".github" / "workflows"
+    if not workflows_dir.is_dir():
+        return False
+    return any(path.is_file() and path.suffix.lower() in {".yml", ".yaml"} for path in workflows_dir.iterdir())
+
+
 def _classify_porcelain_entry(line: str) -> tuple[str, dict[str, str]] | None:
     if not line or line.startswith("## "):
         return None
@@ -496,7 +573,38 @@ def _parse_recent_git_commits(output: str) -> list[dict[str, str]]:
     return commits
 
 
-def _count_unique_git_status_paths(groups: dict[str, list[dict[str, str]]]) -> int:
+def _parse_git_numstat(output: str) -> dict[str, dict[str, int]]:
+    stats: dict[str, dict[str, int]] = {}
+    for line in output.splitlines():
+        parts = line.split("\t")
+        if len(parts) < 3:
+            continue
+        raw_additions, raw_deletions, raw_path = parts[:3]
+        try:
+            additions = int(raw_additions)
+            deletions = int(raw_deletions)
+        except ValueError:
+            continue
+        path = raw_path.strip()
+        if " => " in path:
+            path = path.split(" => ", 1)[1].strip("{}")
+        if path:
+            stats[path] = {"additions": additions, "deletions": deletions}
+    return stats
+
+
+def _attach_git_change_stats(groups: dict[str, list[dict[str, Any]]], staged_stats: dict[str, dict[str, int]], worktree_stats: dict[str, dict[str, int]]) -> None:
+    for key, entries in groups.items():
+        stats_source = staged_stats if key == "staged" else worktree_stats
+        for entry in entries:
+            path = str(entry.get("path", ""))
+            stats = stats_source.get(path) or staged_stats.get(path) or worktree_stats.get(path)
+            if stats:
+                entry["additions"] = stats["additions"]
+                entry["deletions"] = stats["deletions"]
+
+
+def _count_unique_git_status_paths(groups: dict[str, list[dict[str, Any]]]) -> int:
     paths: set[str] = set()
     for entries in groups.values():
         for entry in entries:
@@ -543,10 +651,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)
+        staged_numstat = _run_read_only_git(repo_root, ["diff", "--no-ext-diff", "--numstat", "--cached"], runner=runner)
+        worktree_numstat = _run_read_only_git(repo_root, ["diff", "--no-ext-diff", "--numstat"], 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"],
+            ["log", "-50", "--date=short", "--pretty=format:%h%x1f%s%x1f%an%x1f%ad%x1f%D"],
             runner=runner,
         )
         unpushed = _git_unpushed_commit_count(repo_root, runner=runner)
@@ -558,12 +668,18 @@ def git_status_payload(repo_root: Path, *, runner: Any | None = None, which: Any
 
     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")}
+    groups: dict[str, list[dict[str, Any]]] = {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)
+    if staged_numstat.returncode == 0 or worktree_numstat.returncode == 0:
+        _attach_git_change_stats(
+            groups,
+            _parse_git_numstat(staged_numstat.stdout if staged_numstat.returncode == 0 else ""),
+            _parse_git_numstat(worktree_numstat.stdout if worktree_numstat.returncode == 0 else ""),
+        )
     counts = {key: len(value) for key, value in groups.items()}
     uncommitted_files = _count_unique_git_status_paths(groups)
     dirty = any(counts.values())
@@ -639,6 +755,164 @@ def git_diff_payload(
     }
 
 
+def _current_git_ci_context(repo_root: Path, *, runner: Any | None = None) -> dict[str, str]:
+    context = {"branch": "", "headSha": "", "subject": "", "author": ""}
+    commands = {
+        "branch": ["rev-parse", "--abbrev-ref", "HEAD"],
+        "headSha": ["rev-parse", "HEAD"],
+        "subject": ["log", "-1", "--pretty=format:%s"],
+        "author": ["log", "-1", "--pretty=format:%an"],
+    }
+    for key, args in commands.items():
+        try:
+            result = _run_read_only_git(repo_root, args, runner=runner)
+        except (OSError, subprocess.SubprocessError):
+            continue
+        if result.returncode == 0:
+            context[key] = result.stdout.strip()[:240]
+    if context["branch"] == "HEAD":
+        context["branch"] = ""
+    return context
+
+
+def _ci_badge_state(status: str, conclusion: str) -> str:
+    normalized_status = status.strip().lower()
+    normalized_conclusion = conclusion.strip().lower()
+    if normalized_status in {"queued", "in_progress", "waiting", "requested", "pending"}:
+        return "running" if normalized_status == "in_progress" else "queued"
+    if normalized_conclusion == "success":
+        return "passing"
+    if normalized_conclusion in {"failure", "timed_out", "action_required"}:
+        return "failing"
+    if normalized_conclusion == "cancelled":
+        return "cancelled"
+    return "unknown"
+
+
+def _parse_github_actions_run(run: dict[str, Any], *, match_source: str) -> dict[str, Any]:
+    status = str(run.get("status") or "")
+    conclusion = str(run.get("conclusion") or "")
+    commit = run.get("head_commit") if isinstance(run.get("head_commit"), dict) else {}
+    author = commit.get("author") if isinstance(commit.get("author"), dict) else {}
+    return {
+        "id": run.get("id"),
+        "name": str(run.get("name") or run.get("display_title") or "GitHub Actions"),
+        "workflowName": str(run.get("name") or "GitHub Actions"),
+        "status": status,
+        "conclusion": conclusion,
+        "badgeState": _ci_badge_state(status, conclusion),
+        "branch": str(run.get("head_branch") or ""),
+        "headSha": str(run.get("head_sha") or ""),
+        "event": str(run.get("event") or ""),
+        "htmlUrl": str(run.get("html_url") or ""),
+        "createdAt": str(run.get("created_at") or ""),
+        "updatedAt": str(run.get("updated_at") or ""),
+        "runStartedAt": str(run.get("run_started_at") or ""),
+        "commitMessage": str(commit.get("message") or run.get("display_title") or "").splitlines()[0][:240],
+        "author": str(author.get("name") or ""),
+        "matchSource": match_source,
+    }
+
+
+def _parse_github_actions_jobs(output: str) -> list[dict[str, str]]:
+    try:
+        parsed = json.loads(output or "{}")
+    except json.JSONDecodeError:
+        return []
+    if not isinstance(parsed, dict):
+        return []
+    jobs = parsed.get("jobs")
+    if not isinstance(jobs, list):
+        return []
+    rows: list[dict[str, str]] = []
+    for job in jobs[:30]:
+        if not isinstance(job, dict):
+            continue
+        rows.append(
+            {
+                "name": str(job.get("name") or "Job"),
+                "status": str(job.get("status") or ""),
+                "conclusion": str(job.get("conclusion") or ""),
+                "htmlUrl": str(job.get("html_url") or ""),
+                "startedAt": str(job.get("started_at") or ""),
+                "completedAt": str(job.get("completed_at") or ""),
+            }
+        )
+    return rows
+
+
+def ci_status_payload(repo_root: Path, *, git_runner: Any | None = None, gh_runner: Any | None = None, which: Any | None = None) -> dict[str, Any]:
+    git_which = which or shutil.which
+    github_url = github_repo_url(repo_root, runner=git_runner, which=git_which)
+    if not github_url:
+        return {"state": "hidden", "visible": False, "message": "No GitHub remote detected."}
+    owner_repo = _github_owner_repo_from_web_url(github_url)
+    if not owner_repo:
+        return {"state": "hidden", "visible": False, "message": "GitHub remote could not be parsed."}
+    if not _has_github_actions_workflows(repo_root):
+        return {"state": "hidden", "visible": False, "message": "No GitHub Actions workflows detected."}
+    if not git_which("gh"):
+        return {
+            "state": "unavailable",
+            "visible": True,
+            "message": "GitHub CLI is not available on PATH.",
+            "repositoryUrl": github_url,
+            "badgeState": "unavailable",
+        }
+
+    owner, repo = owner_repo
+    context = _current_git_ci_context(repo_root, runner=git_runner)
+    branch = context.get("branch", "")
+    head_sha = context.get("headSha", "")
+    endpoint = f"repos/{owner}/{repo}/actions/runs?per_page=10"
+    if branch:
+        endpoint = f"{endpoint}&branch={quote(branch, safe='')}"
+    try:
+        runs_result = _run_read_only_gh(repo_root, ["api", endpoint], runner=gh_runner)
+    except subprocess.TimeoutExpired:
+        return {"state": "timeout", "visible": True, "message": "GitHub Actions status timed out.", "repositoryUrl": github_url, **context, "badgeState": "unavailable"}
+    except (OSError, subprocess.SubprocessError) as exc:
+        return {"state": "error", "visible": True, "message": f"Unable to collect GitHub Actions status: {exc}", "repositoryUrl": github_url, **context, "badgeState": "unavailable"}
+    if runs_result.returncode != 0:
+        message = (runs_result.stderr or runs_result.stdout or "GitHub Actions status failed.").strip().splitlines()[0]
+        return {"state": "unavailable", "visible": True, "message": message, "repositoryUrl": github_url, **context, "badgeState": "unavailable"}
+
+    try:
+        parsed = json.loads(runs_result.stdout or "{}")
+    except json.JSONDecodeError:
+        return {"state": "invalid-json", "visible": True, "message": "GitHub Actions status returned invalid JSON.", "repositoryUrl": github_url, **context, "badgeState": "unavailable"}
+    workflow_runs = parsed.get("workflow_runs") if isinstance(parsed, dict) else None
+    runs = [run for run in workflow_runs if isinstance(run, dict)] if isinstance(workflow_runs, list) else []
+    if not runs:
+        return {"state": "ok", "visible": True, "message": "No GitHub Actions runs found for the current branch.", "repositoryUrl": github_url, **context, "badgeState": "unknown", "run": None, "jobs": []}
+
+    selected = next((run for run in runs if head_sha and str(run.get("head_sha") or "") == head_sha), None)
+    match_source = "head" if selected else "branch-latest"
+    if selected is None:
+        selected = runs[0]
+    run_payload = _parse_github_actions_run(selected, match_source=match_source)
+    jobs: list[dict[str, str]] = []
+    run_id = run_payload.get("id")
+    if run_id:
+        try:
+            jobs_result = _run_read_only_gh(repo_root, ["api", f"repos/{owner}/{repo}/actions/runs/{run_id}/jobs?per_page=100"], runner=gh_runner)
+        except (OSError, subprocess.SubprocessError, subprocess.TimeoutExpired):
+            jobs_result = None
+        if jobs_result is not None and jobs_result.returncode == 0:
+            jobs = _parse_github_actions_jobs(jobs_result.stdout)
+
+    return {
+        "state": "ok",
+        "visible": True,
+        "message": "",
+        "repositoryUrl": github_url,
+        **context,
+        "badgeState": run_payload["badgeState"],
+        "run": run_payload,
+        "jobs": jobs,
+    }
+
+
 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"):
@@ -767,6 +1041,9 @@ 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/ci-status":
+            self._send_json({"ok": True, "payload": ci_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
@@ -800,6 +1077,12 @@ class LogicsViewerRequestHandler(BaseHTTPRequestHandler):
             except OSError as exc:
                 self._send_error_json(HTTPStatus.INTERNAL_SERVER_ERROR, str(exc))
             return
+        if parsed.path == "/api/open-repo-folder":
+            try:
+                self._send_json({"ok": True, "payload": open_repo_folder_payload(self.server.repo_root)})
+            except OSError as exc:
+                self._send_error_json(HTTPStatus.INTERNAL_SERVER_ERROR, str(exc))
+            return
         self._send_error_json(HTTPStatus.NOT_FOUND, "Not found")
 
 

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.5.1",
+  "version": "2.6.0",
   "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.5.1"
+version = "2.6.0"
 description = "Canonical Logics CLI"
 requires-python = ">=3.10"