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

janito/agent/setup_agent.py

@@ -1,222 +1,231 @@
-from pathlib import Path
-from jinja2 import Template
-import importlib.resources
-import sys
-import warnings
-from janito.tools import get_local_tools_adapter
-from janito.llm.agent import LLMAgent
-from janito.drivers.driver_registry import get_driver_class
-from queue import Queue
-from janito.platform_discovery import PlatformDiscovery
-
-
-def setup_agent(
-    provider_instance,
-    llm_driver_config,
-    role=None,
-    templates_dir=None,
-    zero_mode=False,
-    input_queue=None,
-    output_queue=None,
-    verbose_tools=False,
-    verbose_agent=False,
-    
-    allowed_permissions=None,
-    profile=None,
-    profile_system_prompt=None,
-):
-    """
-    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 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 "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 (profile-specific system prompt)
-    if templates_dir is None:
-        # Set default template directory
-        templates_dir = Path(__file__).parent / "templates" / "profiles"
-    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_<profile>.txt.j2
-        try:
-            with importlib.resources.files("janito.agent.templates.profiles").joinpath(
-                template_filename
-            ).open("r", encoding="utf-8") as file:
-                template_content = file.read()
-        except (FileNotFoundError, ModuleNotFoundError, AttributeError):
-            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 "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()
-    
-    # Create the agent as before, now passing the explicit role
-    # Do NOT pass temperature; do not depend on to_dict
-    agent = LLMAgent(
-        provider_instance,
-        tools_provider,
-        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
-
-
-def create_configured_agent(
-    *,
-    provider_instance=None,
-    llm_driver_config=None,
-    role=None,
-    verbose_tools=False,
-    verbose_agent=False,
-    templates_dir=None,
-    zero_mode=False,
-    
-    allowed_permissions=None,
-    profile=None,
-    profile_system_prompt=None,
-):
-    """
-    Normalizes agent setup for all CLI modes.
-
-    Args:
-        provider_instance: Provider instance for the agent
-        llm_driver_config: LLM driver configuration
-        role: Optional role string
-        verbose_tools: Optional, default False
-        verbose_agent: Optional, default False
-        templates_dir: Optional
-        zero_mode: Optional, default False
-
-    Returns:
-        Configured agent instance
-    """
-    # If provider_instance has create_driver, wire queues (single-shot mode)
-    input_queue = None
-    output_queue = None
-    driver = None
-    if hasattr(provider_instance, "create_driver"):
-        driver = provider_instance.create_driver()
-        driver.start()  # Ensure the driver background thread is started
-        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,
-        role=role,
-        templates_dir=templates_dir,
-        zero_mode=zero_mode,
-        input_queue=input_queue,
-        output_queue=output_queue,
-        verbose_tools=verbose_tools,
-        verbose_agent=verbose_agent,
-        
-        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
-    return agent
+import importlib.resources
+import re
+import sys
+import time
+import warnings
+import threading
+from pathlib import Path
+from jinja2 import Template
+from rich import print as rich_print
+from queue import Queue
+from janito.tools import get_local_tools_adapter
+from janito.llm.agent import LLMAgent
+from janito.drivers.driver_registry import get_driver_class
+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.
+    """
+    template_filename = f"system_prompt_template_{profile}.txt.j2"
+    template_path = templates_dir / template_filename
+    if template_path.exists():
+        with open(template_path, "r", encoding="utf-8") as file:
+            return file.read(), template_path
+    # Try package import 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):
+        raise FileNotFoundError(
+            f"[janito] Could not find profile-specific template '{template_filename}' in {template_path} nor in janito.agent.templates.profiles package."
+        )
+
+
+def _prepare_template_context(role, profile, allowed_permissions):
+    """
+    Prepares the context dictionary for Jinja2 template rendering.
+    """
+    context = {}
+    context["role"] = role or "developer"
+    context["profile"] = profile
+    if allowed_permissions is None:
+        allowed_permissions = get_global_allowed_permissions()
+    # Convert ToolPermissions -> string like "rwx"
+    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
+    context["allowed_permissions"] = allowed_permissions
+    # Inject platform info if execute permission is present
+    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()
+    return context
+
+
+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.
+    """
+    agent = LLMAgent(
+        provider_instance,
+        tools_provider,
+        agent_name=role or "developer",
+        system_prompt=system_prompt,
+        input_queue=input_queue,
+        output_queue=output_queue,
+        verbose_agent=verbose_agent,
+    )
+    agent.template_vars["role"] = context["role"]
+    agent.template_vars["profile"] = profile
+    agent.system_prompt_template = str(template_path)
+    agent._template_vars = context.copy()
+    agent._original_template_vars = context.copy()
+    return agent
+
+
+def setup_agent(
+    provider_instance,
+    llm_driver_config,
+    role=None,
+    templates_dir=None,
+    zero_mode=False,
+    input_queue=None,
+    output_queue=None,
+    verbose_tools=False,
+    verbose_agent=False,
+    allowed_permissions=None,
+    profile=None,
+    profile_system_prompt=None,
+):
+    """
+    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 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):
+        agent = LLMAgent(
+            provider_instance,
+            tools_provider,
+            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 (profile-specific system prompt)
+    if templates_dir is None:
+        templates_dir = Path(__file__).parent / "templates" / "profiles"
+    template_content, template_path = _load_template_content(profile, templates_dir)
+
+    template = Template(template_content)
+    context = _prepare_template_context(role, profile, allowed_permissions)
+
+    # 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))
+    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]")
+    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)
+
+    return _create_agent(
+        provider_instance,
+        tools_provider,
+        role,
+        rendered_prompt,
+        input_queue,
+        output_queue,
+        verbose_agent,
+        context,
+        template_path,
+        profile,
+    )
+
+
+def create_configured_agent(
+    *,
+    provider_instance=None,
+    llm_driver_config=None,
+    role=None,
+    verbose_tools=False,
+    verbose_agent=False,
+    templates_dir=None,
+    zero_mode=False,
+    allowed_permissions=None,
+    profile=None,
+    profile_system_prompt=None,
+):
+    """
+    Normalizes agent setup for all CLI modes.
+
+    Args:
+        provider_instance: Provider instance for the agent
+        llm_driver_config: LLM driver configuration
+        role: Optional role string
+        verbose_tools: Optional, default False
+        verbose_agent: Optional, default False
+        templates_dir: Optional
+        zero_mode: Optional, default False
+
+    Returns:
+        Configured agent instance
+    """
+    input_queue = None
+    output_queue = None
+    driver = None
+    if hasattr(provider_instance, "create_driver"):
+        driver = provider_instance.create_driver()
+        driver.start()  # Ensure the driver background thread is started
+        input_queue = getattr(driver, "input_queue", None)
+        output_queue = getattr(driver, "output_queue", None)
+
+    agent = setup_agent(
+        provider_instance=provider_instance,
+        llm_driver_config=llm_driver_config,
+        role=role,
+        templates_dir=templates_dir,
+        zero_mode=zero_mode,
+        input_queue=input_queue,
+        output_queue=output_queue,
+        verbose_tools=verbose_tools,
+        verbose_agent=verbose_agent,
+        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
+    return agent

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

@@ -0,0 +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 %}
+

janito/cli/chat_mode/bindings.py

@@ -22,35 +22,10 @@ class KeyBindingsFactory:
             buf.text = "No"
             buf.validate_and_handle()
 
-        @bindings.add("f1")
-        def _(event):
-            buf = event.app.current_buffer
-            buf.text = "/restart"
-            buf.validate_and_handle()
-
         @bindings.add("f2")
         def _(event):
             buf = event.app.current_buffer
-            # 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.text = "/restart"
             buf.validate_and_handle()
 
         @bindings.add("f12")