@ngocsangairvds/vsaf 4.1.7 → 4.1.9

package/skills/vds-skill/vds-scripts/vidp_orchestrator/src/vds_vidp_orchestrator/cli.py

@@ -1,246 +0,0 @@
-"""CLI for the VIDP orchestrator.
-
-Examples:
-    vds-vidp trigger <workflowId>
-    vds-vidp trigger <workflowId> --payload '{"foo": "bar"}'
-    vds-vidp trigger <workflowId> --payload-file ./payload.json
-    vds-vidp status <jobId>
-    vds-vidp status <jobId> --raw
-"""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from typing import Annotated
-
-import typer
-from vds_cli_common.app import make_vds_app
-from vds_cli_common.context import CLIContext
-from vds_cli_common.output import OutputManager
-from vds_platform_core.errors import SettingsError
-from vds_platform_core.logging import configure_structlog
-
-from vds_vidp_orchestrator.client import VidpClient
-from vds_vidp_orchestrator.config import load_settings
-from vds_vidp_orchestrator.workflows import (
-    load_aliases,
-    load_package_aliases,
-    load_user_aliases,
-    package_workflows_file,
-    resolve_workflow_id,
-    save_user_aliases,
-    user_workflows_file,
-)
-
-configure_structlog()
-app = make_vds_app(
-    name="vds-vidp",
-    help="VDS VIDP CLI — trigger third-party workflows and poll job status.",
-    settings_factory=load_settings,
-)
-
-
-def _resolve_payload(payload: str | None, payload_file: Path | None) -> object | None:
-    if payload and payload_file:
-        raise typer.BadParameter("Use either --payload or --payload-file, not both.")
-    if payload:
-        try:
-            return json.loads(payload)
-        except json.JSONDecodeError as exc:
-            raise typer.BadParameter(f"--payload is not valid JSON: {exc}") from exc
-    if payload_file:
-        try:
-            return json.loads(payload_file.read_text(encoding="utf-8"))
-        except json.JSONDecodeError as exc:
-            raise typer.BadParameter(f"--payload-file is not valid JSON: {exc}") from exc
-    return None
-
-
-@app.command()
-def trigger(
-    ctx: typer.Context,
-    workflow: Annotated[
-        str,
-        typer.Argument(
-            help="Workflow UUID OR alias from ~/.vds/vidp-workflows.json (e.g. 'build-jenkins-by-job-name').",
-        ),
-    ],
-    payload: Annotated[
-        str | None,
-        typer.Option("--payload", "-p", help="Inline JSON payload"),
-    ] = None,
-    payload_file: Annotated[
-        Path | None,
-        typer.Option(
-            "--payload-file",
-            "-f",
-            exists=True,
-            readable=True,
-            dir_okay=False,
-            help="Path to a JSON file containing the payload",
-        ),
-    ] = None,
-) -> None:
-    """Trigger a VIDP third-party action by workflow id or alias."""
-    out = OutputManager(CLIContext.from_typer_context(ctx))
-    try:
-        workflow_id, alias_used = resolve_workflow_id(workflow)
-        body = _resolve_payload(payload, payload_file)
-        settings = load_settings()
-        with VidpClient(settings) as client:
-            result = client.trigger(workflow_id, body)
-        out.output_json(
-            {
-                "tool": "vidp.trigger",
-                "endpoint": f"/third-party/v2/start/{workflow_id}",
-                "aliasUsed": alias_used,
-                "workflowId": workflow_id,
-                "requestPayload": body if body is not None else {},
-                "response": result,
-            }
-        )
-    except KeyError as exc:
-        out.output_error(str(exc))
-        raise typer.Exit(1) from None
-    except SettingsError as exc:
-        out.output_error(f"Configuration error: {exc}", hint="Check VDS_VIDP_* / VIDP_* env vars.")
-        raise typer.Exit(1) from None
-    except Exception as exc:  # noqa: BLE001 — surface as JSON for AI consumers
-        out.output_error(str(exc))
-        raise typer.Exit(1) from None
-
-
-@app.command()
-def status(
-    ctx: typer.Context,
-    job_id: Annotated[
-        str,
-        typer.Argument(help="Job id (the {jobId} segment of the VIDP status endpoint)"),
-    ],
-    raw: Annotated[
-        bool,
-        typer.Option("--raw", help="Emit the raw VIDP response only (skip normalization)."),
-    ] = False,
-) -> None:
-    """Fetch full workflow/stage detail for a VIDP job."""
-    out = OutputManager(CLIContext.from_typer_context(ctx))
-    try:
-        settings = load_settings()
-        with VidpClient(settings) as client:
-            response = client.status(job_id)
-        if raw:
-            out.output_json(response)
-            return
-        normalized = VidpClient.normalize_status(response)
-        out.output_json(
-            {
-                "tool": "vidp.status",
-                "endpoint": f"/third-party/v2/status/{job_id}?full=true",
-                "normalized": normalized,
-                "response": response,
-            }
-        )
-    except SettingsError as exc:
-        out.output_error(f"Configuration error: {exc}", hint="Check VDS_VIDP_* / VIDP_* env vars.")
-        raise typer.Exit(1) from None
-    except Exception as exc:  # noqa: BLE001
-        out.output_error(str(exc))
-        raise typer.Exit(1) from None
-
-
-workflows_app = typer.Typer(
-    name="workflows",
-    help=(
-        "Manage workflow alias registry. Package defaults ship with vds-scripts "
-        "(read-only); add/remove writes to the user override file "
-        "(~/.vds/vidp-workflows.json or $VDS_VIDP_WORKFLOWS_FILE)."
-    ),
-)
-app.add_typer(workflows_app, name="workflows")
-
-
-@workflows_app.command("list")
-def workflows_list(ctx: typer.Context) -> None:
-    """List alias → workflow-id mappings, separated by source."""
-    out = OutputManager(CLIContext.from_typer_context(ctx))
-    package = load_package_aliases()
-    user = load_user_aliases()
-    overridden = {k for k in user if k in package and user[k] != package[k]}
-    out.output_json(
-        {
-            "packageFile": str(package_workflows_file()),
-            "userFile": str(user_workflows_file()),
-            "package": package,
-            "user": user,
-            "userOverridesPackage": sorted(overridden),
-            "merged": load_aliases(),
-        }
-    )
-
-
-@workflows_app.command("add")
-def workflows_add(
-    ctx: typer.Context,
-    name: Annotated[str, typer.Argument(help="Alias name (e.g. 'build-jenkins-by-job-name')")],
-    workflow_id: Annotated[str, typer.Argument(help="Workflow UUID")],
-    force: Annotated[
-        bool,
-        typer.Option("--force", help="Overwrite if alias already exists in user file."),
-    ] = False,
-) -> None:
-    """Add or update an alias in the USER override file.
-
-    Package-shipped aliases are read-only; use ``--force`` to override them
-    locally via the user file.
-    """
-    out = OutputManager(CLIContext.from_typer_context(ctx))
-    user = load_user_aliases()
-    package = load_package_aliases()
-    if name in user and not force:
-        out.output_error(
-            f"Alias '{name}' already in user file → '{user[name]}'. Use --force to overwrite."
-        )
-        raise typer.Exit(1) from None
-    user[name] = workflow_id
-    path = save_user_aliases(user)
-    out.output_json(
-        {
-            "saved": str(path),
-            "alias": name,
-            "workflowId": workflow_id,
-            "overridesPackage": name in package and package[name] != workflow_id,
-        }
-    )
-
-
-@workflows_app.command("remove")
-def workflows_remove(
-    ctx: typer.Context,
-    name: Annotated[str, typer.Argument(help="Alias name to remove from user file")],
-) -> None:
-    """Remove an alias from the USER override file.
-
-    Package-shipped aliases cannot be removed via CLI — edit the package
-    workflows.json directly to change the curated catalogue.
-    """
-    out = OutputManager(CLIContext.from_typer_context(ctx))
-    user = load_user_aliases()
-    if name not in user:
-        package = load_package_aliases()
-        if name in package:
-            out.output_error(
-                f"Alias '{name}' is shipped with the package (read-only). "
-                f"Edit {package_workflows_file()} to change it, or use "
-                f"'workflows add {name} <other-uuid> --force' to override locally."
-            )
-        else:
-            out.output_error(f"Alias '{name}' not found.")
-        raise typer.Exit(1) from None
-    removed = user.pop(name)
-    path = save_user_aliases(user)
-    out.output_json({"saved": str(path), "removed": name, "wasMappedTo": removed})
-
-
-if __name__ == "__main__":
-    app()

package/skills/vds-skill/vds-scripts/vidp_orchestrator/src/vds_vidp_orchestrator/client.py

@@ -1,104 +0,0 @@
-"""HTTP client for the VIDP third-party gateway."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-from urllib.parse import quote
-
-import httpx
-from vds_platform_core.http.errors import map_http_error
-
-if TYPE_CHECKING:
-    from vds_vidp_orchestrator.config import VidpSettings
-
-
-class VidpClient:
-    """Thin synchronous client around the two VIDP endpoints we expose."""
-
-    def __init__(self, settings: VidpSettings) -> None:
-        self.settings = settings
-        self._client: httpx.Client | None = None
-
-    def _get_client(self) -> httpx.Client:
-        if self._client is None:
-            self._client = httpx.Client(
-                base_url=self.settings.normalized_base_url,
-                headers={"Accept": "application/json", **self.settings.auth_header},
-                timeout=self.settings.timeout_seconds,
-            )
-        return self._client
-
-    def _request(
-        self,
-        method: str,
-        path: str,
-        *,
-        json_body: Any | None = None,
-    ) -> dict[str, Any]:
-        client = self._get_client()
-        response = client.request(method, path, json=json_body)
-        try:
-            data: Any = response.json()
-        except ValueError:
-            data = {"raw": response.text}
-
-        if not response.is_success:
-            raise map_http_error(response.status_code, data, service="vidp")
-        return data if isinstance(data, dict) else {"data": data}
-
-    def trigger(self, workflow_id: str, payload: Any | None = None) -> dict[str, Any]:
-        """Trigger a third-party action by workflow id.
-
-        Mirrors ``POST /third-party/v2/start/{workflowId}``.
-        """
-        body = payload if payload is not None else {}
-        path = f"third-party/v2/start/{quote(workflow_id, safe='')}"
-        return self._request("POST", path, json_body=body)
-
-    def status(self, job_id: str) -> dict[str, Any]:
-        """Fetch full workflow/stage status for a VIDP job.
-
-        Mirrors ``GET /third-party/v2/status/{jobId}?full=true``.
-        """
-        path = f"third-party/v2/status/{quote(job_id, safe='')}?full=true"
-        return self._request("GET", path)
-
-    @staticmethod
-    def normalize_status(raw: dict[str, Any]) -> dict[str, Any]:
-        """Flatten the nested status response into the shape the original MCP returned."""
-        data = raw.get("data") or {}
-        workflows_raw = data.get("workflows") or []
-        workflows = []
-        for wf in workflows_raw:
-            steps = (wf or {}).get("steps") or {}
-            stages_raw = steps.get("stages") or []
-            workflows.append(
-                {
-                    "name": (wf or {}).get("name"),
-                    "status": (wf or {}).get("status"),
-                    "stepStatus": steps.get("status"),
-                    "stages": [
-                        {"name": (s or {}).get("name"), "status": (s or {}).get("status")}
-                        for s in stages_raw
-                    ],
-                }
-            )
-        return {
-            "jobName": data.get("name"),
-            "jobStatus": data.get("status"),
-            "workflows": workflows,
-        }
-
-    def close(self) -> None:
-        if self._client is not None:
-            self._client.close()
-            self._client = None
-
-    def __enter__(self) -> VidpClient:
-        return self
-
-    def __exit__(self, *_: object) -> None:
-        self.close()
-
-
-__all__ = ["VidpClient"]

package/skills/vds-skill/vds-scripts/vidp_orchestrator/src/vds_vidp_orchestrator/config.py

@@ -1,82 +0,0 @@
-"""Strongly-typed VIDP settings using pydantic-settings.
-
-Loads from the shared VDS env file (~/.vds/.env) with prefix `VDS_VIDP_`.
-Accepts legacy `VIDP_*` env variables as aliases so existing VIDP MCP
-deployments keep working without re-configuring credentials.
-"""
-
-from __future__ import annotations
-
-import base64
-from pathlib import Path
-from typing import Any
-
-from pydantic import AliasChoices, Field, SecretStr, ValidationError
-from pydantic_settings import BaseSettings, SettingsConfigDict
-from vds_cli_common.env import load_shared_env
-from vds_platform_core.credentials import resolve_secret
-from vds_platform_core.errors import SettingsError
-
-
-class VidpSettings(BaseSettings):
-    """VIDP gateway settings."""
-
-    model_config = SettingsConfigDict(
-        env_file=None,
-        env_file_encoding="utf-8",
-        case_sensitive=True,
-        extra="ignore",
-        populate_by_name=False,
-    )
-
-    base_url: str = Field(
-        validation_alias=AliasChoices("VDS_VIDP_BASE_URL", "VIDP_BASE_URL"),
-        description="VIDP base URL (e.g. https://idp.example.com/)",
-    )
-    username: str = Field(
-        validation_alias=AliasChoices("VDS_VIDP_USERNAME", "VIDP_USERNAME"),
-        description="Basic-auth username",
-    )
-    password_secret: SecretStr = Field(
-        validation_alias=AliasChoices("VDS_VIDP_PASSWORD", "VIDP_PASSWORD"),
-        description="Basic-auth password",
-    )
-    timeout_ms: int = Field(
-        default=30_000,
-        ge=1,
-        validation_alias=AliasChoices("VDS_VIDP_TIMEOUT_MS", "VIDP_TIMEOUT_MS"),
-        description="HTTP request timeout in milliseconds",
-    )
-
-    @property
-    def password(self) -> str:
-        return resolve_secret(self.password_secret) or ""
-
-    @property
-    def timeout_seconds(self) -> float:
-        return self.timeout_ms / 1000.0
-
-    @property
-    def normalized_base_url(self) -> str:
-        return self.base_url.rstrip("/") + "/"
-
-    @property
-    def auth_header(self) -> dict[str, str]:
-        token = base64.b64encode(f"{self.username}:{self.password}".encode()).decode()
-        return {"Authorization": f"Basic {token}"}
-
-
-def load_settings(
-    *,
-    env_path: Path | None = None,
-    overrides: dict[str, Any] | None = None,
-) -> VidpSettings:
-    """Load VIDP settings from shared env + environment variables."""
-    load_shared_env(path=env_path)
-    try:
-        return VidpSettings(**(overrides or {}))
-    except ValidationError as exc:
-        raise SettingsError(str(exc)) from exc
-
-
-__all__ = ["VidpSettings", "load_settings", "SettingsError"]

package/skills/vds-skill/vds-scripts/vidp_orchestrator/src/vds_vidp_orchestrator/workflows.json

@@ -1,3 +0,0 @@
-{
-  "build-jenkins-by-job-name": "4afa9a1d-d36c-441a-b2fd-ba9612a854c1"
-}

package/skills/vds-skill/vds-scripts/vidp_orchestrator/src/vds_vidp_orchestrator/workflows.py

@@ -1,130 +0,0 @@
-"""Workflow alias registry — map friendly names to VIDP workflow UUIDs.
-
-Two layers, merged at lookup time:
-
-1. **Package-shipped defaults** at ``<pkg>/workflows.json`` — curated by the
-   maintainer, distributed with the npm package, read-only at runtime.
-2. **User overrides** at ``~/.vds/vidp-workflows.json`` (or
-   ``$VDS_VIDP_WORKFLOWS_FILE``) — optional, user-editable, takes precedence
-   over package defaults. CLI ``add``/``remove`` only touch this file.
-
-``resolve_workflow_id()`` accepts a UUID or an alias and returns the canonical
-UUID. Alias lookup is case-insensitive.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import re
-from pathlib import Path
-
-UUID_RE = re.compile(r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$")
-
-
-def package_workflows_file() -> Path:
-    """Path to the package-shipped alias registry (read-only)."""
-    return Path(__file__).resolve().parent / "workflows.json"
-
-
-def user_workflows_file() -> Path:
-    """Path to the user-override alias registry (mutable; CLI writes here)."""
-    override = os.environ.get("VDS_VIDP_WORKFLOWS_FILE", "").strip()
-    if override:
-        return Path(override).expanduser()
-    return Path.home() / ".vds" / "vidp-workflows.json"
-
-
-# Backwards-compatible name used by the CLI before the split.
-def workflows_file() -> Path:
-    """Deprecated alias for :func:`user_workflows_file`."""
-    return user_workflows_file()
-
-
-def _read_json(path: Path) -> dict[str, str]:
-    if not path.exists():
-        return {}
-    try:
-        data = json.loads(path.read_text(encoding="utf-8"))
-    except json.JSONDecodeError:
-        return {}
-    if not isinstance(data, dict):
-        return {}
-    return {str(k).strip(): str(v).strip() for k, v in data.items() if isinstance(v, str)}
-
-
-def load_package_aliases() -> dict[str, str]:
-    """Aliases shipped with the package."""
-    return _read_json(package_workflows_file())
-
-
-def load_user_aliases() -> dict[str, str]:
-    """Aliases set by the user (override layer)."""
-    return _read_json(user_workflows_file())
-
-
-def load_aliases() -> dict[str, str]:
-    """Merged view: package defaults overlaid with user overrides."""
-    merged = load_package_aliases()
-    merged.update(load_user_aliases())
-    return merged
-
-
-def save_user_aliases(aliases: dict[str, str]) -> Path:
-    """Write the user-override registry, creating parent dir if needed."""
-    path = user_workflows_file()
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(json.dumps(aliases, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
-    return path
-
-
-# Backwards-compatible name used by older callers.
-def save_aliases(aliases: dict[str, str]) -> Path:
-    """Deprecated alias for :func:`save_user_aliases`."""
-    return save_user_aliases(aliases)
-
-
-def is_uuid(value: str) -> bool:
-    return bool(UUID_RE.match(value.strip()))
-
-
-def resolve_workflow_id(name_or_id: str) -> tuple[str, str | None]:
-    """Return ``(workflow_id, alias_used)``.
-
-    - UUID input → returned as-is with ``alias_used=None``.
-    - Otherwise look up case-insensitively in the merged registry.
-    - Raises ``KeyError`` with a helpful message if no match.
-    """
-    value = name_or_id.strip()
-    if is_uuid(value):
-        return value, None
-
-    aliases = load_aliases()
-    if value in aliases:
-        return aliases[value], value
-    lower_map = {k.lower(): (k, v) for k, v in aliases.items()}
-    if value.lower() in lower_map:
-        canonical, wf_id = lower_map[value.lower()]
-        return wf_id, canonical
-
-    raise KeyError(
-        f"No workflow id found for alias '{value}'. "
-        f"Maintainer can add it to {package_workflows_file()} "
-        f"(shipped with package); user can add a private alias via "
-        f"'vds-cli vidp workflows add {value} <uuid>' "
-        f"(writes to {user_workflows_file()})."
-    )
-
-
-__all__ = [
-    "package_workflows_file",
-    "user_workflows_file",
-    "workflows_file",  # backwards-compat
-    "load_package_aliases",
-    "load_user_aliases",
-    "load_aliases",
-    "save_user_aliases",
-    "save_aliases",  # backwards-compat
-    "is_uuid",
-    "resolve_workflow_id",
-]

package/skills/vds-skill/vds-scripts-skill/.openskills.json

@@ -1,6 +0,0 @@
-{
-  "source": "./.agent/skills/vds-scripts-skill",
-  "sourceType": "local",
-  "localPath": "/Users/vds-ai/Library/Mobile Documents/com~apple~CloudDocs/project/vds/.agent/skills/vds-scripts-skill",
-  "installedAt": "2026-01-26T07:07:42.597Z"
-}

package/skills/vds-skill/vds-scripts-skill/QUALITY.md

@@ -1,44 +0,0 @@
-# Quality Baseline — vds-scripts-skill
-
-## Version History
-
-| Version | Date | Score | Evaluator | Notes |
-|---------|------|-------|-----------|-------|
-| 1.0.0 | 2026-03-19 | 3.6/5 | Manual | Initial baseline - needs split |
-| 1.1.0 | 2026-03-23 | pending | Manual | Repositioned as platform-routing skill; pending post-refactor review |
-
-## Evaluation Criteria
-
-| Criterion | Weight | Type | Description |
-|-----------|--------|------|-------------|
-| Accuracy | 40% | Scored 1-5 | Commands and routing guidance are correct |
-| Completeness | 25% | Scored 1-5 | Current WHO capabilities are represented through skill text, references, or routing aids |
-| Actionability | 20% | Scored 1-5 | Users can quickly choose the correct command family or specialist skill |
-| Token Efficiency | 10% | Scored 1-5 | Main skill stays concise and relies on progressive disclosure |
-| Schema Validity | 5% | Binary | Skill follows AgentSkills/OpenSkills structure and metadata |
-
-## Current Role
-
-`vds-scripts-skill` is the platform-routing skill for the WHO scripts ecosystem.
-It is not the deep specialist runbook for audit workflows or other specialist domains.
-
-## Known Issues
-
-- Post-refactor scoring still needs a fresh baseline run.
-- Capability coverage should be validated against the current WHO workspace inventory.
-- Generated/root agent surfaces must be synced after the final skill/doc changes land.
-
-## Validation Checklist
-
-- [ ] `SKILL.md` remains concise and activation-oriented
-- [ ] references/ covers the broader capability map
-- [ ] routing matrix maps common intents to the right skill/command family
-- [ ] registry metadata matches the updated role
-- [ ] scripts docs and skills docs tell the same ownership story
-
-## Quality Hypotheses
-
-| Date | Hypothesis | Expected | Actual | Score Change |
-|------|------------|----------|--------|--------------|
-| 2026-03-23 | Shift from command dump to platform-routing + references | Token Efficiency up, Completeness up, clearer routing | pending | pending |
-| 2026-03-23 | Add capability index and routing matrix | Completeness 3.5→4.2 | pending | pending |