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

janito/cli/chat_mode/session_profile_select.py

@@ -1,16 +1,103 @@
+import os
+from pathlib import Path
+import questionary
+from questionary import Style
+import os
+from pathlib import Path
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit import PromptSession
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.enums import EditingMode
+from prompt_toolkit.formatted_text import HTML
+from .prompt_style import chat_shell_style
+
+
 """
 Profile selection logic for Janito Chat CLI using questionary.
 """
-import questionary
-from questionary import Style
+
+def _handle_helpful_assistant():
+    return {"profile": "assistant", "profile_system_prompt": None}
+
+def _handle_using_role():
+    role_name = questionary.text("Enter the role name:").ask()
+    return f"role:{role_name}"
+
+def _get_toolbar(mode):
+    if mode["multiline"]:
+        return HTML("<b>Multiline mode (Esc+Enter to submit). Type /single to switch.</b>")
+    else:
+        return HTML("<b>Single-line mode (Enter to submit). Type /multi for multiline.</b>")
+
+def _handle_custom_system_prompt():
+    mode = {"multiline": False}
+    bindings = KeyBindings()
+
+    @bindings.add("c-r")
+    def _(event):
+        pass
+
+    @bindings.add("f12")
+    def _(event):
+        buf = event.app.current_buffer
+        buf.text = "Do It"
+        buf.validate_and_handle()
+
+    session = PromptSession(
+        multiline=False,
+        key_bindings=bindings,
+        editing_mode=EditingMode.EMACS,
+        bottom_toolbar=lambda: _get_toolbar(mode),
+        style=chat_shell_style,
+    )
+    prompt_icon = HTML("<inputline>📝 </inputline>")
+    while True:
+        response = session.prompt(prompt_icon)
+        if not mode["multiline"] and response.strip() == "/multi":
+            mode["multiline"] = True
+            session.multiline = True
+            continue
+        elif mode["multiline"] and response.strip() == "/single":
+            mode["multiline"] = False
+            session.multiline = False
+            continue
+        else:
+            sanitized = response.strip()
+            try:
+                sanitized.encode("utf-8")
+            except UnicodeEncodeError:
+                sanitized = sanitized.encode("utf-8", errors="replace").decode("utf-8")
+            return {"profile": None, "profile_system_prompt": sanitized}
+
+
+def _load_user_profiles():
+    user_profiles_dir = Path.home() / ".janito" / "profiles"
+    profiles = {}
+    if user_profiles_dir.exists() and user_profiles_dir.is_dir():
+        for profile_file in user_profiles_dir.glob("*"):
+            if profile_file.is_file():
+                try:
+                    with open(profile_file, "r", encoding="utf-8") as f:
+                        profiles[profile_file.stem] = f.read().strip()
+                except Exception:
+                    # Ignore unreadable files
+                    pass
+    return profiles
+
 
 def select_profile():
+    user_profiles = _load_user_profiles()
     choices = [
         "helpful assistant",
         "developer",
+        "software developer",
         "using role...",
         "full custom system prompt..."
     ]
+    # Add user profiles to choices
+    if user_profiles:
+        choices.extend(user_profiles.keys())
+
     custom_style = Style([
         ("highlighted", "bg:#00aaff #ffffff"),  # background for item under cursor
         ("question", "fg:#00aaff bold"),
@@ -21,60 +108,43 @@ def select_profile():
         default=None,
         style=custom_style
     ).ask()
+
     if answer == "helpful assistant":
-        return {"profile": "assistant", "profile_system_prompt": None}
+        return _handle_helpful_assistant()
     if answer == "using role...":
-        role_name = questionary.text("Enter the role name:").ask()
-        return f"role:{role_name}"
+        return _handle_using_role()
     elif answer == "full custom system prompt...":
-        from prompt_toolkit import PromptSession
-        from prompt_toolkit.key_binding import KeyBindings
-        from prompt_toolkit.enums import EditingMode
-        from prompt_toolkit.formatted_text import HTML
-        from .prompt_style import chat_shell_style
-
-        mode = {"multiline": False}
-        bindings = KeyBindings()
-
-        @bindings.add("c-r")
-        def _(event):
-            pass
-
-        @bindings.add("f12")
-        def _(event):
-            buf = event.app.current_buffer
-            buf.text = "Do It"
-            buf.validate_and_handle()
-
-        def get_toolbar():
-            if mode["multiline"]:
-                return HTML("<b>Multiline mode (Esc+Enter to submit). Type /single to switch.</b>")
-            else:
-                return HTML("<b>Single-line mode (Enter to submit). Type /multi for multiline.</b>")
-
-        session = PromptSession(
-            multiline=False,
-            key_bindings=bindings,
-            editing_mode=EditingMode.EMACS,
-            bottom_toolbar=get_toolbar,
-            style=chat_shell_style,
-        )
-        prompt_icon = HTML("<inputline>📝 </inputline>")
-        while True:
-            response = session.prompt(prompt_icon)
-            if not mode["multiline"] and response.strip() == "/multi":
-                mode["multiline"] = True
-                session.multiline = True
-                continue
-            elif mode["multiline"] and response.strip() == "/single":
-                mode["multiline"] = False
-                session.multiline = False
-                continue
-            else:
-                sanitized = response.strip()
-                try:
-                    sanitized.encode("utf-8")
-                except UnicodeEncodeError:
-                    sanitized = sanitized.encode("utf-8", errors="replace").decode("utf-8")
-                return {"profile": None, "profile_system_prompt": sanitized}
+        return _handle_custom_system_prompt()
+    elif answer in user_profiles:
+        # Return the content of the user profile as a custom system prompt
+        return {"profile": None, "profile_system_prompt": user_profiles[answer]}
+    elif answer == "software developer":
+        # Return the content of the built-in software developer profile prompt
+        with open("./janito/agent/templates/profiles/system_prompt_template_software_developer.txt.j2", "r", encoding="utf-8") as f:
+            prompt = f.read().strip()
+        return {"profile": "software developer", "profile_system_prompt": prompt}
+    return answer
+
+    choices = [
+        "helpful assistant",
+        "developer",
+        "using role...",
+        "full custom system prompt..."
+    ]
+    custom_style = Style([
+        ("highlighted", "bg:#00aaff #ffffff"),  # background for item under cursor
+        ("question", "fg:#00aaff bold"),
+    ])
+    answer = questionary.select(
+        "Select a profile to use:",
+        choices=choices,
+        default=None,
+        style=custom_style
+    ).ask()
+    if answer == "helpful assistant":
+        return _handle_helpful_assistant()
+    if answer == "using role...":
+        return _handle_using_role()
+    elif answer == "full custom system prompt...":
+        return _handle_custom_system_prompt()
     return answer

janito/cli/chat_mode/shell/commands/tools.py

@@ -4,67 +4,70 @@ from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
 class ToolsShellHandler(ShellCmdHandler):
     help_text = "List available tools"
 
+    def _perm_class(self, perms):
+        if perms.execute:
+            if perms.read and perms.write:
+                return "read-write-execute"
+            elif perms.read:
+                return "read-execute"
+            elif perms.write:
+                return "write-execute"
+            else:
+                return "execute-only"
+        elif perms.read and perms.write:
+            return "read-write"
+        elif perms.read:
+            return "read-only"
+        elif perms.write:
+            return "write-only"
+        else:
+            return "none"
+
+    def _group_tools_by_permission(self, tools, tool_instances):
+        perm_groups = {}
+        for tool in tools:
+            inst = tool_instances.get(tool, None)
+            perms = getattr(inst, 'permissions', None)
+            if not perms:
+                group = "unknown"
+            else:
+                group = self._perm_class(perms)
+            perm_groups.setdefault(group, []).append(tool)
+        return perm_groups
+
+    def _print_tools_table(self, perm_groups):
+        from rich.table import Table
+        table = Table(title="Tools by Permission Class")
+        table.add_column("Permission Type", style="cyan", no_wrap=True)
+        table.add_column("Tools", style="magenta")
+        for group, tool_list in sorted(perm_groups.items()):
+            table.add_row(group, " ".join(sorted(tool_list)))
+        shared_console.print(table)
+
+    def _find_exec_tools(self, registry):
+        exec_tools = []
+        for tool_instance in registry.get_tools():
+            perms = getattr(tool_instance, 'permissions', None)
+            if perms and perms.execute:
+                exec_tools.append(tool_instance.tool_name)
+        return exec_tools
+
     def run(self):
         try:
-
             import janito.tools  # Ensure all tools are registered
             from janito.tools.permissions import get_global_allowed_permissions
             registry = janito.tools.get_local_tools_adapter()
             tools = registry.list_tools()
-            from rich.table import Table
             shared_console.print("Registered tools:")
             tool_instances = {t.tool_name: t for t in registry.get_tools()}
             if not tools:
                 shared_console.print("No tools are enabled under the current permission settings.")
                 return
-            # Group tools by permission class
-            perm_groups = {}
-            def perm_class(perms):
-                if perms.execute:
-                    if perms.read and perms.write:
-                        return "read-write-execute"
-                    elif perms.read:
-                        return "read-execute"
-                    elif perms.write:
-                        return "write-execute"
-                    else:
-                        return "execute-only"
-                elif perms.read and perms.write:
-                    return "read-write"
-                elif perms.read:
-                    return "read-only"
-                elif perms.write:
-                    return "write-only"
-                else:
-                    return "none"
-            for tool in tools:
-                inst = tool_instances.get(tool, None)
-                perms = getattr(inst, 'permissions', None)
-                if not perms:
-                    group = "unknown"
-                else:
-                    group = perm_class(perms)
-                perm_groups.setdefault(group, []).append(tool)
-            # Build and print table
-            table = Table(title="Tools by Permission Class")
-            table.add_column("Permission Type", style="cyan", no_wrap=True)
-            table.add_column("Tools", style="magenta")
-            for group, tool_list in sorted(perm_groups.items()):
-                table.add_row(group, " ".join(sorted(tool_list)))
-            shared_console.print(table)
-
-            
-            # Find all possible execution tools (by permission: execute=True)
-            exec_tools = []
-            for tool_instance in registry.get_tools():
-                perms = getattr(tool_instance, 'permissions', None)
-                if perms and perms.execute:
-                    exec_tools.append(tool_instance.tool_name)
-
-            from janito.tools.permissions import get_global_allowed_permissions
+            perm_groups = self._group_tools_by_permission(tools, tool_instances)
+            self._print_tools_table(perm_groups)
+            exec_tools = self._find_exec_tools(registry)
             perms = get_global_allowed_permissions()
             if not perms.execute and exec_tools:
                 shared_console.print("[yellow]⚠️  Warning: Execution tools (e.g., commands, code execution) are disabled. Use -x to enable them.[/yellow]")
-
         except Exception as e:
             shared_console.print(f"[red]Error loading tools: {e}[/red]")

janito/cli/chat_mode/toolbar.py

@@ -3,7 +3,6 @@ from janito.performance_collector import PerformanceCollector
 from janito.cli.config import config
 from janito import __version__ as VERSION
 
-
 def format_tokens(n, tag=None):
     if n is None:
         return "?"
@@ -15,95 +14,70 @@ def format_tokens(n, tag=None):
         val = f"{n/1000000:.1f}M"
     return f"<{tag}>{val}</{tag}>" if tag else val
 
-
 def assemble_first_line(provider_name, model_name, role, agent=None):
     return f" Janito {VERSION} | Provider: <provider>{provider_name}</provider> | Model: <model>{model_name}</model> | Role: <role>{role}</role>"
 
-
 def assemble_bindings_line(width, permissions=None):
-    # permissions: ToolPermissions or None
     def color_state(state):
-        if state == "on":
-            return 'on '
-        else:
-            return 'off'
+        return 'on ' if state == "on" else 'off'
     read_state = color_state("on" if getattr(permissions, "read", False) else "off")
     write_state = color_state("on" if getattr(permissions, "write", False) else "off")
     execute_state = color_state("on" if getattr(permissions, "execute", False) else "off")
     return (
         f" <key-label>CTRL-C</key-label>: Interrupt/Exit | "
-        f"<key-label>F1</key-label>: /restart | "
-                f"<key-label>F2</key-label>: <key-toggle-{('on' if not getattr(permissions, 'read', False) else 'off')}>/read {'on ' if not getattr(permissions, 'read', False) else 'off'}</key-toggle-{('on' if not getattr(permissions, 'read', False) else 'off')}> | "
-                f"<key-label>F3</key-label>: <key-toggle-{('on' if not getattr(permissions, 'write', False) else 'off')}>/write {'on ' if not getattr(permissions, 'write', False) else 'off'}</key-toggle-{('on' if not getattr(permissions, 'write', False) else 'off')}> | "
-                f"<key-label>F4</key-label>: <key-toggle-{('on' if not getattr(permissions, 'execute', False) else 'off')}>/execute {'on ' if not getattr(permissions, 'execute', False) else 'off'}</key-toggle-{('on' if not getattr(permissions, 'execute', False) else 'off')}> | "
+        f"<key-label>F2</key-label>: /restart | "
         f"<b>/help</b>: Help | "
         f"<key-label>F12</key-label>: Do It "
     )
 
+def _get_status(shell_state):
+    _support = getattr(shell_state, "_support", False)
+    _status = getattr(shell_state, "_status", None)
+    if not _support:
+        return None
+    if _status == "starting" or _status is None:
+        return _status
+    live_status = getattr(shell_state, "_live_status", None)
+    if live_status is not None:
+        return live_status
+    return _status
+
+def _get_agent_info(agent):
+    provider_name = agent.get_provider_name() if hasattr(agent, "get_provider_name") else "?"
+    model_name = agent.get_model_name() if hasattr(agent, "get_model_name") else "?"
+    role = agent.template_vars.get("role", "?") if hasattr(agent, "template_vars") else "?"
+    return provider_name, model_name, role
+
+def _get_permissions():
+    try:
+        from janito.tools.permissions import get_global_allowed_permissions
+        return get_global_allowed_permissions()
+    except Exception:
+        return None
+
+def _get_termweb_status_line(this__status, _port):
+    if this__status == "online" and _port:
+        return "\n<> Termweb </>Online"
+    elif this__status == "starting":
+        return "\n<> Termweb </>Starting"
+    elif this__status == "offline":
+        return "\n<> Termweb </>Offline"
+    return ""
 
 def get_toolbar_func(perf: PerformanceCollector, msg_count: int, shell_state):
     from prompt_toolkit.application.current import get_app
-    import importlib
-
     def get_toolbar():
         width = get_app().output.get_size().columns
-        provider_name = "?"
-        model_name = "?"
-        role = "?"
-        agent = shell_state.agent if hasattr(shell_state, "agent") else None
-        _support = getattr(shell_state, "_support", False)
-        _port = (
-            shell_state._port if hasattr(shell_state, "_port") else None
-        )
-        _status = (
-            shell_state._status
-            if hasattr(shell_state, "_status")
-            else None
-        )
-        # Use cached liveness check only (set by background thread in shell_state)
-        this__status = _status
-        if not _support:
-            this__status = None
-        elif _status == "starting" or _status is None:
-            this__status = _status
-        else:
-            live_status = (
-                shell_state._live_status
-                if hasattr(shell_state, "_live_status")
-                else None
-            )
-            if live_status is not None:
-                this__status = live_status
-        if agent is not None:
-            # Use agent API to get provider and model name
-            provider_name = (
-                agent.get_provider_name()
-                if hasattr(agent, "get_provider_name")
-                else "?"
-            )
-            model_name = (
-                agent.get_model_name() if hasattr(agent, "get_model_name") else "?"
-            )
-            if hasattr(agent, "template_vars"):
-                role = agent.template_vars.get("role", "?")
+        agent = getattr(shell_state, "agent", None)
+        this__status = _get_status(shell_state)
+        provider_name, model_name, role = _get_agent_info(agent) if agent is not None else ("?", "?", "?")
         usage = perf.get_last_request_usage()
         first_line = assemble_first_line(provider_name, model_name, role, agent=agent)
-
-        # Get current permissions for toolbar state
-        try:
-            from janito.tools.permissions import get_global_allowed_permissions
-            permissions = get_global_allowed_permissions()
-        except Exception:
-            permissions = None
+        permissions = _get_permissions()
         bindings_line = assemble_bindings_line(width, permissions)
         toolbar_text = first_line + "\n" + bindings_line
-        # Add  status if available, after the F12 line
-        if this__status == "online" and _port:
-            toolbar_text += f"\n<> Termweb </>Online"
-        elif this__status == "starting":
-            toolbar_text += "\n<> Termweb </>Starting"
-        elif this__status == "offline":
-            toolbar_text += "\n<> Termweb </>Offline"
+        _port = getattr(shell_state, "_port", None)
+        toolbar_text += _get_termweb_status_line(this__status, _port)
         return HTML(toolbar_text)
-
     return get_toolbar
+

janito/cli/cli_commands/list_tools.py

@@ -3,16 +3,49 @@ CLI Command: List available tools
 """
 
 
+def _group_tools_by_permission(tools, tool_instances):
+    read_only_tools = []
+    write_only_tools = []
+    read_write_tools = []
+    exec_tools = []
+    import inspect
+    for tool in tools:
+        inst = tool_instances.get(tool, None)
+        param_names = []
+        if inst and hasattr(inst, "run"):
+            sig = inspect.signature(inst.run)
+            param_names = [p for p in sig.parameters if p != "self"]
+        info = {
+            "name": tool,
+            "params": ", ".join(param_names),
+        }
+        perms = getattr(inst, "permissions", None)
+        if perms and perms.execute:
+            exec_tools.append(info)
+        elif perms and perms.read and perms.write:
+            read_write_tools.append(info)
+        elif perms and perms.read:
+            read_only_tools.append(info)
+        elif perms and perms.write:
+            write_only_tools.append(info)
+    return read_only_tools, write_only_tools, read_write_tools, exec_tools
+
+def _print_tools_table(console, title, tools_info):
+    from rich.table import Table
+    table = Table(title=title, show_header=True, header_style="bold", show_lines=False, box=None)
+    table.add_column("Name", style="cyan", no_wrap=True)
+    table.add_column("Parameters", style="yellow")
+    for info in tools_info:
+        table.add_row(info["name"], info["params"] or "-")
+    console.print(table)
+
 def handle_list_tools(args=None):
     from janito.tools.adapters.local.adapter import LocalToolsAdapter
     import janito.tools  # Ensure all tools are registered
-
-    # Determine permissions from args (default: all False)
     from janito.tools.tool_base import ToolPermissions
     read = getattr(args, "read", False) if args else False
     write = getattr(args, "write", False) if args else False
     execute = getattr(args, "exec", False) if args else False
-    # If no permissions are specified, assume user wants to list all tools
     if not (read or write or execute):
         read = write = execute = True
     from janito.tools.permissions import set_global_allowed_permissions
@@ -20,67 +53,19 @@ def handle_list_tools(args=None):
     registry = janito.tools.get_local_tools_adapter()
     tools = registry.list_tools()
     if tools:
-        from rich.table import Table
         from rich.console import Console
         console = Console()
-        # Get tool instances to check provides_execution and get info
         tool_instances = {t.tool_name: t for t in registry.get_tools()}
-        read_only_tools = []
-        write_only_tools = []
-        read_write_tools = []
-        exec_tools = []
-        for tool in tools:
-            inst = tool_instances.get(tool, None)
-            # Extract parameter names from run signature
-            param_names = []
-            if inst and hasattr(inst, "run"):
-                import inspect
-                sig = inspect.signature(inst.run)
-                param_names = [p for p in sig.parameters if p != "self"]
-            info = {
-                "name": tool,
-                "params": ", ".join(param_names),
-            }
-            perms = getattr(inst, "permissions", None)
-            if perms and perms.execute:
-                exec_tools.append(info)
-            elif perms and perms.read and perms.write:
-                read_write_tools.append(info)
-            elif perms and perms.read:
-                read_only_tools.append(info)
-            elif perms and perms.write:
-                write_only_tools.append(info)
-        # Print each group if not empty
+        read_only_tools, write_only_tools, read_write_tools, exec_tools = _group_tools_by_permission(tools, tool_instances)
         if read_only_tools:
-            table = Table(title="Read-only tools (-r)", show_header=True, header_style="bold", show_lines=False, box=None)
-            table.add_column("Name", style="cyan", no_wrap=True)
-            table.add_column("Parameters", style="yellow")
-            for info in read_only_tools:
-                table.add_row(info["name"], info["params"] or "-")
-            console.print(table)
+            _print_tools_table(console, "Read-only tools (-r)", read_only_tools)
         if write_only_tools:
-            table = Table(title="Write-only tools (-w)", show_header=True, header_style="bold", show_lines=False, box=None)
-            table.add_column("Name", style="cyan", no_wrap=True)
-            table.add_column("Parameters", style="yellow")
-            for info in write_only_tools:
-                table.add_row(info["name"], info["params"] or "-")
-            console.print(table)
+            _print_tools_table(console, "Write-only tools (-w)", write_only_tools)
         if read_write_tools:
-            table = Table(title="Read-Write tools (-rw)", show_header=True, header_style="bold", show_lines=False, box=None)
-            table.add_column("Name", style="cyan", no_wrap=True)
-            table.add_column("Parameters", style="yellow")
-            for info in read_write_tools:
-                table.add_row(info["name"], info["params"] or "-")
-            console.print(table)
+            _print_tools_table(console, "Read-Write tools (-rw)", read_write_tools)
         if exec_tools:
-            exec_table = Table(title="Execution tools (-x)", show_header=True, header_style="bold", show_lines=False, box=None)
-            exec_table.add_column("Name", style="cyan", no_wrap=True)
-            exec_table.add_column("Parameters", style="yellow")
-            for info in exec_tools:
-                exec_table.add_row(info["name"], info["params"] or "-")
-            console.print(exec_table)
+            _print_tools_table(console, "Execution tools (-x)", exec_tools)
     else:
         print("No tools registered.")
     import sys
-
     sys.exit(0)