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

janito/__init__.py

@@ -1 +1 @@
-__version__ = "1.6.0"
+__version__ = "1.7.0"

janito/agent/config.py

@@ -38,7 +38,7 @@ class FileConfig(BaseConfig):
 
     def load(self):
         if self.path.exists():
-            with open(self.path, "r") as f:
+            with open(self.path, "r", encoding="utf-8") as f:
                 self._data = json.load(f)
                 # Remove keys with value None (null in JSON)
                 self._data = {k: v for k, v in self._data.items() if v is not None}
@@ -48,7 +48,7 @@ class FileConfig(BaseConfig):
 
     def save(self):
         self.path.parent.mkdir(parents=True, exist_ok=True)
-        with open(self.path, "w") as f:
+        with open(self.path, "w", encoding="utf-8") as f:
             json.dump(self._data, f, indent=2)
 
 

janito/agent/config_defaults.py

@@ -8,5 +8,6 @@ CONFIG_DEFAULTS = {
     "temperature": 0.2,
     "max_tokens": 200000,
     "use_azure_openai": False,
+    "azure_openai_api_version": "2023-05-15",
     "interaction_style": "default",
 }

janito/agent/conversation.py

@@ -72,6 +72,7 @@ class ConversationHandler:
                     )
                 else:
                     response = retry_api_call(api_call)
+                    print("[DEBUG] OpenAI API raw response:", repr(response))
 
             if verbose_response:
                 pprint.pprint(response)
@@ -83,6 +84,8 @@ class ConversationHandler:
             usage = getattr(response, "usage", None)
             usage_info = (
                 {
+                    # DEBUG: Show usage extraction
+                    "_debug_raw_usage": getattr(response, "usage", None),
                     "prompt_tokens": getattr(usage, "prompt_tokens", None),
                     "completion_tokens": getattr(usage, "completion_tokens", None),
                     "total_tokens": getattr(usage, "total_tokens", None),
@@ -126,4 +129,4 @@ class ConversationHandler:
                         "content": tr["content"],
                     }
                 )
-        raise MaxRoundsExceededError("Max conversation rounds exceeded")
+        raise MaxRoundsExceededError(f"Max conversation rounds exceeded ({max_rounds})")

janito/agent/openai_client.py

@@ -72,6 +72,7 @@ class Agent:
         max_rounds=50,
         verbose_events=False,
         stream=False,
+        verbose_stream=False,
     ):
         """
         Start a chat conversation with the agent.
@@ -101,6 +102,7 @@ class Agent:
                     max_tokens=max_tokens,
                     verbose_events=verbose_events,
                     stream=stream,
+                    verbose_stream=verbose_stream,
                 )
             except ProviderError as e:
                 error_data = getattr(e, "error_data", {}) or {}

janito/agent/platform_discovery.py

@@ -0,0 +1,90 @@
+import platform
+import sys
+
+
+def detect_shell():
+    import os
+    import subprocess
+
+    shell_info = None
+
+    # 1. Detect shell (prefer Git Bash if detected)
+    if os.environ.get("MSYSTEM"):
+        shell_info = f"Git Bash ({os.environ.get('MSYSTEM')})"
+    # 2. Detect WSL (before PowerShell)
+    elif os.environ.get("WSL_DISTRO_NAME"):
+        shell = os.environ.get("SHELL")
+        shell_name = shell.split("/")[-1] if shell else "unknown"
+        distro = os.environ.get("WSL_DISTRO_NAME")
+        shell_info = f"{shell_name} (WSL: {distro})"
+    else:
+        # 3. Try to detect PowerShell by running $host.Name
+        try:
+            result = subprocess.run(
+                ["powershell.exe", "-NoProfile", "-Command", "$host.Name"],
+                capture_output=True,
+                text=True,
+                timeout=2,
+            )
+            if result.returncode == 0 and "ConsoleHost" in result.stdout:
+                shell_info = "PowerShell"
+            else:
+                shell_info = None
+        except Exception:
+            shell_info = None
+
+        # 4. If not PowerShell, check SHELL
+        if not shell_info:
+            shell = os.environ.get("SHELL")
+            if shell:
+                shell_info = shell
+            else:
+                # 5. If not, check COMSPEC for PowerShell or cmd.exe
+                comspec = os.environ.get("COMSPEC")
+                if comspec:
+                    if "powershell" in comspec.lower():
+                        shell_info = "PowerShell"
+                    elif "cmd" in comspec.lower():
+                        shell_info = "cmd.exe"
+                    else:
+                        shell_info = "Unknown shell"
+                else:
+                    shell_info = "Unknown shell"
+
+    # 6. Always append TERM and TERM_PROGRAM if present
+    term_env = os.environ.get("TERM")
+    if term_env:
+        shell_info += f" [TERM={term_env}]"
+
+    term_program = os.environ.get("TERM_PROGRAM")
+    if term_program:
+        shell_info += f" [TERM_PROGRAM={term_program}]"
+
+    return shell_info
+
+
+def get_platform_name():
+    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():
+    return platform.python_version()
+
+
+def is_windows():
+    return sys.platform.startswith("win")
+
+
+def is_linux():
+    return sys.platform.startswith("linux")
+
+
+def is_mac():
+    return sys.platform.startswith("darwin")

janito/agent/profile_manager.py

@@ -1,106 +1,48 @@
-from janito.agent.conversation import ConversationHandler
 from openai import OpenAI
-import jinja2
+import toml
+from string import Template
 from pathlib import Path
-import platform
-import os
+from janito.agent.platform_discovery import get_platform_name, get_python_version
+from janito.agent.platform_discovery import detect_shell
 
 
 class AgentProfileManager:
+    def _report_template_not_found(self, template_name, search_dirs):
+        import sys
+
+        search_dirs_str = ", ".join(str(d) for d in search_dirs)
+        print(
+            f"❗ TemplateNotFound: '{template_name}'\n  Searched paths: {search_dirs_str}",
+            file=sys.stderr,
+        )
+
     REFERER = "www.janito.dev"
     TITLE = "Janito"
 
+    def set_role(self, new_role):
+        """Set the agent's role and force prompt re-rendering."""
+        self.role = new_role
+        self.refresh_prompt()
+
     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)
+        # Determine which TOML profile to use
         if main_style == "technical":
-            main_template = "system_prompt_template_technical.j2"
+            main_template = profiles_dir / "system_prompt_template_technical.toml"
         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
+            main_template = profiles_dir / "system_prompt_template_default.toml"
+        # Gather context variables
+        platform_name = get_platform_name()
+        python_version = get_python_version()
+        shell_info = detect_shell()
         tech_txt_path = Path(".janito") / "tech.txt"
         tech_txt_exists = tech_txt_path.exists()
         tech_txt_content = ""
@@ -115,16 +57,58 @@ class AgentProfileManager:
             "platform": platform_name,
             "python_version": python_version,
             "shell_info": shell_info,
-            "tech_txt_exists": tech_txt_exists,
+            "tech_txt_exists": str(tech_txt_exists),
             "tech_txt_content": tech_txt_content,
         }
+
+        # Load and merge TOML templates (handle inheritance)
+        def load_toml_with_inheritance(path):
+            data = toml.load(path)
+            if "extends" in data:
+                base_path = profiles_dir / data["extends"]
+                base_data = toml.load(base_path)
+                base_data.update({k: v for k, v in data.items() if k != "extends"})
+                return base_data
+            return data
+
+        toml_data = load_toml_with_inheritance(main_template)
+        # Merge in feature-specific TOML if any
         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
+            feature_template = profiles_dir / f"system_prompt_template_{feature}.toml"
+            if feature_template.exists():
+                feature_data = toml.load(feature_template)
+                toml_data.update(
+                    {k: v for k, v in feature_data.items() if k != "extends"}
+                )
+
+        # Render the TOML structure as a prompt string
+        def render_section(section):
+            if isinstance(section, dict):
+                out = []
+                for k, v in section.items():
+                    if isinstance(v, list):
+                        out.append(f"{k}:")
+                        for item in v:
+                            out.append(f"  - {item}")
+                    else:
+                        out.append(f"{k}: {v}")
+                return "\n".join(out)
+            elif isinstance(section, list):
+                return "\n".join(f"- {item}" for item in section)
+            else:
+                return str(section)
+
+        prompt_sections = []
+        for section, value in toml_data.items():
+            if section == "extends":
+                continue
+            prompt_sections.append(f"[{section}]")
+            prompt_sections.append(render_section(value))
+            prompt_sections.append("")
+        prompt_template = "\n".join(prompt_sections)
+        # Substitute variables
+        prompt = Template(prompt_template).safe_substitute(context)
+        return prompt
 
     def __init__(
         self,
@@ -161,7 +145,15 @@ class AgentProfileManager:
                 api_key=api_key,
                 default_headers={"HTTP-Referer": self.REFERER, "X-Title": self.TITLE},
             )
-        self.agent = ConversationHandler(self.client, model)
+        from janito.agent.openai_client import Agent
+
+        self.agent = Agent(
+            api_key=api_key,
+            model=model,
+            base_url=base_url,
+            use_azure_openai=use_azure_openai,
+            azure_openai_api_version=azure_openai_api_version,
+        )
         self.system_prompt_template = None
 
     def refresh_prompt(self):

janito/agent/rich_message_handler.py

@@ -1,64 +1,72 @@
-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
+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", "")
+
+        def _remove_surrogates(text):
+            return "".join(c for c in text if not 0xD800 <= ord(c) <= 0xDFFF)
+
+        safe_message = (
+            _remove_surrogates(message) if isinstance(message, str) else message
+        )
+
+        if trust and msg_type != "content":
+            return  # Suppress all except content
+        if msg_type == "content":
+            self.console.print(Markdown(safe_message))
+        elif msg_type == "info":
+            self.console.print(safe_message, style="cyan", end="")
+        elif msg_type == "success":
+            self.console.print(safe_message, style="bold green", end="\n")
+        elif msg_type == "error":
+            self.console.print(safe_message, style="bold red", end="\n")
+        elif msg_type == "progress":
+            self._handle_progress(safe_message)
+        elif msg_type == "warning":
+            self.console.print(safe_message, style="bold yellow", end="\n")
+        elif msg_type == "stdout":
+            from rich.text import Text
+
+            self.console.print(
+                Text(safe_message, style="on #003300", no_wrap=True, overflow=None),
+                end="",
+            )
+        elif msg_type == "stderr":
+            from rich.text import Text
+
+            self.console.print(
+                Text(safe_message, style="on #330000", no_wrap=True, overflow=None),
+                end="",
+            )
+        else:
+            # Ignore unsupported message types silently
+            return

janito/agent/templates/profiles/system_prompt_template_base.toml

@@ -0,0 +1,76 @@
+# Base system prompt template for Janito agent styles
+[agent_profile]
+role = "${role}"
+description = "Agent for analysis and development tool operating on files and directories using text-based operations."
+
+[platform]
+platform = "${platform}"
+python_version = "${python_version}"
+shell_info = "${shell_info}"
+notes = """
+- Always pay careful attention to platform-specific path conventions (e.g., path separator, drive letters, case sensitivity), Python version differences, and shell/command syntax when reading, writing, or executing files and commands.
+- If running in a non-standard shell (such as Git Bash or WSL on Windows), be extra cautious about path and command compatibility.
+"""
+
+[tech]
+exists = "${tech_txt_exists}"
+content = """
+${tech_txt_content}
+"""
+
+[operational_workflow]
+steps = """
+- Provide a concise plan before calling any tool.
+- Plan changes only after gathering all the necessary information.
+- Always execute the plan immediately after presenting it, unless the user requests otherwise.
+"""
+
+[safety_guidelines]
+steps = """
+- Always update all references and validate the system before removing or renaming files.
+- Only remove or rename files after all dependent code has been updated and validated.
+- Prefer the following order for destructive operations:
+  1. Update all imports/references.
+  2. Validate the changes using the tools available to test the type of file changed.
+  3. Remove or rename the file.
+  4. Re-validate the system.
+- Roll back changes if any validation step fails.
+"""
+
+[context]
+steps = """
+- Before answering, always examine the contents of files that are directly related to the user's question or request, and explore the project structure to understand existing directories, files, and their purposes.
+- Always review `README_structure.txt` before conducting file-specific searches.
+- Unless specified otherwise, look for the files that match the questions context.
+- Explore files that might be relevant to the current task.
+- Before providing a detailed plan, always examine the contents of files that are directly related to the user's question or request.
+"""
+
+[analysis]
+steps = """
+- In case of missing code or functions, look into the .bak files and check git diff/history for recent changes.
+"""
+
+[decision_policy]
+steps = """
+- Whenever there is uncertainty, ambiguity, missing information, or multiple valid options, request clarification or input from the user. Otherwise, proceed and inform the user of the decision_policy made.
+- When making changes, prefer optimal, effective, and natural edits. Perform larger refactors, reorganizations, or multi-region edits when they lead to better results, rather than restricting to minimal or single-region changes. Avoid unnecessary splitting of text ranges. Validate changes using available tools before proceeding.
+"""
+
+[finalization]
+steps = """
+- Review the README content if there are user-exposed or public API changes.
+- Update documentation and metadata (e.g., README_structure.txt) to reflect new or modified files.
+- When updating documentation, recommend (when appropriate) adding a footer or note such as: _'generated by janito.dev'_
+"""
+
+[interaction_mode]
+current = "${interaction_mode}"
+notes = """
+- Always adapt your clarification and interaction strategy to the current mode.
+"""
+
+[function_call_summary]
+steps = """
+- Before executing any function calls, emit a concise summary message describing the planned actions, reasoning, and expected outcomes.
+"""

janito/agent/templates/profiles/system_prompt_template_default.toml

@@ -0,0 +1,3 @@
+# Inherits from system_prompt_template_base.toml
+extends = "system_prompt_template_base.toml"
+# Default style: no overrides, inherits all blocks from base

janito/agent/templates/profiles/system_prompt_template_technical.toml

@@ -0,0 +1,13 @@
+# Inherits from system_prompt_template_base.toml
+extends = "system_prompt_template_base.toml"
+
+[agent_profile]
+description = "This Agent follows its Agent Profile, including system settings, role, and toolchain constraints."
+
+[technical_workflow]
+steps = """
+- Enumerate and validate the current file system state before any operation.
+- Use the tools available to test and validate the type of file changed, inferring dependencies, side effects, and potential conflicts.
+- Explicitly handle errors, edge cases, and race conditions. Log all exceptions and recovery actions.
+- Maintain traceability: document all actions, decision_policys, and state transitions.
+"""

janito/agent/tests/test_prompt_toml.py

@@ -0,0 +1,61 @@
+from janito.agent.profile_manager import AgentProfileManager
+
+
+def test_prompt_default(monkeypatch):
+    mgr = AgentProfileManager(
+        api_key="sk-test",
+        model="gpt-test",
+        role="software engineer",
+        interaction_style="default",
+        interaction_mode="chat",
+        verbose_tools=False,
+        base_url="https://test",
+        azure_openai_api_version="2023-05-15",
+        use_azure_openai=False,
+    )
+    prompt = mgr.render_prompt()
+    assert "[agent_profile]" in prompt
+    assert "software engineer" in prompt
+    assert "[platform]" in prompt
+    assert "Always pay careful attention" in prompt
+    assert "[function_call_summary]" in prompt
+
+
+def test_prompt_technical(monkeypatch):
+    mgr = AgentProfileManager(
+        api_key="sk-test",
+        model="gpt-test",
+        role="software engineer",
+        interaction_style="technical",
+        interaction_mode="chat",
+        verbose_tools=False,
+        base_url="https://test",
+        azure_openai_api_version="2023-05-15",
+        use_azure_openai=False,
+    )
+    prompt = mgr.render_prompt()
+    assert "[agent_profile]" in prompt
+    assert "strict adherence" in prompt
+    assert "[technical_workflow]" in prompt
+    assert "Enumerate and validate the current file system state" in prompt
+    assert "[function_call_summary]" in prompt
+
+
+def test_prompt_inheritance(monkeypatch):
+    mgr = AgentProfileManager(
+        api_key="sk-test",
+        model="gpt-test",
+        role="software engineer",
+        interaction_style="technical",
+        interaction_mode="chat",
+        verbose_tools=False,
+        base_url="https://test",
+        azure_openai_api_version="2023-05-15",
+        use_azure_openai=False,
+    )
+    prompt = mgr.render_prompt()
+    # Should inherit context, analysis, etc. from base
+    assert "[context]" in prompt
+    assert "[analysis]" in prompt
+    assert "[decision_policy]" in prompt
+    assert "[finalization]" in prompt