janito 1.8.1__py3-none-any.whl → 1.10.0__py3-none-any.whl

janito/agent/tools/validate_file_syntax/markdown_validator.py

@@ -0,0 +1,66 @@
+from janito.i18n import tr
+import re
+
+
+def validate_markdown(file_path: str) -> str:
+    with open(file_path, "r", encoding="utf-8") as f:
+        content = f.read()
+    errors = []
+    lines = content.splitlines()
+    # Header space check
+    for i, line in enumerate(lines, 1):
+        if re.match(r"^#+[^ #]", line):
+            errors.append(f"Line {i}: Header missing space after # | {line.strip()}")
+    # Unclosed code block
+    if content.count("```") % 2 != 0:
+        errors.append("Unclosed code block (```) detected")
+    # Unclosed link or image
+    for i, line in enumerate(lines, 1):
+        if re.search(r"\[[^\]]*\]\([^)]+$", line):
+            errors.append(
+                f"Line {i}: Unclosed link or image (missing closing parenthesis) | {line.strip()}"
+            )
+    # List item formatting and blank line before new list (bulleted and numbered)
+    for i, line in enumerate(lines, 1):
+        # Skip table lines
+        if line.lstrip().startswith("|"):
+            continue
+        # List item missing space after bullet
+        if re.match(r"^[-*+][^ \n]", line):
+            stripped = line.strip()
+            if not (
+                stripped.startswith("*")
+                and stripped.endswith("*")
+                and len(stripped) > 2
+            ):
+                errors.append(
+                    f"Line {i}: List item missing space after bullet | {line.strip()}"
+                )
+        # Blank line before first item of a new bulleted list
+        if re.match(r"^\s*[-*+] ", line):
+            if i > 1:
+                prev_line = lines[i - 2]
+                prev_is_list = bool(re.match(r"^\s*[-*+] ", prev_line))
+                if not prev_is_list and prev_line.strip() != "":
+                    errors.append(
+                        f"Line {i}: List should be preceded by a blank line for compatibility with MkDocs and other Markdown parsers | {line.strip()}"
+                    )
+        # Blank line before first item of a new numbered list
+        if re.match(r"^\s*\d+\. ", line):
+            if i > 1:
+                prev_line = lines[i - 2]
+                prev_is_numbered_list = bool(re.match(r"^\s*\d+\. ", prev_line))
+                if not prev_is_numbered_list and prev_line.strip() != "":
+                    errors.append(
+                        f"Line {i}: Numbered list should be preceded by a blank line for compatibility with MkDocs and other Markdown parsers | {line.strip()}"
+                    )
+    # Unclosed inline code
+    if content.count("`") % 2 != 0:
+        errors.append("Unclosed inline code (`) detected")
+    if errors:
+        msg = tr(
+            "⚠️ Warning: Markdown syntax issues found:\n{errors}",
+            errors="\n".join(errors),
+        )
+        return msg
+    return "✅ Syntax valid"

janito/agent/tools/validate_file_syntax/ps1_validator.py

@@ -0,0 +1,32 @@
+from janito.i18n import tr
+import re
+
+
+def validate_ps1(file_path: str) -> str:
+    with open(file_path, "r", encoding="utf-8") as f:
+        content = f.read()
+    errors = []
+    # Unmatched curly braces
+    if content.count("{") != content.count("}"):
+        errors.append("Unmatched curly braces { }")
+    # Unmatched parentheses
+    if content.count("(") != content.count(")"):
+        errors.append("Unmatched parentheses ( )")
+    # Unmatched brackets
+    if content.count("[") != content.count("]"):
+        errors.append("Unmatched brackets [ ]")
+    # Unclosed string literals
+    for quote in ["'", '"']:
+        unescaped = re.findall(rf"(?<!\\){quote}", content)
+        if len(unescaped) % 2 != 0:
+            errors.append(f"Unclosed string literal ({quote}) detected")
+    # Unclosed block comments <# ... #>
+    if content.count("<#") != content.count("#>"):
+        errors.append("Unclosed block comment (<# ... #>)")
+    if errors:
+        msg = tr(
+            "⚠️ Warning: PowerShell syntax issues found:\n{errors}",
+            errors="\n".join(errors),
+        )
+        return msg
+    return "✅ Syntax valid"

janito/agent/tools/validate_file_syntax/python_validator.py

@@ -0,0 +1,5 @@
+def validate_python(file_path: str) -> str:
+    import py_compile
+
+    py_compile.compile(file_path, doraise=True)
+    return "✅ Syntax valid"

janito/agent/tools/validate_file_syntax/xml_validator.py

@@ -0,0 +1,11 @@
+from janito.i18n import tr
+
+
+def validate_xml(file_path: str) -> str:
+    try:
+        from lxml import etree
+    except ImportError:
+        return tr("⚠️ lxml not installed. Cannot validate XML.")
+    with open(file_path, "rb") as f:
+        etree.parse(f)
+    return "✅ Syntax valid"

janito/agent/tools/validate_file_syntax/yaml_validator.py

@@ -0,0 +1,6 @@
+def validate_yaml(file_path: str) -> str:
+    import yaml
+
+    with open(file_path, "r", encoding="utf-8") as f:
+        yaml.safe_load(f)
+    return "✅ Syntax valid"

janito/agent/tools_utils/__init__.py

@@ -0,0 +1 @@
+# tools_utils package init

janito/agent/tools_utils/action_type.py

@@ -0,0 +1,7 @@
+from enum import Enum, auto
+
+
+class ActionType(Enum):
+    READ = auto()
+    WRITE = auto()
+    EXECUTE = auto()

janito/agent/tools_utils/dir_walk_utils.py

@@ -0,0 +1,24 @@
+import os
+from .gitignore_utils import GitignoreFilter
+
+
+def walk_dir_with_gitignore(root_dir, max_depth=None):
+    """
+    Walks the directory tree starting at root_dir, yielding (root, dirs, files) tuples,
+    with .gitignore rules applied.
+    - If max_depth is None, unlimited recursion.
+    - If max_depth=0, only the top-level directory (flat, no recursion).
+    - If max_depth=1, only the root directory (matches 'find . -maxdepth 1').
+    - If max_depth=N (N>1), yields files in root and up to N-1 levels below root (matches 'find . -maxdepth N').
+    """
+    gitignore = GitignoreFilter()
+    for root, dirs, files in os.walk(root_dir):
+        rel_path = os.path.relpath(root, root_dir)
+        depth = 0 if rel_path == "." else rel_path.count(os.sep) + 1
+        if max_depth is not None:
+            if depth >= max_depth:
+                # For max_depth=1, only root (depth=0). For max_depth=2, root and one level below (depth=0,1).
+                if depth > 0:
+                    continue
+        dirs, files = gitignore.filter_ignored(root, dirs, files)
+        yield root, dirs, files

janito/agent/tools_utils/formatting.py

@@ -0,0 +1,49 @@
+class OutlineFormatter:
+    """
+    Utility class for formatting code and markdown outlines into human-readable tables.
+    """
+
+    @staticmethod
+    def format_outline_table(outline_items):
+        """
+        Format a list of code outline items (classes, functions, variables) into a table.
+
+        Args:
+            outline_items (list of dict): Each dict should contain keys: 'type', 'name', 'start', 'end', 'parent', 'docstring'.
+
+        Returns:
+            str: Formatted table as a string.
+        """
+        if not outline_items:
+            return "No classes, functions, or variables found."
+        header = "| Type    | Name        | Start | End | Parent   | Docstring                |\n|---------|-------------|-------|-----|----------|--------------------------|"
+        rows = []
+        for item in outline_items:
+            docstring = item.get("docstring", "").replace("\n", " ")
+            if len(docstring) > 24:
+                docstring = docstring[:21] + "..."
+            rows.append(
+                f"| {item['type']:<7} | {item['name']:<11} | {item['start']:<5} | {item['end']:<3} | {item['parent']:<8} | {docstring:<24} |"
+            )
+        return header + "\n" + "\n".join(rows)
+
+    @staticmethod
+    def format_markdown_outline_table(outline_items):
+        """
+        Format a list of markdown outline items (headers) into a table.
+
+        Args:
+            outline_items (list of dict): Each dict should contain keys: 'level', 'title', 'line'.
+
+        Returns:
+            str: Formatted table as a string.
+        """
+        if not outline_items:
+            return "No headers found."
+        header = "| Level | Header                          | Line |\n|-------|----------------------------------|------|"
+        rows = []
+        for item in outline_items:
+            rows.append(
+                f"| {item['level']:<5} | {item['title']:<32} | {item['line']:<4} |"
+            )
+        return header + "\n" + "\n".join(rows)

janito/agent/tools_utils/gitignore_utils.py

@@ -0,0 +1,69 @@
+import os
+import pathspec
+
+
+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.
+
+    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.
+    """
+
+    def __init__(self, gitignore_path: str = ".gitignore"):
+        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

@@ -0,0 +1,30 @@
+import os
+import urllib.parse
+from janito.agent.runtime_config import runtime_config
+
+
+def display_path(path):
+    """
+    Returns a display-friendly path. If runtime_config['termweb_port'] is set, injects an ANSI hyperlink to the local web file viewer.
+    Args:
+        path (str): Path to display.
+    Returns:
+        str: Display path, optionally as an ANSI hyperlink.
+    """
+    if os.path.isabs(path):
+        disp = path
+    else:
+        disp = os.path.relpath(path)
+    port = runtime_config.get("termweb_port")
+    if port:
+        url = f"http://localhost:{port}/?path={urllib.parse.quote(path)}"
+        # Use Rich markup for hyperlinks
+        return f"[link={url}]{disp}[/link]"
+    return disp
+
+
+def pluralize(word: str, count: int) -> str:
+    """Return the pluralized form of word if count != 1, unless word already ends with 's'."""
+    if count == 1 or word.endswith("s"):
+        return word
+    return word + "s"

janito/cli/_livereload_log_utils.py

@@ -0,0 +1,13 @@
+def print_livereload_logs(stdout_path, stderr_path):
+    print("\n[LiveReload stdout log]")
+    try:
+        with open(stdout_path, encoding="utf-8") as f:
+            print(f.read())
+    except Exception as e:
+        print(f"[Error reading stdout log: {e}]")
+    print("\n[LiveReload stderr log]")
+    try:
+        with open(stderr_path, encoding="utf-8") as f:
+            print(f.read())
+    except Exception as e:
+        print(f"[Error reading stderr log: {e}]")

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

@@ -8,8 +8,33 @@ def create_parser():
     parser = argparse.ArgumentParser(
         description="OpenRouter API call using OpenAI Python SDK"
     )
+    # The positional argument is interpreted as either a prompt or session_id depending on context
     parser.add_argument(
-        "prompt", type=str, nargs="?", help="Prompt to send to the model"
+        "input_arg",
+        type=str,
+        nargs="?",
+        help="Prompt to send to the model, or session ID if --continue is used.",
+    )
+
+    parser.add_argument(
+        "--list",
+        nargs="?",
+        type=int,
+        const=10,
+        default=None,
+        help="List the last N sessions (default: 10) and exit.",
+    )
+    parser.add_argument(
+        "--view",
+        type=str,
+        default=None,
+        help="View the content of a conversation history by session id and exit.",
+    )
+    parser.add_argument(
+        "--set-provider-config",
+        nargs=3,
+        metavar=("NAME", "KEY", "VALUE"),
+        help="Set a provider config parameter (e.g., --set-provider-config openai api_key sk-xxx).",
     )
     parser.add_argument(
         "--lang",
@@ -18,11 +43,16 @@ def create_parser():
         help="Language for interface messages (e.g., en, pt). Overrides config if set.",
     )
 
+    parser.add_argument(
+        "--app-shell",
+        action="store_true",
+        help="Use the new prompt_toolkit Application-based chat shell (experimental)",
+    )
     parser.add_argument(
         "--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",
@@ -154,12 +184,19 @@ def create_parser():
     )
     parser.add_argument(
         "--continue-session",
+        "--continue",
         action="store_true",
-        help="Continue from the last saved conversation",
+        default=False,
+        help="Continue from a saved conversation. Uses the session ID from the positional argument if provided, otherwise resumes the most recent session.",
     )
     parser.add_argument(
         "--web", action="store_true", help="Launch the Janito web server instead of CLI"
     )
+    parser.add_argument(
+        "--live",
+        action="store_true",
+        help="Launch the Janito live reload server for web development",
+    )
     parser.add_argument(
         "--config-reset-local",
         action="store_true",
@@ -175,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",
@@ -194,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",
@@ -219,6 +251,17 @@ def create_parser():
         "-i",
         "--info",
         action="store_true",
-        help="Exibe informações básicas do programa e sai (útil para execução única em shell)",
+        help="Show basic program info and exit (useful for one-shot shell execution)",
+    )
+    parser.add_argument(
+        "--ntt",
+        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