janito 1.2.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

janito/agent/tools/find_files.py

@@ -1,37 +1,58 @@
 import os
 import fnmatch
 from janito.agent.tool_handler import ToolHandler
-from janito.agent.tools.rich_utils import print_info, print_success, print_error, format_path, format_number
-from janito.agent.tools.gitignore_utils import load_gitignore_patterns, filter_ignored
+from janito.agent.tools.rich_utils import print_info, print_success, print_error
 
 @ToolHandler.register_tool
-def find_files(directory: str, pattern: str = "*") -> str:
+def find_files(
+    directory: str,
+    pattern: str,
+    recursive: bool = False,
+    max_results: int = 100
+) -> str:
     """
-    Recursively find files matching a pattern within a directory, skipping ignored files/dirs.
-
-    directory: The root directory to start searching from.
-    pattern: Glob pattern to match filenames (default: '*').
+    Find files in a directory matching a pattern.
+    Args:
+        directory (str): The directory to search in.
+        pattern (str): The filename pattern to match (e.g., '*.txt').
+        recursive (bool): Whether to search subdirectories.
+        max_results (int): Maximum number of results to return.
+    Returns:
+        str: Newline-separated list of matching file paths, with summary and warnings if truncated.
     """
-    print_info(f"🔍 Searching for files in '{format_path(directory)}' matching pattern '{pattern}' ... ")
-
-    # Check if pattern is an exact relative path to a file
-    full_path = os.path.join(directory, pattern)
-    if os.path.isfile(full_path):
-        print_success("✅ Found 1 file (exact match)")
-        return full_path
-
+    print_info(f"🔍 find_files | Dir: {directory} | Pattern: {pattern} | Recursive: {recursive} | Max: {max_results}")
+    # Input validation
+    if not os.path.isdir(directory):
+        print_error(f"❌ Not a directory: {directory}")
+        return ""
+    if not isinstance(max_results, int) or max_results <= 0:
+        print_error(f"❌ Invalid max_results value: {max_results}")
+        return ""
     matches = []
-    ignore_patterns = load_gitignore_patterns()
     try:
-        for root, dirs, files in os.walk(directory):
-            dirs, files = filter_ignored(root, dirs, files, ignore_patterns)
-            for filename in fnmatch.filter(files, pattern):
-                matches.append(os.path.join(root, filename))
-        print_success(f"✅ Found {format_number(len(matches))} files")
-        if matches:
-            return "\n".join(matches)
+        if recursive:
+            for root, dirs, files in os.walk(directory):
+                for name in files:
+                    if fnmatch.fnmatch(name, pattern):
+                        matches.append(os.path.join(root, name))
+                        if len(matches) >= max_results:
+                            break
+                if len(matches) >= max_results:
+                    break
         else:
-            return "No matching files found."
+            for name in os.listdir(directory):
+                full_path = os.path.join(directory, name)
+                if os.path.isfile(full_path) and fnmatch.fnmatch(name, pattern):
+                    matches.append(full_path)
+                    if len(matches) >= max_results:
+                        break
     except Exception as e:
-        print_error(f"❌ Error: {e}")
-        return f"❌ Failed to search files in '{directory}': {e}"
+        print_error(f"❌ Error during file search: {e}")
+        return ""
+    print_success(f"✅ Found {len(matches)} file(s)")
+    result = f"Total files found: {len(matches)}\n"
+    result += "\n".join(matches)
+    if len(matches) == max_results:
+        result += "\n# WARNING: Results truncated at max_results. There may be more matching files."
+    return result
+

janito/agent/tools/get_lines.py

@@ -0,0 +1,58 @@
+import os
+from janito.agent.tool_handler import ToolHandler
+from janito.agent.tools.rich_utils import print_info, print_success, print_error, format_path, format_number
+
+@ToolHandler.register_tool
+def get_lines(
+    file_path: str,
+    from_line: int = None,
+    to_line: int = None
+) -> str:
+    """
+    Get lines from a file, optionally with a summary of lines outside the viewed range.
+    Always returns the total number of lines in the file at the top of the output.
+    
+    Parameters:
+      - file_path (string): Path to the file.
+      - from_line (integer, optional): First line to view (1-indexed). If omitted with to_line, returns all lines.
+      - to_line (integer, optional): Last line to view (inclusive, 1-indexed, and cannot be more than 200 lines from from_line).
+    
+    If both from_line and to_line are omitted, returns all lines in the file.
+    It is recommended to request at least 100 lines or the full file for more efficient context building.
+    """
+    if from_line is None and to_line is None:
+        print_info(f"📂 get_lines | Path: {format_path(file_path)} | All lines requested")
+    else:
+        print_info(f"📂 get_lines | Path: {format_path(file_path)} | Lines ({from_line}-{to_line})")
+    if not os.path.isfile(file_path):
+        print_info(f"ℹ️ File not found: {file_path}")
+        return ""
+    with open(file_path, "r", encoding="utf-8") as f:
+        lines = f.readlines()
+    total_lines = len(lines)
+    if from_line is None and to_line is None:
+        numbered_content = ''.join(f"{i+1}: {line}" for i, line in enumerate(lines))
+        print_success(f"✅ Returned all {total_lines} lines")
+        return f"Total lines in file: {total_lines}\n" + numbered_content
+    # Validate range
+    if from_line is None or to_line is None:
+        print_error(f"❌ Both from_line and to_line must be provided, or neither.")
+        return ""
+    if from_line < 1 or to_line < from_line or (to_line - from_line > 200):
+        print_error(f"❌ Invalid line range: {from_line}-{to_line} for file with {total_lines} lines.")
+        return ""
+    if to_line > total_lines:
+        to_line = total_lines
+    selected = lines[from_line-1:to_line]
+    numbered_content = ''.join(f"{i}: {line}" for i, line in zip(range(from_line, to_line+1), selected))
+    before = lines[:from_line-1]
+    after = lines[to_line:]
+    before_summary = f"... {len(before)} lines before ...\n" if before else ""
+    after_summary = f"... {len(after)} lines after ...\n" if after else ""
+    summary = before_summary + after_summary
+    if from_line == 1 and to_line == total_lines:
+        print_success(f"✅ Returned all {total_lines} lines")
+    else:
+        print_success(f"✅ Returned lines {from_line} to {to_line} of {total_lines}")
+    total_line_info = f"Total lines in file: {total_lines}\n"
+    return total_line_info + summary + numbered_content

janito/agent/tools/py_compile.py

@@ -0,0 +1,26 @@
+from janito.agent.tool_handler import ToolHandler
+from janito.agent.tools.rich_utils import print_info
+import py_compile
+from typing import Optional
+
+@ToolHandler.register_tool
+def py_compile_file(path: str, doraise: Optional[bool] = True) -> str:
+    """
+    Validate a Python file by compiling it with py_compile.
+    This tool should be used to validate Python files after changes.
+
+    Args:
+        path (str): Path to the Python file to validate.
+        doraise (Optional[bool]): If True, raise exceptions on compilation errors. Default is True.
+
+    Returns:
+        str: Success message or error details if compilation fails.
+    """
+    print_info(f"[py_compile_file] Validating Python file: {path}")
+    try:
+        py_compile.compile(path, doraise=doraise)
+        return f"Validation successful: {path} is a valid Python file."
+    except FileNotFoundError:
+        return f"Validation failed: File not found: {path}"
+    except py_compile.PyCompileError as e:
+        return f"Validation failed: {e}"

janito/agent/tools/python_exec.py

@@ -0,0 +1,47 @@
+from janito.agent.tool_handler import ToolHandler
+from janito.agent.tools.rich_utils import print_info
+import sys
+import multiprocessing
+import io
+from typing import Callable, Optional
+
+
+def _run_python_code(code: str, result_queue):
+    import traceback
+    import contextlib
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+    with contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr):
+        exec(code, {'__name__': '__main__'})
+    result_queue.put({
+        'stdout': stdout.getvalue(),
+        'stderr': stderr.getvalue(),
+        'returncode': 0
+    })
+
+
+@ToolHandler.register_tool
+def python_exec(code: str, on_progress: Optional[Callable[[dict], None]] = None) -> str:
+    """
+    Execute Python code in a separate process and capture output.
+
+    Args:
+        code (str): The Python code to execute.
+        on_progress (Optional[Callable[[dict], None]]): Optional callback function for streaming progress updates (not used).
+
+    Returns:
+        str: A formatted message string containing stdout, stderr, and return code.
+    """
+    print_info(f"[python_exec] Executing Python code:")
+    print_info(code)
+    result_queue = multiprocessing.Queue()
+    process = multiprocessing.Process(target=_run_python_code, args=(code, result_queue))
+    process.start()
+    process.join()
+    if not result_queue.empty():
+        result = result_queue.get()
+    else:
+        result = {'stdout': '', 'stderr': 'No result returned from process.', 'returncode': -1}
+    print_info(f"[python_exec] Execution completed.")
+    print_info(f"[python_exec] Return code: {result['returncode']}")
+    return f"stdout:\n{result['stdout']}\nstderr:\n{result['stderr']}\nreturncode: {result['returncode']}"

janito/agent/tools/remove_directory.py

@@ -0,0 +1,38 @@
+import os
+import shutil
+from janito.agent.tool_handler import ToolHandler
+from janito.agent.tools.rich_utils import print_info, print_success, print_error, format_path
+
+def _is_dir_empty(path):
+    return not any(os.scandir(path))
+
+@ToolHandler.register_tool
+def remove_directory(path: str, recursive: bool = False) -> str:
+    """
+    Remove a directory. If recursive is False and the directory is not empty, return an error.
+
+    Args:
+        path (str): Path to the directory to remove.
+        recursive (bool): Whether to remove non-empty directories recursively. Default is False.
+    Returns:
+        str: Result message.
+    """
+    if not os.path.exists(path):
+        print_error(f"❌ Directory '{path}' does not exist.")
+        return f"❌ Directory '{path}' does not exist."
+    if not os.path.isdir(path):
+        print_error(f"❌ Path '{path}' is not a directory.")
+        return f"❌ Path '{path}' is not a directory."
+    if recursive:
+        print_info(f"🗑️  Recursively removing directory: '{format_path(path)}' ... ")
+        shutil.rmtree(path)
+        print_success("✅ Success")
+        return f"✅ Successfully removed directory and all contents at '{path}'."
+    else:
+        if not _is_dir_empty(path):
+            print_error(f"❌ Directory '{path}' is not empty. Use recursive=True to remove non-empty directories.")
+            return f"❌ Directory '{path}' is not empty. Use recursive=True to remove non-empty directories."
+        print_info(f"🗑️  Removing empty directory: '{format_path(path)}' ... ")
+        os.rmdir(path)
+        print_success("✅ Success")
+        return f"✅ Successfully removed empty directory at '{path}'."

janito/agent/tools/replace_text_in_file.py

@@ -0,0 +1,67 @@
+import os
+from janito.agent.tool_handler import ToolHandler
+from janito.agent.tools.rich_utils import print_info, print_success, print_error, format_path
+
+@ToolHandler.register_tool
+def replace_text_in_file(file_path: str, search_text: str, replacement_text: str, replace_all: bool = False) -> str:
+    """
+
+    Replace exact occurrences of a given text in a file. The match must be exact, including whitespace and indentation, to avoid breaking file syntax or formatting.
+
+    Args:
+        file_path (str): Path to the plain text file.
+        search_text (str): Text to search for (exact match).
+        replacement_text (str): Text to replace search_text with.
+        replace_all (bool): Whether to replace all occurrences or just the first. Default is False.
+    Returns:
+        str: Result message.
+    """
+    search_preview = (search_text[:15] + '...') if len(search_text) > 15 else search_text
+    replace_preview = (replacement_text[:15] + '...') if len(replacement_text) > 15 else replacement_text
+    replace_all_msg = f" | Replace all: True" if replace_all else ""
+    print_info(f"📝 replace_text_in_file | Path: {format_path(file_path)} | Search: '{search_preview}' | Replacement: '{replace_preview}'{replace_all_msg}")
+    if not os.path.isfile(file_path):
+        print_error(f"❌ File not found: {file_path}")
+        return f"❌ Error: File not found: {file_path}"
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            content = f.read()
+    except PermissionError:
+        print_error(f"❌ Permission denied: {file_path}")
+        return f"❌ Error: Permission denied: {file_path}"
+    except Exception as e:
+        print_error(f"❌ Error reading file: {e}")
+        return f"❌ Error reading file: {e}"
+
+    count = content.count(search_text)
+    if count == 0:
+        print_info(f"ℹ️  Search text not found in file.")
+        return f"ℹ️ No occurrences of search text found in '{file_path}'."
+    if replace_all:
+        new_content = content.replace(search_text, replacement_text)
+        replaced_count = count
+    else:
+        if count > 1:
+            # Find line numbers where search_text appears
+            lines = content.splitlines()
+            found_lines = [i+1 for i, line in enumerate(lines) if search_text in line]
+            preview = search_text[:40] + ('...' if len(search_text) > 40 else '')
+            print_error(f"❌ Search text found multiple times ({count}). Please provide a more exact match or set replace_all=True.")
+            return (
+                f"❌ Error: Search text found {count} times in '{file_path}'. "
+                f"Preview: '{preview}'. Found at lines: {found_lines}. "
+                f"Please provide a more exact match."
+            )
+        new_content = content.replace(search_text, replacement_text, 1)
+        replaced_count = 1 if count == 1 else 0
+    try:
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(new_content)
+    except PermissionError:
+        print_error(f"❌ Permission denied when writing: {file_path}")
+        return f"❌ Error: Permission denied when writing: {file_path}"
+    except Exception as e:
+        print_error(f"❌ Error writing file: {e}")
+        return f"❌ Error writing file: {e}"
+    print_success(f"✅ Replaced {replaced_count} occurrence(s) of search text in '{file_path}'.")
+    return f"✅ Replaced {replaced_count} occurrence(s) of search text in '{file_path}'."

janito/agent/tools/run_bash_command.py

@@ -0,0 +1,134 @@
+from janito.agent.tool_handler import ToolHandler
+from janito.agent.runtime_config import runtime_config
+from janito.agent.tools.rich_utils import print_info, print_success, print_error
+import subprocess
+import multiprocessing
+from typing import Optional
+
+import tempfile
+import os
+
+def _run_bash_command(command: str, result_queue: 'multiprocessing.Queue', trust: bool = False):
+    import subprocess
+    with tempfile.NamedTemporaryFile(delete=False, mode='w+', encoding='utf-8', suffix='.stdout') as stdout_file, \
+         tempfile.NamedTemporaryFile(delete=False, mode='w+', encoding='utf-8', suffix='.stderr') as stderr_file:
+        process = subprocess.Popen(
+            command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, encoding='utf-8', errors='replace'
+        )
+        while True:
+            stdout_line = process.stdout.readline() if process.stdout else ''
+            stderr_line = process.stderr.readline() if process.stderr else ''
+            if stdout_line:
+                if not trust:
+                    print(stdout_line, end='')
+                stdout_file.write(stdout_line)
+                stdout_file.flush()
+            if stderr_line:
+                if not trust:
+                    print(stderr_line, end='')
+                stderr_file.write(stderr_line)
+                stderr_file.flush()
+            if not stdout_line and not stderr_line and process.poll() is not None:
+                break
+        # Capture any remaining output after process ends
+        if process.stdout:
+            for line in process.stdout:
+                if not trust:
+                    print(line, end='')
+                stdout_file.write(line)
+        if process.stderr:
+            for line in process.stderr:
+                if not trust:
+                    print(line, end='')
+                stderr_file.write(line)
+        stdout_file_path = stdout_file.name
+        stderr_file_path = stderr_file.name
+    result_queue.put({
+        'stdout_file': stdout_file_path,
+        'stderr_file': stderr_file_path,
+        'returncode': process.returncode
+    })
+
+
+@ToolHandler.register_tool
+def run_bash_command(command: str, timeout: int = 60, require_confirmation: bool = False) -> str:
+    trust = runtime_config.get('trust', False)
+    """
+    Execute a non-interactive bash command and print output live.
+
+    If require_confirmation is True, the user will be prompted to confirm execution before running the command.
+
+    Args:
+        command (str): The Bash command to execute.
+        timeout (int): Maximum number of seconds to allow the command to run. Default is 60.
+
+    Returns:
+        str: A formatted message string containing stdout, stderr, and return code.
+    """
+    print_info(f"[run_bash_command] Running: {command}")
+    if require_confirmation:
+        # Prompt the user for confirmation directly
+        resp = input(f"Are you sure you want to run this command?\n\n{command}\n\nType 'yes' to confirm: ")
+        if resp.strip().lower() != 'yes':
+            print_error("❌ Command not confirmed by user.")
+            return "❌ Command not confirmed by user."
+    print_info(f"🐛 Running bash command: [bold]{command}[/bold] (timeout: {timeout}s)")
+    result_queue = multiprocessing.Queue()
+    process = multiprocessing.Process(target=_run_bash_command, args=(command, result_queue, trust))
+    process.start()
+    process.join(timeout)
+    if process.is_alive():
+        process.terminate()
+        process.join()
+        result = {'stdout_file': '', 'stderr_file': '', 'error': f'Process timed out after {timeout} seconds.', 'returncode': -1}
+    elif not result_queue.empty():
+        result = result_queue.get()
+    else:
+        result = {'stdout_file': '', 'stderr_file': '', 'error': 'No result returned from process.', 'returncode': -1}
+    if trust:
+        stdout_lines = 0
+        stderr_lines = 0
+        try:
+            with open(result['stdout_file'], 'r', encoding='utf-8') as f:
+                stdout_lines = sum(1 for _ in f)
+        except Exception:
+            pass
+        try:
+            with open(result['stderr_file'], 'r', encoding='utf-8') as f:
+                stderr_lines = sum(1 for _ in f)
+        except Exception:
+            pass
+        print_success(f"✅ Success (trust mode)\nstdout: {result['stdout_file']} (lines: {stdout_lines})\nstderr: {result['stderr_file']} (lines: {stderr_lines})")
+        return (
+            f"✅ Bash command executed in trust mode. Output is stored at:\n"
+            f"stdout: {result['stdout_file']} (lines: {stdout_lines})\n"
+            f"stderr: {result['stderr_file']} (lines: {stderr_lines})\n"
+            f"returncode: {result['returncode']}\n"
+            "To examine the output, use the file-related tools such as get_lines or search_files on the above files."
+        )
+    print_info("🐛 Bash command execution completed.")
+    print_info(f"Return code: {result['returncode']}")
+    if result.get('error'):
+        print_error(f"Error: {result['error']}")
+        return f"❌ Error: {result['error']}\nreturncode: {result['returncode']}"
+    stdout_lines = 0
+    stderr_lines = 0
+    try:
+        with open(result['stdout_file'], 'r', encoding='utf-8') as f:
+            stdout_lines = sum(1 for _ in f)
+    except Exception:
+        pass
+    try:
+        with open(result['stderr_file'], 'r', encoding='utf-8') as f:
+            stderr_lines = sum(1 for _ in f)
+    except Exception:
+        pass
+    print_success(f"✅ Success\nstdout saved to: {result['stdout_file']} (lines: {stdout_lines})\nstderr saved to: {result['stderr_file']} (lines: {stderr_lines})")
+    return (
+        f"✅ Bash command executed.\n"
+        f"stdout saved to: {result['stdout_file']} (lines: {stdout_lines})\n"
+        f"stderr saved to: {result['stderr_file']} (lines: {stderr_lines})\n"
+        f"returncode: {result['returncode']}\n"
+        "\nTo examine the output, use the file-related tools such as get_lines or search_files on the above files."
+    )
+

janito/agent/tools/search_files.py

@@ -0,0 +1,52 @@
+import os
+import re
+import fnmatch
+from janito.agent.tool_handler import ToolHandler
+from janito.agent.tools.rich_utils import print_info, print_success, print_error, format_path, format_number
+from janito.agent.tools.gitignore_utils import load_gitignore_patterns, filter_ignored
+
+@ToolHandler.register_tool
+def search_files(
+    directory: str,
+    pattern: str
+) -> str:
+    """
+    Search for a text pattern in all files within a directory and return matching lines and their content.
+
+    Args:
+        directory (str): The directory to search in.
+        pattern (str): The text pattern to search for.
+    Returns:
+        str: Each match as 'filepath:lineno:linecontent', one per line.
+    """
+    print_info(f"🔎 search_files | Path: {directory} | pattern: '{pattern}'")
+    results = []
+    ignore_patterns = load_gitignore_patterns()
+    try:
+        regex = re.compile(pattern, re.IGNORECASE)
+    except re.error:
+        regex = None
+
+    files_to_search = []
+    if os.path.isfile(directory):
+        files_to_search = [directory]
+    else:
+        for root, dirs, files in os.walk(directory):
+            dirs, files = filter_ignored(root, dirs, files, ignore_patterns)
+            for file in files:
+                filepath = os.path.join(root, file)
+                files_to_search.append(filepath)
+
+    for filepath in files_to_search:
+        with open(filepath, 'r', encoding='utf-8', errors='replace') as f:
+            for lineno, line in enumerate(f, start=1):
+                if regex:
+                    if regex.search(line):
+                        results.append(f"{filepath}:{lineno}:{line.rstrip()}")
+                else:
+                    if pattern.lower() in line.lower():
+                        results.append(f"{filepath}:{lineno}:{line.rstrip()}")
+
+    print_success(f"✅ Found {format_number(len(results))} matches")
+    return "\n".join(results)
+

janito/cli/_print_config.py

@@ -1,22 +1,22 @@
 import os
-from rich import print
+from janito.agent.tools.rich_utils import print_info, print_success, print_error, print_warning, print_magenta
 from ._utils import home_shorten
 
 def print_config_items(items, color_label=None):
     if not items:
         return
     if color_label:
-        print(color_label)
+        print_info(color_label)
     home = os.path.expanduser("~")
     for key, value in items.items():
         if key == "system_prompt" and isinstance(value, str):
             if value.startswith(home):
                 print(f"{key} = {home_shorten(value)}")
             else:
-                print(f"{key} = {value}")
+                print_info(f"{key} = {value}")
         else:
-            print(f"{key} = {value}")
-    print()
+            print_info(f"{key} = {value}")
+    print_info("")
 
 def print_full_config(local_config, global_config, unified_config, config_defaults, console=None):
     """
@@ -28,9 +28,9 @@ def print_full_config(local_config, global_config, unified_config, config_defaul
     local_keys = set(local_config.all().keys())
     global_keys = set(global_config.all().keys())
     all_keys = set(config_defaults.keys()) | global_keys | local_keys
-    out = print if console is None else console.print
+    out = print_info if console is None else console.print
     if not (local_keys or global_keys):
-        out("No configuration found.")
+        print_warning("No configuration found.")
     else:
         for key in sorted(local_keys):
             if key == "api_key":
@@ -57,12 +57,12 @@ def print_full_config(local_config, global_config, unified_config, config_defaul
         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:
-            out("[green]🟢 Defaults (not set in config files)[/green]")
+            print_magenta("[green]🟢 Defaults (not set in config files)[/green]")
             from pathlib import Path
-            template_path = Path(__file__).parent.parent / "templates" / "system_instructions.j2"
+            template_path = Path(__file__).parent / "agent" / "templates" / "system_instructions.j2"
             for key, value in default_items.items():
                 if key == "system_prompt" and value is None:
-                    out(f"{key} = (default template path: {home_shorten(str(template_path))})")
+                    print_info(f"{key} = (default template path: {home_shorten(str(template_path))})")
                 else:
-                    out(f"{key} = {value}")
-            out("")
+                    print_info(f"{key} = {value}")
+            print_info("")

janito/cli/arg_parser.py

@@ -4,8 +4,11 @@ import argparse
 def create_parser():
     parser = argparse.ArgumentParser(description="OpenRouter API call using OpenAI Python SDK")
     parser.add_argument("prompt", type=str, nargs="?", help="Prompt to send to the model")
+
     parser.add_argument("--max-tokens", type=int, default=None, help="Maximum tokens for model response (overrides config, default: 200000)")
+    parser.add_argument("--max-tools", type=int, default=None, help="Maximum number of tool calls allowed within a chat session (default: unlimited)")
     parser.add_argument("--model", type=str, default=None, help="Model name to use for this session (overrides config, does not persist)")
+    parser.add_argument("--max-rounds", type=int, default=None, help="Maximum number of agent rounds per prompt (overrides config, default: 50)")
 
     # Mutually exclusive group for system prompt options
     group = parser.add_mutually_exclusive_group()
@@ -19,9 +22,10 @@ def create_parser():
     parser.add_argument("--verbose-response", action="store_true", help="Pretty print the full response object")
     parser.add_argument("--show-system", action="store_true", help="Show model, parameters, system prompt, and tool definitions, then exit")
     parser.add_argument("--verbose-tools", action="store_true", help="Print tool call parameters and results")
-    parser.add_argument("--disable-tools", action="store_true", default=False, help="Disable tool use (default: enabled)")
+    parser.add_argument("-n", "--no-tools", action="store_true", default=False, help="Disable tool use (default: enabled)")
     parser.add_argument("--set-local-config", type=str, default=None, help='Set a local config key-value pair, format "key=val"')
     parser.add_argument("--set-global-config", type=str, default=None, help='Set a global config key-value pair, format "key=val"')
+    parser.add_argument("--run-config", type=str, action='append', default=None, help='Set a runtime (in-memory only) config key-value pair, format "key=val". Can be repeated.')
     parser.add_argument("--show-config", action="store_true", help="Show effective configuration and exit")
     parser.add_argument("--set-api-key", type=str, default=None, help="Set and save the API key globally")
     parser.add_argument("--version", action="store_true", help="Show program's version number and exit")
@@ -30,4 +34,5 @@ def create_parser():
     parser.add_argument("--web", action="store_true", help="Launch the Janito web server instead of CLI")
     parser.add_argument("--config-reset-local", action="store_true", help="Remove the local config file (~/.janito/config.json)")
     parser.add_argument("--config-reset-global", action="store_true", help="Remove the global config file (~/.janito/config.json)")
+    parser.add_argument("--trust", action="store_true", help="Enable trust mode: suppresses run_bash_command output, only shows output file locations.")
     return parser