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

janito/agent/tools/validate_file_syntax/json_validator.py

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

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/dir_walk_utils.py

@@ -0,0 +1,23 @@
+import os
+from .gitignore_utils import filter_ignored
+
+
+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').
+    """
+    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 = filter_ignored(root, dirs, files)
+        yield root, dirs, files

janito/agent/{tools/outline_file → tools_utils}/formatting.py

@@ -1,11 +1,14 @@
 def format_outline_table(outline_items):
     if not outline_items:
         return "No classes, functions, or variables found."
-    header = "| Type    | Name        | Start | End | Parent   |\n|---------|-------------|-------|-----|----------|"
+    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} |"
+            f"| {item['type']:<7} | {item['name']:<11} | {item['start']:<5} | {item['end']:<3} | {item['parent']:<8} | {docstring:<24} |"
         )
     return header + "\n" + "\n".join(rows)
 

janito/agent/{tools → tools_utils}/gitignore_utils.py

@@ -1,13 +1,11 @@
 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
@@ -19,7 +17,6 @@ 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/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/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 openrouter.ai api_key sk-xxx).",
     )
     parser.add_argument(
         "--lang",
@@ -18,6 +43,11 @@ 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,
@@ -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",
@@ -219,6 +256,11 @@ 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)",
     )
     return parser

janito/cli/{runner/cli_main.py → cli_main.py}

@@ -9,6 +9,7 @@ from janito.agent.conversation_exceptions import (
     EmptyResponseError,
     ProviderError,
 )
+from janito.shell.main import start_chat_shell
 
 
 def is_port_free(port):
@@ -25,6 +26,9 @@ def run_cli(args):
     if getattr(args, "vanilla", False):
         runtime_config.set("vanilla_mode", True)
 
+    # Set no_tools_tracking if --ntt is passed
+    if getattr(args, "ntt", False):
+        runtime_config.set("no_tools_tracking", True)
     # Normalize all verbose flags into runtime_config
     for flag in [
         "verbose_http",
@@ -77,13 +81,14 @@ def run_cli(args):
     if getattr(args, "verbose_reason", False):
         runtime_config.set("verbose_reason", True)
 
-    # --- Liteweb integration ---
+    # --- termweb integration ---
     termweb_proc = None
     selected_port = None
     if (
         not getattr(args, "no_termweb", False)
         and interaction_mode == "chat"
         and not runtime_config.get("vanilla_mode", False)
+        and not getattr(args, "input_arg", None)  # Prevent termweb in one-shot mode
     ):
         default_port = 8088
         max_port = 8100
@@ -94,13 +99,21 @@ def run_cli(args):
                     selected_port = port
                     break
             if selected_port is None:
-                print(
+                from rich.console import Console
+
+                console = Console()
+                console.print(
                     f"[red]No free port found for termweb in range {default_port}-{max_port}.[/red]"
                 )
                 sys.exit(1)
         else:
             if not is_port_free(requested_port):
-                print(f"[red]Port {requested_port} is not available for termweb.[/red]")
+                from rich.console import Console
+
+                console = Console()
+                console.print(
+                    f"[red]Port {requested_port} is not available for termweb.[/red]"
+                )
                 sys.exit(1)
             selected_port = requested_port
         runtime_config.set("termweb_port", selected_port)
@@ -118,22 +131,83 @@ def run_cli(args):
 
     # --- End termweb integration ---
     try:
-        if not getattr(args, "prompt", None):
-            from janito.cli_chat_shell.chat_loop import start_chat_shell
-
-            start_chat_shell(
-                profile_manager,
-                continue_session=getattr(args, "continue_session", False),
-                termweb_stdout_path=(
-                    termweb_stdout_path if "termweb_stdout_path" in locals() else None
-                ),
-                termweb_stderr_path=(
-                    termweb_stderr_path if "termweb_stderr_path" in locals() else None
-                ),
+        livereload_stdout_path = None
+        livereload_stderr_path = None
+        continue_session = False
+        session_id = None
+        if getattr(args, "input_arg", None):
+            from janito.cli.one_shot import run_oneshot_mode
+
+            run_oneshot_mode(args, profile_manager, runtime_config)
+            return
+        if not getattr(args, "input_arg", None) or getattr(
+            args, "continue_session", False
+        ):
+            # Determine continue_session and session_id
+            _cont = getattr(args, "continue_session", False)
+            if _cont:
+                continue_session = True
+                session_id = getattr(args, "input_arg", None)
+                if session_id is None:
+                    # Find the most recent session id from .janito/chat_history/*.json
+                    import os
+                    import glob
+
+                    chat_hist_dir = (
+                        os.path.join(os.path.expanduser("~"), ".janito", "chat_history")
+                        if not os.path.isabs(".janito")
+                        else os.path.join(".janito", "chat_history")
+                    )
+                    if not os.path.exists(chat_hist_dir):
+                        session_id = None
+                    else:
+                        files = glob.glob(os.path.join(chat_hist_dir, "*.json"))
+                        if files:
+                            latest = max(files, key=os.path.getmtime)
+                            session_id = os.path.splitext(os.path.basename(latest))[0]
+                        else:
+                            session_id = None
+            else:
+                continue_session = False
+                session_id = None
+        import time
+
+        info_start_time = None
+        if getattr(args, "info", False):
+            info_start_time = time.time()
+        usage_info = start_chat_shell(
+            profile_manager,
+            continue_session=continue_session,
+            session_id=session_id,
+            termweb_stdout_path=(
+                termweb_stdout_path if "termweb_stdout_path" in locals() else None
+            ),
+            termweb_stderr_path=(
+                termweb_stderr_path if "termweb_stderr_path" in locals() else None
+            ),
+            livereload_stdout_path=(
+                livereload_stdout_path if "livereload_stdout_path" in locals() else None
+            ),
+            livereload_stderr_path=(
+                livereload_stderr_path if "livereload_stderr_path" in locals() else None
+            ),
+        )
+        if (
+            getattr(args, "info", False)
+            and usage_info is not None
+            and info_start_time is not None
+        ):
+            elapsed = time.time() - info_start_time
+            from rich.console import Console
+
+            console = Console()
+            total_tokens = usage_info.get("total_tokens")
+            console.print(
+                f"[bold green]Total tokens used:[/] [yellow]{total_tokens}[/yellow] [bold green]| Elapsed time:[/] [yellow]{elapsed:.2f}s[/yellow]"
             )
-            sys.exit(0)
+        sys.exit(0)
         # --- Prompt mode ---
-        prompt = args.prompt
+        prompt = getattr(args, "input_arg", None)
         from rich.console import Console
         from janito.agent.rich_message_handler import RichMessageHandler
 
@@ -154,15 +228,41 @@ def run_cli(args):
                 {"role": "system", "content": profile_manager.system_prompt_template}
             )
         messages.append({"role": "user", "content": prompt})
+        import time
+
+        info_start_time = None
+        if getattr(args, "info", False):
+            info_start_time = time.time()
         try:
-            max_rounds = 50
-            profile_manager.agent.chat(
-                messages,
+            max_rounds = 100
+            from janito.agent.conversation_history import ConversationHistory
+
+            result = profile_manager.agent.chat(
+                ConversationHistory(messages),
                 message_handler=message_handler,
                 spinner=True,
                 max_rounds=max_rounds,
                 stream=getattr(args, "stream", False),
             )
+            if (
+                getattr(args, "info", False)
+                and info_start_time is not None
+                and result is not None
+            ):
+                usage_info = result.get("usage")
+                total_tokens = usage_info.get("total_tokens") if usage_info else None
+                prompt_tokens = usage_info.get("prompt_tokens") if usage_info else None
+                completion_tokens = (
+                    usage_info.get("completion_tokens") if usage_info else None
+                )
+                elapsed = time.time() - info_start_time
+                from rich.console import Console
+
+                console = Console()
+                console.print(
+                    f"[bold green]Total tokens:[/] [yellow]{total_tokens}[/yellow] [bold green]| Input:[/] [cyan]{prompt_tokens}[/cyan] [bold green]| Output:[/] [magenta]{completion_tokens}[/magenta] [bold green]| Elapsed:[/] [yellow]{elapsed:.2f}s[/yellow]",
+                    style="dim",
+                )
         except MaxRoundsExceededError:
             console.print("[red]Max conversation rounds exceeded.[/red]")
         except ProviderError as e:

janito/cli/livereload_starter.py

@@ -0,0 +1,60 @@
+import sys
+import subprocess
+import tempfile
+import time
+import http.client
+import os
+from rich.console import Console
+
+
+def wait_for_livereload(port, timeout=3.0):
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        try:
+            conn = http.client.HTTPConnection("localhost", port, timeout=0.5)
+            conn.request("GET", "/")
+            resp = conn.getresponse()
+            if resp.status in (200, 404):
+                return True
+        except Exception:
+            pass
+        time.sleep(0.1)
+    return False
+
+
+def start_livereload(selected_port):
+    console = Console()
+    with console.status("[cyan]Starting live reload server...", spinner="dots"):
+        app_py_path = os.path.join(
+            os.path.dirname(__file__), "..", "livereload", "app.py"
+        )
+        app_py_path = os.path.abspath(app_py_path)
+        if not os.path.isfile(app_py_path):
+            console.print("[red]Could not find livereload app.py![/red]")
+            return None, False, None, None
+        livereload_stdout = tempfile.NamedTemporaryFile(
+            delete=False, mode="w+", encoding="utf-8"
+        )
+        livereload_stderr = tempfile.NamedTemporaryFile(
+            delete=False, mode="w+", encoding="utf-8"
+        )
+        livereload_proc = subprocess.Popen(
+            [sys.executable, app_py_path, "--port", str(selected_port)],
+            stdout=livereload_stdout,
+            stderr=livereload_stderr,
+        )
+        if wait_for_livereload(selected_port, timeout=3.0):
+            console.print(
+                f"LiveReload started... Available at http://localhost:{selected_port}"
+            )
+            return livereload_proc, True, livereload_stdout.name, livereload_stderr.name
+        else:
+            livereload_proc.terminate()
+            livereload_proc.wait()
+            from janito.cli._livereload_log_utils import print_livereload_logs
+
+            console.print(
+                f"[red]Failed to start LiveReload on port {selected_port}. Check logs for details.[/red]"
+            )
+            print_livereload_logs(livereload_stdout.name, livereload_stderr.name)
+            return None, False, livereload_stdout.name, livereload_stderr.name