janito 1.10.0__tar.gz → 1.11.1__tar.gz

{janito-1.10.0/janito.egg-info → janito-1.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 1.10.0
+Version: 1.11.1
 Summary: Natural Language Coding Agent,
 Author-email: João Pinto <joao.pinto@gmail.com>
 License-Expression: MIT

janito-1.11.1/janito/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.11.0"

janito-1.11.1/janito/agent/conversation_api.py

@@ -0,0 +1,306 @@
+"""
+Handles OpenAI API calls and retry logic for conversation.
+"""
+
+import time
+from janito.i18n import tr
+import json
+from janito.agent.runtime_config import runtime_config
+from janito.agent.tool_registry import get_tool_schemas
+from janito.agent.conversation_exceptions import NoToolSupportError, EmptyResponseError
+from janito.agent.api_exceptions import ApiError
+from rich.console import Console
+from rich.status import Status
+
+console = Console()
+
+
+def _sanitize_utf8_surrogates(obj):
+    if isinstance(obj, dict):
+        return {k: _sanitize_utf8_surrogates(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [_sanitize_utf8_surrogates(i) for i in obj]
+    elif isinstance(obj, str):
+        return obj.encode("utf-8", "surrogatepass").decode("utf-8", "ignore")
+    else:
+        return obj
+
+
+def get_openai_response(
+    client, model, messages, max_tokens, tools=None, tool_choice=None, temperature=None
+):
+    """OpenAI API call."""
+    messages = _sanitize_utf8_surrogates(messages)
+    from janito.agent.conversation_exceptions import ProviderError
+
+    if runtime_config.get("vanilla_mode", False):
+        response = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            max_tokens=max_tokens,
+        )
+    else:
+        response = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            tools=tools or get_tool_schemas(),
+            tool_choice=tool_choice or "auto",
+            temperature=temperature if temperature is not None else 0.2,
+            max_tokens=max_tokens,
+        )
+    # Explicitly check for missing or empty choices (API/LLM error)
+    if (
+        not hasattr(response, "choices")
+        or response.choices is None
+        or len(response.choices) == 0
+    ):
+        # Always check for error before raising ProviderError
+        error = getattr(response, "error", None)
+        if error:
+            print(f"ApiError: {error.get('message', error)}")
+            print(f"Full error object: {error}")
+            print(f"Raw response: {response}")
+            raise ApiError(error.get("message", str(error)))
+        raise ProviderError(
+            f"No choices in response; possible API or LLM error. Raw response: {response!r}",
+            {"code": 502, "raw_response": str(response)},
+        )
+    return response
+
+
+def _extract_status_and_retry_after(e, error_message):
+    status_code = None
+    retry_after = None
+    if hasattr(e, "status_code"):
+        status_code = getattr(e, "status_code")
+    elif hasattr(e, "response") and hasattr(e.response, "status_code"):
+        status_code = getattr(e.response, "status_code")
+    elif "429" in error_message:
+        status_code = 429
+    import re
+
+    match = re.search(r"status[ _]?code[=: ]+([0-9]+)", error_message)
+    if match:
+        status_code = int(match.group(1))
+    match_retry = re.search(r"retry[-_ ]?after[=: ]+([0-9]+)", error_message)
+    if match_retry:
+        retry_after = int(match_retry.group(1))
+    return status_code, retry_after
+
+
+def _calculate_wait_time(status_code, retry_after, attempt):
+    if status_code == 429 and retry_after:
+        return max(retry_after, 2**attempt)
+    return 2**attempt
+
+
+def _log_and_sleep(
+    message,
+    attempt,
+    max_retries,
+    e=None,
+    wait_time=None,
+    status=None,
+    waiting_message=None,
+    restore_message=None,
+):
+    status_message = tr(
+        message,
+        attempt=attempt,
+        max_retries=max_retries,
+        e=e,
+        wait_time=wait_time,
+    )
+    if (
+        status is not None
+        and waiting_message is not None
+        and restore_message is not None
+    ):
+        original_message = status.status
+        status.update(waiting_message)
+        time.sleep(wait_time)
+        status.update(restore_message)
+    else:
+        with Status(status_message, console=console, spinner="dots"):
+            time.sleep(wait_time)
+
+
+def _handle_json_decode_error(e, attempt, max_retries, status=None):
+    if attempt < max_retries:
+        wait_time = 2**attempt
+        if status is not None:
+            _log_and_sleep(
+                "Invalid/malformed response from OpenAI (attempt {attempt}/{max_retries}). Retrying in {wait_time} seconds...",
+                attempt,
+                max_retries,
+                wait_time=wait_time,
+                status=status,
+                waiting_message="Waiting after error...",
+                restore_message="Waiting for AI response...",
+            )
+        else:
+            _log_and_sleep(
+                "Invalid/malformed response from OpenAI (attempt {attempt}/{max_retries}). Retrying in {wait_time} seconds...",
+                attempt,
+                max_retries,
+                wait_time=wait_time,
+            )
+        return None
+    else:
+        print(tr("Max retries for invalid response reached. Raising error."))
+        raise e
+
+
+def _handle_no_tool_support(error_message):
+    if "No endpoints found that support tool use" in error_message:
+        print(tr("API does not support tool use."))
+        raise NoToolSupportError(error_message)
+
+
+def _handle_rate_limit(e, attempt, max_retries, status, status_code, retry_after):
+    wait_time = _calculate_wait_time(status_code, retry_after, attempt)
+    if attempt < max_retries:
+        if status is not None:
+            _log_and_sleep(
+                "OpenAI API rate limit (429) (attempt {attempt}/{max_retries}): {e}. Retrying in {wait_time} seconds...",
+                attempt,
+                max_retries,
+                e=e,
+                wait_time=wait_time,
+                status=status,
+                waiting_message="Waiting after rate limit reached...",
+                restore_message="Waiting for AI response...",
+            )
+        else:
+            _log_and_sleep(
+                "OpenAI API rate limit (429) (attempt {attempt}/{max_retries}): {e}. Retrying in {wait_time} seconds...",
+                attempt,
+                max_retries,
+                e=e,
+                wait_time=wait_time,
+            )
+        return None
+    else:
+        raise e
+
+
+def _handle_server_error(e, attempt, max_retries, status, status_code):
+    wait_time = 2**attempt
+    if attempt < max_retries:
+        if status is not None:
+            _log_and_sleep(
+                "OpenAI API server error (attempt {attempt}/{max_retries}): {e}. Retrying in {wait_time} seconds...",
+                attempt,
+                max_retries,
+                e=e,
+                wait_time=wait_time,
+                status=status,
+                waiting_message="Waiting after server error...",
+                restore_message="Waiting for AI response...",
+            )
+        else:
+            _log_and_sleep(
+                "OpenAI API server error (attempt {attempt}/{max_retries}): {e}. Retrying in {wait_time} seconds...",
+                attempt,
+                max_retries,
+                e=e,
+                wait_time=wait_time,
+            )
+        return None
+    else:
+        print("Max retries for OpenAI API server error reached. Raising error.")
+        raise e
+
+
+def _handle_client_error(e, status_code):
+    print(
+        tr(
+            "OpenAI API client error {status_code}: {e}. Not retrying.",
+            status_code=status_code,
+            e=e,
+        )
+    )
+    raise e
+
+
+def _handle_generic_error(e, attempt, max_retries, status):
+    wait_time = 2**attempt
+    if attempt < max_retries:
+        if status is not None:
+            _log_and_sleep(
+                "OpenAI API error (attempt {attempt}/{max_retries}): {e}. Retrying in {wait_time} seconds...",
+                attempt,
+                max_retries,
+                e=e,
+                wait_time=wait_time,
+                status=status,
+                waiting_message="Waiting after error...",
+                restore_message="Waiting for AI response...",
+            )
+        else:
+            _log_and_sleep(
+                "OpenAI API error (attempt {attempt}/{max_retries}): {e}. Retrying in {wait_time} seconds...",
+                attempt,
+                max_retries,
+                e=e,
+                wait_time=wait_time,
+            )
+        print(f"[DEBUG] Exception repr: {repr(e)}")
+        return None
+    else:
+        print(tr("Max retries for OpenAI API error reached. Raising error."))
+        raise e
+
+
+def _handle_general_exception(e, attempt, max_retries, status=None):
+    error_message = str(e)
+    _handle_no_tool_support(error_message)
+    status_code, retry_after = _extract_status_and_retry_after(e, error_message)
+    if status_code is not None:
+        if status_code == 429:
+            return _handle_rate_limit(
+                e, attempt, max_retries, status, status_code, retry_after
+            )
+        elif 500 <= status_code < 600:
+            return _handle_server_error(e, attempt, max_retries, status, status_code)
+        elif 400 <= status_code < 500:
+            _handle_client_error(e, status_code)
+    return _handle_generic_error(e, attempt, max_retries, status)
+
+
+def retry_api_call(
+    api_func,
+    max_retries=5,
+    *args,
+    history=None,
+    user_message_on_empty=None,
+    status=None,
+    **kwargs,
+):
+    for attempt in range(1, max_retries + 1):
+        try:
+            response = api_func(*args, **kwargs)
+            error = getattr(response, "error", None)
+            if error:
+                print(f"ApiError: {error.get('message', error)}")
+                raise ApiError(error.get("message", str(error)))
+            return response
+        except ApiError:
+            raise
+        except EmptyResponseError:
+            if history is not None and user_message_on_empty is not None:
+                print(
+                    f"[DEBUG] Adding user message to history: {user_message_on_empty}"
+                )
+                history.add_message({"role": "user", "content": user_message_on_empty})
+                continue  # Retry with updated history
+            else:
+                raise
+        except json.JSONDecodeError as e:
+            result = _handle_json_decode_error(e, attempt, max_retries, status=status)
+            if result is not None:
+                return result
+        except Exception as e:
+            result = _handle_general_exception(e, attempt, max_retries, status=status)
+            if result is not None:
+                return result

{janito-1.10.0 → janito-1.11.1}/janito/agent/conversation_ui.py

@@ -8,7 +8,7 @@ from rich.console import Console
 def show_spinner(message, func, *args, **kwargs):
     console = Console()
     with console.status(message, spinner="dots") as status:
-        result = func(*args, **kwargs)
+        result = func(*args, status=status, **kwargs)
         status.stop()
         return result
 

{janito-1.10.0 → janito-1.11.1}/janito/agent/llm_conversation_history.py

@@ -68,3 +68,15 @@ class LLMConversationHistory:
 
     def __getitem__(self, idx):
         return self._messages[idx]
+
+    def remove_last_message(self):
+        """Remove and return the last message in the history, or None if empty."""
+        if self._messages:
+            return self._messages.pop()
+        return None
+
+    def last_message(self):
+        """Return the last message in the history, or None if empty."""
+        if self._messages:
+            return self._messages[-1]
+        return None

janito-1.11.1/janito/agent/templates/profiles/system_prompt_template_base.txt.j2

@@ -0,0 +1,30 @@
+{#  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 #}
+You will be developing and testing in the following environment:
+ Platform: {{ platform }}
+ Python version: {{ python_version }}
+ Shell/Environment: {{ shell_info }}
+
+Respond according to the following guidelines:
+{# Exploratory hint #}
+  - Before answering to the user, explore the content related to the question
+{# Define exploration order, prefers search/outline, reduces chunking roundtip #}
+  - When exploring full files content, provide empty range to read the entire files instead of chunked reads
+{# Prefix tools with purpose for user awarnesses #}
+  - Before using your namespace functions, provide a concise explanation.
+{# 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.
+ {# 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.
+{# 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.

{janito-1.10.0 → janito-1.11.1}/janito/agent/tools/__init__.py

@@ -3,6 +3,7 @@ from . import create_directory
 from . import create_file
 from . import replace_file
 from . import fetch_url
+from . import open_url
 from . import find_files
 from . import get_lines
 from .get_file_outline import core  # noqa: F401,F811
@@ -25,6 +26,7 @@ __all__ = [
     "create_directory",
     "create_file",
     "fetch_url",
+    "open_url",
     "find_files",
     "GetFileOutlineTool",
     "get_lines",

{janito-1.10.0 → janito-1.11.1}/janito/agent/tools/create_directory.py

@@ -26,7 +26,7 @@ class CreateDirectoryTool(ToolBase):
         disp_path = display_path(file_path)
         self.report_info(
             ActionType.WRITE,
-            tr("📁 Creating directory '{disp_path}' ...", disp_path=disp_path),
+            tr("📁 Create directory '{disp_path}' ...", disp_path=disp_path),
         )
         try:
             if os.path.exists(file_path):

{janito-1.10.0 → janito-1.11.1}/janito/agent/tools/create_file.py

@@ -45,7 +45,7 @@ class CreateFileTool(ToolBase):
             os.makedirs(dir_name, exist_ok=True)
         self.report_info(
             ActionType.WRITE,
-            tr("📝 Creating file '{disp_path}' ...", disp_path=disp_path),
+            tr("📝 Create file '{disp_path}' ...", disp_path=disp_path),
         )
         with open(file_path, "w", encoding="utf-8", errors="replace") as f:
             f.write(content)

{janito-1.10.0 → janito-1.11.1}/janito/agent/tools/fetch_url.py

@@ -25,7 +25,7 @@ class FetchUrlTool(ToolBase):
         if not url.strip():
             self.report_warning(tr("ℹ️ Empty URL provided."))
             return tr("Warning: Empty URL provided. Operation skipped.")
-        self.report_info(ActionType.READ, tr("🌐 Fetching URL '{url}' ...", url=url))
+        self.report_info(ActionType.READ, tr("🌐 Fetch URL '{url}' ...", url=url))
         try:
             response = requests.get(url, timeout=10)
             response.raise_for_status()

{janito-1.10.0 → janito-1.11.1}/janito/agent/tools/find_files.py

@@ -25,6 +25,26 @@ class FindFilesTool(ToolBase):
             If max_results is reached, appends a note to the output.
     """
 
+    def _match_directories(self, root, dirs, pat):
+        dir_output = set()
+        dir_pat = pat.rstrip("/\\")
+        for d in dirs:
+            if fnmatch.fnmatch(d, dir_pat):
+                dir_output.add(os.path.join(root, d) + os.sep)
+        return dir_output
+
+    def _match_files(self, root, files, pat):
+        file_output = set()
+        for filename in fnmatch.filter(files, pat):
+            file_output.add(os.path.join(root, filename))
+        return file_output
+
+    def _match_dirs_without_slash(self, root, dirs, pat):
+        dir_output = set()
+        for d in fnmatch.filter(dirs, pat):
+            dir_output.add(os.path.join(root, d))
+        return dir_output
+
     def run(self, paths: str, pattern: str, max_depth: int = None) -> str:
         if not pattern:
             self.report_warning(tr("ℹ️ Empty file pattern provided."))
@@ -41,7 +61,7 @@ class FindFilesTool(ToolBase):
             self.report_info(
                 ActionType.READ,
                 tr(
-                    "🔍 Searching for files '{pattern}' in '{disp_path}'{depth_msg} ...",
+                    "🔍 Search for files '{pattern}' in '{disp_path}'{depth_msg} ...",
                     pattern=pattern,
                     disp_path=disp_path,
                     depth_msg=depth_msg,
@@ -52,19 +72,13 @@ class FindFilesTool(ToolBase):
                 directory, max_depth=max_depth
             ):
                 for pat in patterns:
-                    # Directory matching: pattern ends with '/' or '\'
                     if pat.endswith("/") or pat.endswith("\\"):
-                        dir_pat = pat.rstrip("/\\")
-                        for d in dirs:
-                            if fnmatch.fnmatch(d, dir_pat):
-                                dir_output.add(os.path.join(root, d) + os.sep)
+                        dir_output.update(self._match_directories(root, dirs, pat))
                     else:
-                        # Match files
-                        for filename in fnmatch.filter(files, pat):
-                            dir_output.add(os.path.join(root, filename))
-                        # Also match directories (without trailing slash)
-                        for d in fnmatch.filter(dirs, pat):
-                            dir_output.add(os.path.join(root, d))
+                        dir_output.update(self._match_files(root, files, pat))
+                        dir_output.update(
+                            self._match_dirs_without_slash(root, dirs, pat)
+                        )
             self.report_success(
                 tr(
                     " ✅ {count} {file_word}",
@@ -72,7 +86,6 @@ class FindFilesTool(ToolBase):
                     file_word=pluralize("file", len(dir_output)),
                 )
             )
-            # If searching in '.', strip leading './' from results
             if directory.strip() == ".":
                 dir_output = {
                     p[2:] if (p.startswith("./") or p.startswith(".\\")) else p

{janito-1.10.0 → janito-1.11.1}/janito/agent/tools/get_file_outline/core.py

@@ -23,7 +23,7 @@ class GetFileOutlineTool(ToolBase):
             self.report_info(
                 ActionType.READ,
                 tr(
-                    "📄 Outlining file '{disp_path}' ...",
+                    "📄 Outline file '{disp_path}' ...",
                     disp_path=display_path(file_path),
                 ),
             )

janito-1.11.1/janito/agent/tools/get_file_outline/python_outline.py

@@ -0,0 +1,178 @@
+import re
+from typing import List
+
+
+def handle_assignment(idx, assign_match, outline):
+    var_name = assign_match.group(2)
+    var_type = "const" if var_name.isupper() else "var"
+    outline.append(
+        {
+            "type": var_type,
+            "name": var_name,
+            "start": idx + 1,
+            "end": idx + 1,
+            "parent": "",
+            "docstring": "",
+        }
+    )
+
+
+def handle_main(idx, outline):
+    outline.append(
+        {
+            "type": "main",
+            "name": "__main__",
+            "start": idx + 1,
+            "end": idx + 1,
+            "parent": "",
+            "docstring": "",
+        }
+    )
+
+
+def close_stack_objects(idx, indent, stack, obj_ranges):
+    while stack and indent < stack[-1][2]:
+        popped = stack.pop()
+        obj_ranges.append((popped[0], popped[1], popped[3], idx, popped[4], popped[2]))
+
+
+def close_last_top_obj(idx, last_top_obj, stack, obj_ranges):
+    if last_top_obj and last_top_obj in stack:
+        stack.remove(last_top_obj)
+        obj_ranges.append(
+            (
+                last_top_obj[0],
+                last_top_obj[1],
+                last_top_obj[3],
+                idx,
+                last_top_obj[4],
+                last_top_obj[2],
+            )
+        )
+        return None
+    return last_top_obj
+
+
+def handle_class(idx, class_match, indent, stack, last_top_obj):
+    name = class_match.group(2)
+    parent = stack[-1][1] if stack and stack[-1][0] == "class" else ""
+    obj = ("class", name, indent, idx + 1, parent)
+    stack.append(obj)
+    if indent == 0:
+        last_top_obj = obj
+    return last_top_obj
+
+
+def handle_function(idx, func_match, indent, stack, last_top_obj):
+    name = func_match.group(2)
+    parent = ""
+    for s in reversed(stack):
+        if s[0] == "class" and indent > s[2]:
+            parent = s[1]
+            break
+    obj = ("function", name, indent, idx + 1, parent)
+    stack.append(obj)
+    if indent == 0:
+        last_top_obj = obj
+    return last_top_obj
+
+
+def process_line(idx, line, regexes, stack, obj_ranges, outline, last_top_obj):
+    class_pat, func_pat, assign_pat, main_pat = regexes
+    class_match = class_pat.match(line)
+    func_match = func_pat.match(line)
+    assign_match = assign_pat.match(line)
+    indent = len(line) - len(line.lstrip())
+    # If a new top-level class or function starts, close the previous one
+    if (class_match or func_match) and indent == 0 and last_top_obj:
+        last_top_obj = close_last_top_obj(idx, last_top_obj, stack, obj_ranges)
+    if class_match:
+        last_top_obj = handle_class(idx, class_match, indent, stack, last_top_obj)
+    elif func_match:
+        last_top_obj = handle_function(idx, func_match, indent, stack, last_top_obj)
+    elif assign_match and indent == 0:
+        handle_assignment(idx, assign_match, outline)
+    main_match = main_pat.match(line)
+    if main_match:
+        handle_main(idx, outline)
+    close_stack_objects(idx, indent, stack, obj_ranges)
+    return last_top_obj
+
+
+def build_outline_entry(obj, lines, outline):
+    obj_type, name, start, end, parent, indent = obj
+    # Determine if this is a method
+    if obj_type == "function" and parent:
+        outline_type = "method"
+    elif obj_type == "function":
+        outline_type = "function"
+    else:
+        outline_type = obj_type
+    docstring = extract_docstring(lines, start, end)
+    outline.append(
+        {
+            "type": outline_type,
+            "name": name,
+            "start": start,
+            "end": end,
+            "parent": parent,
+            "docstring": docstring,
+        }
+    )
+
+
+def process_lines(lines, regexes):
+    outline = []
+    stack = []
+    obj_ranges = []
+    last_top_obj = None
+    for idx, line in enumerate(lines):
+        last_top_obj = process_line(
+            idx, line, regexes, stack, obj_ranges, outline, last_top_obj
+        )
+    # Close any remaining open objects
+    for popped in stack:
+        obj_ranges.append(
+            (popped[0], popped[1], popped[3], len(lines), popped[4], popped[2])
+        )
+    return outline, obj_ranges
+
+
+def build_outline(obj_ranges, lines, outline):
+    for obj in obj_ranges:
+        build_outline_entry(obj, lines, outline)
+    return outline
+
+
+def parse_python_outline(lines: List[str]):
+    class_pat = re.compile(r"^(\s*)class\s+(\w+)")
+    func_pat = re.compile(r"^(\s*)def\s+(\w+)")
+    assign_pat = re.compile(r"^(\s*)([A-Za-z_][A-Za-z0-9_]*)\s*=.*")
+    main_pat = re.compile(r"^\s*if\s+__name__\s*==\s*[\'\"]__main__[\'\"]\s*:")
+    regexes = (class_pat, func_pat, assign_pat, main_pat)
+    outline, obj_ranges = process_lines(lines, regexes)
+    return build_outline(obj_ranges, lines, outline)
+
+
+def extract_docstring(lines, start_idx, end_idx):
+    """Extracts a docstring from lines[start_idx:end_idx] if present."""
+    for i in range(start_idx, min(end_idx, len(lines))):
+        line = lines[i].lstrip()
+        if not line:
+            continue
+        if line.startswith('"""') or line.startswith("'''"):
+            quote = line[:3]
+            doc = line[3:]
+            if doc.strip().endswith(quote):
+                return doc.strip()[:-3].strip()
+            docstring_lines = [doc]
+            for j in range(i + 1, min(end_idx, len(lines))):
+                line = lines[j]
+                if line.strip().endswith(quote):
+                    docstring_lines.append(line.strip()[:-3])
+                    return "\n".join([d.strip() for d in docstring_lines]).strip()
+                docstring_lines.append(line)
+            break
+        else:
+            break
+    return ""