janito 2.6.1__py3-none-any.whl → 2.7.0__py3-none-any.whl

janito/agent/templates/profiles/{system_prompt_template_software developer.txt.j2 → system_prompt_template_plain_software_developer.txt.j2}

@@ -1,39 +1,39 @@
-You are: software developer
-
-{# Improves tool selection and platform specific constrains, eg, path format, C:\ vs /path #}
-{% if allowed_permissions and 'x' in allowed_permissions %}
-You will be using the following environment:
-  Platform: {{ platform }}
-  Shell/Environment: {{ shell_info }}
-{% endif %}
-
-
-{% if allowed_permissions and 'r' in allowed_permissions %}
-Before answering map the questions to artifacts found in the current directory - the current project.
-{% endif %}
-
-Respond according to the following guidelines:
-{% if allowed_permissions %}
-  - Before using the namespace tools provide a short reason
-{% endif %}
-{% if allowed_permissions and 'r' in allowed_permissions %}
-{# Exploratory hint #}
-  - Before answering to the user, explore the content related to the question
-{# Reduces chunking roundtip #}
-  - When exploring full files content, provide empty range to read the entire files instead of chunked reads
-{% endif %}
-{% if allowed_permissions and 'w' in allowed_permissions %}
-{# Reduce unrequest code verbosity overhead #}
-- Use the namespace functions to deliver the code changes instead of showing the code.
-{# Drive edit mode, place holders critical as shown to be crucial to avoid corruption with code placeholders #}
-- Prefer making localized edits using string replacements. If the required change is extensive, replace the entire file instead, provide full content without placeholders.
-{# Without this, the LLM choses to create files from a literal interpretation of the purpose and intention #}
-- Before creating files search the code for the location related to the file purpose
-{# This will trigger a search for the old names/locations to be updates #}
-- After moving, removing or renaming functions or classes to different modules, update all imports, references, tests, and documentation to reflect the new locations, then verify functionality.
-{# Keeping docstrings update is key to have semanatic match between prompts and code  #}
-- Once development or updates are finished, ensure that new or updated packages, modules, functions are properly documented.
-{# Trying to prevent surrogates generation, found this frequently in gpt4.1/windows #}
-- While writing code, if you need an emoji or special Unicode character in a string, then insert the actual character (e.g., 📖) directly instead of using surrogate pairs or escape sequences.
-{% endif %}
-
+You are: software developer
+
+{# Improves tool selection and platform specific constrains, eg, path format, C:\ vs /path #}
+{% if allowed_permissions and 'x' in allowed_permissions %}
+You will be using the following environment:
+  Platform: {{ platform }}
+  Shell/Environment: {{ shell_info }}
+{% endif %}
+
+
+{% if allowed_permissions and 'r' in allowed_permissions %}
+Before answering map the questions to artifacts found in the current directory - the current project.
+{% endif %}
+
+Respond according to the following guidelines:
+{% if allowed_permissions %}
+  - Before using the namespace tools provide a short reason
+{% endif %}
+{% if allowed_permissions and 'r' in allowed_permissions %}
+{# Exploratory hint #}
+  - Before answering to the user, explore the content related to the question
+{# Reduces chunking roundtip #}
+  - When exploring full files content, provide empty range to read the entire files instead of chunked reads
+{% endif %}
+{% if allowed_permissions and 'w' in allowed_permissions %}
+{# Reduce unrequest code verbosity overhead #}
+- Use the namespace functions to deliver the code changes instead of showing the code.
+{# Drive edit mode, place holders critical as shown to be crucial to avoid corruption with code placeholders #}
+- Prefer making localized edits using string replacements. If the required change is extensive, replace the entire file instead, provide full content without placeholders.
+{# Without this, the LLM choses to create files from a literal interpretation of the purpose and intention #}
+- Before creating files search the code for the location related to the file purpose
+{# This will trigger a search for the old names/locations to be updates #}
+- After moving, removing or renaming functions or classes to different modules, update all imports, references, tests, and documentation to reflect the new locations, then verify functionality.
+{# Keeping docstrings update is key to have semanatic match between prompts and code  #}
+- Once development or updates are finished, ensure that new or updated packages, modules, functions are properly documented.
+{# Trying to prevent surrogates generation, found this frequently in gpt4.1/windows #}
+- While writing code, if you need an emoji or special Unicode character in a string, then insert the actual character (e.g., 📖) directly instead of using surrogate pairs or escape sequences.
+{% endif %}
+

janito/cli/__init__.py

@@ -1,10 +1,10 @@
-# janito.cli package
-from .utils import format_tokens, format_generation_time
-
-__all__ = [
-    "setup_provider",
-    "setup_agent",
-    "format_tokens",
-    "format_generation_time",
-]
-
+# janito.cli package
+from .utils import format_tokens, format_generation_time
+
+__all__ = [
+    "setup_provider",
+    "setup_agent",
+    "format_tokens",
+    "format_generation_time",
+]
+

janito/cli/chat_mode/bindings.py

@@ -1,38 +1,38 @@
-"""
-Key bindings for Janito Chat CLI.
-"""
-
-from prompt_toolkit.key_binding import KeyBindings
-from janito.tools.permissions import get_global_allowed_permissions
-
-class KeyBindingsFactory:
-    @staticmethod
-    def create():
-        bindings = KeyBindings()
-
-        @bindings.add("c-y")
-        def _(event):
-            buf = event.app.current_buffer
-            buf.text = "Yes"
-            buf.validate_and_handle()
-
-        @bindings.add("c-n")
-        def _(event):
-            buf = event.app.current_buffer
-            buf.text = "No"
-            buf.validate_and_handle()
-
-        @bindings.add("f2")
-        def _(event):
-            buf = event.app.current_buffer
-            buf.text = "/restart"
-            buf.validate_and_handle()
-
-        @bindings.add("f12")
-        def _(event):
-            buf = event.app.current_buffer
-            buf.text = "Do It"
-            buf.validate_and_handle()
-
-        return bindings
-
+"""
+Key bindings for Janito Chat CLI.
+"""
+
+from prompt_toolkit.key_binding import KeyBindings
+from janito.tools.permissions import get_global_allowed_permissions
+
+class KeyBindingsFactory:
+    @staticmethod
+    def create():
+        bindings = KeyBindings()
+
+        @bindings.add("c-y")
+        def _(event):
+            buf = event.app.current_buffer
+            buf.text = "Yes"
+            buf.validate_and_handle()
+
+        @bindings.add("c-n")
+        def _(event):
+            buf = event.app.current_buffer
+            buf.text = "No"
+            buf.validate_and_handle()
+
+        @bindings.add("f2")
+        def _(event):
+            buf = event.app.current_buffer
+            buf.text = "/restart"
+            buf.validate_and_handle()
+
+        @bindings.add("f12")
+        def _(event):
+            buf = event.app.current_buffer
+            buf.text = "Do It"
+            buf.validate_and_handle()
+
+        return bindings
+

janito/cli/chat_mode/chat_entry.py

@@ -1,23 +1,23 @@
-"""
-Main entry point for the Janito Chat CLI.
-Handles the interactive chat loop and session startup.
-"""
-
-from rich.console import Console
-from prompt_toolkit.formatted_text import HTML
-from janito.cli.chat_mode.session import ChatSession
-
-
-def main(args=None):
-    console = Console()
-    console.clear()
-    from janito.version import __version__
-
-
-    session = ChatSession(console, args=args)
-    session.run()
-
-
-if __name__ == "__main__":
-    main()
-
+"""
+Main entry point for the Janito Chat CLI.
+Handles the interactive chat loop and session startup.
+"""
+
+from rich.console import Console
+from prompt_toolkit.formatted_text import HTML
+from janito.cli.chat_mode.session import ChatSession
+
+
+def main(args=None):
+    console = Console()
+    console.clear()
+    from janito.version import __version__
+
+
+    session = ChatSession(console, args=args)
+    session.run()
+
+
+if __name__ == "__main__":
+    main()
+

janito/cli/chat_mode/prompt_style.py

@@ -1,25 +1,25 @@
-from prompt_toolkit.styles import Style
-
-chat_shell_style = Style.from_dict(
-    {
-        "prompt": "bg:#2323af #ffffff bold",
-        "": "bg:#005fdd #ffffff",  # blue background for input area
-        "bottom-toolbar": "fg:#2323af bg:yellow",
-        "key-label": "bg:#ff9500 fg:#232323 bold",
-        "provider": "fg:#117fbf",
-        "model": "fg:#1f5fa9",
-        "role": "fg:#e87c32 bold",
-        "msg_count": "fg:#5454dd",
-        "session_id": "fg:#704ab9",
-        "tokens_total": "fg:#a022c7",
-        "tokens_in": "fg:#00af5f",
-        "tokens_out": "fg:#01814a",
-        "max-tokens": "fg:#888888",
-        
-        
-        "key-toggle-on": "bg:#ffd700 fg:#232323 bold",
-        "key-toggle-off": "bg:#444444 fg:#ffffff bold",
-        "cmd-label": "bg:#ff9500 fg:#232323 bold",
-    }
-)
-
+from prompt_toolkit.styles import Style
+
+chat_shell_style = Style.from_dict(
+    {
+        "prompt": "bg:#2323af #ffffff bold",
+        "": "bg:#005fdd #ffffff",  # blue background for input area
+        "bottom-toolbar": "fg:#2323af bg:yellow",
+        "key-label": "bg:#ff9500 fg:#232323 bold",
+        "provider": "fg:#117fbf",
+        "model": "fg:#1f5fa9",
+        "role": "fg:#e87c32 bold",
+        "msg_count": "fg:#5454dd",
+        "session_id": "fg:#704ab9",
+        "tokens_total": "fg:#a022c7",
+        "tokens_in": "fg:#00af5f",
+        "tokens_out": "fg:#01814a",
+        "max-tokens": "fg:#888888",
+        
+        
+        "key-toggle-on": "bg:#ffd700 fg:#232323 bold",
+        "key-toggle-off": "bg:#444444 fg:#ffffff bold",
+        "cmd-label": "bg:#ff9500 fg:#232323 bold",
+    }
+)
+

janito/cli/chat_mode/script_runner.py

@@ -1,154 +1,154 @@
-"""
-Scripted runner for Janito chat mode.
-
-This utility allows you to execute the interactive ``ChatSession`` logic with
-an *in-memory* list of user inputs, making it much easier to write automated
-unit or integration tests for the chat CLI without resorting to fragile
-pseudo-terminal tricks.
-
-The runner monkey-patches the private ``_handle_input`` method so that the
-chat loop thinks it is receiving interactive input, while in reality the
-values come from the provided list.  All output is captured through a
-``rich.console.Console`` instance configured with ``record=True`` so the test
-can later inspect the rendered text.
-
-Typical usage
--------------
->>> from janito.cli.chat_mode.script_runner import ChatScriptRunner
->>> inputs = ["Hello!", "/exit"]
->>> runner = ChatScriptRunner(inputs)
->>> transcript = runner.run()
->>> assert "Hello!" in transcript
-
-The ``ChatScriptRunner`` purposefully replaces the internal call to the agent
-with a real agent call by default. If you want to use a stub, you must modify the runner implementation.
-"""
-from __future__ import annotations
-
-from types import MethodType
-from typing import List, Optional
-
-from rich.console import Console
-
-from janito.cli.chat_mode.session import ChatSession
-from janito.provider_registry import ProviderRegistry
-from janito.llm.driver_config import LLMDriverConfig
-
-__all__ = ["ChatScriptRunner"]
-
-
-auth_warning = (
-    "[yellow]ChatScriptRunner is executing in stubbed-agent mode; no calls to an "
-    "external LLM provider will be made.[/yellow]"
-)
-
-
-
-class ChatScriptRunner:
-    """Run a **ChatSession** non-interactively using a predefined set of inputs."""
-
-    def __init__(
-        self,
-        inputs: List[str],
-        *,
-        console: Optional[Console] = None,
-        provider: str = "openai",
-        model: str = "gpt-4.1",
-        use_real_agent: bool = True,
-        **chat_session_kwargs,
-    ) -> None:
-        """Create the runner.
-
-        Parameters
-        ----------
-        inputs:
-            Ordered list of strings that will be fed to the chat loop.
-        console:
-            Optional *rich* console.  If *None*, a new one is created with
-            *record=True* so that output can later be retrieved through
-            :py:meth:`rich.console.Console.export_text`.
-        use_real_agent:
-        chat_session_kwargs:
-            Extra keyword arguments forwarded to :class:`janito.cli.chat_mode.session.ChatSession`.
-        """
-        self._input_queue = list(inputs)
-        self.console = console or Console(record=True)
-        self.provider = provider
-        self.model = model
-        self.use_real_agent = use_real_agent
-        # Ensure we always pass a non-interactive *args* namespace so that the
-        # normal ChatSession logic skips the Questionary profile prompt which
-        # is incompatible with headless test runs.
-        if "args" not in chat_session_kwargs or chat_session_kwargs["args"] is None:
-            from types import SimpleNamespace
-            chat_session_kwargs["args"] = SimpleNamespace(
-                profile="developer",
-                provider=self.provider,
-                model=self.model,
-            )
-
-        # Create the ChatSession instance **after** we monkey-patch methods that rely on
-        # prompt-toolkit so that no attempt is made to instantiate terminal UIs in
-        # a headless environment like CI.
-
-        # 1) Patch *ChatSession._create_prompt_session* to do nothing – the
-        #    interactive session object is irrelevant for scripted runs.
-        from types import MethodType as _MT
-        if "_original_create_prompt_session" not in ChatSession.__dict__:
-            ChatSession._original_create_prompt_session = ChatSession._create_prompt_session  # type: ignore[attr-defined]
-        ChatSession._create_prompt_session = _MT(lambda _self: None, ChatSession)  # type: ignore[method-assign]
-
-        # Resolve provider instance now so that ChatSession uses a ready agent
-        provider_instance = ProviderRegistry().get_instance(self.provider)
-        if provider_instance is None:
-            raise RuntimeError(f"Provider '{self.provider}' is not available on this system.")
-        driver_config = LLMDriverConfig(model=self.model)
-        chat_session_kwargs.setdefault("provider_instance", provider_instance)
-        chat_session_kwargs.setdefault("llm_driver_config", driver_config)
-
-        self.chat_session = ChatSession(console=self.console, **chat_session_kwargs)
-
-
-        # Monkey-patch the *ChatSession._handle_input* method so that it pops
-        # from our in-memory queue instead of reading from stdin.
-        def _script_handle_input(this: ChatSession, _prompt_session_unused):  # noqa: D401
-            if not self._input_queue:
-                # Signal normal shutdown
-                this._handle_exit()
-                return None
-            return self._input_queue.pop(0)
-
-        # Bind the method to the *chat_session* instance.
-        self.chat_session._handle_input = MethodType(  # type: ignore[assignment]
-            _script_handle_input, self.chat_session
-        )
-
-    # ---------------------------------------------------------------------
-    # Public helpers
-    # ---------------------------------------------------------------------
-    def run(self) -> str:
-        """Execute the chat session and return the captured transcript."""
-        self.chat_session.run()
-        return self.console.export_text()
-
-    # ---------------------------------------------------------------------
-    # Helpers to introspect results
-    # ---------------------------------------------------------------------
-    def get_history(self):
-        """Return the structured conversation history produced by the LLM."""
-        try:
-            return self.chat_session.shell_state.conversation_history.get_history()
-        except Exception:
-            return []
-
-    def get_last_response(self) -> str | None:
-        """Return the *assistant* content of the last message, if any."""
-        history = self.get_history()
-        for message in reversed(history):
-            if message.get("role") == "assistant":
-                return message.get("content")
-        return None
-
-    # Convenience alias so tests can simply call *runner()*
-    __call__ = run
-
+"""
+Scripted runner for Janito chat mode.
+
+This utility allows you to execute the interactive ``ChatSession`` logic with
+an *in-memory* list of user inputs, making it much easier to write automated
+unit or integration tests for the chat CLI without resorting to fragile
+pseudo-terminal tricks.
+
+The runner monkey-patches the private ``_handle_input`` method so that the
+chat loop thinks it is receiving interactive input, while in reality the
+values come from the provided list.  All output is captured through a
+``rich.console.Console`` instance configured with ``record=True`` so the test
+can later inspect the rendered text.
+
+Typical usage
+-------------
+>>> from janito.cli.chat_mode.script_runner import ChatScriptRunner
+>>> inputs = ["Hello!", "/exit"]
+>>> runner = ChatScriptRunner(inputs)
+>>> transcript = runner.run()
+>>> assert "Hello!" in transcript
+
+The ``ChatScriptRunner`` purposefully replaces the internal call to the agent
+with a real agent call by default. If you want to use a stub, you must modify the runner implementation.
+"""
+from __future__ import annotations
+
+from types import MethodType
+from typing import List, Optional
+
+from rich.console import Console
+
+from janito.cli.chat_mode.session import ChatSession
+from janito.provider_registry import ProviderRegistry
+from janito.llm.driver_config import LLMDriverConfig
+
+__all__ = ["ChatScriptRunner"]
+
+
+auth_warning = (
+    "[yellow]ChatScriptRunner is executing in stubbed-agent mode; no calls to an "
+    "external LLM provider will be made.[/yellow]"
+)
+
+
+
+class ChatScriptRunner:
+    """Run a **ChatSession** non-interactively using a predefined set of inputs."""
+
+    def __init__(
+        self,
+        inputs: List[str],
+        *,
+        console: Optional[Console] = None,
+        provider: str = "openai",
+        model: str = "gpt-4.1",
+        use_real_agent: bool = True,
+        **chat_session_kwargs,
+    ) -> None:
+        """Create the runner.
+
+        Parameters
+        ----------
+        inputs:
+            Ordered list of strings that will be fed to the chat loop.
+        console:
+            Optional *rich* console.  If *None*, a new one is created with
+            *record=True* so that output can later be retrieved through
+            :py:meth:`rich.console.Console.export_text`.
+        use_real_agent:
+        chat_session_kwargs:
+            Extra keyword arguments forwarded to :class:`janito.cli.chat_mode.session.ChatSession`.
+        """
+        self._input_queue = list(inputs)
+        self.console = console or Console(record=True)
+        self.provider = provider
+        self.model = model
+        self.use_real_agent = use_real_agent
+        # Ensure we always pass a non-interactive *args* namespace so that the
+        # normal ChatSession logic skips the Questionary profile prompt which
+        # is incompatible with headless test runs.
+        if "args" not in chat_session_kwargs or chat_session_kwargs["args"] is None:
+            from types import SimpleNamespace
+            chat_session_kwargs["args"] = SimpleNamespace(
+                profile="developer",
+                provider=self.provider,
+                model=self.model,
+            )
+
+        # Create the ChatSession instance **after** we monkey-patch methods that rely on
+        # prompt-toolkit so that no attempt is made to instantiate terminal UIs in
+        # a headless environment like CI.
+
+        # 1) Patch *ChatSession._create_prompt_session* to do nothing – the
+        #    interactive session object is irrelevant for scripted runs.
+        from types import MethodType as _MT
+        if "_original_create_prompt_session" not in ChatSession.__dict__:
+            ChatSession._original_create_prompt_session = ChatSession._create_prompt_session  # type: ignore[attr-defined]
+        ChatSession._create_prompt_session = _MT(lambda _self: None, ChatSession)  # type: ignore[method-assign]
+
+        # Resolve provider instance now so that ChatSession uses a ready agent
+        provider_instance = ProviderRegistry().get_instance(self.provider)
+        if provider_instance is None:
+            raise RuntimeError(f"Provider '{self.provider}' is not available on this system.")
+        driver_config = LLMDriverConfig(model=self.model)
+        chat_session_kwargs.setdefault("provider_instance", provider_instance)
+        chat_session_kwargs.setdefault("llm_driver_config", driver_config)
+
+        self.chat_session = ChatSession(console=self.console, **chat_session_kwargs)
+
+
+        # Monkey-patch the *ChatSession._handle_input* method so that it pops
+        # from our in-memory queue instead of reading from stdin.
+        def _script_handle_input(this: ChatSession, _prompt_session_unused):  # noqa: D401
+            if not self._input_queue:
+                # Signal normal shutdown
+                this._handle_exit()
+                return None
+            return self._input_queue.pop(0)
+
+        # Bind the method to the *chat_session* instance.
+        self.chat_session._handle_input = MethodType(  # type: ignore[assignment]
+            _script_handle_input, self.chat_session
+        )
+
+    # ---------------------------------------------------------------------
+    # Public helpers
+    # ---------------------------------------------------------------------
+    def run(self) -> str:
+        """Execute the chat session and return the captured transcript."""
+        self.chat_session.run()
+        return self.console.export_text()
+
+    # ---------------------------------------------------------------------
+    # Helpers to introspect results
+    # ---------------------------------------------------------------------
+    def get_history(self):
+        """Return the structured conversation history produced by the LLM."""
+        try:
+            return self.chat_session.shell_state.conversation_history.get_history()
+        except Exception:
+            return []
+
+    def get_last_response(self) -> str | None:
+        """Return the *assistant* content of the last message, if any."""
+        history = self.get_history()
+        for message in reversed(history):
+            if message.get("role") == "assistant":
+                return message.get("content")
+        return None
+
+    # Convenience alias so tests can simply call *runner()*
+    __call__ = run
+

janito/cli/chat_mode/session.py

@@ -99,7 +99,7 @@ class ChatSession:
                     profile = "developer"
                 else:
                     profile = (
-                        "developer" if result == "software developer" else result
+                        "developer" if result == "plain_software_developer" else result
                     )
             except ImportError:
                 profile = "helpful assistant"

janito/cli/chat_mode/session_profile_select.py

@@ -90,7 +90,7 @@ def select_profile():
     choices = [
         "helpful assistant",
         "developer",
-        "software developer",
+        "plain_software_developer",
         "using role...",
         "full custom system prompt..."
     ]
@@ -118,11 +118,11 @@ def select_profile():
     elif answer in user_profiles:
         # Return the content of the user profile as a custom system prompt
         return {"profile": None, "profile_system_prompt": user_profiles[answer]}
-    elif answer == "software developer":
-        # Return the content of the built-in software developer profile prompt
-        with open("./janito/agent/templates/profiles/system_prompt_template_software_developer.txt.j2", "r", encoding="utf-8") as f:
+    elif answer == "plain_software_developer":
+        # Return the content of the built-in plain_software_developer profile prompt
+        with open("./janito/agent/templates/profiles/system_prompt_template_plain_software_developer.txt.j2", "r", encoding="utf-8") as f:
             prompt = f.read().strip()
-        return {"profile": "software developer", "profile_system_prompt": prompt}
+        return {"profile": "plain_software_developer", "profile_system_prompt": prompt}
     return answer
 
     choices = [