janito 1.3.2__tar.gz → 1.4.1__tar.gz

{janito-1.3.2 → janito-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 1.3.2
+Version: 1.4.1
 Summary: A Natural Programming Language Agent,
 Author-email: João Pinto <joao.pinto@gmail.com>
 License: MIT
@@ -8,7 +8,6 @@ Project-URL: homepage, https://github.com/joaompinto/janito
 Project-URL: repository, https://github.com/joaompinto/janito
 Keywords: agent,framework,tools,automation
 Classifier: Programming Language :: Python :: 3.10
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -23,7 +22,7 @@ Requires-Dist: requests
 Requires-Dist: rich
 Dynamic: license-file
 
-# 🚀 Janito: Agent
+# 🚀 Janito: Natural Programming Language Agent
 
 Janito is an AI-powered assistant for the command line and web that interprets natural language instructions to edit code, manage files, and analyze projects using patterns and tools designed by experienced software engineers. It prioritizes transparency, interactive clarification, and precise, reviewable changes.
 
@@ -60,7 +59,7 @@ python -m janito.web
   - `replace_text_in_file`: Replace exact text fragments in files.
   - `search_files`: Search for text patterns across files.
   - `python_exec`: Execute Python code and capture output.
-  - And more, see `janito/agent/tools/` for the full list.
+  - And more built-in operations for code and file management.
 - 🌐 **Web Interface (In Development):** Upcoming simple web UI for streaming responses and tool progress.
 
 ---
@@ -79,9 +78,9 @@ Below are the supported configuration parameters and CLI flags. Some options can
 
 | Key / Flag                | Description                                                                                 | How to set                                                      | Default                                    |
 |---------------------------|---------------------------------------------------------------------------------------------|-----------------------------------------------------------------|--------------------------------------------|
-| `api_key`                 | API key for OpenAI-compatible service                                                       | `--set-api-key`, config file                                    | _None_ (required)                          |
-| `model`                   | Model name to use for this session                                                          | `--model` (session only), `--set-local-config model=...`, or `--set-global-config` | `openai/gpt-4.1`                 |
-| `base_url`                | API base URL (OpenAI-compatible endpoint)                                                   | `--set-local-config base_url=...` or `--set-global-config`      | `https://openrouter.ai/api/v1`            |
+| `api_key`                 | API key for a compatible language model service                                            | `--set-api-key`, config file                                    | _None_ (required)                          |
+| `model`                   | Model name to use for this session                                                          | `--model` (session only), `--set-local-config model=...`, or `--set-global-config` | _(example: gpt-4)_                 |
+| `base_url`                | API base URL for your language model service                                                | `--set-local-config base_url=...` or `--set-global-config`      | _(example: https://api.your-model.com)_            |
 | `role`                    | Role description for the system prompt                                                      | `--role` or config                                            | "software engineer"                     |
 | `system_prompt`           | Override the entire system prompt as a raw string                                           | `--system-prompt` or config                                   | _Default prompt_               |
 | `system_file`             | Use a plain text file as the system prompt (takes precedence over `system_prompt`)         | `--system-file` (CLI only)                                     | _None_                                     |

{janito-1.3.2 → janito-1.4.1}/README.md

@@ -1,4 +1,4 @@
-# 🚀 Janito: Agent
+# 🚀 Janito: Natural Programming Language Agent
 
 Janito is an AI-powered assistant for the command line and web that interprets natural language instructions to edit code, manage files, and analyze projects using patterns and tools designed by experienced software engineers. It prioritizes transparency, interactive clarification, and precise, reviewable changes.
 
@@ -35,7 +35,7 @@ python -m janito.web
   - `replace_text_in_file`: Replace exact text fragments in files.
   - `search_files`: Search for text patterns across files.
   - `python_exec`: Execute Python code and capture output.
-  - And more, see `janito/agent/tools/` for the full list.
+  - And more built-in operations for code and file management.
 - 🌐 **Web Interface (In Development):** Upcoming simple web UI for streaming responses and tool progress.
 
 ---
@@ -54,9 +54,9 @@ Below are the supported configuration parameters and CLI flags. Some options can
 
 | Key / Flag                | Description                                                                                 | How to set                                                      | Default                                    |
 |---------------------------|---------------------------------------------------------------------------------------------|-----------------------------------------------------------------|--------------------------------------------|
-| `api_key`                 | API key for OpenAI-compatible service                                                       | `--set-api-key`, config file                                    | _None_ (required)                          |
-| `model`                   | Model name to use for this session                                                          | `--model` (session only), `--set-local-config model=...`, or `--set-global-config` | `openai/gpt-4.1`                 |
-| `base_url`                | API base URL (OpenAI-compatible endpoint)                                                   | `--set-local-config base_url=...` or `--set-global-config`      | `https://openrouter.ai/api/v1`            |
+| `api_key`                 | API key for a compatible language model service                                            | `--set-api-key`, config file                                    | _None_ (required)                          |
+| `model`                   | Model name to use for this session                                                          | `--model` (session only), `--set-local-config model=...`, or `--set-global-config` | _(example: gpt-4)_                 |
+| `base_url`                | API base URL for your language model service                                                | `--set-local-config base_url=...` or `--set-global-config`      | _(example: https://api.your-model.com)_            |
 | `role`                    | Role description for the system prompt                                                      | `--role` or config                                            | "software engineer"                     |
 | `system_prompt`           | Override the entire system prompt as a raw string                                           | `--system-prompt` or config                                   | _Default prompt_               |
 | `system_file`             | Use a plain text file as the system prompt (takes precedence over `system_prompt`)         | `--system-file` (CLI only)                                     | _None_                                     |

janito-1.4.1/janito/__init__.py

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

{janito-1.3.2 → janito-1.4.1}/janito/agent/conversation.py

@@ -45,7 +45,13 @@ class ConversationHandler:
             if spinner:
                                 # Calculate word count for all messages
                 word_count = sum(len(str(m.get('content', '')).split()) for m in messages if 'content' in m)
-                spinner_msg = f"[bold green]Waiting for AI response... ({word_count} words in conversation)"
+                def format_count(n):
+                    if n >= 1_000_000:
+                        return f"{n/1_000_000:.1f}m"
+                    elif n >= 1_000:
+                        return f"{n/1_000:.1f}k"
+                    return str(n)
+                spinner_msg = f"[bold green]Waiting for AI response... ({format_count(word_count)} words in conversation)"
                 with console.status(spinner_msg, spinner="dots") as status:
                     response = self.client.chat.completions.create(
                         model=self.model,

{janito-1.3.2 → janito-1.4.1}/janito/agent/templates/system_instructions.j2

@@ -4,6 +4,7 @@ You are an assistant for a analysis and development tool that operates on files
 directories using text-based operations.
 
 Provide a concise plan before calling any tool.
+Always execute the plan immediately after presenting it, unless the user requests otherwise.
 
 <context>
 Always review `README_structure.txt` before conducting file-specific searches.
@@ -12,25 +13,20 @@ Explore files that might be relevant to the current task.
 </context>
 
 <analysis>
-When analyzing issues, you might want to look into the git history for clues.
+In case of missing code or functions, look into the .bak files and check git diff/history for recent changes.
 </analysis>
 
 <editing>
 If in doubt during editing, use the `ask_user` function to get additional information; otherwise, proceed and inform the user of the decision made.
 
 When you need to make changes to a file, consider the following:
-
-- Use the `edit_file` tool when you want to update or fix specific text fragments within a file without altering the rest of its content. It is preferred over full file replacement when:
-    - Only small, targeted changes are needed.
-    - You want to avoid the risk of accidentally overwriting unrelated content.
-    - The file is large, and rewriting the entire file would be inefficient.
-    - You want to preserve formatting, comments, or code structure outside the replaced text.
-
+- It is preferred to replace exact text occurrences over file overwriting.
 - When replacing files, review their current content before requesting the update.
 - When reorganizing, moving files, or functions, search for references in other files that might need to be updated accordingly.
 </editing>
 
 <finishing>
+- When asked to commit and no message is provided, check the git diff and summarize the changes in the commit message.
 - Review the README content if there are user-exposed or public API changes.
 - Update `README_structure.txt` considering discovered, created, or modified files.
 </finishing>

{janito-1.3.2 → janito-1.4.1}/janito/agent/tool_handler.py

@@ -1,102 +1,40 @@
 import os
 import json
 import traceback
+from janito.agent.tools.tool_base import ToolBase
 
 class ToolHandler:
     _tool_registry = {}
 
-    @classmethod
-    def register_tool(cls, func):
-        import inspect
-        import typing
-        from typing import get_origin, get_args
-
-        name = func.__name__
-        description = func.__doc__ or ""
-
-        sig = inspect.signature(func)
-        params_schema = {
-            "type": "object",
-            "properties": {},
-            "required": []
-        }
-
-        for param_name, param in sig.parameters.items():
-            if param.annotation is param.empty:
-                raise TypeError(f"Parameter '{param_name}' in tool '{name}' is missing a type hint.")
-            param_type = param.annotation
-            schema = {}
-
-            # Handle typing.Optional, typing.List, typing.Literal, etc.
-            origin = get_origin(param_type)
-            args = get_args(param_type)
-
-            if origin is typing.Union and type(None) in args:
-                # Optional[...] type
-                main_type = args[0] if args[1] is type(None) else args[1]
-                origin = get_origin(main_type)
-                args = get_args(main_type)
-                param_type = main_type
-            else:
-                main_type = param_type
-
-            if origin is list or origin is typing.List:
-                item_type = args[0] if args else str
-                item_schema = {"type": _pytype_to_json_type(item_type)}
-                schema = {"type": "array", "items": item_schema}
-            elif origin is typing.Literal:
-                schema = {"type": _pytype_to_json_type(type(args[0])), "enum": list(args)}
-            elif main_type == int:
-                schema = {"type": "integer"}
-            elif main_type == float:
-                schema = {"type": "number"}
-            elif main_type == bool:
-                schema = {"type": "boolean"}
-            elif main_type == dict:
-                schema = {"type": "object"}
-            elif main_type == list:
-                schema = {"type": "array", "items": {"type": "string"}}
-            else:
-                schema = {"type": "string"}
-
-            # Optionally add description if available in docstring (not implemented here)
-            params_schema["properties"][param_name] = schema
-            if param.default is param.empty:
-                params_schema["required"].append(param_name)
-
-        cls._tool_registry[name] = {
-            "function": func,
-            "description": description,
-            "parameters": params_schema
-        }
-        return func
-
-def _pytype_to_json_type(pytype):
-    import typing
-    if pytype == int:
-        return "integer"
-    elif pytype == float:
-        return "number"
-    elif pytype == bool:
-        return "boolean"
-    elif pytype == dict:
-        return "object"
-    elif pytype == list or pytype == typing.List:
-        return "array"
-    else:
-        return "string"
-
-class ToolHandler:
-    _tool_registry = {}
+    def __init__(self, verbose=False, enable_tools=True):
+        self.verbose = verbose
+        self.tools = []
+        self.enable_tools = enable_tools
 
     @classmethod
-    def register_tool(cls, func):
+    def register_tool(cls, tool=None, *, name: str = None):
+        """
+        Register a tool class derived from ToolBase.
+        Args:
+            tool: The tool class (must inherit from ToolBase).
+            name: Optional override for the tool name.
+        Raises:
+            TypeError: If the tool is not a subclass of ToolBase.
+        """
+        if tool is None:
+            return lambda t: cls.register_tool(t, name=name)
         import inspect
         import typing
         from typing import get_origin, get_args
 
-        name = func.__name__
-        description = func.__doc__ or ""
+        override_name = name
+        if not (isinstance(tool, type) and issubclass(tool, ToolBase)):
+            raise TypeError("Tool must be a class derived from ToolBase.")
+        instance = tool()
+        func = instance.call
+        default_name = tool.__name__
+        name = override_name or default_name
+        description = tool.__doc__ or func.__doc__ or ""
 
         sig = inspect.signature(func)
         params_schema = {
@@ -143,22 +81,30 @@ class ToolHandler:
             else:
                 schema = {"type": "string"}
 
-            # Optionally add description if available in docstring (not implemented here)
+            # Add description from call method docstring if available (Google-style Args parsing)
+            if func.__doc__:
+                import re
+                doc = func.__doc__
+                args_section = re.search(r"Args:\s*(.*?)(?:\n\s*\w|Returns:|$)", doc, re.DOTALL)
+                param_descs = {}
+                if args_section:
+                    args_text = args_section.group(1)
+                    for match in re.finditer(r"(\w+) \([^)]+\): ([^\n]+)", args_text):
+                        pname, pdesc = match.groups()
+                        param_descs[pname] = pdesc.strip()
+                if param_name in param_descs:
+                    schema["description"] = param_descs[param_name]
             params_schema["properties"][param_name] = schema
             if param.default is param.empty:
                 params_schema["required"].append(param_name)
 
+        # register the bound call function
         cls._tool_registry[name] = {
             "function": func,
             "description": description,
             "parameters": params_schema
         }
-        return func
-
-    def __init__(self, verbose=False, enable_tools=True):
-        self.verbose = verbose
-        self.tools = []
-        self.enable_tools = enable_tools
+        return tool
 
     def register(self, func):
         self.tools.append(func)
@@ -194,6 +140,11 @@ class ToolHandler:
             print(f"[Tool Call] {tool_call.function.name} called with arguments: {args}")
         import inspect
         sig = inspect.signature(func)
+        # Set progress callback on tool instance if possible
+        instance = None
+        if hasattr(func, '__self__') and isinstance(func.__self__, ToolBase):
+            instance = func.__self__
+            instance._progress_callback = on_progress
         if on_progress:
             on_progress({
                 'event': 'start',
@@ -201,8 +152,6 @@ class ToolHandler:
                 'tool': tool_call.function.name,
                 'args': args
             })
-        if 'on_progress' in sig.parameters and on_progress is not None:
-            args['on_progress'] = on_progress
         try:
             result = func(**args)
         except Exception as e:
@@ -226,4 +175,22 @@ class ToolHandler:
                 'args': args,
                 'result': result
             })
+        # Clean up progress callback
+        if instance is not None:
+            instance._progress_callback = None
         return result
+
+def _pytype_to_json_type(pytype):
+    import typing
+    if pytype == int:
+        return "integer"
+    elif pytype == float:
+        return "number"
+    elif pytype == bool:
+        return "boolean"
+    elif pytype == dict:
+        return "object"
+    elif pytype == list or pytype == typing.List:
+        return "array"
+    else:
+        return "string"

janito-1.4.1/janito/agent/tools/__init__.py

@@ -0,0 +1,9 @@
+import importlib
+import os
+
+# Dynamically import all tool modules in this directory (except __init__.py and tool_base.py)
+_tool_dir = os.path.dirname(__file__)
+for fname in os.listdir(_tool_dir):
+    if fname.endswith('.py') and fname not in ('__init__.py', 'tool_base.py'):
+        modname = fname[:-3]
+        importlib.import_module(f'janito.agent.tools.{modname}')

janito-1.4.1/janito/agent/tools/ask_user.py

@@ -0,0 +1,61 @@
+from janito.agent.tools.tool_base import ToolBase
+from janito.agent.tools.rich_utils import print_info, print_success
+
+class AskUserTool(ToolBase):
+    """Ask the user a question and return their response."""
+    def call(self, question: str) -> str:
+        from rich import print as rich_print
+        from rich.panel import Panel
+        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_toolkit.styles import Style
+
+        rich_print(Panel.fit(question, title="Question", style="cyan"))
+
+        bindings = KeyBindings()
+        mode = {'multiline': False}
+
+        @bindings.add('c-r')
+        def _(event):
+            pass
+
+        style = Style.from_dict({
+            'bottom-toolbar': 'bg:#333333 #ffffff',
+            'b': 'bold',
+            'prompt': 'bold bg:#000080 #ffffff',
+        })
+
+        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=style
+        )
+
+        prompt_icon = HTML('<prompt>💬 </prompt>')
+
+        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:
+                return response
+
+
+from janito.agent.tool_handler import ToolHandler
+ToolHandler.register_tool(AskUserTool, name="ask_user")

janito-1.4.1/janito/agent/tools/fetch_url.py

@@ -0,0 +1,35 @@
+import requests
+from typing import Optional
+from bs4 import BeautifulSoup
+from janito.agent.tool_handler import ToolHandler
+from janito.agent.tools.rich_utils import print_info, print_success, print_error
+from janito.agent.tools.tool_base import ToolBase
+
+class FetchUrlTool(ToolBase):
+    """Fetch the content of a web page and extract its text."""
+    def call(self, url: str, search_strings: list[str] = None) -> str:
+        print_info(f"🌐 Fetching URL: {url} ... ", end="")
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        self.update_progress(f"Fetched URL with status {response.status_code}")
+        soup = BeautifulSoup(response.text, 'html.parser')
+        text = soup.get_text(separator='\n')
+
+        if search_strings:
+            filtered = []
+            for s in search_strings:
+                idx = text.find(s)
+                if idx != -1:
+                    start = max(0, idx - 200)
+                    end = min(len(text), idx + len(s) + 200)
+                    snippet = text[start:end]
+                    filtered.append(snippet)
+            if filtered:
+                text = '\n...\n'.join(filtered)
+            else:
+                text = "No matches found for the provided search strings."
+
+        print_success("✅ Success")
+        return text
+
+ToolHandler.register_tool(FetchUrlTool, name="fetch_url")

janito-1.4.1/janito/agent/tools/file_ops.py

@@ -0,0 +1,60 @@
+import os
+import shutil
+from janito.agent.tool_handler import ToolHandler
+from janito.agent.tools.rich_utils import print_info, print_success, print_error
+from janito.agent.tools.utils import expand_path, display_path
+from janito.agent.tools.tool_base import ToolBase
+
+class CreateFileTool(ToolBase):
+    """
+    Create a new file or update an existing file with the given content.
+    """
+    def call(self, path: str, content: str, overwrite: bool = False) -> str:
+        original_path = path
+        path = expand_path(path)
+        updating = os.path.exists(path) and not os.path.isdir(path)
+        disp_path = display_path(original_path, path)
+        if os.path.exists(path):
+            if os.path.isdir(path):
+                print_error(f"❌ Error: is a directory")
+                return f"❌ Cannot create file: '{disp_path}' is an existing directory."
+            if not overwrite:
+                print_error(f"❗ Error: file '{disp_path}' exists and overwrite is False")
+                return f"❗ Cannot create file: '{disp_path}' already exists and overwrite is False."
+        if updating and overwrite:
+            print_info(f"📝 Updating file: '{disp_path}' ... ")
+        else:
+            print_info(f"📝 Creating file: '{disp_path}' ... ")
+        old_lines = None
+        if updating and overwrite:
+            with open(path, "r", encoding="utf-8") as f:
+                old_lines = sum(1 for _ in f)
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(content)
+        new_lines = content.count('\n') + 1 if content else 0
+        if old_lines is not None:
+            print_success(f"✅ Successfully updated the file at '{disp_path}' ({old_lines} > {new_lines} lines).")
+            return f"✅ Successfully updated the file at '{disp_path}' ({old_lines} > {new_lines} lines)."
+        print_success(f"✅ Successfully created the file at '{disp_path}' ({new_lines} lines).")
+        return f"✅ Successfully created the file at '{disp_path}' ({new_lines} lines)."
+
+class CreateDirectoryTool(ToolBase):
+    """
+    Create a new directory at the specified path.
+    """
+    def call(self, path: str, overwrite: bool = False) -> str:
+        """
+        Create a new directory at the specified path.
+        Args:
+            path (str): Path to the directory to create.
+            overwrite (bool): Whether to remove the directory if it exists.
+        Returns:
+            str: Result message.
+        """
+        original_path = path
+        path = expand_path(path)
+        disp_path = display_path(original_path, path)
+        if os.path.exists(path):
+            if not os.path.isdir(path):
+                print_error(f"❌ Path '{disp_path}' exists and is not a directory.")
+                return f"❌ Path '{disp_path}' exists and is not a directory."

janito-1.4.1/janito/agent/tools/find_files.py

@@ -0,0 +1,31 @@
+from janito.agent.tools.tool_base import ToolBase
+from janito.agent.tool_handler import ToolHandler
+from janito.agent.tools.rich_utils import print_info, print_success
+import os
+import fnmatch
+
+class FindFilesTool(ToolBase):
+    """Find files in a directory matching a pattern."""
+    def call(self, directory: str, pattern: str, recursive: bool=False, max_results: int=100) -> str:
+        import os
+        def _display_path(path):
+            import os
+            if os.path.isabs(path):
+                return path
+            return os.path.relpath(path)
+        disp_path = _display_path(directory)
+        rec = "recursively" if recursive else "non-recursively"
+        print_info(f"\U0001F50D Searching '{disp_path}' for pattern '{pattern}' ({rec}, max {max_results})", end="")
+        self.update_progress(f"Searching for files in {directory} matching {pattern}")
+        matches = []
+        for root, dirs, files in os.walk(directory):
+            for filename in fnmatch.filter(files, pattern):
+                matches.append(os.path.join(root, filename))
+                if len(matches) >= max_results:
+                    break
+            if not recursive:
+                break
+        print_success(f"✅ {len(matches)} found")
+        return "\n".join(matches)
+
+ToolHandler.register_tool(FindFilesTool, name="find_files")

janito-1.4.1/janito/agent/tools/get_file_outline.py

@@ -0,0 +1,22 @@
+from janito.agent.tools.tool_base import ToolBase
+from janito.agent.tool_handler import ToolHandler
+
+from janito.agent.tools.rich_utils import print_info, print_success, print_error
+
+class GetFileOutlineTool(ToolBase):
+    """Get an outline of a file's structure."""
+    def call(self, file_path: str) -> str:
+        print_info(f"\U0001F4C4 Getting outline for: {file_path}", end="")
+        self.update_progress(f"Getting outline for: {file_path}")
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                lines = f.readlines()
+            outline = [line.strip() for line in lines if line.strip()]
+            num_items = len(outline)
+            print_success(f"✅ Outline generated ({num_items} items)")
+            return f"Outline: {num_items} items\n" + '\n'.join(outline)
+        except Exception as e:
+            print_error(f"\u274c Error reading file: {e}")
+            return f"Error reading file: {e}"
+
+ToolHandler.register_tool(GetFileOutlineTool, name="get_file_outline")

janito-1.4.1/janito/agent/tools/get_lines.py

@@ -0,0 +1,37 @@
+from janito.agent.tools.tool_base import ToolBase
+from janito.agent.tool_handler import ToolHandler
+from janito.agent.tools.rich_utils import print_info, print_success, print_error
+
+class GetLinesTool(ToolBase):
+    """Get specific lines from a file."""
+    def call(self, file_path: str, from_line: int=None, to_line: int=None) -> str:
+        import os
+        def _display_path(path):
+            import os
+            if os.path.isabs(path):
+                return path
+            return os.path.relpath(path)
+        disp_path = _display_path(file_path)
+        if from_line and to_line:
+            count = to_line - from_line + 1
+            print_info(f"📄 Reading {disp_path}:{from_line} ({count} lines)", end="")
+        else:
+            print_info(f"📄 Reading {disp_path} (all lines)", end="")
+        self.update_progress(f"Getting lines {from_line} to {to_line} from {file_path}")
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                lines = f.readlines()
+            selected = lines[(from_line-1 if from_line else 0):(to_line if to_line else None)]
+            if from_line and to_line:
+                print_success(f" ✅ {to_line - from_line + 1} lines read")
+            else:
+                print_success(f" ✅ {len(lines)} lines read")
+            return ''.join(selected)
+        except Exception as e:
+            if isinstance(e, FileNotFoundError):
+                print_error(f"❗ not found")
+                return "❗ not found"
+            print_error(f" ❌ Error: {e}")
+            return f"Error reading file: {e}"
+
+ToolHandler.register_tool(GetLinesTool, name="get_lines")

{janito-1.3.2 → janito-1.4.1}/janito/agent/tools/gitignore_utils.py

@@ -1,15 +1,17 @@
 import os
 import pathspec
+from janito.agent.tools.utils import expand_path
 
 _spec = None
 
 
 def load_gitignore_patterns(gitignore_path='.gitignore'):
     global _spec
+    gitignore_path = expand_path(gitignore_path)
     if not os.path.exists(gitignore_path):
         _spec = pathspec.PathSpec.from_lines('gitwildmatch', [])
         return _spec
-    with open(gitignore_path, 'r') as f:
+    with open(gitignore_path, 'r', encoding='utf-8') as f:
         lines = f.readlines()
     _spec = pathspec.PathSpec.from_lines('gitwildmatch', lines)
     return _spec
@@ -17,6 +19,7 @@ def load_gitignore_patterns(gitignore_path='.gitignore'):
 
 def is_ignored(path):
     global _spec
+    path = expand_path(path)
     if _spec is None:
         _spec = load_gitignore_patterns()
     # Normalize path to be relative and use forward slashes

janito-1.4.1/janito/agent/tools/py_compile.py

@@ -0,0 +1,23 @@
+from janito.agent.tools.tool_base import ToolBase
+from janito.agent.tool_handler import ToolHandler
+from janito.agent.tools.rich_utils import print_info, print_success, print_error
+from typing import Optional
+import py_compile
+
+class PyCompileTool(ToolBase):
+    """Validate a Python file by compiling it with py_compile."""
+    def call(self, file_path: str, doraise: Optional[bool] = True) -> str:
+        print_info(f"[py_compile] Compiling Python file: {file_path}", end="")
+        self.update_progress(f"Compiling Python file: {file_path}")
+        try:
+            py_compile.compile(file_path, doraise=doraise)
+            print_success(f"[py_compile] Compiled successfully: {file_path}")
+            return f"Compiled successfully: {file_path}"
+        except py_compile.PyCompileError as e:
+            print_error(f"[py_compile] Compile error: {e}")
+            return f"Compile error: {e}"
+        except Exception as e:
+            print_error(f"[py_compile] Error: {e}")
+            return f"Error: {e}"
+
+ToolHandler.register_tool(PyCompileTool, name="py_compile_file")