mas-lab-component-controller 0.2.0__py3-none-any.whl

mas/lab/controller/artifact_discovery.py

@@ -0,0 +1,107 @@
+#  Copyright (c) 2026 Cisco Systems, Inc. and its affiliates
+#  SPDX-License-Identifier: Apache-2.0
+"""Discover tools and skills from a library directory (filesystem scan)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+
+
+def discover_tools(base_dir: Path, namespaces: list[str] | None = None) -> list[dict]:
+    """Scan library tree for Tool manifests and ToolProvider infra entries."""
+    if not namespaces:
+        namespaces = ["global"]
+
+    tools: dict[str, str] = {}
+
+    for ns in namespaces:
+        if ns == "global":
+            tools_dir = base_dir / "tools"
+            if tools_dir.exists():
+                for tf in sorted(tools_dir.rglob("*.tool.yaml")):
+                    data = yaml.safe_load(tf.read_text(encoding="utf-8"))
+                    if (data or {}).get("kind") != "Tool":
+                        continue
+                    meta = (data or {}).get("metadata", {})
+                    name = meta.get("name")
+                    if name:
+                        tools[f"global/{name}"] = meta.get("description", "")
+
+            infra_dir = base_dir / "infra"
+            if infra_dir.exists():
+                for infra_file in infra_dir.rglob("*.yaml"):
+                    data = yaml.safe_load(infra_file.read_text(encoding="utf-8"))
+                    if (data or {}).get("kind") == "ToolProvider":
+                        for name in (data or {}).get("spec", {}).get("tools", {}).keys():
+                            tools.setdefault(f"global/{name}", "")
+        else:
+            app_tools_dir = base_dir / "apps" / ns / "tools"
+            if app_tools_dir.exists():
+                for tf in sorted(app_tools_dir.rglob("*.tool.yaml")):
+                    data = yaml.safe_load(tf.read_text(encoding="utf-8"))
+                    if (data or {}).get("kind") != "Tool":
+                        continue
+                    meta = (data or {}).get("metadata", {})
+                    name = meta.get("name")
+                    if name:
+                        tools[name] = meta.get("description", "")
+
+    return sorted(
+        [{"name": n, "description": d} for n, d in tools.items()],
+        key=lambda t: t["name"],
+    )
+
+
+def discover_skills(base_dir: Path, namespaces: list[str] | None = None) -> list[dict]:
+    """Scan library tree for skill folders containing SKILL.md."""
+    if not namespaces:
+        namespaces = ["global"]
+
+    skills: dict[str, str] = {}
+
+    def _scan_skills_dir(skills_dir: Path, prefix: str) -> None:
+        if not skills_dir.exists():
+            return
+        for skill_path in sorted(skills_dir.iterdir()):
+            if not skill_path.is_dir():
+                continue
+            skill_md = skill_path / "SKILL.md"
+            if not skill_md.exists():
+                continue
+
+            content = skill_md.read_text(encoding="utf-8")
+            name = skill_path.name
+            description = ""
+
+            if content.startswith("---"):
+                parts = content.split("---", 2)
+                if len(parts) >= 3:
+                    try:
+                        frontmatter = yaml.safe_load(parts[1])
+                        if frontmatter:
+                            name = frontmatter.get("name", name)
+                            description = frontmatter.get("description", "").strip()
+                    except Exception:
+                        pass
+
+            if not description:
+                for line in content.splitlines():
+                    if line.startswith("# "):
+                        description = line[2:].strip()
+                        break
+
+            display = f"{prefix}{name}" if prefix else name
+            skills.setdefault(display, description)
+
+    for ns in namespaces:
+        if ns == "global":
+            _scan_skills_dir(base_dir / "skills", "global/")
+        else:
+            _scan_skills_dir(base_dir / "apps" / ns / "skills", "")
+
+    return sorted(
+        [{"name": n, "description": d} for n, d in skills.items()],
+        key=lambda s: s["name"],
+    )

mas/lab/controller/artifacts.py

@@ -0,0 +1,112 @@
+#  Copyright (c) 2026 Cisco Systems, Inc. and its affiliates
+#  SPDX-License-Identifier: Apache-2.0
+"""Opaque artifact ids for run outputs. Paths never leave this module."""
+
+from __future__ import annotations
+
+import hashlib
+import mimetypes
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+def _artifact_id(run_id: str, relative: str) -> str:
+    digest = hashlib.sha256(f"{run_id}:{relative}".encode("utf-8")).hexdigest()
+    return digest
+
+
+@dataclass
+class Artifact:
+    artifact_id: str
+    name: str
+    kind: str
+    size: int
+    media_type: str
+    children: list["Artifact"] = field(default_factory=list)
+    # Internal
+    path: Path | None = None
+
+    def public_dict(self) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "artifact_id": self.artifact_id,
+            "name": self.name,
+            "kind": self.kind,
+            "size": self.size,
+            "media_type": self.media_type,
+        }
+        if self.children:
+            payload["children"] = [c.public_dict() for c in self.children]
+        return payload
+
+
+class ArtifactRegistry:
+    def __init__(self) -> None:
+        self._by_id: dict[str, Artifact] = {}
+        self._by_run: dict[str, list[str]] = {}
+
+    def register_tree(self, run_id: str, root: Path) -> list[Artifact]:
+        if not root.exists():
+            return []
+        artifacts: list[Artifact] = []
+        for path in sorted(root.rglob("*")):
+            if not path.is_file():
+                continue
+            rel = path.relative_to(root).as_posix()
+            art = self.register_file(run_id, rel, path)
+            artifacts.append(art)
+        return artifacts
+
+    def register_file(self, run_id: str, name: str, path: Path) -> Artifact:
+        aid = _artifact_id(run_id, name)
+        media, _ = mimetypes.guess_type(name)
+        kind = "file"
+        suffix = Path(name).suffix.lower()
+        if suffix in {".csv"}:
+            kind = "csv"
+        elif suffix in {".json", ".jsonl"}:
+            kind = "json"
+        elif suffix in {".yaml", ".yml"}:
+            kind = "yaml"
+        elif suffix in {".html", ".htm"}:
+            kind = "html"
+        elif suffix in {".svg"}:
+            kind = "svg"
+        elif suffix in {".png", ".jpg", ".jpeg"}:
+            kind = "image"
+        art = Artifact(
+            artifact_id=aid,
+            name=Path(name).name,
+            kind=kind,
+            size=path.stat().st_size if path.exists() else 0,
+            media_type=media or "application/octet-stream",
+            path=path.resolve(),
+        )
+        self._by_id[aid] = art
+        self._by_run.setdefault(run_id, []).append(aid)
+        return art
+
+    def get(self, artifact_id: str) -> Artifact | None:
+        return self._by_id.get(artifact_id)
+
+    def for_run(self, run_id: str) -> list[Artifact]:
+        return [self._by_id[i] for i in self._by_run.get(run_id, []) if i in self._by_id]
+
+    def drop_run(self, run_id: str) -> None:
+        for aid in self._by_run.pop(run_id, []):
+            self._by_id.pop(aid, None)
+
+
+_registry: ArtifactRegistry | None = None
+
+
+def get_artifact_registry() -> ArtifactRegistry:
+    global _registry
+    if _registry is None:
+        _registry = ArtifactRegistry()
+    return _registry
+
+
+def set_artifact_registry(registry: ArtifactRegistry | None) -> None:
+    global _registry
+    _registry = registry