opencode-agenthub 0.1.0

package/dist/skills/hr-support/bin/validate_staged_package.py

@@ -0,0 +1,290 @@
+#!/usr/bin/env python3
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+
+def resolve_agenthub_bin() -> str:
+    if os.getenv("OPENCODE_AGENTHUB_BIN"):
+        return os.environ["OPENCODE_AGENTHUB_BIN"]
+    found = shutil.which("opencode-agenthub")
+    if found:
+        return found
+    # Portable repo-local fallback: when running from src/skills/hr-support/bin/
+    # inside the source tree, try <repo-root>/bin/opencode-agenthub
+    this_file = Path(__file__).resolve()
+    parts = this_file.parts
+    # Expected: .../<repo>/src/skills/hr-support/bin/validate_staged_package.py
+    # so repo root is 4 levels up from this file's directory
+    if (
+        len(parts) >= 6
+        and parts[-2] == "bin"
+        and parts[-3] == "hr-support"
+        and parts[-4] == "skills"
+        and parts[-5] == "src"
+    ):
+        repo_bin = this_file.parents[4] / "bin" / "opencode-agenthub"
+        if repo_bin.exists():
+            return str(repo_bin)
+    raise SystemExit(
+        "Could not locate opencode-agenthub.\n"
+        "  Set OPENCODE_AGENTHUB_BIN to the full path, or add opencode-agenthub to PATH.\n"
+        "  When running from source, ensure bin/opencode-agenthub exists in the repo root."
+    )
+
+
+def run(cmd: list[str], env: dict[str, str] | None = None) -> None:
+    result = subprocess.run(cmd, capture_output=True, text=True, env=env)
+    if result.returncode != 0:
+        message = result.stderr.strip() or result.stdout.strip()
+        raise SystemExit(f"Command failed: {' '.join(cmd)}\n{message}")
+
+
+def resolve_import_root(stage_arg: str) -> Path:
+    stage_path = Path(stage_arg).resolve()
+    if (stage_path / "bundles").exists() and (stage_path / "profiles").exists():
+        return stage_path
+    import_root = stage_path / "agenthub-home"
+    if (import_root / "bundles").exists() and (import_root / "profiles").exists():
+        return import_root
+    raise SystemExit(f"No importable Agent Hub root found under: {stage_path}")
+
+
+def read_json(path: Path) -> dict:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def validate_bundle_metadata(import_root: Path) -> None:
+    forbidden = {"optional_skills", "runtime_conditional_skills"}
+    violations: list[str] = []
+    for bundle_file in sorted((import_root / "bundles").glob("*.json")):
+        bundle = read_json(bundle_file)
+        metadata = bundle.get("metadata", {})
+        if not isinstance(metadata, dict):
+            continue
+        bad = sorted(forbidden.intersection(metadata.keys()))
+        if bad:
+            violations.append(f"{bundle_file.name}: {', '.join(bad)}")
+    if violations:
+        detail = "\n".join(f"- {item}" for item in violations)
+        raise SystemExit(
+            "Bundle metadata contains non-runtime semantic keys that the current platform does not consume:\n"
+            f"{detail}"
+        )
+
+
+def validate_staged_skills(import_root: Path) -> None:
+    skills_root = import_root / "skills"
+    missing: list[str] = []
+    for bundle_file in sorted((import_root / "bundles").glob("*.json")):
+        bundle = read_json(bundle_file)
+        for skill_name in bundle.get("skills", []):
+            if not (skills_root / skill_name).exists():
+                missing.append(f"{bundle_file.name}: {skill_name}")
+    if missing:
+        detail = "\n".join(f"- {item}" for item in missing)
+        raise SystemExit(f"Missing staged skills referenced by bundles:\n{detail}")
+
+
+def validate_staged_mcps(import_root: Path) -> None:
+    mcp_root = import_root / "mcp"
+    bundles_root = import_root / "bundles"
+    if not bundles_root.exists():
+        return
+
+    missing_configs: list[str] = []
+    missing_servers: list[str] = []
+
+    for bundle_file in sorted(bundles_root.glob("*.json")):
+        bundle = read_json(bundle_file)
+        for mcp_name in bundle.get("mcp", []):
+            config_path = mcp_root / f"{mcp_name}.json"
+            if not config_path.exists():
+                missing_configs.append(f"{bundle_file.name}: {mcp_name}")
+
+    if missing_configs:
+        detail = "\n".join(f"- {item}" for item in missing_configs)
+        raise SystemExit(f"Missing staged MCP configs referenced by bundles:\n{detail}")
+
+    if not mcp_root.exists():
+        return
+
+    for mcp_file in sorted(mcp_root.glob("*.json")):
+        config = read_json(mcp_file)
+        command = config.get("command", [])
+        if not isinstance(command, list):
+            continue
+        for item in command:
+            if not isinstance(item, str) or "${LIBRARY_ROOT}/" not in item:
+                continue
+            relative = item.split("${LIBRARY_ROOT}/", 1)[1]
+            if not relative.startswith("mcp-servers/"):
+                continue
+            target = import_root / relative
+            if not target.exists():
+                missing_servers.append(f"{mcp_file.name}: {relative}")
+
+    if missing_servers:
+        detail = "\n".join(f"- {item}" for item in missing_servers)
+        raise SystemExit(
+            f"Missing staged MCP server artifacts referenced by MCP configs:\n{detail}"
+        )
+
+
+def validate_profile_default_agents(import_root: Path) -> None:
+    bundle_specs = {
+        bundle_file.stem: read_json(bundle_file)
+        for bundle_file in sorted((import_root / "bundles").glob("*.json"))
+    }
+
+    for profile_file in sorted((import_root / "profiles").glob("*.json")):
+        profile = read_json(profile_file)
+        profile_name = profile.get("name") or profile_file.stem
+        bundle_names = profile.get("bundles", [])
+        if not isinstance(bundle_names, list):
+            raise SystemExit(
+                f"Profile '{profile_name}' has invalid bundles metadata; expected a list."
+            )
+
+        references: list[tuple[str, str]] = []
+        missing_bundles: list[str] = []
+        for raw_bundle_name in bundle_names:
+            if not isinstance(raw_bundle_name, str) or not raw_bundle_name.strip():
+                raise SystemExit(
+                    f"Profile '{profile_name}' contains an invalid bundle reference: {raw_bundle_name!r}."
+                )
+            bundle_name = raw_bundle_name.strip()
+            bundle = bundle_specs.get(bundle_name)
+            if not bundle:
+                missing_bundles.append(bundle_name)
+                continue
+            agent = bundle.get("agent", {})
+            agent_name = agent.get("name") if isinstance(agent, dict) else None
+            if not isinstance(agent_name, str) or not agent_name.strip():
+                raise SystemExit(
+                    f"Bundle '{bundle_name}' is missing required agent.name; profile '{profile_name}' cannot use it."
+                )
+            references.append((bundle_name, agent_name.strip()))
+
+        if missing_bundles:
+            detail = ", ".join(missing_bundles)
+            raise SystemExit(
+                f"Profile '{profile_name}' references missing bundle(s): {detail}."
+            )
+
+        default_agent = profile.get("defaultAgent")
+        native_agent_policy = profile.get("nativeAgentPolicy")
+        if native_agent_policy == "team-only" and default_agent is None:
+            raise SystemExit(
+                f"Profile '{profile_name}' uses nativeAgentPolicy 'team-only' and must set defaultAgent explicitly."
+            )
+        if default_agent is None:
+            continue
+        if not isinstance(default_agent, str) or not default_agent.strip():
+            raise SystemExit(
+                f"Profile '{profile_name}' has an invalid defaultAgent value: {default_agent!r}."
+            )
+
+        normalized_default_agent = default_agent.strip()
+        bundle_match = next(
+            (
+                agent_name
+                for bundle_name, agent_name in references
+                if bundle_name == normalized_default_agent
+                and agent_name != normalized_default_agent
+            ),
+            None,
+        )
+        if bundle_match:
+            raise SystemExit(
+                f"Profile '{profile_name}' defaultAgent '{normalized_default_agent}' does not match any bundle agent.name. "
+                f"Bundle '{normalized_default_agent}' uses bundle agent.name '{bundle_match}'. Set defaultAgent to that value."
+            )
+
+        agent_names = {agent_name for _, agent_name in references}
+        if normalized_default_agent in agent_names:
+            continue
+
+        available = ", ".join(sorted(agent_names)) or "(none)"
+        raise SystemExit(
+            f"Profile '{profile_name}' defaultAgent '{normalized_default_agent}' does not match any bundle agent.name. "
+            f"Available bundle agent.name values: {available}."
+        )
+
+
+def main() -> int:
+    if len(sys.argv) != 2:
+        raise SystemExit(
+            "Usage: validate_staged_package.py <stage-package-root|agenthub-home-root>"
+        )
+
+    agenthub_bin = resolve_agenthub_bin()
+    import_root = resolve_import_root(sys.argv[1])
+    workspace_root = Path.cwd()
+    validate_bundle_metadata(import_root)
+    validate_staged_skills(import_root)
+    validate_staged_mcps(import_root)
+    validate_profile_default_agents(import_root)
+
+    profiles = sorted(p.stem for p in (import_root / "profiles").glob("*.json"))
+    if not profiles:
+        raise SystemExit("No profiles found in staged import root.")
+
+    with tempfile.TemporaryDirectory(prefix="agenthub-stage-validate-") as temp_dir:
+        temp_root = Path(temp_dir)
+        temp_home = temp_root / "home"
+        temp_hr_home = temp_root / "hr-home"
+        temp_cfg = temp_root / "config"
+
+        run(
+            [
+                agenthub_bin,
+                "setup",
+                "minimal",
+                "--target-root",
+                str(temp_home),
+            ]
+        )
+        run(
+            [
+                agenthub_bin,
+                "hub-import",
+                "--source",
+                str(import_root),
+                "--target-root",
+                str(temp_home),
+                "--overwrite",
+            ]
+        )
+
+        env = os.environ.copy()
+        env["OPENCODE_AGENTHUB_HOME"] = str(temp_home)
+        env["OPENCODE_AGENTHUB_HR_HOME"] = str(temp_hr_home)
+        for profile in profiles:
+            run(
+                [
+                    agenthub_bin,
+                    "run",
+                    profile,
+                    "--workspace",
+                    str(workspace_root),
+                    "--config-root",
+                    str(temp_cfg / profile),
+                    "--assemble-only",
+                ],
+                env=env,
+            )
+
+    print("VALIDATED")
+    print(f"- import_root: {import_root}")
+    print(f"- profiles: {', '.join(profiles)}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/dist/skills/hr-support/bin/vendor_stage_mcps.py

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+def resolve_hr_home() -> Path:
+    explicit = os.environ.get("OPENCODE_AGENTHUB_HR_HOME")
+    if explicit:
+        return Path(explicit).resolve()
+    return Path(__file__).resolve().parent.parent
+
+
+def resolve_builtin_mcp_root() -> Path | None:
+    this_file = Path(__file__).resolve()
+    parts = this_file.parts
+    if (
+        len(parts) >= 6
+        and parts[-2] == "bin"
+        and parts[-3] == "hr-support"
+        and parts[-4] == "skills"
+        and parts[-5] == "src"
+    ):
+        candidate = this_file.parents[3] / "composer" / "library" / "mcp"
+        if candidate.exists():
+            return candidate
+    return None
+
+
+HR_HOME = resolve_hr_home()
+WORKERS_ROOT = HR_HOME / "inventory" / "workers"
+BUILTIN_MCP_ROOT = resolve_builtin_mcp_root()
+
+
+def resolve_import_root(stage_arg: str) -> Path:
+    stage_path = Path(stage_arg).resolve()
+    if (stage_path / "bundles").exists() and (stage_path / "profiles").exists():
+        return stage_path
+    import_root = stage_path / "agenthub-home"
+    if (import_root / "bundles").exists() and (import_root / "profiles").exists():
+        return import_root
+    raise SystemExit(f"No importable Agent Hub root found under: {stage_path}")
+
+
+def read_json(path: Path) -> dict:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def load_worker_cards() -> list[dict]:
+    cards: list[dict] = []
+    for worker_file in sorted(WORKERS_ROOT.glob("*.json")):
+        try:
+            cards.append(read_json(worker_file))
+        except json.JSONDecodeError:
+            continue
+    return cards
+
+
+def find_source_root(mcp_name: str, cards: list[dict]) -> Path | None:
+    normalized = mcp_name.lower()
+    for card in cards:
+        if card.get("asset_kind") != "profile":
+            continue
+        selected = card.get("selected_mcps") or []
+        if normalized not in {str(item).lower() for item in selected}:
+            continue
+        cached_repo = card.get("artifacts", {}).get("cached_repo")
+        if not cached_repo:
+            continue
+        repo_root = Path(cached_repo)
+        if not repo_root.is_absolute():
+            repo_root = HR_HOME / repo_root
+        if (repo_root / "mcp" / f"{mcp_name}.json").exists():
+            return repo_root
+    return None
+
+
+def copy_tree_if_exists(source: Path, target: Path) -> None:
+    if not source.exists():
+        return
+    if source.is_dir():
+        shutil.copytree(source, target, dirs_exist_ok=True)
+    else:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source, target)
+
+
+def resolve_library_root_from_command(command: list[object]) -> str | None:
+    for item in command:
+        if isinstance(item, str) and "${LIBRARY_ROOT}" in item:
+            suffix = item.split("${LIBRARY_ROOT}/", 1)
+            if len(suffix) == 2:
+                return suffix[1]
+    return None
+
+
+def command_available(name: str) -> bool:
+    return shutil.which(name) is not None
+
+
+def install_mcp_dependencies(target_root: Path) -> str:
+    if command_available("bun"):
+        subprocess.run(["bun", "install"], cwd=target_root, check=True)
+        return "bun"
+    if command_available("npm"):
+        subprocess.run(["npm", "install"], cwd=target_root, check=True)
+        return "npm"
+    raise SystemExit(
+        "MCP dependencies are required but neither 'bun' nor 'npm' is available on PATH."
+    )
+
+
+def main() -> int:
+    if len(sys.argv) != 2:
+        raise SystemExit(
+            "Usage: vendor_stage_mcps.py <stage-package-root|agenthub-home-root>"
+        )
+
+    import_root = resolve_import_root(sys.argv[1])
+    bundles_root = import_root / "bundles"
+    staged_mcp_root = import_root / "mcp"
+    staged_mcp_servers_root = import_root / "mcp-servers"
+    staged_mcp_root.mkdir(parents=True, exist_ok=True)
+
+    required_mcps: set[str] = set()
+    for bundle_file in sorted(bundles_root.glob("*.json")):
+        bundle = read_json(bundle_file)
+        for mcp_name in bundle.get("mcp", []):
+            required_mcps.add(str(mcp_name))
+
+    if not required_mcps:
+        print("Vendored MCPs:\n- none required")
+        return 0
+
+    cards = load_worker_cards()
+    vendored_mcps: list[str] = []
+    vendored_servers: set[str] = set()
+    deferred_install_paths: set[str] = set()
+
+    for mcp_name in sorted(required_mcps):
+        source_root = find_source_root(mcp_name, cards)
+        if source_root is None:
+            raise SystemExit(
+                f"Missing cached source repo for MCP '{mcp_name}'. Add a worker card with selected_mcps and cached_repo."
+            )
+
+        source_mcp_file = source_root / "mcp" / f"{mcp_name}.json"
+        if not source_mcp_file.exists():
+            builtin_candidate = (
+                BUILTIN_MCP_ROOT / f"{mcp_name}.json" if BUILTIN_MCP_ROOT else None
+            )
+            if builtin_candidate and builtin_candidate.exists():
+                source_mcp_file = builtin_candidate
+            else:
+                raise SystemExit(
+                    f"Missing MCP registration for '{mcp_name}' in {source_root / 'mcp'}"
+                )
+
+        target_mcp_file = staged_mcp_root / f"{mcp_name}.json"
+        target_mcp_file.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source_mcp_file, target_mcp_file)
+        vendored_mcps.append(mcp_name)
+
+        config = read_json(source_mcp_file)
+        command = config.get("command") or []
+        if not isinstance(command, list):
+            continue
+        for entry in command:
+            if not isinstance(entry, str) or "${LIBRARY_ROOT}/" not in entry:
+                continue
+            relative = resolve_library_root_from_command([entry])
+            if not relative:
+                continue
+            source_path = source_root / relative
+            if "mcp-servers/" not in relative:
+                continue
+            if relative.startswith("mcp-servers/node_modules/"):
+                package_manifest = source_root / "mcp-servers" / "package.json"
+                if package_manifest.exists():
+                    deferred_install_paths.add(relative)
+                    continue
+            if not source_path.exists():
+                raise SystemExit(
+                    f"MCP '{mcp_name}' references '{relative}' but it does not exist under {source_root}"
+                )
+            target_path = import_root / relative
+            copy_tree_if_exists(source_path, target_path)
+            vendored_servers.add(relative)
+
+        package_manifest = source_root / "mcp-servers" / "package.json"
+        if package_manifest.exists():
+            copy_tree_if_exists(
+                package_manifest, staged_mcp_servers_root / "package.json"
+            )
+            vendored_servers.add("mcp-servers/package.json")
+
+    install_tool: str | None = None
+    if deferred_install_paths:
+        missing_after_copy = [
+            relative
+            for relative in sorted(deferred_install_paths)
+            if not (import_root / relative).exists()
+        ]
+        if missing_after_copy:
+            if not (staged_mcp_servers_root / "package.json").exists():
+                detail = ", ".join(missing_after_copy)
+                raise SystemExit(
+                    f"MCP configs reference runtime dependencies ({detail}) but no staged mcp-servers/package.json is available."
+                )
+            install_tool = install_mcp_dependencies(staged_mcp_servers_root)
+            for relative in missing_after_copy:
+                if not (import_root / relative).exists():
+                    raise SystemExit(
+                        f"Installed MCP dependencies with {install_tool}, but required runtime file is still missing: {relative}"
+                    )
+                vendored_servers.add(relative)
+
+    print("Vendored MCP configs:")
+    for name in vendored_mcps:
+        print(f"- {name}")
+    print("Vendored MCP server artifacts:")
+    for relative in sorted(vendored_servers):
+        print(f"- {relative}")
+    if install_tool:
+        print(f"Installed MCP dependencies with: {install_tool}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/dist/skills/hr-support/bin/vendor_stage_skills.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+
+import json
+import shutil
+import sys
+from pathlib import Path
+
+
+HR_HOME = Path(__file__).resolve().parent.parent
+WORKERS_ROOT = HR_HOME / "inventory" / "workers"
+
+
+def resolve_import_root(stage_arg: str) -> Path:
+    stage_path = Path(stage_arg).resolve()
+    if (stage_path / "bundles").exists() and (stage_path / "profiles").exists():
+        return stage_path
+    import_root = stage_path / "agenthub-home"
+    if (import_root / "bundles").exists() and (import_root / "profiles").exists():
+        return import_root
+    raise SystemExit(f"No importable Agent Hub root found under: {stage_path}")
+
+
+def read_json(path: Path) -> dict:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def locate_skill_card(skill_name: str) -> dict:
+    for worker_file in sorted(WORKERS_ROOT.glob("*.json")):
+        card = read_json(worker_file)
+        if card.get("asset_kind") != "skill":
+            continue
+        if skill_name in {
+            card.get("candidate_slug"),
+            card.get("name"),
+            worker_file.stem,
+        }:
+            return card
+    raise SystemExit(f"Missing worker card for skill: {skill_name}")
+
+
+def resolve_source_dir(card: dict) -> Path:
+    cached_repo = Path(card.get("artifacts", {}).get("cached_repo", ""))
+    if not cached_repo:
+        raise SystemExit(
+            f"Missing cached_repo artifact for skill: {card.get('name', 'unknown')}"
+        )
+    repo_root = cached_repo if cached_repo.is_absolute() else HR_HOME / cached_repo
+    source_path = card.get("source_path") or card.get("artifacts", {}).get(
+        "source_file"
+    )
+    if not source_path:
+        raise SystemExit(
+            f"Missing source_path for skill: {card.get('name', 'unknown')}"
+        )
+    source_file = repo_root / source_path
+    if source_file.is_dir():
+        return source_file
+    if source_file.exists():
+        return source_file.parent
+    raise SystemExit(
+        f"Missing source directory for skill {card.get('name', 'unknown')}: {source_file}"
+    )
+
+
+def main() -> int:
+    if len(sys.argv) != 2:
+        raise SystemExit(
+            "Usage: vendor_stage_skills.py <stage-package-root|agenthub-home-root>"
+        )
+
+    import_root = resolve_import_root(sys.argv[1])
+    skills_root = import_root / "skills"
+    skills_root.mkdir(parents=True, exist_ok=True)
+
+    required_skills: set[str] = set()
+    for bundle_file in sorted((import_root / "bundles").glob("*.json")):
+        bundle = read_json(bundle_file)
+        for skill_name in bundle.get("skills", []):
+            required_skills.add(skill_name)
+
+    vendored: list[str] = []
+    skipped: list[str] = []
+    for skill_name in sorted(required_skills):
+        target_dir = skills_root / skill_name
+        if target_dir.exists():
+            skipped.append(skill_name)
+            continue
+
+        card = locate_skill_card(skill_name)
+        shutil.copytree(resolve_source_dir(card), target_dir, dirs_exist_ok=True)
+        vendored.append(skill_name)
+
+    print("Vendored skills:")
+    for skill in vendored:
+        print(f"- {skill}")
+    if skipped:
+        print("Already present:")
+        for skill in skipped:
+            print(f"- {skill}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/dist/types.js

@@ -0,0 +1,11 @@
+class GuardResolutionError extends Error {
+  constructor(message, guardName, chain) {
+    super(message);
+    this.guardName = guardName;
+    this.chain = chain;
+    this.name = "GuardResolutionError";
+  }
+}
+export {
+  GuardResolutionError
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "opencode-agenthub",
+  "version": "0.1.0",
+  "description": "Systematic control plane for opencode agents, skills, profiles, and shared runtime assets.",
+  "type": "module",
+  "main": "./dist/plugins/opencode-agenthub.js",
+  "exports": {
+    ".": "./dist/plugins/opencode-agenthub.js",
+    "./question": "./dist/plugins/opencode-question.js"
+  },
+  "bin": {
+    "agenthub": "dist/composer/opencode-profile.js",
+    "opencode-agenthub": "dist/composer/opencode-profile.js"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "test:smoke": "bun test test/smoke-*.test.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "dist/"
+  ],
+  "keywords": [
+    "opencode",
+    "agents",
+    "agenthub",
+    "skills",
+    "mcp",
+    "workflow",
+    "llm",
+    "ai-agents"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sdwolf4103/opencode-agenthub.git"
+  },
+  "homepage": "https://github.com/sdwolf4103/opencode-agenthub#readme",
+  "bugs": {
+    "url": "https://github.com/sdwolf4103/opencode-agenthub/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "packageManager": "bun@1.3.9",
+  "devDependencies": {
+    "esbuild": "^0.25.9"
+  }
+}