janito 2.16.0__tar.gz → 2.17.1__tar.gz

{janito-2.16.0 → janito-2.17.1}/CHANGELOG.md

@@ -4,6 +4,34 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [2.17.0] - 2025-08-05
+
+### Added
+
+- **New Provider Support**
+  - **Cerebras Provider**: Added complete support for Cerebras with qwen-3-coder-480b model
+    - qwen-3-coder-480b: 32k context, reasoning-focused model with function calling support
+
+- **Enhanced UX**
+  - Improved error handling for invalid provider names in set-api-key command
+  - Better error messages when provider is not found
+
+### Changed
+
+- **Provider Improvements**
+  - Updated Alibaba endpoint to international URL for better global access
+  - Simplified region display to 2-letter codes for cleaner output
+  - Improved driver listing and region display functionality
+
+- **Zero Mode Enhancement**
+  - Zero mode now properly disables system prompt and tools for minimal interaction
+
+### Fixed
+
+- **Bug Fixes**
+  - Added missing tools adapter to Cerebras provider
+  - Improved error handling for invalid provider names in set-api-key command
+
 ## [2.16.0] - 2025-01-08
 
 ### Added

{janito-2.16.0 → janito-2.17.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.16.0
+Version: 2.17.1
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito

janito-2.17.1/docs/cerebras-setup.md

@@ -0,0 +1,56 @@
+# Cerebras Setup Guide
+
+This guide will help you set up Janito to use Cerebras as an LLM provider.
+
+## Prerequisites
+
+1. A Cerebras account
+2. An API key from Cerebras
+
+## Getting an API Key
+
+1. Visit the [Cerebras API Keys page](https://api.cerebras.ai/)
+2. Log in to your account
+3. Generate a new API key
+4. Copy the API key for use in Janito
+
+## Configuration
+
+To configure Janito to use Cerebras, you need to set your API key:
+
+```bash
+janito --set-api-key YOUR_CEREBRAS_API_KEY -p cerebras
+```
+
+Replace `YOUR_CEREBRAS_API_KEY` with the API key you obtained from Cerebras.
+
+## Usage
+
+After setting up your API key, you can use Cerebras models with Janito:
+
+```bash
+janito -p cerebras "Hello, how are you?"
+```
+
+By default, Janito will use the `qwen-3-coder-480b` model. You can specify a different model if needed:
+
+```bash
+janito -p cerebras -m qwen-3-coder-480b "Explain quantum computing"
+```
+
+## Available Models
+
+Cerebras offers several models through their API:
+
+- `qwen-3-coder-480b`: 32k context, reasoning-focused model with function calling support
+
+## Troubleshooting
+
+If you encounter issues:
+
+1. Verify your API key is correct and active
+2. Check that you have internet connectivity
+3. Ensure you're using a supported model name
+4. Check the Cerebras status page for any service outages
+
+For further assistance, consult the [Cerebras documentation](https://api.cerebras.ai/docs) or [Janito documentation](https://docs.janito.dev).

{janito-2.16.0 → janito-2.17.1}/docs/supported-providers-models.md

@@ -36,7 +36,7 @@ This page lists the supported providers and their available models.
 - qwen-turbo
 - qwen-plus
 - qwen-max
-- qwen3-coder-plus
+- qwen3-coder-plus (default)
 - qwen3-coder-480b-a35b-instruct
 
 ## Z.AI
@@ -44,4 +44,22 @@ This page lists the supported providers and their available models.
 - glm-4.5
 - glm-4.5-air
 
+## Cerebras
+
+**Production Models:**
+- llama-4-scout-17b-16e-instruct
+- llama-3.3-70b
+- llama3.1-8b
+- qwen-3-32b
+
+**Preview Models:**
+- llama-4-maverick-17b-128e-instruct
+- qwen-3-235b-a22b-instruct-2507
+- qwen-3-235b-a22b-thinking-2507
+- qwen-3-coder-480b
+- gpt-oss-120b
+
+**Notes:**
+- qwen-3-coder-480b: 32k context, reasoning-focused model with function calling support
+
 <!-- Removed links to model_info.py files for all providers to avoid broken references. -->

{janito-2.16.0 → janito-2.17.1}/janito/agent/setup_agent.py

@@ -167,7 +167,7 @@ def setup_agent(
     """
     Creates an agent. A system prompt is rendered from a template only when a profile is specified.
     """
-    if no_tools_mode:
+    if no_tools_mode or zero_mode:
         tools_provider = None
     else:
         tools_provider = get_local_tools_adapter()

{janito-2.16.0 → janito-2.17.1}/janito/cli/cli_commands/list_drivers.py

@@ -92,6 +92,7 @@ def get_driver_info():
         ("janito.drivers.openai.driver", "OpenAIModelDriver"),
         ("janito.drivers.azure_openai.driver", "AzureOpenAIModelDriver"),
         ("janito.drivers.zai.driver", "ZAIModelDriver"),
+        ("janito.drivers.cerebras.driver", "CerebrasModelDriver"),
     ]
 
     for module_path, class_name in driver_modules:

janito-2.17.1/janito/cli/cli_commands/set_api_key.py

@@ -0,0 +1,30 @@
+"""
+CLI Command: Set API key for the current or selected provider
+"""
+
+from janito.provider_config import set_api_key
+from janito.llm.auth import LLMAuthManager
+from janito.providers.registry import LLMProviderRegistry
+
+
+def handle_set_api_key(args):
+    api_key = getattr(args, "set_api_key", None)
+    provider = getattr(args, "provider", None)
+    if not provider:
+        print("Error: --set-api-key requires -p/--provider to be specified.")
+        return
+    
+    # Validate provider name
+    if provider not in LLMProviderRegistry.list_providers():
+        valid_providers = LLMProviderRegistry.list_providers()
+        print(f"Error: Unknown provider '{provider}'. Valid providers are: {', '.join(valid_providers)}")
+        return
+        
+    try:
+        set_api_key(provider, api_key)
+        auth_manager = LLMAuthManager()
+        print(
+            f"API key set for provider '{provider}'. Auth file updated: {auth_manager._auth_file}"
+        )
+    except ValueError as e:
+        print(f"Error: {e}")

{janito-2.16.0 → janito-2.17.1}/janito/cli/prompt_setup.py

@@ -37,6 +37,8 @@ def setup_agent_and_prompt_handler(
     no_tools_mode = False
     if hasattr(args, 'no_tools_mode'):
         no_tools_mode = getattr(args, 'no_tools_mode', False)
+    
+    zero_mode = getattr(args, 'zero', False)
     agent = create_configured_agent(
         provider_instance=provider_instance,
         llm_driver_config=llm_driver_config,
@@ -46,6 +48,7 @@ def setup_agent_and_prompt_handler(
         allowed_permissions=allowed_permissions,
         profile=profile,
         profile_system_prompt=profile_system_prompt,
+        zero_mode=zero_mode,
         no_tools_mode=no_tools_mode,
     )
 

janito-2.17.1/janito/drivers/cerebras/__init__.py

@@ -0,0 +1 @@
+# Cerebras driver package

{janito-2.16.0 → janito-2.17.1}/janito/providers/__init__.py

@@ -7,3 +7,4 @@ import janito.providers.deepseek.provider
 import janito.providers.moonshotai.provider
 import janito.providers.alibaba.provider
 import janito.providers.zai.provider
+import janito.providers.cerebras.provider

{janito-2.16.0 → janito-2.17.1}/janito/providers/alibaba/provider.py

@@ -17,9 +17,7 @@ class AlibabaProvider(LLMProvider):
     NAME = "alibaba"
     MAINTAINER = "João Pinto <janito@ikignosis.org>"
     MODEL_SPECS = MODEL_SPECS
-    DEFAULT_MODEL = (
-        "qwen3-coder-plus"  # Options: qwen-turbo, qwen-plus, qwen-max, qwen3-coder-plus
-    )
+    DEFAULT_MODEL = "qwen3-coder-plus"  # 128k context, coding-focused model
 
     def __init__(
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None

janito-2.17.1/janito/providers/cerebras/__init__.py

@@ -0,0 +1 @@
+# Cerebras provider package

janito-2.17.1/janito/providers/cerebras/model_info.py

@@ -0,0 +1,76 @@
+"""Model specifications for Cerebras Inference API."""
+
+from janito.llm.model import LLMModelInfo
+
+MODEL_SPECS = {
+    "qwen-3-32b": LLMModelInfo(
+        name="qwen-3-32b",
+        max_input=128000,
+        max_response=16384,
+        default_temp=0.7,
+        driver="CerebrasModelDriver",
+        other={
+            "description": "Qwen 3 32B model for general instruction following",
+            "pricing": {
+                "input_per_1k_tokens": 0.0002,
+                "output_per_1k_tokens": 0.0006
+            }
+        }
+    ),
+    "qwen-3-235b-a22b-instruct-2507": LLMModelInfo(
+        name="qwen-3-235b-a22b-instruct-2507",
+        max_input=128000,
+        max_response=16384,
+        default_temp=0.7,
+        driver="CerebrasModelDriver",
+        other={
+            "description": "Qwen 3 235B A22B instruction-tuned model (preview)",
+            "pricing": {
+                "input_per_1k_tokens": 0.001,
+                "output_per_1k_tokens": 0.003
+            }
+        }
+    ),
+    "qwen-3-235b-a22b-thinking-2507": LLMModelInfo(
+        name="qwen-3-235b-a22b-thinking-2507",
+        max_input=128000,
+        max_response=16384,
+        default_temp=0.7,
+        driver="CerebrasModelDriver",
+        other={
+            "description": "Qwen 3 235B A22B thinking model for reasoning tasks (preview)",
+            "pricing": {
+                "input_per_1k_tokens": 0.001,
+                "output_per_1k_tokens": 0.003
+            }
+        }
+    ),
+    "qwen-3-coder-480b": LLMModelInfo(
+        name="qwen-3-coder-480b",
+        max_input=128000,
+        max_response=16384,
+        default_temp=0.7,
+        driver="CerebrasModelDriver",
+        other={
+            "description": "Qwen 3 Coder 480B model for programming tasks (preview)",
+            "pricing": {
+                "input_per_1k_tokens": 0.002,
+                "output_per_1k_tokens": 0.006
+            }
+        }
+    ),
+    "gpt-oss-120b": LLMModelInfo(
+        name="gpt-oss-120b",
+        max_input=128000,
+        max_response=16384,
+        default_temp=0.7,
+        driver="CerebrasModelDriver",
+        other={
+            "description": "GPT-OSS 120B open-source model (preview)",
+            "pricing": {
+                "input_per_1k_tokens": 0.0008,
+                "output_per_1k_tokens": 0.0024
+            }
+        }
+    )
+}

janito-2.17.1/janito/providers/cerebras/provider.py

@@ -0,0 +1,145 @@
+"""Cerebras Inference provider implementation."""
+
+from typing import Dict, Any
+from janito.llm.provider import LLMProvider
+from janito.llm.auth import LLMAuthManager
+from janito.llm.driver_config import LLMDriverConfig
+from janito.drivers.openai.driver import OpenAIModelDriver
+from janito.tools import get_local_tools_adapter
+from janito.providers.registry import LLMProviderRegistry
+from .model_info import MODEL_SPECS
+
+
+class CerebrasProvider(LLMProvider):
+    """Cerebras Inference API provider."""
+    
+    name = "cerebras"
+    NAME = "cerebras"
+    DEFAULT_MODEL = "qwen-3-coder-480b"
+    MAINTAINER = "João Pinto <janito@ikignosis.org>"
+    MODEL_SPECS = MODEL_SPECS
+
+    def __init__(self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None):
+        """Initialize Cerebras provider with optional configuration."""
+        super().__init__()
+        self._tools_adapter = get_local_tools_adapter()
+        self._driver = None
+        self._tools_adapter = get_local_tools_adapter()
+        self._driver = None
+        if not self.available:
+            return
+
+        self._initialize_config(auth_manager, config)
+        self._setup_model_config()
+        self.fill_missing_device_info(self._driver_config)
+        
+        if not self.available:
+            return
+            
+        self._initialize_config(None, None)
+        self._driver_config.base_url = "https://api.cerebras.ai/v1"
+
+    def _initialize_config(self, auth_manager, config):
+        """Initialize configuration and API key."""
+        self.auth_manager = auth_manager or LLMAuthManager()
+        self._api_key = self.auth_manager.get_credentials(type(self).NAME)
+        if not self._api_key:
+            from janito.llm.auth_utils import handle_missing_api_key
+
+            handle_missing_api_key(self.name, "CEREBRAS_API_KEY")
+
+        self._driver_config = config or LLMDriverConfig(model=None)
+        if not self._driver_config.model:
+            self._driver_config.model = self.DEFAULT_MODEL
+        if not self._driver_config.api_key:
+            self._driver_config.api_key = self._api_key
+
+        self._setup_model_config()
+        self.fill_missing_device_info(self._driver_config)
+
+    def _setup_model_config(self):
+        """Configure token limits based on model specifications."""
+        model_name = self._driver_config.model
+        model_spec = self.MODEL_SPECS.get(model_name)
+
+        # Reset token parameters
+        if hasattr(self._driver_config, "max_tokens"):
+            self._driver_config.max_tokens = None
+        if hasattr(self._driver_config, "max_completion_tokens"):
+            self._driver_config.max_completion_tokens = None
+
+        if model_spec:
+            # Set context length
+            if hasattr(model_spec, "context") and model_spec.context:
+                self._driver_config.context_length = model_spec.context
+            
+            # Set max tokens based on model spec
+            if hasattr(model_spec, "max_response") and model_spec.max_response:
+                self._driver_config.max_tokens = model_spec.max_response
+            
+            # Set max completion tokens if thinking is supported
+            if getattr(model_spec, "thinking_supported", False):
+                max_cot = getattr(model_spec, "max_cot", None)
+                if max_cot and max_cot != "N/A":
+                    self._driver_config.max_completion_tokens = int(max_cot)
+            else:
+                max_response = getattr(model_spec, "max_response", None)
+                if max_response and max_response != "N/A":
+                    self._driver_config.max_tokens = int(max_response)
+
+    @property
+    @property
+    def driver(self) -> OpenAIModelDriver:
+        if not self.available:
+            raise ImportError(
+                f"CerebrasProvider unavailable: {self.unavailable_reason}"
+            )
+        if self._driver is None:
+            self._driver = self.create_driver()
+        return self._driver
+
+    @property
+    def available(self):
+        return OpenAIModelDriver.available
+
+    @property
+    def unavailable_reason(self):
+        return OpenAIModelDriver.unavailable_reason
+
+    def create_driver(self) -> OpenAIModelDriver:
+        """Create and return an OpenAI-compatible Cerebras driver instance."""
+        driver = OpenAIModelDriver(
+            tools_adapter=self._tools_adapter, provider_name=self.name
+        )
+        driver.config = self._driver_config
+        return driver
+
+    @property
+    def driver_config(self):
+        """Return the driver configuration."""
+        return self._driver_config
+
+    def is_model_available(self, model_name: str) -> bool:
+        """Check if a model is available for this provider."""
+        return model_name in self.MODEL_SPECS
+
+    def get_model_info(self, model_name: str = None) -> Dict[str, Any]:
+        """Get model information for the specified model or all models."""
+        if model_name is None:
+            return {
+                name: model_info.to_dict()
+                for name, model_info in self.MODEL_SPECS.items()
+            }
+        
+        if model_name in self.MODEL_SPECS:
+            return self.MODEL_SPECS[model_name].to_dict()
+        
+        return None
+
+    def execute_tool(self, tool_name: str, event_bus, *args, **kwargs):
+        self._tools_adapter.event_bus = event_bus
+        return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
+
+
+# Register the provider
+LLMProviderRegistry.register(CerebrasProvider.name, CerebrasProvider)

{janito-2.16.0 → janito-2.17.1}/janito/tools/adapters/local/read_files.py

@@ -52,4 +52,4 @@ class ReadFilesTool(ToolBase):
                 results.append(
                     f"--- File: {disp_path} (error) ---\nError reading file: {e}\n"
                 )
-        return "\n".join(results)
+        return "\n".join(results)

{janito-2.16.0 → janito-2.17.1}/janito/tools/path_security.py

@@ -135,6 +135,7 @@ def _extract_path_keys_from_schema(schema: Mapping[str, Any]) -> set[str]:
     path_keys: set[str] = set()
     if schema is not None:
         for k, v in schema.get("properties", {}).items():
+            # Handle direct path strings
             if v.get("format") == "path" or (
                 v.get("type") == "string"
                 and (
@@ -144,6 +145,19 @@ def _extract_path_keys_from_schema(schema: Mapping[str, Any]) -> set[str]:
                 )
             ):
                 path_keys.add(k)
+            # Handle arrays of path strings
+            elif v.get("type") == "array" and "items" in v:
+                items = v["items"]
+                if items.get("format") == "path" or (
+                    items.get("type") == "string"
+                    and (
+                        "path" in items.get("description", "").lower()
+                        or "path" in v.get("description", "").lower()
+                        or k.endswith("paths")
+                        or k == "paths"
+                    )
+                ):
+                    path_keys.add(k)
     return path_keys
 
 

{janito-2.16.0 → janito-2.17.1}/janito/tools/tools_adapter.py

@@ -131,9 +131,15 @@ class ToolsAdapterBase:
 
         if arguments is None:
             arguments = {}
-        # Ensure the input is a dict to avoid breaking the inspect-based logic
+        # If arguments are provided as a non-dict (e.g. a list or a scalar)
+        # we skip signature *keyword* validation completely and defer the
+        # decision to Python's own call mechanics when the function is
+        # eventually invoked.  This allows positional / variadic arguments to
+        # be supplied by callers that intentionally bypass the structured
+        # JSON-schema style interface.
         if not isinstance(arguments, dict):
-            return "Tool arguments should be provided as an object / mapping"
+            # Nothing to validate at this stage – treat as OK.
+            return None
 
         sig = inspect.signature(func)
         params = sig.parameters
@@ -193,30 +199,32 @@ class ToolsAdapterBase:
             )
 
             schema = getattr(tool, "schema", None)
-            try:
-                validate_paths_in_arguments(arguments, workdir, schema=schema)
-            except PathSecurityError as sec_err:
-                # Publish both a ToolCallError and a user-facing ReportEvent for path security errors
-                self._publish_tool_call_error(
-                    tool_name, request_id, str(sec_err), arguments
-                )
-                if self._event_bus:
-                    from janito.report_events import (
-                        ReportEvent,
-                        ReportSubtype,
-                        ReportAction,
+            # Only validate paths for dictionary-style arguments
+            if isinstance(arguments, dict):
+                try:
+                    validate_paths_in_arguments(arguments, workdir, schema=schema)
+                except PathSecurityError as sec_err:
+                    # Publish both a ToolCallError and a user-facing ReportEvent for path security errors
+                    self._publish_tool_call_error(
+                        tool_name, request_id, str(sec_err), arguments
                     )
+                    if self._event_bus:
+                        from janito.report_events import (
+                            ReportEvent,
+                            ReportSubtype,
+                            ReportAction,
+                        )
 
-                    self._event_bus.publish(
-                        ReportEvent(
-                            subtype=ReportSubtype.ERROR,
-                            message=f"[SECURITY] Path access denied: {sec_err}",
-                            action=ReportAction.EXECUTE,
-                            tool=tool_name,
-                            context={"arguments": arguments, "request_id": request_id},
+                        self._event_bus.publish(
+                            ReportEvent(
+                                subtype=ReportSubtype.ERROR,
+                                message=f"[SECURITY] Path access denied: {sec_err}",
+                                action=ReportAction.EXECUTE,
+                                tool=tool_name,
+                                context={"arguments": arguments, "request_id": request_id},
+                            )
                         )
-                    )
-                return f"Security error: {sec_err}"
+                    return f"Security error: {sec_err}"
         # --- END SECURITY ---
 
         self._publish_tool_call_started(tool_name, request_id, arguments)
@@ -224,7 +232,18 @@ class ToolsAdapterBase:
             f"[tools-adapter] Executing tool: {tool_name} with arguments: {arguments}"
         )
         try:
-            result = self.execute(tool, **(arguments or {}), **kwargs)
+            # Normalize arguments to ensure proper type handling
+            normalized_args = self._normalize_arguments(arguments, tool, func)
+            
+            if isinstance(normalized_args, (list, tuple)):
+                # Positional arguments supplied as an array → expand as *args
+                result = self.execute(tool, *normalized_args, **kwargs)
+            elif isinstance(normalized_args, dict) or normalized_args is None:
+                # Keyword-style arguments (the default) – pass as **kwargs
+                result = self.execute(tool, **(normalized_args or {}), **kwargs)
+            else:
+                # Single positional argument (scalar/str/int/…)
+                result = self.execute(tool, normalized_args, **kwargs)
         except Exception as e:
             self._handle_execution_error(tool_name, request_id, e, arguments)
         self._print_verbose(
@@ -281,6 +300,65 @@ class ToolsAdapterBase:
         if self.verbose_tools:
             print(message)
 
+    def _normalize_arguments(self, arguments, tool, func):
+        """
+        Normalize arguments to ensure proper type handling at the adapter level.
+        
+        This handles cases where:
+        1. String is passed instead of list for array parameters
+        2. JSON string parsing issues
+        3. Other type mismatches that can be automatically resolved
+        """
+        import inspect
+        import json
+        
+        # If arguments is already a dict or None, return as-is
+        if isinstance(arguments, dict) or arguments is None:
+            return arguments
+            
+        # If arguments is a list/tuple, return as-is (positional args)
+        if isinstance(arguments, (list, tuple)):
+            return arguments
+            
+        # Handle string arguments
+        if isinstance(arguments, str):
+            # Try to parse as JSON if it looks like JSON
+            stripped = arguments.strip()
+            if (stripped.startswith('{') and stripped.endswith('}')) or \
+               (stripped.startswith('[') and stripped.endswith(']')):
+                try:
+                    parsed = json.loads(arguments)
+                    return parsed
+                except json.JSONDecodeError:
+                    # If it looks like JSON but failed, try to handle common issues
+                    pass
+            
+            # Check if the function expects a list parameter
+            try:
+                sig = inspect.signature(func)
+                params = list(sig.parameters.values())
+                
+                # Skip 'self' parameter for methods
+                if len(params) > 0 and params[0].name == 'self':
+                    params = params[1:]
+                
+                # If there's exactly one parameter that expects a list, wrap string in list
+                if len(params) == 1:
+                    param = params[0]
+                    annotation = param.annotation
+                    
+                    # Check if annotation is list[str] or similar
+                    if hasattr(annotation, '__origin__') and annotation.__origin__ is list:
+                        return [arguments]
+                    elif str(annotation).startswith('list[') or str(annotation) == 'list':
+                        return [arguments]
+                        
+            except (ValueError, TypeError):
+                pass
+                
+        # Return original arguments for other cases
+        return arguments
+
     def execute_function_call_message_part(self, function_call_message_part):
         """
         Execute a FunctionCallMessagePart by extracting the tool name and arguments and dispatching to execute_by_name.
@@ -298,9 +376,23 @@ class ToolsAdapterBase:
         # Parse arguments if they are a JSON string
         if isinstance(arguments, str):
             try:
+                # Try to parse as JSON first
                 arguments = json.loads(arguments)
-            except Exception:
-                pass  # Leave as string if not JSON
+            except json.JSONDecodeError:
+                # Handle single quotes in JSON strings
+                try:
+                    # Replace single quotes with double quotes for JSON compatibility
+                    fixed_json = arguments.replace("'", '"')
+                    arguments = json.loads(fixed_json)
+                except (json.JSONDecodeError, ValueError):
+                    # If it's a string that looks like it might be a single path parameter,
+                    # try to handle it gracefully
+                    if arguments.startswith("{") and arguments.endswith("}"):
+                        # Looks like JSON but failed to parse - this is likely an error
+                        pass
+                    else:
+                        # Single string argument - let the normalization handle it
+                        pass
         if self.verbose_tools:
             print(
                 f"[tools-adapter] Executing FunctionCallMessagePart: tool={tool_name}, arguments={arguments}, tool_call_id={tool_call_id}"

{janito-2.16.0 → janito-2.17.1}/janito.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.16.0
+Version: 2.17.1
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito