@grifhinz/logics-manager 2.8.0 → 2.8.1

package/logics_manager/viewer.py

@@ -49,6 +49,8 @@ CDX_MISSION_STRENGTHS = {
     "deep": {"id": "deep", "label": "Deep", "timeout": 300, "reasoningEffort": "high", "power": "high"},
     "max": {"id": "max", "label": "Max", "timeout": 600, "reasoningEffort": "high", "power": "high"},
 }
+CDX_MISSION_PARENT_TIMEOUT_GRACE_SECONDS = 90
+CDX_WRITABLE_MISSION_MIN_TIMEOUT_SECONDS = 600
 CDX_MISSION_CATALOG = {
     "full-audit": {
         "id": "full-audit",
@@ -142,6 +144,26 @@ GIT_FILE_PREVIEW_MAX_BYTES = 30000
 GIT_FILE_PREVIEW_MAX_CHARS = 20000
 FILE_PREVIEW_MAX_BYTES = 300000
 FILE_PREVIEW_MAX_CHARS = 200000
+WORKSPACE_TREE_MAX_ENTRIES = 250
+WORKSPACE_PREVIEW_MAX_BYTES = 30000
+WORKSPACE_PREVIEW_MAX_CHARS = 20000
+WORKSPACE_IGNORED_DIRS = {
+    ".git",
+    ".hg",
+    ".svn",
+    "__pycache__",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".ruff_cache",
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    ".next",
+    ".turbo",
+    ".venv",
+    "venv",
+}
 REPO_ROOT = Path(__file__).resolve().parents[1]
 PACKAGE_VIEWER_ASSETS_ROOT = Path(__file__).resolve().parent / "viewer_assets"
 VIEWER_ROOT = REPO_ROOT / "clients" / "viewer"
@@ -442,6 +464,7 @@ def viewer_data_payload(
     selected_id: str | None = None,
     *,
     auto_refresh_interval_seconds: int = 15,
+    auto_refresh_interval_forced: bool = False,
     projects: list[dict[str, Any]] | None = None,
 ) -> dict[str, Any]:
     capabilities = viewer_project_capabilities(repo_root)
@@ -457,6 +480,7 @@ def viewer_data_payload(
         "capabilities": capabilities,
         "projects": projects if projects is not None else viewer_project_registry(repo_root),
         "autoRefreshIntervalSeconds": auto_refresh_interval_seconds,
+        "autoRefreshIntervalForced": auto_refresh_interval_forced,
         "items": collect_viewer_items(repo_root),
         "updateInfo": get_update_info(_current_version()).to_payload(),
         "selectedId": selected_id,
@@ -611,9 +635,16 @@ def viewer_project_capabilities(
     else:
         cdx = _viewer_capability("missing", available=False, message="CDX executable is not available.")
         cdx_runs = _viewer_capability("missing", available=False, message="CDX is required before assistant runs can be tracked.")
+    workspace = _viewer_capability(
+        "ready" if repo_root.is_dir() else "missing",
+        available=repo_root.is_dir(),
+        message="Workspace root can be inspected." if repo_root.is_dir() else "Workspace root is unavailable.",
+        detail={"root": str(repo_root.resolve())} if repo_root.is_dir() else {},
+    )
 
     return {
         "logics": logics,
+        "workspace": workspace,
         "git": git,
         "ci": ci,
         "cdx": cdx,
@@ -1156,6 +1187,168 @@ def git_file_preview_payload(
     }
 
 
+def _normalize_workspace_path(rel_path: str) -> str:
+    normalized = unquote(rel_path or "").replace("\\", "/").strip()
+    normalized = normalized.lstrip("/")
+    if normalized in {"", "."}:
+        return ""
+    if normalized.startswith("~") or re.match(r"^[A-Za-z]:", normalized):
+        raise ValueError("Unsafe workspace path.")
+    parts = [part for part in normalized.split("/") if part not in {"", "."}]
+    if any(part == ".." for part in parts):
+        raise ValueError("Workspace path escapes root.")
+    return "/".join(parts)
+
+
+def _resolve_workspace_path(repo_root: Path, rel_path: str) -> tuple[str, Path]:
+    normalized = _normalize_workspace_path(rel_path)
+    root = repo_root.resolve()
+    target = (root / normalized).resolve()
+    try:
+        target.relative_to(root)
+    except ValueError as exc:
+        raise ValueError("Workspace path escapes root.") from exc
+    return normalized, target
+
+
+def _workspace_entry_payload(root: Path, path: Path) -> dict[str, Any]:
+    try:
+        stat = path.stat()
+    except OSError:
+        stat = None
+    rel_path = path.relative_to(root).as_posix()
+    is_dir = path.is_dir()
+    ignored = is_dir and path.name in WORKSPACE_IGNORED_DIRS
+    return {
+        "name": path.name or root.name,
+        "path": rel_path,
+        "kind": "directory" if is_dir else "file",
+        "size": stat.st_size if stat else 0,
+        "ignored": ignored,
+        "childrenAvailable": is_dir and not ignored,
+    }
+
+
+def workspace_tree_payload(
+    repo_root: Path,
+    rel_path: str = "",
+    *,
+    max_entries: int = WORKSPACE_TREE_MAX_ENTRIES,
+) -> dict[str, Any]:
+    normalized, target = _resolve_workspace_path(repo_root, rel_path)
+    root = repo_root.resolve()
+    if not target.exists():
+        return {"state": "missing", "path": normalized, "message": "Workspace path does not exist."}
+    if not target.is_dir():
+        return {"state": "not-directory", "path": normalized, "message": "Workspace path is not a directory."}
+    entries = []
+    truncated = False
+    try:
+        children = sorted(target.iterdir(), key=lambda path: (not path.is_dir(), path.name.lower()))
+    except OSError as exc:
+        return {"state": "error", "path": normalized, "message": f"Unable to list workspace path: {exc}"}
+    for child in children:
+        if len(entries) >= max_entries:
+            truncated = True
+            break
+        entries.append(_workspace_entry_payload(root, child))
+    return {
+        "state": "ok",
+        "root": str(root),
+        "path": normalized,
+        "entries": entries,
+        "truncated": truncated,
+        "ignoredDirectories": sorted(WORKSPACE_IGNORED_DIRS),
+    }
+
+
+def workspace_preview_payload(
+    repo_root: Path,
+    rel_path: str,
+    *,
+    max_bytes: int = WORKSPACE_PREVIEW_MAX_BYTES,
+    max_chars: int = WORKSPACE_PREVIEW_MAX_CHARS,
+) -> dict[str, Any]:
+    normalized, target = _resolve_workspace_path(repo_root, rel_path)
+    if not target.exists():
+        return {"state": "missing", "path": normalized, "message": "Workspace path does not exist."}
+    if target.is_dir():
+        try:
+            count = sum(1 for _ in target.iterdir())
+        except OSError:
+            count = 0
+        return {
+            "state": "directory",
+            "path": normalized,
+            "name": target.name or repo_root.resolve().name,
+            "kind": "directory",
+            "message": f"{count} item(s)",
+            "childrenAvailable": target.name not in WORKSPACE_IGNORED_DIRS,
+        }
+    if not target.is_file():
+        return {"state": "unsupported", "path": normalized, "message": "Workspace object cannot be previewed."}
+    try:
+        size = target.stat().st_size
+    except OSError as exc:
+        return {"state": "error", "path": normalized, "message": f"Unable to inspect file: {exc}"}
+    if size > max_bytes:
+        return {
+            "state": "oversized",
+            "path": normalized,
+            "name": target.name,
+            "size": size,
+            "message": f"File preview is limited to {max_bytes} bytes; this file is {size} bytes.",
+        }
+    try:
+        data = target.read_bytes()
+    except OSError as exc:
+        return {"state": "error", "path": normalized, "message": f"Unable to read file preview: {exc}"}
+    content_type = mimetypes.guess_type(target.name)[0] or ""
+    if content_type.startswith("image/"):
+        return {
+            "state": "image",
+            "path": normalized,
+            "name": target.name,
+            "size": size,
+            "contentType": content_type,
+            "message": "Image preview is available from the workspace file endpoint.",
+        }
+    if b"\x00" in data:
+        return {
+            "state": "unsupported",
+            "path": normalized,
+            "name": target.name,
+            "size": size,
+            "message": "Binary or unsupported file content cannot be previewed.",
+        }
+    try:
+        content = data.decode("utf-8")
+    except UnicodeDecodeError:
+        return {
+            "state": "unsupported",
+            "path": normalized,
+            "name": target.name,
+            "size": size,
+            "message": "Binary or unsupported file encoding cannot be previewed.",
+        }
+    content = content.replace("\r\n", "\n").replace("\r", "\n")
+    truncated = len(content) > max_chars
+    if truncated:
+        content = content[:max_chars]
+    return {
+        "state": "ok",
+        "path": normalized,
+        "name": target.name,
+        "kind": "file",
+        "size": size,
+        "contentType": content_type or "text/plain",
+        "content": content,
+        "truncated": truncated,
+        "logicsType": _logics_doc_type(normalized),
+        "message": "",
+    }
+
+
 def _current_git_ci_context(repo_root: Path, *, runner: Any | None = None) -> dict[str, str]:
     context = {"branch": "", "headSha": "", "subject": "", "author": ""}
     commands = {
@@ -1195,28 +1388,21 @@ def _is_active_ci_status(run: dict[str, Any]) -> bool:
 
 
 def _select_github_actions_run(runs: list[dict[str, Any]], head_sha: str) -> tuple[dict[str, Any], str]:
-    head_runs = [run for run in runs if head_sha and str(run.get("head_sha") or "") == head_sha]
+    ci_runs = [run for run in runs if str(run.get("name") or "").strip().lower() == "ci"]
+    candidate_runs = ci_runs or runs
+    head_runs = [run for run in candidate_runs if head_sha and str(run.get("head_sha") or "") == head_sha]
     active_head_run = next((run for run in head_runs if _is_active_ci_status(run)), None)
     if active_head_run is not None:
         return active_head_run, "head-active"
-    failing_head_run = next((run for run in head_runs if _ci_badge_state(str(run.get("status") or ""), str(run.get("conclusion") or "")) == "failing"), None)
-    if failing_head_run is not None:
-        return failing_head_run, "head-failing"
-    cancelled_head_run = next((run for run in head_runs if _ci_badge_state(str(run.get("status") or ""), str(run.get("conclusion") or "")) == "cancelled"), None)
-    if cancelled_head_run is not None:
-        return cancelled_head_run, "head-cancelled"
-    unknown_head_run = next((run for run in head_runs if _ci_badge_state(str(run.get("status") or ""), str(run.get("conclusion") or "")) == "unknown"), None)
-    if unknown_head_run is not None:
-        return unknown_head_run, "head-unknown"
     if head_runs:
+        head_state = _ci_badge_state(str(head_runs[0].get("status") or ""), str(head_runs[0].get("conclusion") or ""))
+        if head_state in {"failing", "cancelled", "unknown"}:
+            return head_runs[0], f"head-{head_state}"
         return head_runs[0], "head"
-    active_branch_run = next((run for run in runs if _is_active_ci_status(run)), None)
+    active_branch_run = next((run for run in candidate_runs if _is_active_ci_status(run)), None)
     if active_branch_run is not None:
         return active_branch_run, "branch-active"
-    failing_branch_run = next((run for run in runs if _ci_badge_state(str(run.get("status") or ""), str(run.get("conclusion") or "")) == "failing"), None)
-    if failing_branch_run is not None:
-        return failing_branch_run, "branch-failing"
-    return runs[0], "branch-latest"
+    return candidate_runs[0], "branch-latest"
 
 
 def _parse_github_actions_run(run: dict[str, Any], *, match_source: str) -> dict[str, Any]:
@@ -1605,6 +1791,13 @@ def _cdx_mission_prompt(
     raise ValueError("Unknown CDX mission.")
 
 
+def _cdx_mission_timeout(strength: dict[str, Any], *, allow_file_writes: bool = False, commit_at_end: bool = False) -> int:
+    timeout = int(strength.get("timeout") or 180)
+    if allow_file_writes or commit_at_end:
+        return max(timeout, CDX_WRITABLE_MISSION_MIN_TIMEOUT_SECONDS)
+    return timeout
+
+
 def _cdx_mission_command(
     repo_root: Path,
     mission_id: str,
@@ -1627,7 +1820,7 @@ def _cdx_mission_command(
         direct_fixes=mission_inputs.get("directFixes") == "true",
         commit_at_end=commit_at_end,
     )
-    timeout = int(strength.get("timeout") or 180)
+    timeout = _cdx_mission_timeout(strength, allow_file_writes=allow_file_writes, commit_at_end=commit_at_end)
     reasoning_effort = str(strength.get("reasoningEffort") or "medium")
     power = str(strength.get("power") or "medium")
     permission = "workspace-write" if allow_file_writes else "read-only"
@@ -1868,6 +2061,7 @@ def cdx_mission_plan_payload(
         "requestedCommitAtEnd": requested_commit_at_end,
         "supportsFileWrites": supports_file_writes,
         "permission": permission,
+        "timeoutSeconds": _cdx_mission_timeout(strength_def, allow_file_writes=allow_file_writes, commit_at_end=commit_at_end),
         "command": ["cdx", *command],
         "arguments": command,
         "warnings": warnings,
@@ -1895,9 +2089,10 @@ def cdx_mission_run_payload(
     if plan_payload.get("state") != "ok":
         return {"state": plan_payload.get("state") or "error", "message": plan_payload.get("message") or "Unable to plan CDX mission.", "plan": plan_payload.get("plan"), "run": None}
     plan = plan_payload["plan"]
-    timeout = int(plan["strength"].get("timeout") or 180)
+    timeout = int(plan.get("timeoutSeconds") or plan["strength"].get("timeout") or 180)
+    process_timeout = timeout + CDX_MISSION_PARENT_TIMEOUT_GRACE_SECONDS
     try:
-        result = _run_cdx_mission(repo_root, list(plan["arguments"]), timeout=timeout, runner=cdx_runner)
+        result = _run_cdx_mission(repo_root, list(plan["arguments"]), timeout=process_timeout, runner=cdx_runner)
     except subprocess.TimeoutExpired:
         return {"state": "timeout", "message": "CDX mission timed out.", "plan": plan, "run": None}
     except (OSError, subprocess.SubprocessError) as exc:
@@ -2123,6 +2318,7 @@ class LogicsViewerServer(ThreadingHTTPServer):
         repo_root: Path,
         *,
         auto_refresh_interval_seconds: int = 15,
+        auto_refresh_interval_forced: bool = False,
     ):
         self.launch_repo_root = repo_root.resolve()
         self.project_roots = discover_viewer_project_roots(self.launch_repo_root)
@@ -2130,6 +2326,7 @@ class LogicsViewerServer(ThreadingHTTPServer):
         self.active_project_id = _viewer_project_id(self.launch_repo_root)
         self.repo_root = self.launch_repo_root
         self.auto_refresh_interval_seconds = auto_refresh_interval_seconds
+        self.auto_refresh_interval_forced = auto_refresh_interval_forced
         super().__init__(server_address, LogicsViewerRequestHandler)
 
     def project_registry_payload(self) -> list[dict[str, Any]]:
@@ -2140,6 +2337,7 @@ class LogicsViewerServer(ThreadingHTTPServer):
             self.repo_root,
             selected_id=selected_id,
             auto_refresh_interval_seconds=self.auto_refresh_interval_seconds,
+            auto_refresh_interval_forced=self.auto_refresh_interval_forced,
             projects=self.project_registry_payload(),
         )
 
@@ -2266,6 +2464,32 @@ class LogicsViewerRequestHandler(BaseHTTPRequestHandler):
             rel_path = params.get("path", [""])[0]
             self._send_json({"ok": True, "payload": git_file_preview_payload(self.server.repo_root, rel_path)})
             return
+        if route == "/api/workspace-tree":
+            rel_path = parse_qs(parsed.query).get("path", [""])[0]
+            try:
+                self._send_json({"ok": True, "payload": workspace_tree_payload(self.server.repo_root, rel_path)})
+            except ValueError as exc:
+                self._send_error_json(HTTPStatus.FORBIDDEN, str(exc))
+            return
+        if route == "/api/workspace-preview":
+            rel_path = parse_qs(parsed.query).get("path", [""])[0]
+            try:
+                self._send_json({"ok": True, "payload": workspace_preview_payload(self.server.repo_root, rel_path)})
+            except ValueError as exc:
+                self._send_error_json(HTTPStatus.FORBIDDEN, str(exc))
+            return
+        if route == "/api/workspace-file":
+            rel_path = parse_qs(parsed.query).get("path", [""])[0]
+            try:
+                payload = workspace_preview_payload(self.server.repo_root, rel_path)
+                if payload.get("state") != "image":
+                    self._send_error_json(HTTPStatus.BAD_REQUEST, "Workspace file is not an image preview.")
+                    return
+                _normalized, absolute = _resolve_workspace_path(self.server.repo_root, rel_path)
+                self._serve_file(absolute)
+            except (FileNotFoundError, ValueError) as exc:
+                self._send_error_json(HTTPStatus.NOT_FOUND, str(exc))
+            return
         self._send_error_json(HTTPStatus.NOT_FOUND, "Not found")
 
     def do_POST(self) -> None:
@@ -2394,11 +2618,13 @@ def create_viewer_server(
     port: int = 8765,
     *,
     auto_refresh_interval_seconds: int = 15,
+    auto_refresh_interval_forced: bool = False,
 ) -> LogicsViewerServer:
     return LogicsViewerServer(
         (host, port),
         repo_root,
         auto_refresh_interval_seconds=auto_refresh_interval_seconds,
+        auto_refresh_interval_forced=auto_refresh_interval_forced,
     )
 
 
@@ -2446,7 +2672,7 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument(
         "--refresh-interval",
         type=int,
-        default=15,
+        default=None,
         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.")
@@ -2459,7 +2685,9 @@ 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:
+    refresh_interval_forced = args.refresh_interval is not None
+    refresh_interval = args.refresh_interval if args.refresh_interval is not None else 15
+    if 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.")
@@ -2471,7 +2699,8 @@ def main(argv: list[str]) -> int:
         repo_root,
         host=args.host,
         port=args.port,
-        auto_refresh_interval_seconds=args.refresh_interval,
+        auto_refresh_interval_seconds=refresh_interval,
+        auto_refresh_interval_forced=refresh_interval_forced,
     )
     host, port = server.server_address[:2]
     url = build_viewer_url(str(host), int(port), focus=focus, read=bool(args.read))
@@ -2483,7 +2712,7 @@ def main(argv: list[str]) -> int:
             focus=focus,
             network_url=network_url,
             bind_host=str(host),
-            auto_refresh_interval_seconds=args.refresh_interval,
+            auto_refresh_interval_seconds=refresh_interval,
         ),
         flush=True,
     )

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.8.0",
+  "version": "2.8.1",
   "publisher": "cdx-logics",
   "icon": "clients/shared-web/media/icon.png",
   "repository": {
@@ -138,6 +138,7 @@
     "audit:logics": "node scripts/run-python.mjs -m logics_manager audit && node scripts/run-python.mjs -m logics_manager lint",
     "audit:logics:strict": "node scripts/run-python.mjs -m logics_manager audit --governance-profile strict && node scripts/run-python.mjs -m logics_manager lint --require-status",
     "audit:ci": "node scripts/check-npm-audit.mjs",
+    "docs:check": "node scripts/check-readme-badges.mjs",
     "logics:finish:task": "node scripts/run-python.mjs -m logics_manager flow finish task",
     "ci:fast": "npm run compile && npm run lint && npm run test:coverage && npm run test:smoke && npm run lint:logics && npm run package:ci",
     "ci:check": "node scripts/ci-check.mjs",

package/pyproject.toml

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