janito 1.9.0__py3-none-any.whl → 1.11.0__py3-none-any.whl

janito/agent/tools_utils/gitignore_utils.py

@@ -1,43 +1,92 @@
 import os
 import pathspec
 
-_spec = None
-
-
-def load_gitignore_patterns(gitignore_path=".gitignore"):
-    global _spec
-    if not os.path.exists(gitignore_path):
-        _spec = pathspec.PathSpec.from_lines("gitwildmatch", [])
-        return _spec
-    with open(gitignore_path, "r", encoding="utf-8", errors="replace") as f:
-        lines = f.readlines()
-    _spec = pathspec.PathSpec.from_lines("gitwildmatch", lines)
-    return _spec
-
-
-def is_ignored(path):
-    global _spec
-    if _spec is None:
-        _spec = load_gitignore_patterns()
-    # Normalize path to be relative and use forward slashes
-    rel_path = os.path.relpath(path).replace(os.sep, "/")
-    return _spec.match_file(rel_path)
-
-
-def filter_ignored(root, dirs, files, spec=None):
-    if spec is None:
-        global _spec
-        if _spec is None:
-            _spec = load_gitignore_patterns()
-        spec = _spec
-
-    def not_ignored(p):
-        rel_path = os.path.relpath(os.path.join(root, p)).replace(os.sep, "/")
-        # Always ignore .git directory (like git does)
-        if rel_path == ".git" or rel_path.startswith(".git/"):
-            return False
-        return not spec.match_file(rel_path)
-
-    dirs[:] = [d for d in dirs if not_ignored(d)]
-    files = [f for f in files if not_ignored(f)]
-    return dirs, files
+
+class GitignoreFilter:
+    """
+    Utility class for loading, interpreting, and applying .gitignore patterns to file and directory paths.
+
+    Methods
+    -------
+    __init__(self, gitignore_path: str = ".gitignore")
+        Loads and parses .gitignore patterns from the specified path or finds the nearest .gitignore if a directory is given.
+
+    is_ignored(self, path: str) -> bool
+        Returns True if the given path matches any of the loaded .gitignore patterns.
+
+    filter_ignored(self, root: str, dirs: list, files: list) -> tuple[list, list]
+        Filters out ignored directories and files from the provided lists, returning only those not ignored.
+    """
+
+    @staticmethod
+    def find_nearest_gitignore(start_path):
+        """
+        Search upward from start_path for the nearest .gitignore file.
+        Returns the path to the found .gitignore, or the default .gitignore in start_path if none found.
+        """
+        current_dir = os.path.abspath(start_path)
+        if os.path.isfile(current_dir):
+            current_dir = os.path.dirname(current_dir)
+        while True:
+            candidate = os.path.join(current_dir, ".gitignore")
+            if os.path.isfile(candidate):
+                return candidate
+            parent = os.path.dirname(current_dir)
+            if parent == current_dir:
+                # Reached filesystem root, return default .gitignore path (may not exist)
+                return os.path.join(start_path, ".gitignore")
+            current_dir = parent
+
+    def __init__(self, gitignore_path: str = ".gitignore"):
+        # If a directory is passed, find the nearest .gitignore up the tree
+        if os.path.isdir(gitignore_path):
+            self.gitignore_path = self.find_nearest_gitignore(gitignore_path)
+        else:
+            self.gitignore_path = os.path.abspath(gitignore_path)
+        self.base_dir = os.path.dirname(self.gitignore_path)
+        lines = []
+        if not os.path.exists(self.gitignore_path):
+            self._spec = pathspec.PathSpec.from_lines("gitwildmatch", [])
+        else:
+            with open(
+                self.gitignore_path, "r", encoding="utf-8", errors="replace"
+            ) as f:
+                lines = f.readlines()
+            self._spec = pathspec.PathSpec.from_lines("gitwildmatch", lines)
+        # Collect directory patterns (ending with /)
+        self.dir_patterns = [
+            line.strip() for line in lines if line.strip().endswith("/")
+        ]
+
+    def is_ignored(self, path: str) -> bool:
+        """Return True if the given path is ignored by the loaded .gitignore patterns."""
+        abs_path = os.path.abspath(path)
+        rel_path = os.path.relpath(abs_path, self.base_dir).replace(os.sep, "/")
+        return self._spec.match_file(rel_path)
+
+    def filter_ignored(self, root: str, dirs: list, files: list) -> tuple[list, list]:
+        """
+        Filter out ignored directories and files from the provided lists.
+        Always ignores the .git directory (like git does).
+        """
+
+        def dir_is_ignored(d):
+            abs_path = os.path.abspath(os.path.join(root, d))
+            rel_path = os.path.relpath(abs_path, self.base_dir).replace(os.sep, "/")
+            if rel_path == ".git" or rel_path.startswith(".git/"):
+                return True
+            # Remove directory if it matches a directory pattern
+            for pat in self.dir_patterns:
+                pat_clean = pat.rstrip("/")
+                if rel_path == pat_clean or rel_path.startswith(pat_clean + "/"):
+                    return True
+            return self._spec.match_file(rel_path)
+
+        def file_is_ignored(f):
+            abs_path = os.path.abspath(os.path.join(root, f))
+            rel_path = os.path.relpath(abs_path, self.base_dir).replace(os.sep, "/")
+            return self._spec.match_file(rel_path)
+
+        dirs[:] = [d for d in dirs if not dir_is_ignored(d)]
+        files = [f for f in files if not file_is_ignored(f)]
+        return dirs, files

janito/agent/tools_utils/test_gitignore_utils.py

@@ -0,0 +1,46 @@
+import os
+import tempfile
+import shutil
+import pytest
+from janito.agent.tools_utils.gitignore_utils import GitignoreFilter
+
+
+def test_gitignore_filter_basic(tmp_path):
+    # Create a .gitignore file
+    gitignore_content = """
+ignored_file.txt
+ignored_dir/
+*.log
+"""
+    gitignore_path = tmp_path / ".gitignore"
+    gitignore_path.write_text(gitignore_content)
+
+    # Create files and directories
+    (tmp_path / "ignored_file.txt").write_text("should be ignored")
+    (tmp_path / "not_ignored.txt").write_text("should not be ignored")
+    (tmp_path / "ignored_dir").mkdir()
+    (tmp_path / "ignored_dir" / "file.txt").write_text("should be ignored")
+    (tmp_path / "not_ignored_dir").mkdir()
+    (tmp_path / "not_ignored_dir" / "file.txt").write_text("should not be ignored")
+    (tmp_path / "file.log").write_text("should be ignored")
+
+    gi = GitignoreFilter(str(gitignore_path))
+
+    assert gi.is_ignored(str(tmp_path / "ignored_file.txt"))
+    assert not gi.is_ignored(str(tmp_path / "not_ignored.txt"))
+    # Directory itself is not ignored, only its contents
+    assert not gi.is_ignored(str(tmp_path / "ignored_dir"))
+    assert gi.is_ignored(str(tmp_path / "ignored_dir" / "file.txt"))
+    assert not gi.is_ignored(str(tmp_path / "not_ignored_dir"))
+    assert not gi.is_ignored(str(tmp_path / "not_ignored_dir" / "file.txt"))
+    assert gi.is_ignored(str(tmp_path / "file.log"))
+
+    # Test filter_ignored
+    dirs = ["ignored_dir", "not_ignored_dir"]
+    files = ["ignored_file.txt", "not_ignored.txt", "file.log"]
+    filtered_dirs, filtered_files = gi.filter_ignored(str(tmp_path), dirs, files)
+    assert "ignored_dir" not in filtered_dirs
+    assert "not_ignored_dir" in filtered_dirs
+    assert "ignored_file.txt" not in filtered_files
+    assert "file.log" not in filtered_files
+    assert "not_ignored.txt" in filtered_files

janito/agent/tools_utils/utils.py

@@ -12,7 +12,13 @@ def display_path(path):
         str: Display path, optionally as an ANSI hyperlink.
     """
     if os.path.isabs(path):
-        disp = path
+        cwd = os.path.abspath(os.getcwd())
+        abs_path = os.path.abspath(path)
+        # Check if the absolute path is within the current working directory
+        if abs_path.startswith(cwd + os.sep):
+            disp = os.path.relpath(abs_path, cwd)
+        else:
+            disp = path
     else:
         disp = os.path.relpath(path)
     port = runtime_config.get("termweb_port")

janito/cli/_print_config.py

@@ -1,5 +1,7 @@
 import os
-from janito.rich_utils import print_info, print_warning, print_magenta
+from janito.rich_utils import RichPrinter
+
+_rich_printer = RichPrinter()
 from ._utils import home_shorten
 
 
@@ -7,17 +9,65 @@ def print_config_items(items, color_label=None):
     if not items:
         return
     if color_label:
-        print_info(color_label)
+        _rich_printer.print_info(color_label)
     home = os.path.expanduser("~")
     for key, value in items.items():
         if key == "system_prompt_template" and isinstance(value, str):
             if value.startswith(home):
                 print(f"{key} = {home_shorten(value)}")
             else:
-                print_info(f"{key} = {value}")
+                _rich_printer.print_info(f"{key} = {value}")
+        else:
+            _rich_printer.print_info(f"{key} = {value}")
+    _rich_printer.print_info("")
+
+
+def _mask_api_key(value):
+    if value and len(value) > 8:
+        return value[:4] + "..." + value[-4:]
+    elif value:
+        return "***"
+    return None
+
+
+def _collect_config_items(config, unified_config, keys):
+    items = {}
+    for key in sorted(keys):
+        if key == "api_key":
+            value = config.get("api_key")
+            value = _mask_api_key(value)
         else:
-            print_info(f"{key} = {value}")
-    print_info("")
+            value = unified_config.get(key)
+        items[key] = value
+    return items
+
+
+def _print_defaults(config_defaults, shown_keys):
+    default_items = {
+        k: v
+        for k, v in config_defaults.items()
+        if k not in shown_keys and k != "api_key"
+    }
+    if default_items:
+        _rich_printer.print_magenta(
+            "[green]\U0001f7e2 Defaults (not set in config files)[/green]"
+        )
+        from pathlib import Path
+
+        template_path = (
+            Path(__file__).parent
+            / "agent"
+            / "templates"
+            / "system_prompt_template_default.j2"
+        )
+        for key, value in default_items.items():
+            if key == "system_prompt_template" and value is None:
+                _rich_printer.print_info(
+                    f"{key} = (default template path: {home_shorten(str(template_path))})"
+                )
+            else:
+                _rich_printer.print_info(f"{key} = {value}")
+        _rich_printer.print_info("")
 
 
 def print_full_config(
@@ -27,68 +77,20 @@ def print_full_config(
     Print local, global, and default config values in a unified way.
     Handles masking API keys and showing the template file for system_prompt_template if not set.
     """
-    local_items = {}
-    global_items = {}
     local_keys = set(local_config.all().keys())
     global_keys = set(global_config.all().keys())
     if not (local_keys or global_keys):
-        print_warning("No configuration found.")
+        _rich_printer.print_warning("No configuration found.")
     else:
-        for key in sorted(local_keys):
-            if key == "api_key":
-                value = local_config.get("api_key")
-                value = (
-                    value[:4] + "..." + value[-4:]
-                    if value and len(value) > 8
-                    else ("***" if value else None)
-                )
-            else:
-                value = unified_config.get(key)
-            local_items[key] = value
-        for key in sorted(global_keys - local_keys):
-            if key == "api_key":
-                value = global_config.get("api_key")
-                value = (
-                    value[:4] + "..." + value[-4:]
-                    if value and len(value) > 8
-                    else ("***" if value else None)
-                )
-            else:
-                value = unified_config.get(key)
-            global_items[key] = value
-        # Mask API key
-        for cfg in (local_items, global_items):
-            if "api_key" in cfg and cfg["api_key"]:
-                val = cfg["api_key"]
-                cfg["api_key"] = val[:4] + "..." + val[-4:] if len(val) > 8 else "***"
+        local_items = _collect_config_items(local_config, unified_config, local_keys)
+        global_items = _collect_config_items(
+            global_config, unified_config, global_keys - local_keys
+        )
         print_config_items(
-            local_items, color_label="[cyan]🏠 Local Configuration[/cyan]"
+            local_items, color_label="[cyan]\U0001f3e0 Local Configuration[/cyan]"
         )
         print_config_items(
-            global_items, color_label="[yellow]🌐 Global Configuration[/yellow]"
+            global_items, color_label="[yellow]\U0001f310 Global Configuration[/yellow]"
         )
-        # Show defaults for unset keys
         shown_keys = set(local_items.keys()) | set(global_items.keys())
-        default_items = {
-            k: v
-            for k, v in config_defaults.items()
-            if k not in shown_keys and k != "api_key"
-        }
-        if default_items:
-            print_magenta("[green]🟢 Defaults (not set in config files)[/green]")
-            from pathlib import Path
-
-            template_path = (
-                Path(__file__).parent
-                / "agent"
-                / "templates"
-                / "system_prompt_template_default.j2"
-            )
-            for key, value in default_items.items():
-                if key == "system_prompt_template" and value is None:
-                    print_info(
-                        f"{key} = (default template path: {home_shorten(str(template_path))})"
-                    )
-                else:
-                    print_info(f"{key} = {value}")
-            print_info("")
+        _print_defaults(config_defaults, shown_keys)

janito/cli/arg_parser.py

@@ -34,7 +34,7 @@ def create_parser():
         "--set-provider-config",
         nargs=3,
         metavar=("NAME", "KEY", "VALUE"),
-        help="Set a provider config parameter (e.g., --set-provider-config openrouter.ai api_key sk-xxx).",
+        help="Set a provider config parameter (e.g., --set-provider-config openai api_key sk-xxx).",
     )
     parser.add_argument(
         "--lang",
@@ -52,7 +52,7 @@ def create_parser():
         "--max-tokens",
         type=int,
         default=None,
-        help="Maximum tokens for model response (overrides config, default: 200000)",
+        help="Maximum tokens for model response (overrides config, default: 32000)",
     )
     parser.add_argument(
         "--max-tools",
@@ -212,6 +212,11 @@ def create_parser():
         action="store_true",
         help="Print all agent events before dispatching to the message handler (for debugging)",
     )
+    parser.add_argument(
+        "--verbose-messages",
+        action="store_true",
+        help="Print every new message added to the conversation history with a colored background.",
+    )
     parser.add_argument(
         "-V",
         "--vanilla",
@@ -231,16 +236,6 @@ def create_parser():
         default=None,
         help="Agent Profile name (only 'base' is supported)",
     )
-    parser.add_argument(
-        "--stream",
-        action="store_true",
-        help="Enable OpenAI streaming mode (yields tokens as they arrive)",
-    )
-    parser.add_argument(
-        "--verbose-stream",
-        action="store_true",
-        help="Print raw chunks as they are fetched from OpenAI (for debugging)",
-    )
     parser.add_argument(
         "--no-termweb",
         action="store_true",
@@ -263,4 +258,10 @@ def create_parser():
         action="store_true",
         help="Disable tool call reason tracking (no tools tracking)",
     )
+    parser.add_argument(
+        "--tool-user",
+        action="store_true",
+        default=False,
+        help="When set, tool responses will use role 'user' instead of 'tool' in the conversation history.",
+    )
     return parser