janito 1.5.2__py3-none-any.whl → 1.6.0__py3-none-any.whl

janito/agent/{agent.py → openai_client.py}

@@ -2,7 +2,9 @@
 
 import time
 from openai import OpenAI
-from janito.agent.conversation import ConversationHandler, ProviderError
+from janito.agent.conversation import ConversationHandler
+from janito.agent.conversation_exceptions import ProviderError
+
 
 class Agent:
     """Agent capable of handling conversations and tool calls."""
@@ -14,11 +16,11 @@ class Agent:
         self,
         api_key: str,
         model: str = None,
-        system_prompt: str | None = None,
+        system_prompt_template: str | None = None,
         verbose_tools: bool = False,
         base_url: str = "https://openrouter.ai/api/v1",
         azure_openai_api_version: str = "2023-05-15",
-        use_azure_openai: bool = False
+        use_azure_openai: bool = False,
     ):
         """
         Initialize Agent.
@@ -26,7 +28,7 @@ class Agent:
         Args:
             api_key: API key for OpenAI-compatible service.
             model: Model name to use.
-            system_prompt: Optional system prompt override.
+            system_prompt_template: Optional system prompt override.
             verbose_tools: Enable verbose tool call logging.
             base_url: API base URL.
             azure_openai_api_version: Azure OpenAI API version (default: "2023-05-15").
@@ -34,10 +36,11 @@ class Agent:
         """
         self.api_key = api_key
         self.model = model
-        self.system_prompt = system_prompt
+        self.system_prompt_template = system_prompt_template
         if use_azure_openai:
             # Import inside conditional to avoid requiring AzureOpenAI unless needed
             from openai import AzureOpenAI
+
             self.client = AzureOpenAI(
                 api_key=api_key,
                 azure_endpoint=base_url,
@@ -47,22 +50,45 @@ class Agent:
             self.client = OpenAI(
                 base_url=base_url,
                 api_key=api_key,
-                default_headers={
-                    "HTTP-Referer": self.REFERER,
-                    "X-Title": self.TITLE
-                }
+                default_headers={"HTTP-Referer": self.REFERER, "X-Title": self.TITLE},
             )
 
         self.conversation_handler = ConversationHandler(
-            self.client, self.model, 
+            self.client,
+            self.model,
         )
 
     @property
     def usage_history(self):
         return self.conversation_handler.usage_history
 
-    def chat(self, messages, message_handler=None, verbose_response=False, spinner=False, max_tokens=None, max_rounds=50):
+    def chat(
+        self,
+        messages,
+        message_handler=None,
+        verbose_response=False,
+        spinner=False,
+        max_tokens=None,
+        max_rounds=50,
+        verbose_events=False,
+        stream=False,
+    ):
+        """
+        Start a chat conversation with the agent.
 
+        Args:
+            messages: List of message dicts.
+            message_handler: Optional handler for streaming or event messages.
+            verbose_response: Print full response for debugging.
+            spinner: Show spinner during request.
+            max_tokens: Max tokens for completion.
+            max_rounds: Max conversation rounds.
+            verbose_events: Print all events for debugging.
+            stream: If True, enable OpenAI streaming mode (yields tokens incrementally).
+        Returns:
+            If stream=False: dict with 'content', 'usage', and 'usage_history'.
+            If stream=True: generator yielding content chunks or events.
+        """
         max_retries = 5
         for attempt in range(1, max_retries + 1):
             try:
@@ -72,21 +98,27 @@ class Agent:
                     message_handler=message_handler,
                     verbose_response=verbose_response,
                     spinner=spinner,
-                    max_tokens=max_tokens
+                    max_tokens=max_tokens,
+                    verbose_events=verbose_events,
+                    stream=stream,
                 )
             except ProviderError as e:
-                error_data = getattr(e, 'error_data', {}) or {}
-                code = error_data.get('code', '')
+                error_data = getattr(e, "error_data", {}) or {}
+                code = error_data.get("code", "")
                 # Retry only on 5xx errors
                 if isinstance(code, int) and 500 <= code < 600:
                     pass
-                elif isinstance(code, str) and code.isdigit() and 500 <= int(code) < 600:
+                elif (
+                    isinstance(code, str) and code.isdigit() and 500 <= int(code) < 600
+                ):
                     code = int(code)
                 else:
                     raise
 
                 if attempt < max_retries:
-                    print(f"ProviderError with 5xx code encountered (attempt {attempt}/{max_retries}). Retrying in 5 seconds...")
+                    print(
+                        f"ProviderError with 5xx code encountered (attempt {attempt}/{max_retries}). Retrying in 5 seconds..."
+                    )
                     time.sleep(5)
                 else:
                     print("Max retries reached. Raising error.")

janito/agent/openai_schema_generator.py

@@ -5,7 +5,6 @@ MUST BE IMPLEMENTED:
 - backward compatibility is not required
 """
 
-
 import inspect
 import re
 import typing
@@ -19,10 +18,23 @@ PYTHON_TYPE_TO_JSON = {
     dict: "object",
 }
 
+
+def _type_to_json_schema(annotation):
+    if hasattr(annotation, "__origin__"):
+        if annotation.__origin__ is list or annotation.__origin__ is typing.List:
+            return {
+                "type": "array",
+                "items": _type_to_json_schema(annotation.__args__[0]),
+            }
+        if annotation.__origin__ is dict or annotation.__origin__ is typing.Dict:
+            return {"type": "object"}
+    return {"type": PYTHON_TYPE_TO_JSON.get(annotation, "string")}
+
+
 def _parse_docstring(docstring: str):
     """
     Parses a docstring to extract summary, parameter descriptions, and return description.
-    Expects Google or NumPy style docstrings.
+    Accepts Google, NumPy, and relaxed formats.
     Returns: summary, {param: description}, return_description
     """
     if not docstring:
@@ -33,52 +45,44 @@ def _parse_docstring(docstring: str):
     return_desc = ""
     in_params = False
     in_returns = False
+    param_section_headers = ("args", "arguments", "params", "parameters")
     for line in lines[1:]:
-        l = line.strip()
-        if l.lower().startswith(("args:", "parameters:")):
+        stripped_line = line.strip()
+        if any(
+            stripped_line.lower().startswith(h + ":") or stripped_line.lower() == h
+            for h in param_section_headers
+        ):
             in_params = True
             in_returns = False
             continue
-        if l.lower().startswith("returns:"):
+        if (
+            stripped_line.lower().startswith("returns:")
+            or stripped_line.lower() == "returns"
+        ):
             in_returns = True
             in_params = False
             continue
         if in_params:
-            m = re.match(r"([a-zA-Z_][a-zA-Z0-9_]*)(?: \(([^)]+)\))?: (.+)", l)
+            # Accept: name: desc, name (type): desc, name - desc, name desc
+            m = re.match(
+                r"([a-zA-Z_][a-zA-Z0-9_]*)\s*(?:\(([^)]+)\))?\s*[:\-]?\s*(.+)",
+                stripped_line,
+            )
             if m:
                 param, _, desc = m.groups()
                 param_descs[param] = desc.strip()
-            elif l and l[0] != "-":
+            elif stripped_line and stripped_line[0] != "-":
                 # Continuation of previous param
                 if param_descs:
                     last = list(param_descs)[-1]
-                    param_descs[last] += " " + l
+                    param_descs[last] += " " + stripped_line
         elif in_returns:
-            if l:
-                return_desc += (" " if return_desc else "") + l
+            if stripped_line:
+                return_desc += (" " if return_desc else "") + stripped_line
     return summary, param_descs, return_desc
 
-def _type_to_json_schema(tp):
-    # Handle typing.Optional, typing.Union, typing.List, etc.
-    origin = typing.get_origin(tp)
-    args = typing.get_args(tp)
-    if origin is None:
-        return {"type": PYTHON_TYPE_TO_JSON.get(tp, "string")}
-    if origin is list or origin is typing.List:
-        item_type = args[0] if args else str
-        return {"type": "array", "items": _type_to_json_schema(item_type)}
-    if origin is dict or origin is typing.Dict:
-        return {"type": "object"}
-    if origin is typing.Union:
-        # Optional[...] is Union[..., NoneType]
-        non_none = [a for a in args if a is not type(None)]
-        if len(non_none) == 1:
-            return _type_to_json_schema(non_none[0])
-        # Otherwise, fallback
-        return {"type": "string"}
-    return {"type": "string"}
 
-def generate_openai_function_schema(func, tool_name: str):
+def generate_openai_function_schema(func, tool_name: str, tool_class=None):
     """
     Generates an OpenAI-compatible function schema for a callable.
     Raises ValueError if the return type is not explicitly str.
@@ -86,13 +90,25 @@ def generate_openai_function_schema(func, tool_name: str):
     sig = inspect.signature(func)
     # Enforce explicit str return type
     if sig.return_annotation is inspect._empty or sig.return_annotation is not str:
-        raise ValueError(f"Tool '{tool_name}' must have an explicit return type of 'str'. Found: {sig.return_annotation}")
-    docstring = func.__doc__
-    summary, param_descs, _ = _parse_docstring(docstring)
+        raise ValueError(
+            f"Tool '{tool_name}' must have an explicit return type of 'str'. Found: {sig.return_annotation}"
+        )
+    # Only use the class docstring for schema generation
+    class_doc = tool_class.__doc__.strip() if tool_class and tool_class.__doc__ else ""
+    summary, param_descs, return_desc = _parse_docstring(class_doc)
+    description = summary
+    if return_desc:
+        description += f"\n\nReturns: {return_desc}"
     # Check that all parameters in the signature have documentation
-    undocumented = [name for name, param in sig.parameters.items() if name != "self" and name not in param_descs]
+    undocumented = [
+        name
+        for name, param in sig.parameters.items()
+        if name != "self" and name not in param_descs
+    ]
     if undocumented:
-        raise ValueError(f"Tool '{tool_name}' is missing docstring documentation for parameter(s): {', '.join(undocumented)}")
+        raise ValueError(
+            f"Tool '{tool_name}' is missing docstring documentation for parameter(s): {', '.join(undocumented)}"
+        )
     properties = {}
     required = []
     for name, param in sig.parameters.items():
@@ -107,10 +123,10 @@ def generate_openai_function_schema(func, tool_name: str):
             required.append(name)
     return {
         "name": tool_name,
-        "description": summary,
+        "description": description,
         "parameters": {
             "type": "object",
             "properties": properties,
             "required": required,
-        }
+        },
     }

janito/agent/profile_manager.py

@@ -0,0 +1,172 @@
+from janito.agent.conversation import ConversationHandler
+from openai import OpenAI
+import jinja2
+from pathlib import Path
+import platform
+import os
+
+
+class AgentProfileManager:
+    REFERER = "www.janito.dev"
+    TITLE = "Janito"
+
+    def parse_style_string(self, style: str):
+        if "-" in style:
+            parts = style.split("-")
+            return parts[0], parts[1:]
+        return style, []
+
+    def get_platform_name(self):
+        sys_platform = platform.system().lower()
+        if sys_platform.startswith("win"):
+            return "windows"
+        elif sys_platform.startswith("linux"):
+            return "linux"
+        elif sys_platform.startswith("darwin"):
+            return "darwin"
+        return sys_platform
+
+    def get_python_version(self):
+        return platform.python_version()
+
+    def get_shell_info(self):
+        shell = os.environ.get("SHELL")
+        term = os.environ.get("TERM")
+        term_program = os.environ.get("TERM_PROGRAM")
+        if shell:
+            info = shell
+        elif os.environ.get("MSYSTEM"):
+            info = f"Git Bash ({os.environ.get('MSYSTEM')})"
+        elif os.environ.get("WSL_DISTRO_NAME"):
+            info = f"WSL ({os.environ.get('WSL_DISTRO_NAME')})"
+        else:
+            comspec = os.environ.get("COMSPEC")
+            if comspec:
+                if "powershell" in comspec.lower():
+                    info = "PowerShell"
+                elif "cmd" in comspec.lower():
+                    info = "cmd.exe"
+                else:
+                    info = "Unknown shell"
+            else:
+                info = "Unknown shell"
+        if term:
+            info += f", TERM={term}"
+        if term_program and term_program.lower() == "vscode":
+            info += ", running in VSCode"
+        home_dir = os.path.expanduser("~")
+        if home_dir:
+            info += f", HOME={home_dir}"
+        return info
+        return "unknown"
+
+    def render_prompt(self):
+        main_style, features = self.parse_style_string(self.interaction_style)
+        base_dir = Path(__file__).parent / "templates"
+        profiles_dir = base_dir / "profiles"
+        features_dir = base_dir / "features"
+        loader = jinja2.ChoiceLoader(
+            [
+                jinja2.FileSystemLoader(str(profiles_dir)),
+                jinja2.FileSystemLoader(str(features_dir)),
+            ]
+        )
+        env = jinja2.Environment(loader=loader)
+        if main_style == "technical":
+            main_template = "system_prompt_template_technical.j2"
+        else:
+            main_template = "system_prompt_template.j2"
+        platform_name = self.get_platform_name()
+        python_version = self.get_python_version()
+        shell_info = self.get_shell_info()
+        if not features:
+            # Inject tech.txt existence and content
+            tech_txt_path = Path(".janito") / "tech.txt"
+            tech_txt_exists = tech_txt_path.exists()
+            tech_txt_content = ""
+            if tech_txt_exists:
+                try:
+                    tech_txt_content = tech_txt_path.read_text(encoding="utf-8")
+                except Exception:
+                    tech_txt_content = "⚠️ Error reading janito/tech.txt."
+            template = env.get_template(main_template)
+            return template.render(
+                role=self.role,
+                interaction_mode=self.interaction_mode,
+                platform=platform_name,
+                python_version=python_version,
+                shell_info=shell_info,
+                tech_txt_exists=tech_txt_exists,
+                tech_txt_content=tech_txt_content,
+            )
+        parent_template = main_template
+        # Inject tech.txt existence and content for feature templates as well
+        tech_txt_path = Path(".janito") / "tech.txt"
+        tech_txt_exists = tech_txt_path.exists()
+        tech_txt_content = ""
+        if tech_txt_exists:
+            try:
+                tech_txt_content = tech_txt_path.read_text(encoding="utf-8")
+            except Exception:
+                tech_txt_content = "⚠️ Error reading janito/tech.txt."
+        context = {
+            "role": self.role,
+            "interaction_mode": self.interaction_mode,
+            "platform": platform_name,
+            "python_version": python_version,
+            "shell_info": shell_info,
+            "tech_txt_exists": tech_txt_exists,
+            "tech_txt_content": tech_txt_content,
+        }
+        for feature in features:
+            feature_template = f"system_prompt_template_{feature}.j2"
+            template = env.get_template(feature_template)
+            context["parent_template"] = parent_template
+            rendered = template.render(**context)
+            parent_template = feature_template
+        return rendered
+
+    def __init__(
+        self,
+        api_key,
+        model,
+        role,
+        interaction_style,
+        interaction_mode,
+        verbose_tools,
+        base_url,
+        azure_openai_api_version,
+        use_azure_openai,
+    ):
+        self.api_key = api_key
+        self.model = model
+        self.role = role
+        self.interaction_style = interaction_style
+        self.interaction_mode = interaction_mode
+        self.verbose_tools = verbose_tools
+        self.base_url = base_url
+        self.azure_openai_api_version = azure_openai_api_version
+        self.use_azure_openai = use_azure_openai
+        if use_azure_openai:
+            from openai import AzureOpenAI
+
+            self.client = AzureOpenAI(
+                api_key=api_key,
+                azure_endpoint=base_url,
+                api_version=azure_openai_api_version,
+            )
+        else:
+            self.client = OpenAI(
+                base_url=base_url,
+                api_key=api_key,
+                default_headers={"HTTP-Referer": self.REFERER, "X-Title": self.TITLE},
+            )
+        self.agent = ConversationHandler(self.client, model)
+        self.system_prompt_template = None
+
+    def refresh_prompt(self):
+        self.system_prompt_template = self.render_prompt()
+        self.agent.system_prompt_template = self.system_prompt_template
+
+
+# All prompt rendering is now handled by AgentProfileManager.

janito/agent/queued_message_handler.py

@@ -4,29 +4,28 @@ class QueuedMessageHandler:
 
     def handle_message(self, msg, msg_type=None):
         # Unified: send content (agent/LLM) messages to the frontend via queue
-        if isinstance(msg, dict):
-            msg_type = msg.get('type', 'info')
-            # For tool_call and tool_result, print and forward the full dict
-            if msg_type in ("tool_call", "tool_result"):
-                print(f"[QueuedMessageHandler] {msg_type}: {msg}")
-                self._queue.put(msg)
-                return
-            message = msg.get('message', '')
-        else:
-            message = msg
-            msg_type = msg_type or 'info'
+        if not isinstance(msg, dict):
+            raise TypeError(
+                f"QueuedMessageHandler.handle_message expects a dict with 'type' and 'message', got {type(msg)}: {msg!r}"
+            )
+        msg_type = msg.get("type", "info")
+        # For tool_call and tool_result, print and forward the full dict
+        if msg_type in ("tool_call", "tool_result"):
+            print(f"[QueuedMessageHandler] {msg_type}: {msg}")
+            self._queue.put(msg)
+            return
+        message = msg.get("message", "")
         # For normal agent/user/info messages, emit type 'content' for frontend compatibility
         print(f"[QueuedMessageHandler] {msg_type}: {message}")
         if msg_type == "content":
             self._queue.put({"type": "content", "content": message})
         elif msg_type == "info":
             out = {"type": "info", "message": message}
-            if 'tool' in msg:
+            if "tool" in msg:
                 out["tool"] = msg["tool"]
             self._queue.put(out)
         else:
             out = {"type": msg_type, "message": message}
-            if 'tool' in msg:
+            if "tool" in msg:
                 out["tool"] = msg["tool"]
             self._queue.put(out)
-

janito/agent/rich_live.py

@@ -0,0 +1,32 @@
+from rich.live import Live
+from rich.markdown import Markdown
+from rich.console import Console
+
+
+class LiveMarkdownDisplay:
+    def __init__(self, console=None):
+        self.console = console or Console()
+        self._accumulated = ""
+        self._live = None
+
+    def start(self):
+        self._live = Live(
+            Markdown(self._accumulated), console=self.console, refresh_per_second=8
+        )
+        self._live.__enter__()
+
+    def update(self, part):
+        self._accumulated += part
+        # Only re-render on newlines for efficiency
+        if "\n" in part:
+            self._live.update(Markdown(self._accumulated))
+
+    def stop(self):
+        if self._live:
+            self._live.__exit__(None, None, None)
+            self._live = None
+
+    def reset(self):
+        self._accumulated = ""
+        if self._live:
+            self._live.update(Markdown(self._accumulated))

janito/agent/rich_message_handler.py

@@ -0,0 +1,64 @@
+from rich.console import Console
+from janito.agent.runtime_config import runtime_config, unified_config
+
+console = Console()
+
+
+class RichMessageHandler:
+    """
+    Unified message handler for all output (tool, agent, system) using Rich for styled output.
+    """
+
+    def __init__(self):
+        self.console = console
+
+    def handle_message(self, msg, msg_type=None):
+        """
+        Handles a dict with 'type' and 'message'.
+        All messages must be dicts. Raises if not.
+        """
+        # Check trust config: suppress all output except 'content' if enabled
+        trust = runtime_config.get("trust")
+        if trust is None:
+            trust = unified_config.get("trust", False)
+
+        from rich.markdown import Markdown
+
+        if not isinstance(msg, dict):
+            raise TypeError(
+                f"RichMessageHandler.handle_message expects a dict with 'type' and 'message', got {type(msg)}: {msg!r}"
+            )
+
+        msg_type = msg.get("type", "info")
+        message = msg.get("message", "")
+        if trust and msg_type != "content":
+            return  # Suppress all except content
+        if msg_type == "content":
+            self.console.print(Markdown(message))
+        elif msg_type == "info":
+            self.console.print(message, style="cyan", end="")
+        elif msg_type == "success":
+            self.console.print(message, style="bold green", end="\n")
+        elif msg_type == "error":
+            self.console.print(message, style="bold red", end="\n")
+        elif msg_type == "progress":
+            self._handle_progress(message)
+        elif msg_type == "warning":
+            self.console.print(message, style="bold yellow", end="\n")
+        elif msg_type == "stdout":
+            from rich.text import Text
+
+            self.console.print(
+                Text(message, style="on #003300", no_wrap=True, overflow=None),
+                end="",
+            )
+        elif msg_type == "stderr":
+            from rich.text import Text
+
+            self.console.print(
+                Text(message, style="on #330000", no_wrap=True, overflow=None),
+                end="",
+            )
+        else:
+            # Ignore unsupported message types silently
+            return

janito/agent/runtime_config.py

@@ -1,22 +1,26 @@
 from .config import BaseConfig, effective_config
 
+
 class RuntimeConfig(BaseConfig):
     """In-memory only config, reset on restart"""
+
     pass
 
+
 runtime_config = RuntimeConfig()
 
+
 class UnifiedConfig:
     """
     Config lookup order:
     1. runtime_config (in-memory, highest priority)
     2. effective_config (local/global, read-only)
     """
+
     def __init__(self, runtime_cfg, effective_cfg):
         self.runtime_cfg = runtime_cfg
         self.effective_cfg = effective_cfg
 
-
     def get(self, key, default=None):
         val = self.runtime_cfg.get(key)
         if val is not None:
@@ -28,4 +32,5 @@ class UnifiedConfig:
         merged.update(self.runtime_cfg.all())
         return merged
 
+
 unified_config = UnifiedConfig(runtime_config, effective_config)

janito/agent/{tools/tool_base.py → tool_base.py}

@@ -1,9 +1,11 @@
 from abc import ABC, abstractmethod
 
+
 class ToolBase(ABC):
     """
     Base class for all tools. Inherit from this class to implement a new tool.
     """
+
     def __init__(self):
         self.progress_messages = []
         self._progress_callback = None  # Will be set by ToolHandler if available
@@ -25,9 +27,6 @@ class ToolBase(ABC):
         Returns:
             Any: The result of the tool execution.
         """
-        """
-        Trigger the tool's action. Must be implemented by subclasses.
-        """
         pass
 
     def update_progress(self, progress: dict):
@@ -35,17 +34,25 @@ class ToolBase(ABC):
         Report progress. Subclasses can override this to customize progress reporting.
         """
         self.progress_messages.append(progress)
-        if hasattr(self, '_progress_callback') and self._progress_callback:
+        if hasattr(self, "_progress_callback") and self._progress_callback:
             self._progress_callback(progress)
 
     def report_info(self, message: str):
-        self.update_progress({"type": "info", "tool": self.__class__.__name__, "message": message})
+        self.update_progress(
+            {"type": "info", "tool": self.__class__.__name__, "message": message}
+        )
 
     def report_success(self, message: str):
-        self.update_progress({"type": "success", "tool": self.__class__.__name__, "message": message})
+        self.update_progress(
+            {"type": "success", "tool": self.__class__.__name__, "message": message}
+        )
 
     def report_error(self, message: str):
-        self.update_progress({"type": "error", "tool": self.__class__.__name__, "message": message})
+        self.update_progress(
+            {"type": "error", "tool": self.__class__.__name__, "message": message}
+        )
 
     def report_warning(self, message: str):
-        self.update_progress({"type": "warning", "tool": self.__class__.__name__, "message": message})
+        self.update_progress(
+            {"type": "warning", "tool": self.__class__.__name__, "message": message}
+        )