janito 2.1.0__tar.gz → 2.2.0__tar.gz

janito-2.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{janito-2.1.0 → janito-2.2.0}/PKG-INFO

@@ -1,11 +1,30 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.1.0
+Version: 2.2.0
 Summary: A new Python package called janito.
-Author-email: Your Name <your.email@example.com>
+Author-email: João Pinto <lamego.pinto@gmail.com>
 Project-URL: Homepage, https://github.com/janito-dev/janito
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: attrs==25.3.0
+Requires-Dist: rich==14.0.0
+Requires-Dist: pathspec==0.12.1
+Requires-Dist: setuptools>=61.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: jinja2>=3.0.0
+Requires-Dist: prompt_toolkit>=3.0.51
+Requires-Dist: lxml>=5.4.0
+Requires-Dist: requests>=2.32.4
+Requires-Dist: bs4>=0.0.2
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: ruff==0.11.9; extra == "dev"
+Requires-Dist: detect-secrets==1.4.0; extra == "dev"
+Requires-Dist: codespell==2.4.1; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Dynamic: license-file
 
 # Janito
 

{janito-2.1.0 → janito-2.2.0}/janito/__init__.py

@@ -3,4 +3,4 @@ janito: A Python package for managing and interacting with Large Language Model
 Provides a CLI for credential management and an extensible driver system for LLMs.
 """
 
-__version__ = "2.1.0"
+__version__ = "2.2.0"

{janito-2.1.0 → janito-2.2.0}/janito/cli/chat_mode/shell/commands/__init__.py

@@ -3,7 +3,6 @@ from .edit import EditShellHandler
 from .history_view import ViewShellHandler
 from .lang import LangShellHandler
 from .livelogs import LivelogsShellHandler
-from .last import LastShellHandler
 from .prompt import PromptShellHandler, RoleShellHandler, ProfileShellHandler
 from .multi import MultiShellHandler
 from .role import RoleCommandShellHandler
@@ -25,7 +24,6 @@ COMMAND_HANDLERS = {
     "/view": ViewShellHandler,
     "/lang": LangShellHandler,
     "/livelogs": LivelogsShellHandler,
-    "/last": LastShellHandler,
     "/prompt": PromptShellHandler,
     "/role": RoleShellHandler,
     "/profile": ProfileShellHandler,

{janito-2.1.0 → janito-2.2.0}/janito/cli/chat_mode/shell/input_history.py

@@ -7,7 +7,7 @@ from typing import List, Any, Dict
 class UserInputHistory:
     """
     Handles loading, saving, and appending of user input history for the shell.
-    Each day's history is stored in a line-delimited JSON file (.json.log) under .janito/input_history/.
+    Each day's history is stored in a line-delimited JSONL file (.jsonl) under .janito/input_history/.
     Each line is a JSON dict, e.g., {"input": ..., "ts": ...}
     """
 
@@ -17,7 +17,7 @@ class UserInputHistory:
 
     def _get_today_file(self):
         today_str = datetime.now().strftime("%y%m%d")
-        return os.path.join(self.history_dir, f"{today_str}.json.log")
+        return os.path.join(self.history_dir, f"{today_str}.jsonl")
 
     def load(self) -> List[Dict[str, Any]]:
         """Load today's input history as a list of dicts."""

{janito-2.1.0 → janito-2.2.0}/janito/cli/chat_mode/toolbar.py

@@ -22,7 +22,8 @@ def assemble_first_line(provider_name, model_name, role, agent=None):
 
 def assemble_bindings_line(width):
     return (
-        f" <key-label>F1</key-label>: Restart conversation | "
+        f" <key-label>CTRL-C</key-label>: Interrupt Request/Exit Shell | "
+        f"<key-label>F1</key-label>: Restart conversation | "
         f"<b>/help</b>: Help | "
         f"<key-label>F12</key-label>: Do It "
     )

{janito-2.1.0 → janito-2.2.0}/janito/cli/config.py

@@ -3,12 +3,11 @@ from janito.config import config
 CONFIG_OPTIONS = {
     "api_key": "API key for OpenAI-compatible service (required)",  # pragma: allowlist secret
     "trust": "Trust mode: suppress all console output (bool, default: False)",
-    "model": "Model name to use (e.g., 'gpt-4.1', 'gpt-4o', 'gpt-4-turbo', 'o3-mini', 'o4-mini', 'o4-mini-high')",
+    "model": "Model name to use (e.g., 'gpt-4.1', 'gpt-4o', 'gpt-4-turbo', 'o3-mini', 'o4-mini')",
     "base_url": "API base URL (OpenAI-compatible endpoint)",
     "role": "Role description for the Agent Profile (e.g., 'software engineer')",
     "temperature": "Sampling temperature (float, e.g., 0.0 - 2.0)",
     "max_tokens": "Maximum tokens for model response (int)",
-    "use_azure_openai": "Whether to use Azure OpenAI client (default: False)",
     "template": "Template context dictionary for Agent Profile prompt rendering (nested)",
     "profile": "Agent Profile name (only 'base' is supported)",
 }

{janito-2.1.0 → janito-2.2.0}/janito/cli/core/runner.py

@@ -1,141 +1,148 @@
-"""Handles LLM driver config preparation and execution modes."""
-
-from janito.llm.driver_config import LLMDriverConfig
-from janito.provider_config import get_config_provider
-from janito.cli.verbose_output import print_verbose_info
-
-
-def _choose_provider(args):
-    provider = getattr(args, "provider", None)
-    if provider is None:
-        provider = get_config_provider()
-        if provider and getattr(args, "verbose", False):
-            print_verbose_info(
-                "Default provider", provider, style="magenta", align_content=True
-            )
-        elif provider is None:
-            print(
-                "Error: No provider selected and no provider found in config. Please set a provider using '-p PROVIDER', '--set provider=name', or configure a provider."
-            )
-            return None
-    return provider
-
-
-def _populate_driver_config_data(args, modifiers, provider, model):
-    from janito.provider_config import get_effective_setting
-
-    CONFIG_LOOKUP_KEYS = ("max_tokens", "base_url")
-    driver_config_data = {"model": model}
-    if getattr(args, "verbose_api", None) is not None:
-        driver_config_data["verbose_api"] = args.verbose_api
-    for field in LLMDriverConfig.__dataclass_fields__:
-        if field in CONFIG_LOOKUP_KEYS:
-            if field in modifiers and modifiers[field] is not None:
-                driver_config_data[field] = modifiers[field]
-            else:
-                value = get_effective_setting(provider, model, field)
-                if value is not None:
-                    driver_config_data[field] = value
-        elif field in modifiers and field != "model":
-            driver_config_data[field] = modifiers[field]
-    return driver_config_data
-
-
-def prepare_llm_driver_config(args, modifiers):
-    """Prepare the LLMDriverConfig instance based on CLI *args* and *modifiers*.
-
-    This helper additionally validates that the chosen ``--model`` (or the
-    resolved model coming from config precedence) is actually available for the
-    selected provider.  If the combination is invalid an error is printed and
-    ``None`` is returned for the config so that the caller can abort execution
-    gracefully.
-    """
-    provider = _choose_provider(args)
-    if provider is None:
-        return None, None, None
-    from janito.provider_config import get_effective_model
-
-    model = getattr(args, "model", None)
-    if not model:
-        model = get_effective_model(provider)
-
-    # Validate that the chosen model is supported by the selected provider
-    if model:
-        from janito.provider_registry import ProviderRegistry
-
-        provider_instance = None
-        try:
-            provider_instance = ProviderRegistry().get_instance(provider)
-            available_models = [
-                m["name"]
-                for m in provider_instance.get_model_info().values()
-                if isinstance(m, dict) and "name" in m
-            ]
-            if model not in available_models:
-                print(
-                    f"Error: Model '{model}' is not available for provider '{provider}'."
-                )
-                print(f"Available models: {', '.join(available_models)}")
-                return provider, None, None
-        except Exception as e:
-            print(f"Error validating model for provider '{provider}': {e}")
-            return provider, None, None
-    driver_config_data = _populate_driver_config_data(args, modifiers, provider, model)
-    llm_driver_config = LLMDriverConfig(**driver_config_data)
-    if getattr(llm_driver_config, "verbose_api", None):
-        pass
-    agent_role = modifiers.get("role", "software developer")
-    return provider, llm_driver_config, agent_role
-
-
-def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=False, exec_enabled=False):
-    """
-    Main runner for CLI execution. If exec_enabled is False, disables execution/run tools.
-    """
-    zero_mode = getattr(args, "zero", False)
-    from janito.provider_registry import ProviderRegistry
-
-    # Patch: disable execution/run tools if not enabled
-    if not exec_enabled:
-        import janito.tools
-        adapter = janito.tools.get_local_tools_adapter()
-        if hasattr(adapter, "disable_execution_tools"):
-            adapter.disable_execution_tools()
-    else:
-        pass
-
-    provider_instance = ProviderRegistry().get_instance(provider, llm_driver_config)
-    mode = get_prompt_mode(args)
-    if getattr(args, "verbose", False):
-        print_verbose_info(
-            "Active LLMDriverConfig (after provider)", llm_driver_config, style="green"
-        )
-        print_verbose_info("Agent role", agent_role, style="green")
-    if mode == "single_shot":
-        from janito.cli.single_shot_mode.handler import (
-            PromptHandler as SingleShotPromptHandler,
-        )
-
-        handler = SingleShotPromptHandler(
-            args, provider_instance, llm_driver_config, role=agent_role
-        )
-        handler.handle()
-    else:
-        from janito.cli.chat_mode.session import ChatSession
-        from rich.console import Console
-
-        console = Console()
-        session = ChatSession(
-            console,
-            provider_instance,
-            llm_driver_config,
-            role=agent_role,
-            args=args,
-            verbose_tools=verbose_tools,
-            verbose_agent=getattr(args, "verbose_agent", False),
-        )
-        session.run()
-
-
-def get_prompt_mode(args):
-    return "single_shot" if getattr(args, "user_prompt", None) else "chat_mode"
+"""Handles LLM driver config preparation and execution modes."""
+
+from janito.llm.driver_config import LLMDriverConfig
+from janito.provider_config import get_config_provider
+from janito.cli.verbose_output import print_verbose_info
+
+
+def _choose_provider(args):
+    provider = getattr(args, "provider", None)
+    if provider is None:
+        provider = get_config_provider()
+        if provider and getattr(args, "verbose", False):
+            print_verbose_info(
+                "Default provider", provider, style="magenta", align_content=True
+            )
+        elif provider is None:
+            print(
+                "Error: No provider selected and no provider found in config. Please set a provider using '-p PROVIDER', '--set provider=name', or configure a provider."
+            )
+            return None
+    return provider
+
+
+def _populate_driver_config_data(args, modifiers, provider, model):
+    from janito.provider_config import get_effective_setting
+
+    CONFIG_LOOKUP_KEYS = ("max_tokens", "base_url")
+    driver_config_data = {"model": model}
+    if getattr(args, "verbose_api", None) is not None:
+        driver_config_data["verbose_api"] = args.verbose_api
+    for field in LLMDriverConfig.__dataclass_fields__:
+        if field in CONFIG_LOOKUP_KEYS:
+            if field in modifiers and modifiers[field] is not None:
+                driver_config_data[field] = modifiers[field]
+            else:
+                value = get_effective_setting(provider, model, field)
+                if value is not None:
+                    driver_config_data[field] = value
+        elif field in modifiers and field != "model":
+            driver_config_data[field] = modifiers[field]
+    return driver_config_data
+
+
+def prepare_llm_driver_config(args, modifiers):
+    """Prepare the LLMDriverConfig instance based on CLI *args* and *modifiers*.
+
+    This helper additionally validates that the chosen ``--model`` (or the
+    resolved model coming from config precedence) is actually available for the
+    selected provider.  If the combination is invalid an error is printed and
+    ``None`` is returned for the config so that the caller can abort execution
+    gracefully.
+    """
+    provider = _choose_provider(args)
+    if provider is None:
+        return None, None, None
+    from janito.provider_config import get_effective_model
+
+    model = getattr(args, "model", None)
+    if not model:
+        model = get_effective_model(provider)
+
+    # Validate that the chosen model is supported by the selected provider
+    if model:
+        from janito.provider_registry import ProviderRegistry
+
+        provider_instance = None
+        provider_instance = ProviderRegistry().get_instance(provider)
+        if provider_instance is None:
+            return provider, None, None
+        try:
+            if not provider_instance.is_model_available(model):
+                print(
+                    f"Error: Model '{model}' is not available for provider '{provider}'."
+                )
+                # Optionally, print available models if possible
+                if hasattr(provider_instance, 'get_model_info'):
+                    available_models = [
+                        m["name"]
+                        for m in provider_instance.get_model_info().values()
+                        if isinstance(m, dict) and "name" in m
+                    ]
+                    print(f"Available models: {', '.join(available_models)}")
+                return provider, None, None
+        except Exception as e:
+            print(f"Error validating model for provider '{provider}': {e}")
+            return provider, None, None
+    driver_config_data = _populate_driver_config_data(args, modifiers, provider, model)
+    llm_driver_config = LLMDriverConfig(**driver_config_data)
+    if getattr(llm_driver_config, "verbose_api", None):
+        pass
+    agent_role = modifiers.get("role", "software developer")
+    return provider, llm_driver_config, agent_role
+
+
+def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=False, exec_enabled=False):
+    """
+    Main runner for CLI execution. If exec_enabled is False, disables execution/run tools.
+    """
+    zero_mode = getattr(args, "zero", False)
+    from janito.provider_registry import ProviderRegistry
+
+    # Patch: disable execution/run tools if not enabled
+    if not exec_enabled:
+        import janito.tools
+        adapter = janito.tools.get_local_tools_adapter(workdir=getattr(args, "workdir", None))
+        if hasattr(adapter, "disable_execution_tools"):
+            adapter.disable_execution_tools()
+    else:
+        import janito.tools
+        adapter = janito.tools.get_local_tools_adapter(workdir=getattr(args, "workdir", None))
+
+    provider_instance = ProviderRegistry().get_instance(provider, llm_driver_config)
+    if provider_instance is None:
+        return
+    mode = get_prompt_mode(args)
+    if getattr(args, "verbose", False):
+        print_verbose_info(
+            "Active LLMDriverConfig (after provider)", llm_driver_config, style="green"
+        )
+        print_verbose_info("Agent role", agent_role, style="green")
+    if mode == "single_shot":
+        from janito.cli.single_shot_mode.handler import (
+            PromptHandler as SingleShotPromptHandler,
+        )
+
+        handler = SingleShotPromptHandler(
+            args, provider_instance, llm_driver_config, role=agent_role
+        )
+        handler.handle()
+    else:
+        from janito.cli.chat_mode.session import ChatSession
+        from rich.console import Console
+
+        console = Console()
+        session = ChatSession(
+            console,
+            provider_instance,
+            llm_driver_config,
+            role=agent_role,
+            args=args,
+            verbose_tools=verbose_tools,
+            verbose_agent=getattr(args, "verbose_agent", False),
+        )
+        session.run()
+
+
+def get_prompt_mode(args):
+    return "single_shot" if getattr(args, "user_prompt", None) else "chat_mode"

{janito-2.1.0 → janito-2.2.0}/janito/cli/main_cli.py

@@ -13,6 +13,14 @@ from janito.cli.core.event_logger import (
 )
 
 definition = [
+    (
+        ["-W", "--workdir"],
+        {
+            "metavar": "WORKDIR",
+            "help": "Working directory to chdir to before tool execution",
+            "default": None,
+        },
+    ),
     (
         ["--verbose-api"],
         {

janito-2.2.0/janito/drivers/azure_openai/driver.py

@@ -0,0 +1,55 @@
+from janito.drivers.openai.driver import OpenAIModelDriver
+
+# Safe import of AzureOpenAI SDK
+try:
+    from openai import AzureOpenAI
+
+    DRIVER_AVAILABLE = True
+    DRIVER_UNAVAILABLE_REASON = None
+except ImportError:
+    DRIVER_AVAILABLE = False
+    DRIVER_UNAVAILABLE_REASON = "Missing dependency: openai (pip install openai)"
+
+from janito.llm.driver_config import LLMDriverConfig
+
+
+class AzureOpenAIModelDriver(OpenAIModelDriver):
+    available = DRIVER_AVAILABLE
+    unavailable_reason = DRIVER_UNAVAILABLE_REASON
+
+    @classmethod
+    def is_available(cls):
+        return cls.available
+
+    required_config = {"base_url"}  # Update key as used in your config logic
+
+    def __init__(self, tools_adapter=None):
+        if not self.available:
+            raise ImportError(
+                f"AzureOpenAIModelDriver unavailable: {self.unavailable_reason}"
+            )
+        # Do NOT call super().__init__ if Azure SDK is not available
+        OpenAIModelDriver.__init__(self, tools_adapter=tools_adapter)
+        self.azure_endpoint = None
+        self.api_version = None
+        self.api_key = None
+
+    def _instantiate_openai_client(self, config):
+        try:
+            from openai import AzureOpenAI
+            api_key_display = str(config.api_key)
+            if api_key_display and len(api_key_display) > 8:
+                api_key_display = api_key_display[:4] + "..." + api_key_display[-4:]
+            client_kwargs = {
+                "api_key": config.api_key,
+                "azure_endpoint": getattr(config, "base_url", None),
+                "api_version": config.extra.get("api_version", "2023-05-15"),
+            }
+            client = AzureOpenAI(**client_kwargs)
+            return client
+        except Exception as e:
+            print(f"[ERROR] Exception during AzureOpenAI client instantiation: {e}", flush=True)
+            import traceback
+            print(traceback.format_exc(), flush=True)
+            raise
+

{janito-2.1.0 → janito-2.2.0}/janito/llm/provider.py

@@ -93,6 +93,15 @@ class LLMProvider(ABC):
     def driver(self) -> LLMDriver:
         pass
 
+    def is_model_available(self, model_name):
+        """
+        Returns True if the given model is available for this provider.
+        Default implementation checks MODEL_SPECS; override for dynamic providers.
+        """
+        if not hasattr(self, "MODEL_SPECS"):
+            return False
+        return model_name in self.MODEL_SPECS
+
     def get_model_info(self, model_name=None):
         """
         Return the info dict for a given model (driver, params, etc). If model_name is None, return all model info dicts.