skillware 0.4.2__tar.gz → 0.4.3__tar.gz

{skillware-0.4.2/skillware.egg-info → skillware-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skillware
-Version: 0.4.2
+Version: 0.4.3
 Summary: A framework for modular, self-contained AI skills.
 Author-email: ARPA Hellenic Logical Systems <skillware-os@arpacorp.net>
 License: MIT License

{skillware-0.4.2 → skillware-0.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "skillware"
-version = "0.4.2"
+version = "0.4.3"
 description = "A framework for modular, self-contained AI skills."
 readme = "README.md"
 authors = [

{skillware-0.4.2 → skillware-0.4.3}/skillware/core/loader.py

@@ -291,34 +291,6 @@ class SkillLoader:
             }
         return {}
 
-    @staticmethod
-    def to_gemini_tool(skill_bundle: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Converts a skill manifest to a Gemini function declaration.
-        Handles type conversion (lowercase to UPPERCASE) for Gemini Protobuf compatibility.
-        """
-        manifest = skill_bundle.get("manifest", {})
-        name = manifest.get("name", "unknown_tool")
-        description = manifest.get("description", "")
-        parameters = manifest.get("parameters", {})
-
-        # Helper to recursively upper-case 'type' fields
-        def sanitize_schema(schema):
-            new_schema = schema.copy()
-            if "type" in new_schema:
-                new_schema["type"] = new_schema["type"].upper()
-            if "properties" in new_schema:
-                new_schema["properties"] = {
-                    k: sanitize_schema(v) for k, v in new_schema["properties"].items()
-                }
-            return new_schema
-
-        return {
-            "name": name,
-            "description": description,
-            "parameters": sanitize_schema(parameters),
-        }
-
     @staticmethod
     def to_claude_tool(skill_bundle: Dict[str, Any]) -> Dict[str, Any]:
         """
@@ -345,6 +317,10 @@ class SkillLoader:
             return "unknown_tool"
         return safe[:64]
 
+    @staticmethod
+    def _sanitize_gemini_tool_name(name: str) -> str:
+        return SkillLoader._sanitize_function_tool_name(name)
+
     @staticmethod
     def _sanitize_openai_tool_name(name: str) -> str:
         return SkillLoader._sanitize_function_tool_name(name)
@@ -353,6 +329,47 @@ class SkillLoader:
     def _sanitize_deepseek_tool_name(name: str) -> str:
         return SkillLoader._sanitize_function_tool_name(name)
 
+    @staticmethod
+    def to_gemini_tool(skill_bundle: Dict[str, Any]) -> Any:
+        """
+        Converts a skill manifest to a Gemini function declaration.
+        Handles type conversion (lowercase to UPPERCASE) for Gemini Protobuf compatibility.
+        See: https://ai.google.dev/gemini-api/docs/generate-content/function-calling#how-it-works
+        """
+        try:
+            from google.genai import types
+        except ImportError:
+            raise ImportError(
+                "google-genai is required for to_gemini_tool. Install with: pip install google-genai"
+            )
+
+        manifest = skill_bundle.get("manifest", {})
+        raw_name = manifest.get("name", "unknown_tool")
+        name = SkillLoader._sanitize_gemini_tool_name(raw_name)
+        description = manifest.get("description", "")
+        parameters = manifest.get("parameters", {})
+
+        # Helper to recursively upper-case 'type' fields
+        def sanitize_schema(schema):
+            new_schema = schema.copy()
+            if "type" in new_schema:
+                new_schema["type"] = new_schema["type"].upper()
+            if "properties" in new_schema:
+                new_schema["properties"] = {
+                    k: sanitize_schema(v) for k, v in new_schema["properties"].items()
+                }
+            return new_schema
+
+        return types.Tool(
+            function_declarations=[
+                {
+                    "name": name,
+                    "description": description,
+                    "parameters": sanitize_schema(parameters),
+                }
+            ]
+        )
+
     @staticmethod
     def to_openai_tool(skill_bundle: Dict[str, Any]) -> Dict[str, Any]:
         """

{skillware-0.4.2 → skillware-0.4.3/skillware.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skillware
-Version: 0.4.2
+Version: 0.4.3
 Summary: A framework for modular, self-contained AI skills.
 Author-email: ARPA Hellenic Logical Systems <skillware-os@arpacorp.net>
 License: MIT License

{skillware-0.4.2 → skillware-0.4.3}/skillware.egg-info/SOURCES.txt

@@ -131,6 +131,7 @@ skillware/core/base_skill.py
 skillware/core/env.py
 skillware/core/loader.py
 tests/test_cli.py
+tests/test_github_labels.py
 tests/test_loader.py
 tests/test_registry_docs.py
 tests/test_skill_issuer.py

skillware-0.4.3/tests/test_github_labels.py

@@ -0,0 +1,64 @@
+"""Validate .github/labels.json matches repository label policy."""
+
+import json
+import re
+from pathlib import Path
+
+LABELS_PATH = Path(__file__).resolve().parent.parent / ".github" / "labels.json"
+HEX_COLOR = re.compile(r"^[0-9A-Fa-f]{6}$")
+
+REQUIRED_LABELS = {
+    "bug",
+    "documentation",
+    "enhancement",
+    "good first issue",
+    "help wanted",
+    "skill request",
+    "skill upgrade",
+    "core framework",
+    "cli",
+    "examples",
+    "testing",
+    "packaging",
+    "ci",
+    "security",
+    "discussion",
+    "question",
+    "wontfix",
+}
+
+
+def _load_labels() -> list[dict]:
+    return json.loads(LABELS_PATH.read_text(encoding="utf-8"))
+
+
+def test_labels_json_exists_and_is_array():
+    labels = _load_labels()
+    assert isinstance(labels, list)
+    assert len(labels) >= len(REQUIRED_LABELS)
+
+
+def test_required_labels_present():
+    names = {entry["name"] for entry in _load_labels()}
+    missing = REQUIRED_LABELS - names
+    assert not missing, f"Missing labels in labels.json: {sorted(missing)}"
+
+
+def test_label_entries_well_formed():
+    names: set[str] = set()
+    for entry in _load_labels():
+        name = entry.get("name")
+        color = entry.get("color", "")
+        description = entry.get("description", "")
+        assert name and isinstance(name, str)
+        assert name not in names, f"Duplicate label: {name}"
+        names.add(name)
+        assert HEX_COLOR.match(color), f"Bad color for {name}: {color!r}"
+        assert description and isinstance(description, str)
+
+
+def test_rfc_template_labels_exist():
+    """Issue template 05_rfc.yml references discussion and core framework."""
+    names = {entry["name"] for entry in _load_labels()}
+    assert "discussion" in names
+    assert "core framework" in names

{skillware-0.4.2 → skillware-0.4.3}/tests/test_loader.py

@@ -316,7 +316,7 @@ def test_to_ollama_prompt():
 def test_to_gemini_tool():
     dummy_bundle = {
         "manifest": {
-            "name": "test_gemini_skill",
+            "name": "finance/wallet_screening",
             "parameters": {
                 "type": "object",
                 "properties": {"param1": {"type": "string"}},
@@ -324,10 +324,25 @@ def test_to_gemini_tool():
         }
     }
     tool = SkillLoader.to_gemini_tool(dummy_bundle)
-    assert tool["name"] == "test_gemini_skill"
+    decl = tool.function_declarations[0]
+    assert decl.name == "finance_wallet_screening"
+    assert type(tool).__name__ == "Tool"
     # Gemini requires UPPERCASE types for Protobufs
-    assert tool["parameters"]["type"] == "OBJECT"
-    assert tool["parameters"]["properties"]["param1"]["type"] == "STRING"
+    assert decl.parameters.type.name == "OBJECT"
+    assert decl.parameters.properties["param1"].type.name == "STRING"
+
+
+def test_sanitize_gemini_tool_name():
+    assert (
+        SkillLoader._sanitize_gemini_tool_name("compliance/tos_evaluator")
+        == "compliance_tos_evaluator"
+    )
+    assert (
+        SkillLoader._sanitize_gemini_tool_name("wallet_screening") == "wallet_screening"
+    )
+    assert SkillLoader._sanitize_gemini_tool_name("") == "unknown_tool"
+    assert SkillLoader._sanitize_gemini_tool_name("a" * 80).startswith("a")
+    assert len(SkillLoader._sanitize_gemini_tool_name("a" * 80)) == 64
 
 
 def test_to_claude_tool():

{skillware-0.4.2 → skillware-0.4.3}/tests/test_registry_docs.py

@@ -164,3 +164,37 @@ def test_agent_loops_reference_all_skills(
     assert not missing, "Skills missing from docs/usage/agent_loops.md:\n" + "\n".join(
         f"  - {skill}" for skill in missing
     )
+
+
+def test_skill_docs_gemini_anti_patterns():
+    """Verify Gemini snippets in skill catalog pages do not use anti-patterns."""
+    docs_root = REPO_ROOT / "docs" / "skills"
+
+    anti_patterns = [
+        (r'tool_decl\["name"\]\s*=', 'tool_decl["name"] mutation'),
+        (r'gemini_decl\["name"\]\s*=', 'gemini_decl["name"] mutation'),
+        (
+            r"types\.Tool\s*\(\s*function_declarations\s*=\s*\[",
+            "types.Tool(function_declarations=[ manual wrap",
+        ),
+        (
+            r'function_call\.name\s*==\s*(?:bundle|skill)\["manifest"\]\["name"\]',
+            'function_call.name == bundle["manifest"]["name"] without sanitize',
+        ),
+    ]
+
+    failures = []
+
+    for md_file in docs_root.glob("*.md"):
+        if md_file.name == "README.md":
+            continue
+
+        content = md_file.read_text(encoding="utf-8")
+
+        for pattern, name in anti_patterns:
+            if re.search(pattern, content):
+                failures.append(f"{md_file.name}: {name}")
+
+    assert not failures, "Gemini anti-patterns found in skill docs:\n" + "\n".join(
+        f"  - {f}" for f in failures
+    )

{skillware-0.4.2 → skillware-0.4.3}/tests/test_version_policy.py

@@ -39,7 +39,7 @@ def test_emit_advisory_silent_for_current_release(monkeypatch, capsys):
     monkeypatch.setattr(
         version_policy.metadata,
         "version",
-        lambda _name: "0.4.2",
+        lambda _name: "0.4.3",
     )
     version_policy.emit_upgrade_advisory()
     assert capsys.readouterr().err == ""