janito 2.3.0__py3-none-any.whl → 2.4.0__py3-none-any.whl

janito/__init__.py

@@ -1,6 +1,6 @@
-"""
-janito: A Python package for managing and interacting with Large Language Model (LLM) providers and their APIs.
-Provides a CLI for credential management and an extensible driver system for LLMs.
-"""
-
-__version__ = "2.3.0"
+"""
+janito: A Python package for managing and interacting with Large Language Model (LLM) providers and their APIs.
+Provides a CLI for credential management and an extensible driver system for LLMs.
+"""
+
+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

@@ -21,61 +21,122 @@ def setup_agent(
     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
-    # Normal flow
+    # 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_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
 
 
@@ -105,6 +171,9 @@ def create_configured_agent(
     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,
@@ -142,6 +213,9 @@ def create_configured_agent(
         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_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/session.py

@@ -3,6 +3,8 @@ Session management for Janito Chat CLI.
 Defines ChatSession and ChatShellState classes.
 """
 
+from __future__ import annotations
+
 import types
 from rich.console import Console
 from rich.rule import Rule
@@ -17,23 +19,22 @@ from janito.cli.chat_mode.bindings import KeyBindingsFactory
 from janito.cli.chat_mode.shell.commands import handle_command
 from janito.cli.chat_mode.shell.autocomplete import ShellCommandCompleter
 
+# Shared prompt/agent factory
+from janito.cli.prompt_setup import setup_agent_and_prompt_handler
+
 
 class ChatShellState:
     def __init__(self, mem_history, conversation_history):
-        self.allow_execution = False  # Controls whether execution tools are enabled
         self.mem_history = mem_history
         self.conversation_history = conversation_history
         self.paste_mode = False
-        self.termweb_port = None
-        self.termweb_pid = None
-        self.termweb_stdout_path = None
-        self.termweb_stderr_path = None
+        self._port = None
+        self._pid = None
+        self._stdout_path = None
+        self._stderr_path = None
         self.livereload_stderr_path = None
-        self.termweb_status = "starting"  # Tracks the current termweb status (updated by background thread/UI)
-        self.termweb_live_status = (
-            None  # 'online', 'offline', updated by background checker
-        )
-        self.termweb_live_checked_time = None  # datetime.datetime of last status check
+        self._status = "starting"  # Tracks the current  status (updated by background thread/UI)
+
         self.last_usage_info = {}
         self.last_elapsed = None
         self.main_agent = {}
@@ -53,25 +54,10 @@ class ChatSession:
         args=None,
         verbose_tools=False,
         verbose_agent=False,
-        exec_enabled=False
+        exec_enabled=False,
+        allowed_permissions=None,
     ):
-        # Set allow_execution from exec_enabled or args
-        if args is not None and hasattr(args, "exec"):
-            allow_execution = bool(getattr(args, "exec", False))
-        else:
-            allow_execution = exec_enabled
-        from janito.cli.prompt_core import PromptHandler as GenericPromptHandler
-
-        self._prompt_handler = GenericPromptHandler(
-            args=None,
-            conversation_history=(
-                None
-                if not hasattr(self, "shell_state")
-                else self.shell_state.conversation_history
-            ),
-            provider_instance=provider_instance,
-        )
-        self._prompt_handler.agent = None  # Will be set below if agent exists
+
         self.console = console
         self.user_input_history = UserInputHistory()
         self.input_dicts = self.user_input_history.load()
@@ -81,27 +67,57 @@ class ChatSession:
                 self.mem_history.append_string(item["input"])
         self.provider_instance = provider_instance
         self.llm_driver_config = llm_driver_config
-        from janito.agent.setup_agent import create_configured_agent
 
-        agent = create_configured_agent(
+        # --- Profile selection (interactive) ---------------------------------
+        profile = getattr(args, "profile", None) if args is not None else None
+        profile_system_prompt = None
+        if profile is None:
+            try:
+                from janito.cli.chat_mode.session_profile_select import select_profile
+
+                result = select_profile()
+                if (
+                    isinstance(result, dict)
+                    and result.get("profile") is None
+                    and result.get("profile_system_prompt")
+                ):
+                    profile_system_prompt = result["profile_system_prompt"]
+                elif isinstance(result, str) and result.startswith("role:"):
+                    role = result[len("role:") :].strip()
+                    profile = "developer"
+                else:
+                    profile = (
+                        "developer" if result == "software developer" else result
+                    )
+            except ImportError:
+                profile = "helpful assistant"
+
+        # ---------------------------------------------------------------------
+        from janito.conversation_history import LLMConversationHistory
+
+        conversation_history = LLMConversationHistory()
+
+        # Build agent and core prompt handler via the shared helper
+        self.agent, self._prompt_handler = setup_agent_and_prompt_handler(
+            args=args,
             provider_instance=provider_instance,
             llm_driver_config=llm_driver_config,
             role=role,
             verbose_tools=verbose_tools,
             verbose_agent=verbose_agent,
-            exec_enabled=allow_execution
+            exec_enabled=exec_enabled,
+            allowed_permissions=allowed_permissions,
+            profile=profile,
+            profile_system_prompt=profile_system_prompt,
+            conversation_history=conversation_history,
         )
-        from janito.conversation_history import LLMConversationHistory
 
-        self.shell_state = ChatShellState(self.mem_history, LLMConversationHistory())
-        self.shell_state.agent = agent
-        self.shell_state.allow_execution = allow_execution
-        self.agent = agent
+        self.shell_state = ChatShellState(self.mem_history, conversation_history)
+        self.shell_state.agent = self.agent
         # Filter execution tools at startup
         try:
-            registry = getattr(__import__('janito.tools', fromlist=['get_local_tools_adapter']), 'get_local_tools_adapter')()
-            if hasattr(registry, 'set_execution_tools_enabled'):
-                registry.set_execution_tools_enabled(allow_execution)
+            # Permissions are now managed globally; registry filtering is automatic
+            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]")
         from janito.perf_singleton import performance_collector
@@ -114,76 +130,46 @@ class ChatSession:
             self.shell_state.conversation_history
         )
 
-        # TERMWEB logic migrated from runner
-        self.termweb_support = False
+        self._support = False
         if args and getattr(args, "web", False):
-            self.termweb_support = True
-            self.shell_state.termweb_support = self.termweb_support
-            from janito.cli.termweb_starter import termweb_start_and_watch
-            from janito.cli.config import get_termweb_port
+            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 termweb in background...[/yellow]")
-            self.termweb_lock = threading.Lock()
-            termweb_thread = termweb_start_and_watch(
-                self.shell_state, self.termweb_lock, get_termweb_port()
+            Console().print("[yellow]Starting  in background...[/yellow]")
+            self._lock = threading.Lock()
+            _thread = _start_and_watch(
+                self.shell_state, self._lock, get__port()
             )
             # Initial status is set to 'starting' by constructor; the watcher will update
-            self.termweb_thread = termweb_thread
+            self._thread = _thread
 
-            # Start a background timer to update live termweb status (for UI responsiveness)
+            # Start a background timer to update live  status (for UI responsiveness)
             import threading, datetime
 
-            def update_termweb_liveness():
-                while True:
-                    with self.termweb_lock:
-                        port = getattr(self.shell_state, "termweb_port", None)
-                        if port:
-                            try:
-                                # is_termweb_running is removed; inline health check here:
-                                try:
-                                    import http.client
-
-                                    conn = http.client.HTTPConnection(
-                                        "localhost", port, timeout=0.5
-                                    )
-                                    conn.request("GET", "/")
-                                    resp = conn.getresponse()
-                                    running = resp.status == 200
-                                except Exception:
-                                    running = False
-                                self.shell_state.termweb_live_status = (
-                                    "online" if running else "offline"
-                                )
-                            except Exception:
-                                self.shell_state.termweb_live_status = "offline"
-                            self.shell_state.termweb_live_checked_time = (
-                                datetime.datetime.now()
-                            )
-                        else:
-                            self.shell_state.termweb_live_status = None
-                            self.shell_state.termweb_live_checked_time = (
-                                datetime.datetime.now()
-                            )
-                    # sleep outside lock
-                    threading.Event().wait(1.0)
-
-            self._termweb_liveness_thread = threading.Thread(
-                target=update_termweb_liveness, daemon=True
-            )
-            self._termweb_liveness_thread.start()
-            # No queue or blocking checks; UI (and timer) will observe self.shell_state fields
+            # Health check and liveness thread removed as per refactor to eliminate localhost references.
 
         else:
-            self.shell_state.termweb_support = False
-            self.shell_state.termweb_status = "offline"
+            self.shell_state._support = False
+            self.shell_state._status = "offline"
 
     def run(self):
-        session = self._create_prompt_session()
+        self.console.clear()
+        from janito import __version__
         self.console.print(
-            "[bold green]Type /help for commands. Type /exit or press Ctrl+C to quit.[/bold green]"
+            f"[bold green]Janito Chat Mode v{__version__}[/bold green]"
         )
+        self.console.print("[green]/help for commands   /exit or Ctrl+C to quit[/green]")
+
+        # Inform user if no privileges are enabled
+        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]")
+
+        session = self._create_prompt_session()
         self._chat_loop(session)
 
     def _chat_loop(self, session):