plugin-scanner 2.0.627__tar.gz → 2.0.628__tar.gz

{plugin_scanner-2.0.627 → plugin_scanner-2.0.628}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.627
+Version: 2.0.628
 Summary: Lint, verify, and gate plugin ecosystems for maintainers, CI, and publish workflows.
 Project-URL: Homepage, https://github.com/hashgraph-online/hol-guard
 Project-URL: Repository, https://github.com/hashgraph-online/hol-guard

{plugin_scanner-2.0.627 → plugin_scanner-2.0.628}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "plugin-scanner"
-version = "2.0.627"
+version = "2.0.628"
 description = "Lint, verify, and gate plugin ecosystems for maintainers, CI, and publish workflows."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.627 → plugin_scanner-2.0.628}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.627"
+version = "2.0.628"
 description = "Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, and OpenCode."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.627 → plugin_scanner-2.0.628}/src/codex_plugin_scanner/guard/aibom_detection.py

@@ -16,9 +16,14 @@ InstructionRole = Literal[
     "agents_md",
     "cursor_rules",
     "claude_md",
-    "design_md",
     "mcp_json",
+    "design_md",
     "product_md",
+    "roadmap_md",
+    "security_md",
+    "policy_md",
+    "standards_md",
+    "unknown_instruction",
 ]
 INVENTORY_ITEM_KINDS: tuple[str, ...] = (
     "agent",
@@ -46,11 +51,26 @@ _CURSOR_RULE_PATTERNS = ("*.mdc", "*.md")
 _CODEX_WORKSPACE_SKILL_ROOTS = (".agents/skills",)
 _CODEX_HOME_SKILL_ROOTS = (".codex/skills", ".agents/skills")
 _STANDARDS_CONTEXT_ROOTS = (".", ".agents/context", "docs")
-_STANDARDS_INSTRUCTION_FILES: tuple[tuple[str, InstructionRole], ...] = (
-    ("PRODUCT.md", "product_md"),
-    ("DESIGN.md", "design_md"),
+_ROOT_INSTRUCTION_ROLE_NAMES: tuple[tuple[str, InstructionRole], ...] = (
     ("CLAUDE.md", "claude_md"),
+    ("DESIGN.md", "design_md"),
+    ("PRODUCT.md", "product_md"),
+    ("ROADMAP.md", "roadmap_md"),
+    ("SECURITY.md", "security_md"),
+    ("POLICY.md", "policy_md"),
+    ("POLICIES.md", "policy_md"),
+    ("STANDARDS.md", "standards_md"),
+)
+_DOC_DIRECTORY_ROLES: tuple[tuple[str, InstructionRole], ...] = (
+    ("design", "design_md"),
+    ("product", "product_md"),
+    ("standards", "standards_md"),
+    ("policy", "policy_md"),
+    ("policies", "policy_md"),
+    ("security", "security_md"),
+    ("roadmap", "roadmap_md"),
 )
+_STANDARDS_INSTRUCTION_FILES = _ROOT_INSTRUCTION_ROLE_NAMES
 
 
 def file_content_hash(path: Path, *, max_bytes: int | None = None) -> str | None:
@@ -119,6 +139,14 @@ def instruction_role_for_path(path: Path) -> InstructionRole | None:
         return "design_md"
     if name == "product.md":
         return "product_md"
+    if name == "roadmap.md":
+        return "roadmap_md"
+    if name == "security.md":
+        return "security_md"
+    if name in {"policy.md", "policies.md"}:
+        return "policy_md"
+    if name == "standards.md":
+        return "standards_md"
     if name == "mcp.json":
         return "mcp_json"
     if path.suffix.lower() in {".md", ".mdc"}:
@@ -126,6 +154,11 @@ def instruction_role_for_path(path: Path) -> InstructionRole | None:
         for index, part in enumerate(parts):
             if part == ".cursor" and index + 1 < len(parts) and parts[index + 1] == "rules":
                 return "cursor_rules"
+            if part == "docs" and index + 1 < len(parts):
+                child = parts[index + 1].lower()
+                for directory_name, role in _DOC_DIRECTORY_ROLES:
+                    if child == directory_name:
+                        return role
     return None
 
 
@@ -205,6 +238,30 @@ def _discover_standards_context_files(harness: str, *, workspace_dir: Path) -> l
                     artifact_id=legacy_artifact_id,
                 )
             )
+        docs_root = search_root / "docs"
+        if not docs_root.is_dir() or not resolves_within_root(workspace_dir, docs_root, require_exists=True):
+            continue
+        for directory_name, _role in _DOC_DIRECTORY_ROLES:
+            base_dir = docs_root / directory_name
+            if not base_dir.is_dir() or not resolves_within_root(workspace_dir, base_dir, require_exists=True):
+                continue
+            for doc_path in _iter_recursive_markdown_files(workspace_dir, base_dir):
+                normalized_path = doc_path.resolve().as_posix()
+                if normalized_path in seen_paths:
+                    continue
+                seen_paths.add(normalized_path)
+                role = instruction_role_for_path(doc_path) or "unknown_instruction"
+                relative_id = doc_path.relative_to(workspace_dir).as_posix()
+                artifacts.append(
+                    _instruction_artifact(
+                        harness,
+                        doc_path,
+                        role=role,
+                        scope="project",
+                        display_name=relative_id,
+                        artifact_name=relative_id.replace("/", ":"),
+                    )
+                )
     return artifacts
 
 
@@ -227,6 +284,16 @@ def _discover_cursor_rules(harness: str, *, workspace_dir: Path) -> list[GuardAr
     return artifacts
 
 
+def _iter_recursive_markdown_files(root: Path, base_dir: Path) -> tuple[Path, ...]:
+    return tuple(
+        candidate
+        for candidate in sorted(base_dir.rglob("*.md"))
+        if candidate.is_file()
+        and not candidate.is_symlink()
+        and resolves_within_root(root, candidate, require_exists=True)
+    )
+
+
 def discover_codex_skill_artifacts(
     harness: str,
     *,

plugin_scanner-2.0.628/src/codex_plugin_scanner/guard/aibom_trust_metadata.py

@@ -0,0 +1,487 @@
+"""Attach local HCS trust domain evidence to AIBOM inventory metadata."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+from typing import Literal
+
+from ..checks.skill_security import resolve_skill_security_context
+from ..models import ScanOptions
+from ..trust_instruction_scoring import build_instruction_domain
+from ..trust_mcp_scoring import build_mcp_domain
+from ..trust_models import TrustAdapterScore, TrustComponentScore, TrustDomainScore
+from ..trust_plugin_scoring import build_plugin_domain
+from ..trust_skill_scoring import build_skill_domain
+
+_INVENTORY_TRUST_SCAN_OPTIONS = ScanOptions(cisco_skill_scan="off")
+
+InventoryItemKind = Literal[
+    "agent",
+    "channel",
+    "container_image",
+    "daemon_plugin",
+    "harness",
+    "hook",
+    "mcp_server",
+    "mcp_tool",
+    "model_provider",
+    "network_endpoint",
+    "overlay",
+    "package",
+    "plugin",
+    "policy",
+    "prompt_pack",
+    "repository",
+    "secret_reference",
+    "skill",
+]
+
+TrustLayerType = Literal["local_baseline", "cisco_skill_scanner", "cisco_mcp_scanner"]
+
+
+def trust_resolution_from_domain(
+    domain: TrustDomainScore,
+    *,
+    captured_at: str,
+) -> dict[str, object]:
+    from .inventory_contract import _normalize_inventory_datetime
+
+    trust_components = _trust_components_from_domain(domain)
+    normalized_captured_at = _normalize_inventory_datetime(captured_at)
+    metadata = {
+        "profileId": domain.profile_id,
+        "profileVersion": domain.profile_version,
+        "scorer": "hol-guard-local",
+        "specId": domain.spec_id,
+        "specVersion": domain.spec_version,
+        "trustDomain": domain.domain,
+        "attestationStatus": "unsigned",
+        "evidenceHash": _trust_evidence_hash(
+            {
+                "capturedAt": normalized_captured_at,
+                "resolutionSource": "local",
+                "status": "local",
+                "trustScore": round(domain.score),
+                "trustComponents": trust_components,
+                "trustDomain": domain.domain,
+            }
+        ),
+    }
+
+    return {
+        "resolutionSource": "local",
+        "status": "local",
+        "trustScore": round(domain.score),
+        "trustComponents": trust_components,
+        "capturedAt": normalized_captured_at,
+        "metadata": metadata,
+    }
+
+
+def apply_local_trust_metadata(
+    artifact: object,
+    *,
+    captured_at: str,
+    item_kind: InventoryItemKind,
+    metadata: dict[str, object],
+    workspace_dir: Path | None,
+    cisco_runs: tuple[object, ...] = (),
+) -> dict[str, object]:
+    enriched = dict(metadata)
+    trust_layers: list[dict[str, object]] = []
+
+    if item_kind in {"skill", "plugin", "mcp_server", "overlay", "policy", "prompt_pack"} and not isinstance(
+        metadata.get("trustResolution"),
+        dict,
+    ):
+        domain = _local_trust_domain_for_artifact(
+            artifact,
+            item_kind=item_kind,
+            metadata=metadata,
+            workspace_dir=workspace_dir,
+        )
+        if domain is not None:
+            enriched["trustResolution"] = trust_resolution_from_domain(domain, captured_at=captured_at)
+            trust_layers.append(_trust_layer_from_domain(domain, captured_at=captured_at))
+
+    trust_layers.extend(
+        _cisco_trust_layers_for_artifact(
+            artifact,
+            item_kind=item_kind,
+            captured_at=captured_at,
+            cisco_runs=cisco_runs,
+            workspace_dir=workspace_dir,
+        )
+    )
+
+    if trust_layers:
+        enriched["trustLayers"] = _merge_trust_layers(metadata.get("trustLayers"), trust_layers)
+    return enriched
+
+
+def _local_trust_domain_for_artifact(
+    artifact: object,
+    *,
+    item_kind: InventoryItemKind,
+    metadata: dict[str, object],
+    workspace_dir: Path | None,
+) -> TrustDomainScore | None:
+    trust_root = _trust_root_for_artifact(artifact, item_kind=item_kind, workspace_dir=workspace_dir)
+    if trust_root is None:
+        return None
+    if item_kind == "plugin":
+        return build_plugin_domain(trust_root, ())
+    if item_kind == "skill":
+        context = resolve_skill_security_context(trust_root, _INVENTORY_TRUST_SCAN_OPTIONS)
+        return build_skill_domain(trust_root, context)
+    if item_kind == "mcp_server":
+        return build_mcp_domain(trust_root, ())
+    if item_kind in {"overlay", "policy", "prompt_pack"}:
+        role = metadata.get("instructionRole")
+        normalized_role = role if isinstance(role, str) and role else "unknown_instruction"
+        return build_instruction_domain(trust_root, role=normalized_role, item_kind=item_kind)
+    return None
+
+
+def _trust_root_for_artifact(
+    artifact: object,
+    *,
+    item_kind: InventoryItemKind,
+    workspace_dir: Path | None,
+) -> Path | None:
+    config_path = getattr(artifact, "config_path", None)
+    if not isinstance(config_path, str) or not config_path.strip():
+        return None
+    path = Path(config_path)
+    if not path.exists():
+        return None
+
+    if item_kind == "skill":
+        skill_dir = path.parent if path.name.lower() == "skill.md" else path
+        for candidate in (skill_dir, *skill_dir.parents):
+            if (candidate / ".codex-plugin" / "plugin.json").is_file():
+                return candidate
+            if workspace_dir is not None and candidate.resolve() == workspace_dir.resolve():
+                break
+        return skill_dir if skill_dir.is_dir() else None
+
+    if item_kind == "mcp_server":
+        if path.is_file():
+            return path.parent
+        return path if path.is_dir() else None
+
+    if item_kind == "plugin":
+        if path.is_dir():
+            return path
+        parent = path.parent
+        return parent if parent.is_dir() else None
+
+    if item_kind in {"overlay", "policy", "prompt_pack"}:
+        return path if path.is_file() else None
+
+    return None
+
+
+def _trust_layer_from_domain(
+    domain: TrustDomainScore,
+    *,
+    captured_at: str,
+) -> dict[str, object]:
+    from .inventory_contract import _normalize_inventory_datetime
+
+    trust_components = _trust_components_from_domain(domain)
+    normalized_captured_at = _normalize_inventory_datetime(captured_at)
+
+    return {
+        "layerId": "local_baseline",
+        "layerType": "local_baseline",
+        "status": "local",
+        "trustScore": round(domain.score),
+        "trustComponents": trust_components,
+        "capturedAt": normalized_captured_at,
+        "metadata": {
+            "profileId": domain.profile_id,
+            "profileVersion": domain.profile_version,
+            "scorer": "hol-guard-local",
+            "specId": domain.spec_id,
+            "specVersion": domain.spec_version,
+            "trustDomain": domain.domain,
+            "attestationStatus": "unsigned",
+            "evidenceHash": _trust_evidence_hash(
+                {
+                    "capturedAt": normalized_captured_at,
+                    "layerId": "local_baseline",
+                    "layerType": "local_baseline",
+                    "status": "local",
+                    "trustScore": round(domain.score),
+                    "trustComponents": trust_components,
+                    "trustDomain": domain.domain,
+                }
+            ),
+        },
+    }
+
+
+def _merge_trust_layers(
+    existing: object,
+    additions: list[dict[str, object]],
+) -> list[dict[str, object]]:
+    merged: dict[str, dict[str, object]] = {}
+    if isinstance(existing, list):
+        for raw_layer in existing:
+            if not isinstance(raw_layer, dict):
+                continue
+            layer_type = raw_layer.get("layerType")
+            if isinstance(layer_type, str) and layer_type:
+                merged[layer_type] = dict(raw_layer)
+    for layer in additions:
+        layer_type = layer.get("layerType")
+        if isinstance(layer_type, str) and layer_type:
+            merged[layer_type] = layer
+    return list(merged.values())
+
+
+def _cisco_trust_layers_for_artifact(
+    artifact: object,
+    *,
+    item_kind: InventoryItemKind,
+    captured_at: str,
+    cisco_runs: tuple[object, ...],
+    workspace_dir: Path | None,
+) -> list[dict[str, object]]:
+    layers: list[dict[str, object]] = []
+    for run in cisco_runs:
+        source = getattr(run, "source", None)
+        if (
+            source == "cisco-skill-scanner"
+            and item_kind in {"skill", "plugin"}
+            and _matches_skill_cisco_run(
+                artifact,
+                item_kind=item_kind,
+                run=run,
+                workspace_dir=workspace_dir,
+            )
+        ):
+            layers.append(
+                _cisco_trust_layer(
+                    run,
+                    captured_at=captured_at,
+                    layer_id="cisco_skill_scanner",
+                    component_id="cisco.skill.score",
+                    label="Cisco Skill Scanner",
+                )
+            )
+        if source == "cisco-mcp-scanner" and item_kind == "mcp_server" and _matches_mcp_cisco_run(artifact, run=run):
+            layers.append(
+                _cisco_trust_layer(
+                    run,
+                    captured_at=captured_at,
+                    layer_id="cisco_mcp_scanner",
+                    component_id="cisco.mcp.score",
+                    label="Cisco MCP Scanner",
+                )
+            )
+    return layers
+
+
+def _matches_skill_cisco_run(
+    artifact: object,
+    *,
+    item_kind: InventoryItemKind,
+    run: object,
+    workspace_dir: Path | None,
+) -> bool:
+    run_target = _cisco_run_target_path(run)
+    if run_target is None:
+        return False
+    trust_root = _trust_root_for_artifact(artifact, item_kind=item_kind, workspace_dir=workspace_dir)
+    if trust_root is None:
+        return False
+    return _paths_related(trust_root, run_target)
+
+
+def _matches_mcp_cisco_run(artifact: object, *, run: object) -> bool:
+    run_target = _cisco_run_target_path(run)
+    config_path = getattr(artifact, "config_path", None)
+    if run_target is None or not isinstance(config_path, str) or not config_path.strip():
+        return False
+    path = Path(config_path)
+    if path.is_file() and (_paths_related(path, run_target) or _paths_related(path.parent, run_target)):
+        return True
+    return _paths_related(path, run_target)
+
+
+def _paths_related(left: Path, right: Path) -> bool:
+    try:
+        left_resolved = left.resolve()
+        right_resolved = right.resolve()
+    except OSError:
+        return False
+    return (
+        left_resolved == right_resolved
+        or left_resolved in right_resolved.parents
+        or right_resolved in left_resolved.parents
+    )
+
+
+def _cisco_run_target_path(run: object) -> Path | None:
+    metadata = getattr(run, "metadata", None)
+    if not isinstance(metadata, dict):
+        return None
+    target = metadata.get("target")
+    if not isinstance(target, str) or not target.strip() or target == "missing":
+        return None
+    return Path(target)
+
+
+def _cisco_trust_layer(
+    run: object,
+    *,
+    captured_at: str,
+    layer_id: TrustLayerType,
+    component_id: str,
+    label: str,
+) -> dict[str, object]:
+    from .inventory_contract import _normalize_inventory_datetime
+
+    status = str(getattr(run, "status", "unknown"))
+    message = str(getattr(run, "message", ""))
+    severity_counts = _cisco_severity_counts(run)
+    trust_score = _cisco_layer_score(severity_counts) if status == "enabled" else None
+    trust_components: list[dict[str, object]] = []
+    if trust_score is not None:
+        component_status = "positive"
+        if trust_score < 40:
+            component_status = "critical"
+        elif trust_score < 70:
+            component_status = "warning"
+        trust_components.append(
+            {
+                "componentId": component_id,
+                "confidence": 90,
+                "label": label,
+                "score": trust_score,
+                "status": component_status,
+                "summary": message or f"{label} completed with {sum(severity_counts.values())} findings.",
+                "weight": 1.0,
+            }
+        )
+
+    run_metadata = getattr(run, "metadata", None)
+    safe_metadata: dict[str, object] = {
+        "scannerSource": str(getattr(run, "source", "unknown")),
+        "message": message,
+        "durationMs": getattr(run, "duration_ms", None) if isinstance(getattr(run, "duration_ms", None), int) else None,
+        "totalFindings": sum(severity_counts.values()),
+        "findingsBySeverity": severity_counts,
+    }
+    if isinstance(run_metadata, dict):
+        for key in (
+            "analyzersUsed",
+            "policyName",
+            "scanMode",
+            "mode",
+            "targetsScanned",
+            "skillsScanned",
+            "skillsSkipped",
+        ):
+            value = run_metadata.get(key)
+            if value is not None:
+                safe_metadata[key] = value
+    safe_metadata["attestationStatus"] = "unsigned"
+    safe_metadata["evidenceHash"] = _trust_evidence_hash(
+        {
+            "capturedAt": _normalize_inventory_datetime(captured_at),
+            "layerId": layer_id,
+            "layerType": layer_id,
+            "status": status,
+            "trustScore": trust_score,
+            "trustComponents": trust_components,
+            "metadata": {
+                key: value for key, value in safe_metadata.items() if key not in {"attestationStatus", "evidenceHash"}
+            },
+        }
+    )
+
+    return {
+        "layerId": layer_id,
+        "layerType": layer_id,
+        "status": status,
+        "trustScore": trust_score,
+        "trustComponents": trust_components,
+        "capturedAt": _normalize_inventory_datetime(captured_at),
+        "metadata": safe_metadata,
+    }
+
+
+def _cisco_severity_counts(run: object) -> dict[str, int]:
+    counts = {"critical": 0, "high": 0, "medium": 0, "low": 0}
+    metadata = getattr(run, "metadata", None)
+    if isinstance(metadata, dict):
+        raw_counts = metadata.get("findingsBySeverity")
+        if isinstance(raw_counts, dict):
+            for key in counts:
+                value = raw_counts.get(key)
+                counts[key] = value if isinstance(value, int) and value >= 0 else 0
+            return counts
+    for finding in tuple(getattr(run, "findings", ()) or ()):
+        severity = getattr(getattr(finding, "severity", None), "value", getattr(finding, "severity", None))
+        if isinstance(severity, str) and severity in counts:
+            counts[severity] += 1
+    return counts
+
+
+def _cisco_layer_score(severity_counts: dict[str, int]) -> int:
+    raw_score = 100 - (
+        30 * severity_counts["critical"]
+        + 12 * severity_counts["high"]
+        + 4 * severity_counts["medium"]
+        + severity_counts["low"]
+    )
+    return max(0, min(100, raw_score))
+
+
+def _trust_components_from_domain(domain: TrustDomainScore) -> list[dict[str, object]]:
+    components: list[dict[str, object]] = []
+    for adapter in domain.adapters:
+        if not adapter.emitted:
+            continue
+        components.extend(_trust_components_from_adapter(adapter))
+        if len(components) >= 32:
+            break
+    return components[:32]
+
+
+def _trust_components_from_adapter(adapter: TrustAdapterScore) -> list[dict[str, object]]:
+    return [_trust_component_row(adapter, component) for component in adapter.components]
+
+
+def _trust_component_row(
+    adapter: TrustAdapterScore,
+    component: TrustComponentScore,
+) -> dict[str, object]:
+    score = round(component.score)
+    status = "positive"
+    if score < 40:
+        status = "critical"
+    elif score < 70:
+        status = "warning"
+    payload: dict[str, object] = {
+        "componentId": f"{adapter.adapter_id}:{component.key}",
+        "confidence": 85,
+        "label": adapter.label,
+        "score": score,
+        "status": status,
+        "summary": component.rationale,
+        "weight": adapter.weight,
+    }
+    if component.evidence:
+        payload["evidence"] = {"lines": list(component.evidence)}
+    return payload
+
+
+def _trust_evidence_hash(payload: dict[str, object]) -> str:
+    encoded = json.dumps(payload, sort_keys=True, separators=(",", ":"), ensure_ascii=True)
+    return hashlib.sha256(encoded.encode("utf-8")).hexdigest()