janito 2.3.1__py3-none-any.whl → 2.5.0__py3-none-any.whl

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.3.1"
+from ._version import __version__

janito/_version.py

@@ -0,0 +1,57 @@
+"""Version handling for Janito.
+Attempts to obtain the package version in the following order:
+1. If a janito.version module exists (generated when the package is built with
+   setuptools-scm), use the version attribute from that module.
+2. Ask importlib.metadata for the installed distribution version – works for
+   both regular and editable installs handled by pip.
+3. Fall back to calling setuptools_scm.get_version() directly, using the git
+   repository when running from source without an installed distribution.
+4. If everything else fails, return the literal string ``"unknown"`` so that
+   the application continues to work even when the version cannot be
+   determined.
+
+This layered approach guarantees that a meaningful version string is returned
+in most development and production scenarios while keeping Janito free from
+hard-coded version numbers.
+"""
+
+from __future__ import annotations
+
+import pathlib
+from importlib import metadata as importlib_metadata
+
+__all__ = ["__version__"]
+
+
+# 1. "janito.version" (generated at build time by setuptools-scm)
+try:
+    from . import version as _generated_version  # type: ignore
+
+    __version__: str = _generated_version.version  # pytype: disable=module-attr
+except ImportError:  # pragma: no cover – not available in editable installs
+
+    def _resolve_version() -> str:
+        """Resolve the version string using several fallbacks."""
+
+        # 2. importlib.metadata – works for both regular and `pip install -e`.
+        try:
+            return importlib_metadata.version("janito")
+        except importlib_metadata.PackageNotFoundError:
+            pass  # Not installed – probably running from a source checkout.
+
+        # 3. setuptools_scm – query the VCS metadata directly.
+        try:
+            from setuptools_scm import get_version  # Imported lazily.
+
+            package_root = pathlib.Path(__file__).resolve().parent.parent
+            return get_version(root=str(package_root), relative_to=__file__)
+        except Exception:  # pragma: no cover – any failure here falls through
+            # Either setuptools_scm is not available or this is not a git repo.
+            pass
+
+        # 4. Ultimate fallback – return a placeholder.
+        return "unknown"
+
+    __version__ = _resolve_version()
+
+

janito/agent/setup_agent.py

@@ -20,62 +20,123 @@ def setup_agent(
     output_queue=None,
     verbose_tools=False,
     verbose_agent=False,
-    exec_enabled=False,
+    
+    allowed_permissions=None,
+    profile=None,
+    profile_system_prompt=None,
 ):
     """
-    Creates an agent using a rendered system prompt template, passing an explicit role.
+    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 zero_mode:
+    # 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):
         # Pass provider to agent, let agent create driver
         agent = LLMAgent(
             provider_instance,
             tools_provider,
-            agent_name=role or "software developer",
+            agent_name=role or "developer",
             system_prompt=None,
+            input_queue=input_queue,
+            output_queue=output_queue,
+            verbose_agent=verbose_agent,
+        )
+        if role:
+            agent.template_vars["role"] = role
+        return agent
+    # If profile_system_prompt is set, use it directly
+    if profile_system_prompt is not None:
+        agent = LLMAgent(
+            provider_instance,
+            tools_provider,
+            agent_name=role or "developer",
+            system_prompt=profile_system_prompt,
+            input_queue=input_queue,
+            output_queue=output_queue,
             verbose_agent=verbose_agent,
         )
+        agent.template_vars["role"] = role or "developer"
+        agent.template_vars["profile"] = None
+        agent.template_vars["profile_system_prompt"] = profile_system_prompt
         return agent
-    # Normal flow
+    # Normal flow (profile-specific system prompt)
     if templates_dir is None:
         # Set default template directory
         templates_dir = Path(__file__).parent / "templates" / "profiles"
-    template_path = templates_dir / "system_prompt_template_main.txt.j2"
+    template_filename = f"system_prompt_template_{profile}.txt.j2"
+    template_path = templates_dir / template_filename
 
     template_content = None
     if template_path.exists():
         with open(template_path, "r", encoding="utf-8") as file:
             template_content = file.read()
     else:
-        # Try package import fallback: janito.agent.templates.profiles.system_prompt_template_main.txt.j2
+        # Try package import fallback: janito.agent.templates.profiles.system_prompt_template_<profile>.txt.j2
         try:
             with importlib.resources.files("janito.agent.templates.profiles").joinpath(
-                "system_prompt_template_main.txt.j2"
+                template_filename
             ).open("r", encoding="utf-8") as file:
                 template_content = file.read()
         except (FileNotFoundError, ModuleNotFoundError, AttributeError):
-            warnings.warn(
-                f"[janito] Could not find system_prompt_template_main.txt.j2 in {template_path} nor in janito.agent.templates.profiles package."
-            )
-            raise FileNotFoundError(
-                f"Template file not found in either {template_path} or package resource."
-            )
+            if profile:
+                raise FileNotFoundError(
+                    f"[janito] Could not find profile-specific template '{template_filename}' in {template_path} nor in janito.agent.templates.profiles package."
+                )
+            else:
+                warnings.warn(
+                    f"[janito] Could not find {template_filename} in {template_path} nor in janito.agent.templates.profiles package."
+                )
+                raise FileNotFoundError(
+                    f"Template file not found in either {template_path} or package resource."
+                )
 
     import time
     template = Template(template_content)
     # Prepare context for Jinja2 rendering from llm_driver_config
     # Compose context for Jinja2 rendering without using to_dict or temperature
     context = {}
-    context["role"] = role or "software developer"
-    # Inject current platform environment information only if exec_enabled
-    context["exec_enabled"] = bool(exec_enabled)
-    if exec_enabled:
+    context["role"] = role or "developer"
+    context["profile"] = profile
+    # Normalize and inject allowed tool permissions
+    from janito.tools.tool_base import ToolPermissions
+    from janito.tools.permissions import get_global_allowed_permissions
+
+    if allowed_permissions is None:
+        # Fallback to globally configured permissions if not explicitly provided
+        allowed_permissions = get_global_allowed_permissions()
+
+    # Convert ToolPermissions -> string like "rwx" so the Jinja template can use
+    # membership checks such as `'r' in allowed_permissions`.
+    if isinstance(allowed_permissions, ToolPermissions):
+        perm_str = ""
+        if allowed_permissions.read:
+            perm_str += "r"
+        if allowed_permissions.write:
+            perm_str += "w"
+        if allowed_permissions.execute:
+            perm_str += "x"
+        allowed_permissions = perm_str or None  # None if empty
+
+    context["allowed_permissions"] = allowed_permissions
+
+    # Inject platform information only when execute permission is granted
+    if allowed_permissions and 'x' in allowed_permissions:
         pd = PlatformDiscovery()
         context["platform"] = pd.get_platform_name()
         context["python_version"] = pd.get_python_version()
         context["shell_info"] = pd.detect_shell()
+    # DEBUG: Show permissions passed to template
+        from rich import print as rich_print
+    debug_flag = False
+    try:
+        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_filename}[/cyan]' with allowed_permissions: [yellow]{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()
@@ -85,13 +146,18 @@ def setup_agent(
     agent = LLMAgent(
         provider_instance,
         tools_provider,
-        agent_name=role or "software developer",
+        agent_name=role or "developer",
         system_prompt=rendered_prompt,
         input_queue=input_queue,
         output_queue=output_queue,
         verbose_agent=verbose_agent,
     )
     agent.template_vars["role"] = context["role"]
+    agent.template_vars["profile"] = profile
+    # Store template path and context for dynamic prompt refresh
+    agent.system_prompt_template = str(template_path)
+    agent._template_vars = context.copy()
+    agent._original_template_vars = context.copy()
     return agent
 
 
@@ -104,7 +170,10 @@ def create_configured_agent(
     verbose_agent=False,
     templates_dir=None,
     zero_mode=False,
-    exec_enabled=False,
+    
+    allowed_permissions=None,
+    profile=None,
+    profile_system_prompt=None,
 ):
     """
     Normalizes agent setup for all CLI modes.
@@ -131,6 +200,8 @@ def create_configured_agent(
         input_queue = getattr(driver, "input_queue", None)
         output_queue = getattr(driver, "output_queue", None)
 
+    # Automatically enable system prompt when a profile is specified
+
     agent = setup_agent(
         provider_instance=provider_instance,
         llm_driver_config=llm_driver_config,
@@ -141,7 +212,10 @@ def create_configured_agent(
         output_queue=output_queue,
         verbose_tools=verbose_tools,
         verbose_agent=verbose_agent,
-        exec_enabled=exec_enabled,
+        
+        allowed_permissions=allowed_permissions,
+        profile=profile,
+        profile_system_prompt=profile_system_prompt,
     )
     if driver is not None:
         agent.driver = driver  # Attach driver to agent for thread management

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

@@ -0,0 +1 @@
+You are a helpful assistant.

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

@@ -0,0 +1,44 @@
+{#  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 %}
+
+
+
+{% 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/chat_mode/bindings.py

@@ -3,7 +3,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
@@ -31,7 +31,26 @@ class KeyBindingsFactory:
         @bindings.add("f2")
         def _(event):
             buf = event.app.current_buffer
-            buf.text = "/exec on"
+            # Toggle read permission based on current state
+            current = get_global_allowed_permissions()
+            next_state = "off" if getattr(current, "read", False) else "on"
+            buf.text = f"/read {next_state}"
+            buf.validate_and_handle()
+
+        @bindings.add("f3")
+        def _(event):
+            buf = event.app.current_buffer
+            current = get_global_allowed_permissions()
+            next_state = "off" if getattr(current, "write", False) else "on"
+            buf.text = f"/write {next_state}"
+            buf.validate_and_handle()
+
+        @bindings.add("f4")
+        def _(event):
+            buf = event.app.current_buffer
+            current = get_global_allowed_permissions()
+            next_state = "off" if getattr(current, "execute", False) else "on"
+            buf.text = f"/execute {next_state}"
             buf.validate_and_handle()
 
         @bindings.add("f12")

janito/cli/chat_mode/chat_entry.py

@@ -10,11 +10,10 @@ from janito.cli.chat_mode.session import ChatSession
 
 def main(args=None):
     console = Console()
+    console.clear()
     from janito.version import __version__
 
-    console.print(
-        f"[bold green]Welcome to the Janito Chat Mode (v{__version__})! Type /exit or press Ctrl+C to quit.[/bold green]"
-    )
+
     session = ChatSession(console, args=args)
     session.run()
 

janito/cli/chat_mode/prompt_style.py

@@ -15,5 +15,10 @@ 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

@@ -0,0 +1,153 @@
+"""
+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