skillware 0.2.3__tar.gz → 0.2.5__tar.gz

{skillware-0.2.3/skillware.egg-info → skillware-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skillware
-Version: 0.2.3
+Version: 0.2.5
 Summary: A framework for modular, self-contained AI skills.
 Author-email: ARPA Hellenic Logic Systems <skillware-os@arpacorp.net>
 License: MIT License
@@ -38,6 +38,7 @@ Requires-Dist: pyyaml
 Requires-Dist: anthropic
 Requires-Dist: google-generativeai
 Requires-Dist: pymupdf
+Requires-Dist: beautifulsoup4
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-mock; extra == "dev"
@@ -102,7 +103,8 @@ Skillware/
 │       └── skill_name/         # The Skill bundle
 │           ├── manifest.yaml   # Definition, schema, and constitution
 │           ├── skill.py        # Executable Python logic
-│           └── instructions.md # Cognitive map for the LLM
+│           ├── instructions.md # Cognitive map for the LLM
+│           └── test_skill.py   # Unit tests & schema validation
 ├── skillware/                  # Core Framework Package
 │   └── core/
 │       ├── base_skill.py       # Abstract Base Class for skills
@@ -172,6 +174,7 @@ print(response.text)
 ## Documentation
 
 *   **[Core Logic & Philosophy](docs/introduction.md)**: Details on how Skillware decouples Logic, Cognition, and Governance.
+*   **[Testing Guidelines](docs/TESTING.md)**: Instructions for validating skills and checking local coverage.
 *   **[Usage Guide: Gemini](docs/usage/gemini.md)**: Integration with Google's GenAI SDK.
 *   **[Usage Guide: Claude](docs/usage/claude.md)**: Integration with Anthropic's SDK.
 *   **[Usage Guide: Ollama](docs/usage/ollama.md)**: Native integration for local models via Ollama.

{skillware-0.2.3 → skillware-0.2.5}/README.md

@@ -55,7 +55,8 @@ Skillware/
 │       └── skill_name/         # The Skill bundle
 │           ├── manifest.yaml   # Definition, schema, and constitution
 │           ├── skill.py        # Executable Python logic
-│           └── instructions.md # Cognitive map for the LLM
+│           ├── instructions.md # Cognitive map for the LLM
+│           └── test_skill.py   # Unit tests & schema validation
 ├── skillware/                  # Core Framework Package
 │   └── core/
 │       ├── base_skill.py       # Abstract Base Class for skills
@@ -125,6 +126,7 @@ print(response.text)
 ## Documentation
 
 *   **[Core Logic & Philosophy](docs/introduction.md)**: Details on how Skillware decouples Logic, Cognition, and Governance.
+*   **[Testing Guidelines](docs/TESTING.md)**: Instructions for validating skills and checking local coverage.
 *   **[Usage Guide: Gemini](docs/usage/gemini.md)**: Integration with Google's GenAI SDK.
 *   **[Usage Guide: Claude](docs/usage/claude.md)**: Integration with Anthropic's SDK.
 *   **[Usage Guide: Ollama](docs/usage/ollama.md)**: Native integration for local models via Ollama.

{skillware-0.2.3 → skillware-0.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "skillware"
-version = "0.2.3"
+version = "0.2.5"
 description = "A framework for modular, self-contained AI skills."
 readme = "README.md"
 authors = [
@@ -23,6 +23,7 @@ dependencies = [
     "anthropic",
     "google-generativeai",
     "pymupdf",
+    "beautifulsoup4",
 ]
 requires-python = ">=3.10"
 

skillware-0.2.5/skills/compliance/mica_module/__init__.py

@@ -0,0 +1,3 @@
+from .skill import MiCAModuleSkill
+
+__all__ = ["MiCAModuleSkill"]

skillware-0.2.5/skills/compliance/mica_module/skill.py

@@ -0,0 +1,229 @@
+import json
+import os
+from typing import Any, Dict, List
+import google.generativeai as genai
+from skillware.core.base_skill import BaseSkill
+
+
+class MiCAModuleSkill(BaseSkill):
+    """
+    Acts as a highly specialized, localized RAG and policy enforcement engine for MiCA.
+    """
+
+    @property
+    def manifest(self) -> Dict[str, Any]:
+        return {"name": "compliance/mica_module", "version": "0.1.0"}
+
+    _corpus_cache: List[Dict[str, Any]] = None
+
+    def __init__(self, config: Dict[str, Any] = None):
+        super().__init__(config)
+        self._ensure_corpus_loaded()
+
+    def _ensure_corpus_loaded(self):
+        """Lazy loader for the MiCA JSON corpus."""
+        if MiCAModuleSkill._corpus_cache is not None:
+            return
+
+        corpus_path = os.path.join(os.path.dirname(__file__), "mica_corpus.json")
+        try:
+            with open(corpus_path, "r", encoding="utf-8") as f:
+                MiCAModuleSkill._corpus_cache = json.load(f)
+        except Exception as e:
+            print(f"Error loading MiCA corpus: {e}")
+            MiCAModuleSkill._corpus_cache = []
+
+    def execute(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        user_prompt = params.get("user_prompt", "")
+        run_evaluator = params.get("run_evaluator", False)
+        evaluator_model = params.get("evaluator_model", "gemini-2.5-flash-lite")
+
+        # Use the cached corpus
+        mica_data = MiCAModuleSkill._corpus_cache
+
+        # 2. Extract Intent and Route to matched sections
+        relevant_chunks = self._route_and_fetch(user_prompt, mica_data)
+
+        # Format the retrieved sections list
+        retrieved_sections = []
+        context_text = ""
+        for chunk in relevant_chunks:
+            title_info = chunk.get("title_num", "")
+            if chunk.get("title_name"):
+                title_info += f": {chunk.get('title_name')}"
+
+            art_info = chunk.get("article_num", "")
+            if chunk.get("article_title"):
+                art_info += f": {chunk.get('article_title')}"
+
+            sec_name = f"{title_info} | {art_info}"
+            retrieved_sections.append(sec_name)
+            context_text += f"\n--- {sec_name} ---\n{chunk.get('content', '')}\n"
+
+        # 3. Default Policy Status if no evaluator runs
+        policy_status = "CAUTION"
+        gemini_feedback = {
+            "grade": "N/A",
+            "holes_found": (
+                "Evaluator disabled. Review MiCA context manually for regulatory holes."
+            ),
+            "suggestion": "Follow the integrated MiCA chunks exactly.",
+        }
+
+        if not retrieved_sections:
+            final_context = "No specific MiCA articles matched the user query."
+        else:
+            final_context = (
+                "Output your final answer seamlessly integrating and adhering to "
+                f"these MiCA rules:\n{context_text}"
+            )
+
+        # 4. Optional Evaluator Node execution
+        if run_evaluator and relevant_chunks:
+            eval_result = self._run_evaluator(
+                user_prompt, context_text, evaluator_model
+            )
+            policy_status = eval_result.get("policy_status", policy_status)
+            gemini_feedback = eval_result.get(
+                "gemini_evaluator_feedback", gemini_feedback
+            )
+            final_context = eval_result.get("final_context_for_agent", final_context)
+
+        return {
+            "retrieved_sections": list(set(retrieved_sections)),
+            "policy_status": policy_status,
+            "gemini_evaluator_feedback": gemini_feedback,
+            "final_context_for_agent": final_context,
+        }
+
+    def _route_and_fetch(
+        self, prompt: str, corpus: List[Dict[str, Any]]
+    ) -> List[Dict[str, Any]]:
+        # Lightweight keyword overlap router to prevent huge context bloat.
+        prompt_lower = prompt.lower()
+
+        # Normalize common spelling variations (US to UK for the European regulation)
+        replacements = {
+            "authorization": "authorisation",
+            "authorize": "authorise",
+            "organization": "organisation",
+            "crypto asset": "crypto-asset",
+            "stablecoin": "asset-referenced token",  # High-level intent mapping
+        }
+        normalized_prompt = prompt_lower
+        for us, uk in replacements.items():
+            normalized_prompt = normalized_prompt.replace(us, uk)
+
+        # We look for significant words to increase collision hits
+        prompt_words = [
+            w.lower()
+            for w in normalized_prompt.replace("?", "")
+            .replace(".", "")
+            .replace(",", "")
+            .split()
+            if len(w) > 3
+        ]
+
+        scored_matches = []
+        # We look for significant words to increase collision hits
+        prompt_words = [
+            w.lower()
+            for w in normalized_prompt.replace("?", "")
+            .replace(".", "")
+            .replace(",", "")
+            .split()
+            if len(w) > 3
+        ]
+
+        for article in corpus:
+            score = 0
+            keywords = [k.lower() for k in article.get("keywords", [])]
+            art_num = article.get("article_num", "").lower()
+            art_title = article.get("article_title", "").lower()
+
+            # Match 1: Specific article mention (Highest Priority)
+            if art_num and f"article {art_num}" in normalized_prompt:
+                score += 100
+
+            # Match 2: Exact keyword match in prompt
+            for k in keywords:
+                if k in normalized_prompt:
+                    score += 20
+
+            # Match 3: Article title collision
+            if any(w in art_title for w in prompt_words):
+                score += 10
+
+            # Match 4: Significant word collision with keywords (Normalized by length)
+            collision_count = 0
+            for w in prompt_words:
+                for k in keywords:
+                    if w in k:
+                        # Favor specificity: longer word matches are more significant
+                        collision_count += len(w) / max(len(k), 1)
+            score += collision_count * 5
+
+            if score > 0:
+                scored_matches.append((score, article))
+
+        # Sort by score descending
+        scored_matches.sort(key=lambda x: x[0], reverse=True)
+
+        # Deduplicate and limit
+        unique_matches = []
+        seen = set()
+        for score, m in scored_matches:
+            a_id = f"{m.get('title_num', '')}_{m.get('article_num', '')}"
+            if a_id not in seen:
+                unique_matches.append(m)
+                seen.add(a_id)
+
+        # Return top 10 most relevant hits to maximize production depth
+        return unique_matches[:10]
+
+    def _run_evaluator(
+        self, prompt: str, context: str, model_name: str
+    ) -> Dict[str, Any]:
+        prompt_payload = f"""
+        You are a MiCA Regulation Evaluator.
+        User Query: {prompt}
+        MiCA Rule Context from RAG: {context}
+
+        Draft a response silently to see what an AI would say based on the user query.
+        Then, evaluate that draft against the MiCA rules to see if it violates
+        anything or misses vital compliance disclosures (like publishing a
+        White Paper, authorization required, etc).
+        Return exactly a JSON summarizing the grade and issues found.
+        Schema:
+        {{
+            "policy_status": "APPROVED|CAUTION|HIGH_RISK_DETECTED",
+            "gemini_evaluator_feedback": {{
+                "grade": "<Letter Grade (A to F)>",
+                "holes_found": "<Issues the drafted response missed>",
+                "suggestion": "<How the agent should fix the holes in its final answer>"
+            }},
+            "final_context_for_agent": "Output instructions for the agent embedding your suggestion and the context."
+        }}
+        """
+
+        try:
+            model = genai.GenerativeModel(model_name)
+            resp = model.generate_content(
+                prompt_payload,
+                generation_config=genai.GenerationConfig(
+                    response_mime_type="application/json", temperature=0.0
+                ),
+            )
+            return json.loads(resp.text)
+        except Exception as e:
+            return {
+                "policy_status": "CAUTION",
+                "gemini_evaluator_feedback": {
+                    "grade": "N/A",
+                    "holes_found": f"Evaluator API failed or rate-limited: {str(e)}",
+                    "suggestion": "Proceed manually integrating the extracted logic.",
+                },
+                "final_context_for_agent": (
+                    f"Output your final answer seamlessly integrating and adhering to these MiCA rules:\n{context}"
+                ),
+            }

skillware-0.2.5/skills/compliance/tos_evaluator/__init__.py

@@ -0,0 +1,3 @@
+from .skill import TOSEvaluatorSkill
+
+__all__ = ["TOSEvaluatorSkill"]

skillware-0.2.5/skills/compliance/tos_evaluator/skill.py

@@ -0,0 +1,587 @@
+import json
+import os
+import re
+from typing import Any, Dict, List, Optional
+from urllib.parse import urljoin, urlparse
+from urllib.robotparser import RobotFileParser
+
+import requests
+import yaml
+from bs4 import BeautifulSoup
+from skillware.core.base_skill import BaseSkill
+
+try:
+    import google.generativeai as genai
+except ImportError:  # pragma: no cover - dependency is optional at runtime
+    genai = None
+
+
+class TOSEvaluatorSkill(BaseSkill):
+    """
+    Evaluates whether an automated website action appears permissible based on
+    robots.txt and discovered legal policy pages.
+    """
+
+    WELL_KNOWN_POLICY_PATHS = [
+        "/terms",
+        "/terms-of-service",
+        "/terms-of-use",
+        "/tos",
+        "/legal/terms",
+        "/legal",
+        "/conditions",
+        "/policies/terms",
+        "/acceptable-use",
+        "/aup",
+        "/developer-terms",
+        "/api-terms",
+    ]
+
+    POLICY_KEYWORDS = {
+        "terms": 8,
+        "terms of service": 12,
+        "terms of use": 12,
+        "tos": 6,
+        "legal": 5,
+        "conditions": 4,
+        "user agreement": 8,
+        "acceptable use": 10,
+        "developer terms": 8,
+        "api terms": 10,
+        "api policy": 9,
+        "robots": 3,
+    }
+
+    ACTION_PATTERNS = {
+        "scrape": [r"\bscrap", r"\bextract", r"\bharvest", r"\bcollect data\b"],
+        "crawl": [r"\bcrawl", r"\bspider", r"\bbot\b", r"\bautomated access\b"],
+        "index": [r"\bindex", r"\bsearch engine", r"\barchive", r"\bmirror"],
+        "api_use": [r"\bapi\b", r"\bdeveloper\b", r"\bintegration\b"],
+        "monitor": [r"\bmonitor", r"\bwatch", r"\btrack", r"\bcheck periodically\b"],
+        "download": [r"\bdownload", r"\bexport", r"\bbulk\b"],
+        "automated_access": [r"\bautomation\b", r"\bscript", r"\bprogrammatic\b"],
+    }
+
+    CLAUSE_PATTERNS = [
+        {
+            "label": "hard_block",
+            "severity": "high",
+            "weight": -45,
+            "patterns": [
+                r"may not scrape",
+                r"must not scrape",
+                r"no scraping",
+                r"no crawlers",
+                r"no robots",
+                r"no automated means",
+                r"prohibited automated access",
+                r"automated means.*prohibited",
+                r"harvest.*prohibited",
+                r"crawl.*prohibited",
+            ],
+        },
+        {
+            "label": "soft_caution",
+            "severity": "medium",
+            "weight": -20,
+            "patterns": [
+                r"prior written consent",
+                r"without our permission",
+                r"reasonable rate",
+                r"rate limit",
+                r"commercial use.*restricted",
+                r"access.*subject to",
+                r"must comply with.*api",
+                r"use the api",
+            ],
+        },
+        {
+            "label": "permission",
+            "severity": "low",
+            "weight": 18,
+            "patterns": [
+                r"permitted to access",
+                r"you may use.*api",
+                r"public api",
+                r"developers may access",
+                r"search engines may crawl",
+            ],
+        },
+    ]
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        super().__init__(config)
+        self.session = requests.Session()
+        self.session.headers.update(
+            {
+                "User-Agent": "Skillware-TOS-Evaluator/0.1 (+https://github.com/ARPAHLS/skillware)"
+            }
+        )
+
+    @property
+    def manifest(self) -> Dict[str, Any]:
+        manifest_path = os.path.join(os.path.dirname(__file__), "manifest.yaml")
+        if os.path.exists(manifest_path):
+            with open(manifest_path, "r", encoding="utf-8") as f:
+                return yaml.safe_load(f)
+        return {}
+
+    def execute(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        normalized = self._normalize_input(params)
+        if "error" in normalized:
+            return normalized
+
+        robots_assessment = self._evaluate_robots(
+            normalized["origin"], normalized["target_url"], normalized["user_agent"]
+        )
+        policy_candidates = self._discover_policy_pages(
+            normalized["origin"], robots_assessment, normalized["max_terms_pages"]
+        )
+        tos_assessment = self._evaluate_policy_pages(
+            normalized, policy_candidates, normalized["max_terms_pages"]
+        )
+
+        llm_assessment = None
+        if self._should_use_llm(normalized, robots_assessment, tos_assessment):
+            llm_assessment = self._run_llm_evaluator(normalized, tos_assessment)
+
+        return self._build_final_result(
+            normalized,
+            robots_assessment,
+            tos_assessment,
+            llm_assessment,
+            policy_candidates,
+        )
+
+    def _normalize_input(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        target_url = params.get("target_url", "").strip()
+        intended_action = params.get("intended_action", "").strip()
+        if not target_url:
+            return {"error": "target_url is required."}
+        if not intended_action:
+            return {"error": "intended_action is required."}
+
+        parsed = urlparse(target_url)
+        if not parsed.scheme or not parsed.netloc:
+            return {"error": "target_url must be a fully qualified URL."}
+
+        origin = f"{parsed.scheme}://{parsed.netloc}"
+        action_type = self._classify_action(intended_action)
+        user_agent = params.get("user_agent", self.session.headers["User-Agent"])
+
+        return {
+            "target_url": target_url,
+            "intended_action": intended_action,
+            "action_type": action_type,
+            "origin": origin,
+            "path": parsed.path or "/",
+            "user_agent": user_agent,
+            "fetch_mode": params.get("fetch_mode", "lightweight"),
+            "use_llm_evaluator": bool(params.get("use_llm_evaluator", False)),
+            "llm_provider": params.get("llm_provider", "gemini"),
+            "llm_model": params.get("llm_model", "gemini-2.5-flash-lite"),
+            "assume_authenticated_session": bool(
+                params.get("assume_authenticated_session", False)
+            ),
+            "max_terms_pages": max(1, min(int(params.get("max_terms_pages", 5)), 10)),
+        }
+
+    def _classify_action(self, intended_action: str) -> str:
+        lowered = intended_action.lower()
+        for action, patterns in self.ACTION_PATTERNS.items():
+            if any(re.search(pattern, lowered) for pattern in patterns):
+                return action
+        return "automated_access"
+
+    def _evaluate_robots(
+        self, origin: str, target_url: str, user_agent: str
+    ) -> Dict[str, Any]:
+        robots_url = f"{origin}/robots.txt"
+        assessment = {
+            "status": "unavailable",
+            "robots_url": robots_url,
+            "can_fetch": None,
+            "matched_rule": "unknown",
+            "crawl_delay": None,
+            "request_rate": None,
+            "sitemaps": [],
+            "reason": "robots.txt could not be retrieved.",
+        }
+
+        try:
+            response = self.session.get(robots_url, timeout=10)
+            if response.status_code >= 400:
+                assessment["reason"] = f"robots.txt returned HTTP {response.status_code}."
+                return assessment
+
+            parser = RobotFileParser()
+            parser.set_url(robots_url)
+            parser.parse(response.text.splitlines())
+
+            can_fetch = parser.can_fetch(user_agent, target_url)
+            assessment["status"] = "parsed"
+            assessment["can_fetch"] = can_fetch
+            assessment["matched_rule"] = "allowed" if can_fetch else "disallowed"
+            assessment["crawl_delay"] = parser.crawl_delay(user_agent)
+            assessment["request_rate"] = parser.request_rate(user_agent)
+            assessment["sitemaps"] = parser.site_maps() or []
+            assessment["reason"] = (
+                "robots.txt allows the target path."
+                if can_fetch
+                else "robots.txt disallows the target path for the supplied user-agent."
+            )
+            return assessment
+        except requests.RequestException as exc:
+            assessment["reason"] = f"robots.txt request failed: {str(exc)}"
+            return assessment
+
+    def _discover_policy_pages(
+        self, origin: str, robots_assessment: Dict[str, Any], max_terms_pages: int
+    ) -> Dict[str, List[Dict[str, Any]]]:
+        candidates: Dict[str, Dict[str, Any]] = {}
+
+        for path in self.WELL_KNOWN_POLICY_PATHS:
+            url = urljoin(origin, path)
+            score = 50 if "terms" in path or "acceptable" in path else 35
+            candidates[url] = {
+                "url": url,
+                "score": score,
+                "source": "well_known_path",
+                "label": path.strip("/") or "legal",
+            }
+
+        html_pages = [origin]
+        for sitemap_url in robots_assessment.get("sitemaps", [])[:2]:
+            html_pages.append(sitemap_url)
+
+        for url in html_pages:
+            discovered = self._extract_candidate_links(url, origin)
+            for item in discovered:
+                existing = candidates.get(item["url"])
+                if existing:
+                    existing["score"] = max(existing["score"], item["score"])
+                    existing["source"] = f"{existing['source']},{item['source']}"
+                else:
+                    candidates[item["url"]] = item
+
+        ordered = sorted(candidates.values(), key=lambda item: item["score"], reverse=True)
+        return {"candidates": ordered[:max_terms_pages]}
+
+    def _extract_candidate_links(self, page_url: str, origin: str) -> List[Dict[str, Any]]:
+        links: List[Dict[str, Any]] = []
+        response = self._safe_get(page_url, timeout=10)
+        if not response or "html" not in response.headers.get("Content-Type", "").lower():
+            return links
+
+        soup = BeautifulSoup(response.text[:300000], "html.parser")
+        for anchor in soup.find_all("a", href=True):
+            href = anchor.get("href", "").strip()
+            text = " ".join(anchor.stripped_strings).strip().lower()
+            if not href:
+                continue
+
+            absolute = urljoin(page_url, href)
+            parsed = urlparse(absolute)
+            if not parsed.scheme.startswith("http"):
+                continue
+            if f"{parsed.scheme}://{parsed.netloc}" != origin:
+                continue
+
+            score = self._score_policy_link(absolute.lower(), text)
+            if score <= 0:
+                continue
+
+            links.append(
+                {
+                    "url": absolute,
+                    "score": score,
+                    "source": "link_discovery",
+                    "label": text or parsed.path,
+                }
+            )
+
+        return links
+
+    def _score_policy_link(self, href: str, text: str) -> int:
+        combined = f"{href} {text}".lower()
+        score = 0
+        for keyword, weight in self.POLICY_KEYWORDS.items():
+            if keyword in combined:
+                score += weight
+        return score
+
+    def _evaluate_policy_pages(
+        self,
+        normalized: Dict[str, Any],
+        policy_candidates: Dict[str, List[Dict[str, Any]]],
+        max_terms_pages: int,
+    ) -> Dict[str, Any]:
+        pages_evaluated = []
+        clause_hits = []
+
+        for candidate in policy_candidates.get("candidates", [])[:max_terms_pages]:
+            url = candidate["url"]
+            response = self._safe_get(url, timeout=12)
+            if not response:
+                continue
+
+            content_type = response.headers.get("Content-Type", "").lower()
+            if "html" not in content_type:
+                pages_evaluated.append(
+                    {
+                        "url": url,
+                        "status": "skipped",
+                        "reason": f"Unsupported content type: {content_type or 'unknown'}",
+                    }
+                )
+                continue
+
+            extracted_sections = self._extract_policy_sections(response.text)
+            page_hits = self._score_policy_sections(
+                normalized["action_type"], extracted_sections, url
+            )
+            clause_hits.extend(page_hits)
+            pages_evaluated.append(
+                {
+                    "url": url,
+                    "status": "parsed",
+                    "candidate_score": candidate["score"],
+                    "matched_clauses": len(page_hits),
+                }
+            )
+
+        clause_hits.sort(key=lambda item: abs(item["score_delta"]), reverse=True)
+        aggregate_score = sum(item["score_delta"] for item in clause_hits)
+        if not pages_evaluated:
+            status = "insufficient_evidence"
+            summary = "No candidate Terms or policy pages could be parsed."
+        elif any(item["classification"] == "hard_block" for item in clause_hits):
+            status = "blocked"
+            summary = "Discovered policy text contains an explicit restriction on the requested automated behavior."
+        elif aggregate_score <= -20:
+            status = "caution"
+            summary = "Discovered policy text suggests restrictions or conditions on the requested automated behavior."
+        elif aggregate_score > 0:
+            status = "allowed"
+            summary = "Discovered policy text includes language that appears permissive for the requested behavior."
+        else:
+            status = "insufficient_evidence"
+            summary = "Policy pages were found, but none produced strong action-specific evidence."
+
+        return {
+            "status": status,
+            "summary": summary,
+            "pages_evaluated": pages_evaluated,
+            "matched_clauses": clause_hits[:10],
+            "aggregate_score": aggregate_score,
+        }
+
+    def _extract_policy_sections(self, html: str) -> List[Dict[str, str]]:
+        soup = BeautifulSoup(html[:400000], "html.parser")
+        for tag in soup(["script", "style", "noscript", "svg"]):
+            tag.decompose()
+
+        body = soup.body or soup
+        sections: List[Dict[str, str]] = []
+        current_heading = "General"
+
+        for element in body.find_all(["h1", "h2", "h3", "p", "li"]):
+            text = " ".join(element.stripped_strings)
+            text = re.sub(r"\s+", " ", text).strip()
+            if not text or len(text) < 20:
+                continue
+
+            if element.name in {"h1", "h2", "h3"}:
+                current_heading = text[:160]
+                continue
+
+            sections.append({"heading": current_heading, "text": text[:1200]})
+
+        return sections[:200]
+
+    def _score_policy_sections(
+        self, action_type: str, sections: List[Dict[str, str]], page_url: str
+    ) -> List[Dict[str, Any]]:
+        hits = []
+        action_relevance_patterns = self.ACTION_PATTERNS.get(action_type, [])
+        for section in sections:
+            text_lower = section["text"].lower()
+            heading_lower = section["heading"].lower()
+            combined = f"{heading_lower} {text_lower}"
+
+            if action_relevance_patterns and not any(
+                re.search(pattern, combined) for pattern in action_relevance_patterns
+            ):
+                generic_automation = re.search(
+                    r"automated|bot|crawl|scrap|harvest|api|programmatic", combined
+                )
+                if not generic_automation:
+                    continue
+
+            for clause in self.CLAUSE_PATTERNS:
+                for pattern in clause["patterns"]:
+                    if re.search(pattern, combined):
+                        hits.append(
+                            {
+                                "url": page_url,
+                                "heading": section["heading"],
+                                "snippet": section["text"],
+                                "classification": clause["label"],
+                                "severity": clause["severity"],
+                                "score_delta": clause["weight"],
+                            }
+                        )
+                        break
+
+        return hits
+
+    def _should_use_llm(
+        self,
+        normalized: Dict[str, Any],
+        robots_assessment: Dict[str, Any],
+        tos_assessment: Dict[str, Any],
+    ) -> bool:
+        if not normalized.get("use_llm_evaluator"):
+            return False
+        if tos_assessment["status"] in {"blocked", "allowed"}:
+            return False
+        if robots_assessment.get("can_fetch") is False:
+            return False
+        return bool(tos_assessment.get("matched_clauses") or tos_assessment["status"] == "caution")
+
+    def _run_llm_evaluator(
+        self, normalized: Dict[str, Any], tos_assessment: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        provider = normalized["llm_provider"].lower()
+        if provider != "gemini":
+            return {
+                "status": "skipped",
+                "reason": f"Unsupported llm_provider '{normalized['llm_provider']}'.",
+            }
+        if genai is None:
+            return {"status": "skipped", "reason": "google-generativeai is not installed."}
+
+        api_key = os.environ.get("GOOGLE_API_KEY")
+        if not api_key:
+            return {"status": "skipped", "reason": "GOOGLE_API_KEY is not configured."}
+
+        genai.configure(api_key=api_key)
+        prompt = {
+            "target_url": normalized["target_url"],
+            "intended_action": normalized["intended_action"],
+            "action_type": normalized["action_type"],
+            "matched_clauses": tos_assessment.get("matched_clauses", [])[:6],
+            "task": (
+                "Classify whether these policy snippets forbid, allow, or condition "
+                "the requested action. Return strict JSON with keys: "
+                "verdict, confidence_score, rationale."
+            ),
+        }
+
+        try:
+            model = genai.GenerativeModel(normalized["llm_model"])
+            response = model.generate_content(
+                json.dumps(prompt, ensure_ascii=True),
+                generation_config=genai.GenerationConfig(
+                    response_mime_type="application/json", temperature=0.0
+                ),
+            )
+            parsed = json.loads(response.text)
+            return {
+                "status": "used",
+                "provider": provider,
+                "model": normalized["llm_model"],
+                "verdict": parsed.get("verdict", "CAUTION"),
+                "confidence_score": float(parsed.get("confidence_score", 0.5)),
+                "rationale": parsed.get("rationale", "No rationale returned."),
+            }
+        except Exception as exc:
+            return {"status": "error", "reason": f"LLM evaluator failed: {str(exc)}"}
+
+    def _build_final_result(
+        self,
+        normalized: Dict[str, Any],
+        robots_assessment: Dict[str, Any],
+        tos_assessment: Dict[str, Any],
+        llm_assessment: Optional[Dict[str, Any]],
+        policy_candidates: Dict[str, List[Dict[str, Any]]],
+    ) -> Dict[str, Any]:
+        verdict = "INSUFFICIENT_EVIDENCE"
+        confidence_score = 0.35
+        reason = "Insufficient policy evidence to safely approve the requested action."
+        recommended_next_step = "Review the discovered policy pages manually before proceeding."
+
+        if robots_assessment.get("can_fetch") is False:
+            verdict = "UNSAFE"
+            confidence_score = 0.98
+            reason = robots_assessment["reason"]
+            recommended_next_step = (
+                "Do not automate access to this path unless you have explicit permission."
+            )
+        elif tos_assessment["status"] == "blocked":
+            verdict = "UNSAFE"
+            confidence_score = 0.9
+            reason = tos_assessment["summary"]
+            recommended_next_step = "Avoid the requested action or obtain explicit written permission."
+        elif tos_assessment["status"] == "caution":
+            verdict = "CAUTION"
+            confidence_score = 0.65
+            reason = tos_assessment["summary"]
+            recommended_next_step = "Prefer an official API or documented integration path if one exists."
+        elif tos_assessment["status"] == "allowed" and robots_assessment.get("can_fetch") is not False:
+            verdict = "SAFE"
+            confidence_score = 0.72
+            reason = tos_assessment["summary"]
+            recommended_next_step = "Proceed conservatively and continue honoring crawl delays and rate limits."
+
+        if llm_assessment and llm_assessment.get("status") == "used":
+            verdict = llm_assessment.get("verdict", verdict)
+            confidence_score = max(
+                confidence_score,
+                llm_assessment.get("confidence_score", confidence_score),
+            )
+            reason = llm_assessment.get("rationale", reason)
+
+        evidence = []
+        if robots_assessment.get("reason"):
+            evidence.append(
+                {
+                    "source": robots_assessment.get("robots_url"),
+                    "type": "robots",
+                    "snippet": robots_assessment["reason"],
+                }
+            )
+        for clause in tos_assessment.get("matched_clauses", [])[:5]:
+            evidence.append(
+                {
+                    "source": clause["url"],
+                    "type": clause["classification"],
+                    "heading": clause["heading"],
+                    "snippet": clause["snippet"],
+                }
+            )
+
+        return {
+            "is_safe_to_proceed": verdict == "SAFE",
+            "confidence_score": round(float(confidence_score), 2),
+            "verdict": verdict,
+            "reason": reason,
+            "recommended_next_step": recommended_next_step,
+            "action_type": normalized["action_type"],
+            "robots_assessment": robots_assessment,
+            "tos_assessment": tos_assessment,
+            "llm_assessment": llm_assessment or {"status": "not_used"},
+            "discovered_policy_urls": {
+                "candidates": [item["url"] for item in policy_candidates.get("candidates", [])]
+            },
+            "evidence": evidence,
+        }
+
+    def _safe_get(self, url: str, timeout: int = 10) -> Optional[requests.Response]:
+        try:
+            response = self.session.get(url, timeout=timeout, allow_redirects=True)
+            if response.status_code >= 400:
+                return None
+            return response
+        except requests.RequestException:
+            return None

skillware-0.2.5/skills/compliance/tos_evaluator/test_skill.py

@@ -0,0 +1,30 @@
+import os
+
+import pytest
+import yaml
+
+from .skill import TOSEvaluatorSkill
+
+
+@pytest.fixture
+def skill():
+    return TOSEvaluatorSkill()
+
+
+@pytest.fixture
+def manifest():
+    manifest_path = os.path.join(os.path.dirname(__file__), "manifest.yaml")
+    with open(manifest_path, "r", encoding="utf-8") as f:
+        return yaml.safe_load(f)
+
+
+def test_skill_manifest_consistency(skill, manifest):
+    skill_manifest = skill.manifest
+    assert skill_manifest["name"] == manifest["name"]
+    assert skill_manifest["version"] == manifest["version"]
+
+
+def test_skill_execution_requires_inputs(skill):
+    result = skill.execute({})
+    assert "error" in result
+    assert "target_url" in result["error"]

{skillware-0.2.3 → skillware-0.2.5/skillware.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skillware
-Version: 0.2.3
+Version: 0.2.5
 Summary: A framework for modular, self-contained AI skills.
 Author-email: ARPA Hellenic Logic Systems <skillware-os@arpacorp.net>
 License: MIT License
@@ -38,6 +38,7 @@ Requires-Dist: pyyaml
 Requires-Dist: anthropic
 Requires-Dist: google-generativeai
 Requires-Dist: pymupdf
+Requires-Dist: beautifulsoup4
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-mock; extra == "dev"
@@ -102,7 +103,8 @@ Skillware/
 │       └── skill_name/         # The Skill bundle
 │           ├── manifest.yaml   # Definition, schema, and constitution
 │           ├── skill.py        # Executable Python logic
-│           └── instructions.md # Cognitive map for the LLM
+│           ├── instructions.md # Cognitive map for the LLM
+│           └── test_skill.py   # Unit tests & schema validation
 ├── skillware/                  # Core Framework Package
 │   └── core/
 │       ├── base_skill.py       # Abstract Base Class for skills
@@ -172,6 +174,7 @@ print(response.text)
 ## Documentation
 
 *   **[Core Logic & Philosophy](docs/introduction.md)**: Details on how Skillware decouples Logic, Cognition, and Governance.
+*   **[Testing Guidelines](docs/TESTING.md)**: Instructions for validating skills and checking local coverage.
 *   **[Usage Guide: Gemini](docs/usage/gemini.md)**: Integration with Google's GenAI SDK.
 *   **[Usage Guide: Claude](docs/usage/claude.md)**: Integration with Anthropic's SDK.
 *   **[Usage Guide: Ollama](docs/usage/ollama.md)**: Native integration for local models via Ollama.

{skillware-0.2.3 → skillware-0.2.5}/skillware.egg-info/SOURCES.txt

@@ -1,8 +1,13 @@
 LICENSE
 README.md
 pyproject.toml
+skills/compliance/mica_module/__init__.py
+skills/compliance/mica_module/skill.py
 skills/compliance/pii_masker/__init__.py
 skills/compliance/pii_masker/skill.py
+skills/compliance/tos_evaluator/__init__.py
+skills/compliance/tos_evaluator/skill.py
+skills/compliance/tos_evaluator/test_skill.py
 skills/data_engineering/synthetic_generator/__init__.py
 skills/data_engineering/synthetic_generator/skill.py
 skills/finance/wallet_screening/__init__.py
@@ -23,4 +28,5 @@ skillware/core/__init__.py
 skillware/core/base_skill.py
 skillware/core/env.py
 skillware/core/loader.py
-tests/test_loader.py
+tests/test_loader.py
+tests/test_mica_module.py

{skillware-0.2.3 → skillware-0.2.5}/skillware.egg-info/requires.txt

@@ -3,6 +3,7 @@ pyyaml
 anthropic
 google-generativeai
 pymupdf
+beautifulsoup4
 
 [dev]
 pytest

skillware-0.2.5/tests/test_mica_module.py

@@ -0,0 +1,66 @@
+import pytest
+from skillware.core.loader import SkillLoader
+
+
+# Fixture to load the skill module
+@pytest.fixture
+def mica_skill():
+    skill_bundle = SkillLoader.load_skill("compliance/mica_module")
+    MiCAModuleSkill = skill_bundle["module"].MiCAModuleSkill
+    return MiCAModuleSkill()
+
+
+def test_mica_module_manifest(mica_skill):
+    manifest = mica_skill.manifest
+    assert manifest["name"] == "compliance/mica_module"
+    assert manifest["version"] == "0.1.0"
+
+
+def test_mica_module_stateless_rag_execution(mica_skill):
+    # Test that the module correctly pulls information without running the evaluator
+    params = {
+        "user_prompt": "I want to issue an asset-referenced token. What are the authorization rules?",
+        "run_evaluator": False,
+    }
+
+    result = mica_skill.execute(params)
+
+    # Since run_evaluator is False, policy_status should default to CAUTION
+    assert result["policy_status"] == "CAUTION"
+
+    # It should have either found some chunks or correctly reported no matches
+    assert "retrieved_sections" in result
+    assert "final_context_for_agent" in result
+
+    feedback = result["gemini_evaluator_feedback"]
+    assert "Evaluator disabled" in feedback["holes_found"]
+
+
+def test_mica_module_router_normalization(mica_skill):
+    # Verify that 'authorization' (US) matches 'authorisation' (UK)
+    mock_corpus = [
+        {
+            "title_num": "Title V",
+            "article_num": "Article 59",
+            "keywords": ["authorisation", "casp"],
+            "content": "CASP Authorization rules...",
+        }
+    ]
+    matched = mica_skill._route_and_fetch("Authorization of a CASP", mock_corpus)
+    assert len(matched) > 0
+    assert matched[0]["article_num"] == "Article 59"
+
+
+def test_mica_module_router_deduplication(mica_skill):
+    # Verify that multiple keyword matches dont duplicate the same article
+    mock_corpus = [
+        {
+            "title_num": "Title V",
+            "article_num": "Article 59",
+            "keywords": ["authorisation", "casp"],
+            "content": "CASP Authorization rules...",
+        }
+    ]
+    # 'authorisation' and 'casp' both match
+    matched = mica_skill._route_and_fetch("authorisation casp", mock_corpus)
+    assert len(matched) == 1