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

janito/__init__.py

@@ -4,4 +4,3 @@ Provides a CLI for credential management and an extensible driver system for LLM
 """
 
 from ._version import __version__
-

janito/__main__.py

@@ -2,4 +2,3 @@ from .cli.main import main
 
 if __name__ == "__main__":
     main()
-

janito/_version.py

@@ -53,6 +53,3 @@ except ImportError:  # pragma: no cover – not available in editable installs
         return "unknown"
 
     __version__ = _resolve_version()
-
-
-

janito/agent/setup_agent.py

@@ -17,14 +17,55 @@ from janito.platform_discovery import PlatformDiscovery
 from janito.tools.tool_base import ToolPermissions
 from janito.tools.permissions import get_global_allowed_permissions
 
+
 def _load_template_content(profile, templates_dir):
     """
     Loads the template content for the given profile from the specified directory or package resources.
     If the profile template is not found in the default locations, tries to load from the user profiles directory ~/.janito/profiles.
+
+    Spaces in the profile name are converted to underscores to align with the file-naming convention (e.g. "Developer with Python Tools" ➜ "Developer_with_Python_Tools" (matches: system_prompt_template_Developer_with_Python_Tools.txt.j2)).
     """
+    # Sanitize profile for filename resolution (convert whitespace to underscores)
+    sanitized_profile = re.sub(r"\s+", "_", profile.strip()) if profile else profile
+
+    template_filename = f"system_prompt_template_{sanitized_profile}.txt.j2"
+    template_path = templates_dir / template_filename
+
+    # 1) Check local templates directory
+    if template_path.exists():
+        with open(template_path, "r", encoding="utf-8") as file:
+            return file.read(), template_path
+
+    # 2) Try package resources fallback
+    try:
+        with importlib.resources.files("janito.agent.templates.profiles").joinpath(
+            template_filename
+        ).open("r", encoding="utf-8") as file:
+            return file.read(), template_path
+    except (FileNotFoundError, ModuleNotFoundError, AttributeError):
+        pass
 
+    # 3) Finally, look in the user profiles directory (~/.janito/profiles)
+    user_profiles_dir = Path(os.path.expanduser("~/.janito/profiles"))
+    user_template_path = user_profiles_dir / template_filename
+    if user_template_path.exists():
+        with open(user_template_path, "r", encoding="utf-8") as file:
+            return file.read(), user_template_path
+
+    # If nothing matched, raise an informative error
+    raise FileNotFoundError(
+        f"[janito] Could not find profile-specific template '{template_filename}' in {template_path} nor in janito.agent.templates.profiles package nor in user profiles directory {user_template_path}."
+    )
+    # Replace spaces in profile name with underscores for filename resolution
+    sanitized_profile = re.sub(r"\\s+", "_", profile.strip()) if profile else profile
+    """
+    Loads the template content for the given profile from the specified directory or package resources.
+    If the profile template is not found in the default locations, tries to load from the user profiles directory ~/.janito/profiles.
+    """
 
-    template_filename = f"system_prompt_template_{profile}.txt.j2"
+    # Sanitize profile name by replacing spaces with underscores to match filename conventions
+    sanitized_profile = re.sub(r"\\s+", "_", profile.strip())
+    template_filename = f"system_prompt_template_{sanitized_profile}.txt.j2"
     template_path = templates_dir / template_filename
     if template_path.exists():
         with open(template_path, "r", encoding="utf-8") as file:
@@ -68,7 +109,7 @@ def _prepare_template_context(role, profile, allowed_permissions):
         allowed_permissions = perm_str or None
     context["allowed_permissions"] = allowed_permissions
     # Inject platform info if execute permission is present
-    if allowed_permissions and 'x' in allowed_permissions:
+    if allowed_permissions and "x" in allowed_permissions:
         pd = PlatformDiscovery()
         context["platform"] = pd.get_platform_name()
         context["python_version"] = pd.get_python_version()
@@ -76,7 +117,18 @@ def _prepare_template_context(role, profile, allowed_permissions):
     return context
 
 
-def _create_agent(provider_instance, tools_provider, role, system_prompt, input_queue, output_queue, verbose_agent, context, template_path, profile):
+def _create_agent(
+    provider_instance,
+    tools_provider,
+    role,
+    system_prompt,
+    input_queue,
+    output_queue,
+    verbose_agent,
+    context,
+    template_path,
+    profile,
+):
     """
     Creates and returns an LLMAgent instance with the provided parameters.
     """
@@ -110,12 +162,16 @@ def setup_agent(
     allowed_permissions=None,
     profile=None,
     profile_system_prompt=None,
+    no_tools_mode=False,
 ):
     """
     Creates an agent. A system prompt is rendered from a template only when a profile is specified.
     """
-    tools_provider = get_local_tools_adapter()
-    tools_provider.set_verbose_tools(verbose_tools)
+    if no_tools_mode:
+        tools_provider = None
+    else:
+        tools_provider = get_local_tools_adapter()
+        tools_provider.set_verbose_tools(verbose_tools)
 
     # If zero_mode is enabled or no profile is given we skip the system prompt.
     if zero_mode or (profile is None and profile_system_prompt is None):
@@ -159,17 +215,23 @@ def setup_agent(
     # Debug output if requested
     debug_flag = False
     try:
-        debug_flag = (hasattr(sys, 'argv') and ('--debug' in sys.argv or '--verbose' in sys.argv or '-v' in sys.argv))
+        debug_flag = hasattr(sys, "argv") and (
+            "--debug" in sys.argv or "--verbose" in sys.argv or "-v" in sys.argv
+        )
     except Exception:
         pass
     if debug_flag:
-        rich_print(f"[bold magenta][DEBUG][/bold magenta] Rendering system prompt template '[cyan]{template_path.name}[/cyan]' with allowed_permissions: [yellow]{context.get('allowed_permissions')}[/yellow]")
-        rich_print(f"[bold magenta][DEBUG][/bold magenta] Template context: [green]{context}[/green]")
+        rich_print(
+            f"[bold magenta][DEBUG][/bold magenta] Rendering system prompt template '[cyan]{template_path.name}[/cyan]' with allowed_permissions: [yellow]{context.get('allowed_permissions')}[/yellow]"
+        )
+        rich_print(
+            f"[bold magenta][DEBUG][/bold magenta] Template context: [green]{context}[/green]"
+        )
     start_render = time.time()
     rendered_prompt = template.render(**context)
     end_render = time.time()
     # Merge multiple empty lines into a single empty line
-    rendered_prompt = re.sub(r'\n{3,}', '\n\n', rendered_prompt)
+    rendered_prompt = re.sub(r"\n{3,}", "\n\n", rendered_prompt)
 
     return _create_agent(
         provider_instance,
@@ -197,6 +259,7 @@ def create_configured_agent(
     allowed_permissions=None,
     profile=None,
     profile_system_prompt=None,
+    no_tools_mode=False,
 ):
     """
     Normalizes agent setup for all CLI modes.
@@ -218,6 +281,9 @@ def create_configured_agent(
     driver = None
     if hasattr(provider_instance, "create_driver"):
         driver = provider_instance.create_driver()
+        # Ensure no tools are passed to the driver when --no-tools flag is active
+        if no_tools_mode:
+            driver.tools_adapter = None
         driver.start()  # Ensure the driver background thread is started
         input_queue = getattr(driver, "input_queue", None)
         output_queue = getattr(driver, "output_queue", None)
@@ -235,7 +301,8 @@ def create_configured_agent(
         allowed_permissions=allowed_permissions,
         profile=profile,
         profile_system_prompt=profile_system_prompt,
+        no_tools_mode=no_tools_mode,
     )
     if driver is not None:
         agent.driver = driver  # Attach driver to agent for thread management
-    return agent
+    return agent

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

@@ -1,9 +1,13 @@
-You are: software developer
+{#  General role setup
+  ex. "Search in code" -> Python Developer -> find(*.py) | Java Developer -> find(*.java)
+#}
+You are: {{ role }}
 
 {# 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 }}
+  Python version: {{ python_version }}
   Shell/Environment: {{ shell_info }}
 {% endif %}
 

janito/agent/templates/profiles/system_prompt_template_developer.txt.j2

@@ -1,21 +1,12 @@
-{#  General role setup
-  ex. "Search in code" -> Python Developer -> find(*.py) | Java Developer -> find(*.java)
-#}
-You are: {{ role }}
+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 }}
-  Python version: {{ python_version }}
-  Shell/Environment: {{ shell_info }}
-{% endif %}
-
+  Platform: Windows
+  Shell/Environment: PowerShell
 
 
-{% 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 %}

janito/cli/__init__.py

@@ -7,4 +7,3 @@ __all__ = [
     "format_tokens",
     "format_generation_time",
 ]
-

janito/cli/chat_mode/bindings.py

@@ -5,6 +5,7 @@ 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():
@@ -35,4 +36,3 @@ class KeyBindingsFactory:
             buf.validate_and_handle()
 
         return bindings
-

janito/cli/chat_mode/chat_entry.py

@@ -13,11 +13,9 @@ def main(args=None):
     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

@@ -15,11 +15,8 @@ chat_shell_style = Style.from_dict(
         "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

@@ -23,6 +23,7 @@ Typical usage
 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
@@ -43,7 +44,6 @@ auth_warning = (
 )
 
 
-
 class ChatScriptRunner:
     """Run a **ChatSession** non-interactively using a predefined set of inputs."""
 
@@ -81,6 +81,7 @@ class ChatScriptRunner:
         # 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,
@@ -94,6 +95,7 @@ class ChatScriptRunner:
         # 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]
@@ -101,17 +103,20 @@ class ChatScriptRunner:
         # 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.")
+            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
+        def _script_handle_input(
+            this: ChatSession, _prompt_session_unused
+        ):  # noqa: D401
             if not self._input_queue:
                 # Signal normal shutdown
                 this._handle_exit()
@@ -151,4 +156,3 @@ class ChatScriptRunner:
 
     # Convenience alias so tests can simply call *runner()*
     __call__ = run
-

janito/cli/chat_mode/session.py

@@ -25,17 +25,20 @@ from janito.cli.prompt_setup import setup_agent_and_prompt_handler
 
 import time
 
+
 class ChatShellState:
     def __init__(self, mem_history, conversation_history):
         self.mem_history = mem_history
         self.conversation_history = conversation_history
         self.paste_mode = False
-        self._port = None
+
         self._pid = None
         self._stdout_path = None
         self._stderr_path = None
-        self.livereload_stderr_path = None
-        self._status = "starting"  # Tracks the current  status (updated by background thread/UI)
+
+        self._status = (
+            "starting"  # Tracks the current  status (updated by background thread/UI)
+        )
 
         self.last_usage_info = {}
         self.last_elapsed = None
@@ -44,6 +47,8 @@ class ChatShellState:
         self.agent = None
         self.main_agent = None
         self.main_enabled = False
+        self.no_tools_mode = False
+
 
 class ChatSession:
     def __init__(
@@ -67,53 +72,92 @@ class ChatSession:
         self.provider_instance = provider_instance
         self.llm_driver_config = llm_driver_config
 
-        profile, role, profile_system_prompt = self._select_profile_and_role(args, role)
+        profile, role, profile_system_prompt, no_tools_mode = (
+            self._select_profile_and_role(args, role)
+        )
+        # Propagate no_tools_mode flag to downstream components via args
+        if args is not None and not hasattr(args, "no_tools_mode"):
+            try:
+                setattr(args, "no_tools_mode", no_tools_mode)
+            except Exception:
+                pass
         conversation_history = self._create_conversation_history()
         self.agent, self._prompt_handler = self._setup_agent_and_prompt_handler(
-            args, provider_instance, llm_driver_config, role, verbose_tools, verbose_agent, allowed_permissions, profile, profile_system_prompt, conversation_history
+            args,
+            provider_instance,
+            llm_driver_config,
+            role,
+            verbose_tools,
+            verbose_agent,
+            allowed_permissions,
+            profile,
+            profile_system_prompt,
+            conversation_history,
         )
         self.shell_state = ChatShellState(self.mem_history, conversation_history)
         self.shell_state.agent = self.agent
+        # Set no_tools_mode if present
+        self.shell_state.no_tools_mode = bool(no_tools_mode)
         self._filter_execution_tools()
         from janito.perf_singleton import performance_collector
+
         self.performance_collector = performance_collector
         self.key_bindings = KeyBindingsFactory.create()
         self._prompt_handler.agent = self.agent
-        self._prompt_handler.conversation_history = self.shell_state.conversation_history
+        self._prompt_handler.conversation_history = (
+            self.shell_state.conversation_history
+        )
         self._support = False
-        self._maybe_enable_web_support(args)
 
     def _select_profile_and_role(self, args, role):
         profile = getattr(args, "profile", None) if args is not None else None
         role_arg = getattr(args, "role", None) if args is not None else None
         profile_system_prompt = None
+        no_tools_mode = False
         if profile is None and role_arg is None:
             try:
                 from janito.cli.chat_mode.session_profile_select import select_profile
+
                 result = select_profile()
                 if isinstance(result, dict):
                     profile = result.get("profile")
                     profile_system_prompt = result.get("profile_system_prompt")
+                    no_tools_mode = result.get("no_tools_mode", False)
                 elif isinstance(result, str) and result.startswith("role:"):
                     role = result[len("role:") :].strip()
-                    profile = "developer"
+                    profile = "Developer with Python Tools"
                 else:
                     profile = (
-                        "developer" if result == "plain_software_developer" else result
+                        "Developer with Python Tools"
+                        if result == "Developer"
+                        else result
                     )
             except ImportError:
-                profile = "helpful assistant"
+                profile = "Raw Model Session (no tools, no context)"
         if role_arg is not None:
             role = role_arg
             if profile is None:
-                profile = "developer"
-        return profile, role, profile_system_prompt
+                profile = "Developer with Python Tools"
+        return profile, role, profile_system_prompt, no_tools_mode
 
     def _create_conversation_history(self):
         from janito.conversation_history import LLMConversationHistory
+
         return LLMConversationHistory()
 
-    def _setup_agent_and_prompt_handler(self, args, provider_instance, llm_driver_config, role, verbose_tools, verbose_agent, allowed_permissions, profile, profile_system_prompt, conversation_history):
+    def _setup_agent_and_prompt_handler(
+        self,
+        args,
+        provider_instance,
+        llm_driver_config,
+        role,
+        verbose_tools,
+        verbose_agent,
+        allowed_permissions,
+        profile,
+        profile_system_prompt,
+        conversation_history,
+    ):
         return setup_agent_and_prompt_handler(
             args=args,
             provider_instance=provider_instance,
@@ -129,23 +173,16 @@ class ChatSession:
 
     def _filter_execution_tools(self):
         try:
-            getattr(__import__('janito.tools', fromlist=['get_local_tools_adapter']), 'get_local_tools_adapter')()
+            getattr(
+                __import__("janito.tools", fromlist=["get_local_tools_adapter"]),
+                "get_local_tools_adapter",
+            )()
         except Exception as e:
-            self.console.print(f"[yellow]Warning: Could not filter execution tools at startup: {e}[/yellow]")
-
-    def _maybe_enable_web_support(self, args):
-        if args and getattr(args, "web", False):
-            self._support = True
-            self.shell_state._support = self._support
-            from janito.cli._starter import _start_and_watch
-            from janito.cli.config import get__port
-            import threading
-            from rich.console import Console
-            Console().print("[yellow]Starting  in background...[/yellow]")
-            self._lock = threading.Lock()
-            _thread = _start_and_watch(
-                self.shell_state, self._lock, get__port()
+            self.console.print(
+                f"[yellow]Warning: Could not filter execution tools at startup: {e}[/yellow]"
             )
+
+            _thread = _start_and_watch(self.shell_state, self._lock, get__port())
             self._thread = _thread
         else:
             self.shell_state._support = False
@@ -154,22 +191,43 @@ class ChatSession:
     def run(self):
         self.console.clear()
         from janito import __version__
+
+        self.console.print(f"[bold green]Janito Chat Mode v{__version__}[/bold green]")
         self.console.print(
-            f"[bold green]Janito Chat Mode v{__version__}[/bold green]"
+            "[green]/help for commands   /exit or Ctrl+C to quit[/green]"
         )
-        self.console.print("[green]/help for commands   /exit or Ctrl+C to quit[/green]")
         import os
+
         cwd = os.getcwd()
-        home = os.path.expanduser('~')
+        home = os.path.expanduser("~")
         if cwd.startswith(home):
-            cwd_display = '~' + cwd[len(home):]
+            cwd_display = "~" + cwd[len(home) :]
         else:
             cwd_display = cwd
-        self.console.print(f"[green]Working Dir:[/green] {cwd_display}")
+        from janito.cli.chat_mode.shell.commands._priv_status import (
+            get_privilege_status_message,
+        )
+
+        priv_status = get_privilege_status_message()
+        self.console.print(
+            f"[green]Working Dir:[/green] {cwd_display}  |  {priv_status}"
+        )
 
-        from janito.cli.chat_mode.shell.commands._priv_check import user_has_any_privileges
-        if not user_has_any_privileges():
-            self.console.print("[yellow]Note: You currently have no privileges enabled. If you need to interact with files or the system, enable permissions using /read on, /write on, or /execute on.[/yellow]")
+        from janito.cli.chat_mode.shell.commands._priv_check import (
+            user_has_any_privileges,
+        )
+
+        perms = __import__(
+            "janito.tools.permissions", fromlist=["get_global_allowed_permissions"]
+        ).get_global_allowed_permissions()
+        if perms.execute:
+            self.console.print(
+                "[bold red]Commands/Code execution is enabled -  Be cautious[/bold red]"
+            )
+        if not (perms.read or perms.write or perms.execute):
+            self.console.print(
+                "[yellow]Note: You currently have no privileges enabled. If you need to interact with files or the system, enable permissions using /read on, /write on, or /execute on.[/yellow]"
+            )
 
         session = self._create_prompt_session()
         self._chat_loop(session)
@@ -204,6 +262,7 @@ class ChatSession:
     def _process_prompt(self, cmd_input):
         try:
             import time
+
             final_event = (
                 self._prompt_handler.agent.last_event
                 if hasattr(self._prompt_handler.agent, "last_event")
@@ -215,8 +274,11 @@ class ChatSession:
             elapsed = end_time - start_time
             self.msg_count += 1
             from janito.formatting_token import print_token_message_summary
+
             usage = self.performance_collector.get_last_request_usage()
-            print_token_message_summary(self.console, self.msg_count, usage, elapsed=elapsed)
+            print_token_message_summary(
+                self.console, self.msg_count, usage, elapsed=elapsed
+            )
             if final_event and hasattr(final_event, "metadata"):
                 exit_reason = (
                     final_event.metadata.get("exit_reason")
@@ -230,6 +292,7 @@ class ChatSession:
         except Exception as exc:
             self.console.print(f"[red]Exception in agent: {exc}[/red]")
             import traceback
+
             self.console.print(traceback.format_exc())
 
     def _create_prompt_session(self):