janito 1.6.0__py3-none-any.whl → 1.7.0__py3-none-any.whl

janito/agent/tools/__init__.py

@@ -13,10 +13,12 @@ from . import remove_file
 from . import replace_text_in_file
 from . import rich_live
 from . import run_bash_command
+from . import run_powershell_command
 from . import run_python_command
 from . import search_files
 from . import tools_utils
 from . import replace_file
+from . import memory
 
 __all__ = [
     "ask_user",
@@ -34,8 +36,10 @@ __all__ = [
     "replace_text_in_file",
     "rich_live",
     "run_bash_command",
+    "run_powershell_command",
     "run_python_command",
     "search_files",
     "tools_utils",
     "replace_file",
+    "memory",
 ]

janito/agent/tools/ask_user.py

@@ -34,12 +34,18 @@ class AskUserTool(ToolBase):
         def _(event):
             pass
 
+        # F12 instruction rotation
+        _f12_instructions = ["proceed", "go ahead", "continue", "next", "okay"]
+        _f12_index = {"value": 0}
+
         @bindings.add("f12")
         def _(event):
-            """When F12 is pressed, send 'proceed' as input immediately."""
+            """When F12 is pressed, rotate through a set of short instructions."""
             buf = event.app.current_buffer
-            buf.text = "proceed"
+            idx = _f12_index["value"]
+            buf.text = _f12_instructions[idx]
             buf.validate_and_handle()
+            _f12_index["value"] = (idx + 1) % len(_f12_instructions)
 
         style = Style.from_dict(
             {

janito/agent/tools/create_directory.py

@@ -1,6 +1,8 @@
 from janito.agent.tool_registry import register_tool
 from janito.agent.tools.utils import expand_path, display_path
 from janito.agent.tool_base import ToolBase
+import os
+import shutil
 
 
 @register_tool(name="create_directory")
@@ -21,13 +23,28 @@ class CreateDirectoryTool(ToolBase):
         original_path = path
         path = expand_path(path)
         disp_path = display_path(original_path, path)
-        import os
-
-        if os.path.exists(path):
-            if not os.path.isdir(path):
-                self.report_error(
-                    f"\u274c Path '{disp_path}' exists and is not a directory."
-                )
-                return f"\u274c Path '{disp_path}' exists and is not a directory."
-        # Directory creation logic would go here
-        return f"\u2705 Successfully created the directory at '{disp_path}'."
+        self.report_info(
+            f"\U0001f4c1 Creating directory: '{disp_path}' (overwrite={overwrite}) ... "
+        )
+        try:
+            if os.path.exists(path):
+                if not os.path.isdir(path):
+                    self.report_error(
+                        f"\u274c Path '{disp_path}' exists and is not a directory."
+                    )
+                    return f"\u274c Path '{disp_path}' exists and is not a directory."
+                if not overwrite:
+                    self.report_error(
+                        f"\u2757 Directory '{disp_path}' already exists (overwrite=False)"
+                    )
+                    return (
+                        f"\u2757 Cannot create directory: '{disp_path}' already exists."
+                    )
+                # Overwrite: remove existing directory
+                shutil.rmtree(path)
+            os.makedirs(path, exist_ok=True)
+            self.report_success(f"\u2705 Directory created at '{disp_path}'")
+            return f"\u2705 Successfully created the directory at '{disp_path}'."
+        except Exception as e:
+            self.report_error(f"\u274c Error creating directory '{disp_path}': {e}")
+            return f"\u274c Cannot create directory: {e}"

janito/agent/tools/find_files.py

@@ -14,8 +14,7 @@ class FindFilesTool(ToolBase):
     Args:
         directories (list[str]): List of directories to search in.
         pattern (str): File pattern to match. Uses Unix shell-style wildcards (fnmatch), e.g. '*.py', 'data_??.csv', '[a-z]*.txt'.
-        recursive (bool, optional): Whether to search recursively in subdirectories. Defaults to False.
-        max_depth (int, optional): Maximum directory depth to search (0 = only top-level). If None, unlimited. Defaults to None.
+        recursive (bool, optional): Whether to search recursively in subdirectories. Defaults to True.
     Returns:
         str: Newline-separated list of matching file paths. Example:
             "/path/to/file1.py\n/path/to/file2.py"
@@ -26,8 +25,7 @@ class FindFilesTool(ToolBase):
         self,
         directories: list[str],
         pattern: str,
-        recursive: bool = False,
-        max_depth: int = None,
+        recursive: bool = True,
     ) -> str:
         import os
 
@@ -43,15 +41,9 @@ class FindFilesTool(ToolBase):
             disp_path = display_path(directory)
             self.report_info(f"🔍 Searching for files '{pattern}' in '{disp_path}'")
             for root, dirs, files in os.walk(directory):
-                # Calculate depth
                 rel_path = os.path.relpath(root, directory)
                 depth = 0 if rel_path == "." else rel_path.count(os.sep) + 1
-                if max_depth is not None and depth > max_depth:
-                    # Prune traversal
-                    dirs[:] = []
-                    continue
                 if not recursive and depth > 0:
-                    # Only top-level if not recursive
                     break
                 dirs, files = filter_ignored(root, dirs, files)
                 for filename in fnmatch.filter(files, pattern):

janito/agent/tools/get_file_outline.py

@@ -39,6 +39,12 @@ class GetFileOutlineTool(ToolBase):
                 table = self._format_outline_table(outline_items)
                 self.report_success(f"✅ {len(outline_items)} items ({outline_type})")
                 return f"Outline: {len(outline_items)} items ({outline_type})\n" + table
+            elif ext == ".md":
+                outline_items = self._parse_markdown_outline(lines)
+                outline_type = "markdown"
+                table = self._format_markdown_outline_table(outline_items)
+                self.report_success(f"✅ {len(outline_items)} items ({outline_type})")
+                return f"Outline: {len(outline_items)} items ({outline_type})\n" + table
             else:
                 outline_type = "default"
                 self.report_success(f"✅ {len(lines)} lines ({outline_type})")
@@ -105,6 +111,29 @@ class GetFileOutlineTool(ToolBase):
             )
         return outline
 
+    def _parse_markdown_outline(self, lines: List[str]):
+        # Extract Markdown headers (e.g., #, ##, ###)
+        header_pat = re.compile(r"^(#+)\s+(.*)")
+        outline = []
+        for idx, line in enumerate(lines):
+            match = header_pat.match(line)
+            if match:
+                level = len(match.group(1))
+                title = match.group(2).strip()
+                outline.append({"level": level, "title": title, "line": idx + 1})
+        return outline
+
+    def _format_markdown_outline_table(self, outline_items):
+        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)
+
     def _format_outline_table(self, outline_items):
         if not outline_items:
             return "No classes or functions found."

janito/agent/tools/get_lines.py

@@ -37,32 +37,31 @@ class GetLinesTool(ToolBase):
             ]
             selected_len = len(selected)
             total_lines = len(lines)
+            at_end = False
             if from_line and to_line:
                 requested = to_line - from_line + 1
-                if selected_len < requested:
+                if to_line >= total_lines or selected_len < requested:
+                    at_end = True
+                if at_end:
                     self.report_success(
-                        f" ✅ {selected_len} {pluralize('line', selected_len)} (end at line {total_lines})"
+                        f" ✅ {selected_len} {pluralize('line', selected_len)} (end)"
                     )
                 elif to_line < total_lines:
                     self.report_success(
                         f" ✅ {selected_len} {pluralize('line', selected_len)} ({total_lines - to_line} lines to end)"
                     )
-                else:
-                    self.report_success(
-                        f" ✅ {selected_len} {pluralize('line', selected_len)} (end at line {total_lines})"
-                    )
             else:
                 self.report_success(
                     f" ✅ {selected_len} {pluralize('line', selected_len)} (full file)"
                 )
             # Prepare header
             if from_line and to_line:
-                header = f"---\nFile: {disp_path} | Lines: {from_line}-{to_line} (of {total_lines})\n---\n"
-                if to_line >= total_lines:
-                    header = f"---\nFile: {disp_path} | Lines: {from_line}-{to_line} (end at line {total_lines})\n---\n"
+                if to_line >= total_lines or selected_len < (to_line - from_line + 1):
+                    header = f"---\nFile: {disp_path} | Lines: {from_line}-{to_line} (end)\n---\n"
+                else:
+                    header = f"---\nFile: {disp_path} | Lines: {from_line}-{to_line} (of {total_lines})\n---\n"
             elif from_line:
                 header = f"---\nFile: {disp_path} | Lines: {from_line}-END (of {total_lines})\n---\n"
-                header = f"---\nFile: {disp_path} | Lines: {from_line}-END (end at line {total_lines})\n---\n"
             else:
                 header = (
                     f"---\nFile: {disp_path} | All lines (total: {total_lines})\n---\n"

janito/agent/tools/memory.py

@@ -0,0 +1,68 @@
+"""
+In-memory memory tools for storing and retrieving reusable information during an agent session.
+These tools allow the agent to remember and recall arbitrary key-value pairs for the duration of the process.
+"""
+
+from janito.agent.tool_base import ToolBase
+from janito.agent.tool_registry import register_tool
+
+# Simple in-memory store (process-local, not persistent)
+_memory_store = {}
+
+
+@register_tool(name="store_memory")
+class StoreMemoryTool(ToolBase):
+    """
+    Store a value for later retrieval using a key. Use this tool to remember information that may be useful in future steps or requests.
+
+    Args:
+        key (str): The identifier for the value to store.
+        value (str): The value to store for later retrieval.
+    Returns:
+        str: Status message indicating success or error. Example:
+            - "✅ Stored value for key: 'foo'"
+            - "❗ Error storing value: ..."
+    """
+
+    def call(self, key: str, value: str) -> str:
+        self.report_info(f"Storing value for key: '{key}'")
+        try:
+            _memory_store[key] = value
+            msg = f"✅ Stored value for key: '{key}'"
+            self.report_success(msg)
+            return msg
+        except Exception as e:
+            msg = f"❗ Error storing value: {e}"
+            self.report_error(msg)
+            return msg
+
+
+@register_tool(name="retrieve_memory")
+class RetrieveMemoryTool(ToolBase):
+    """
+    Retrieve a value previously stored using a key. Use this tool to recall information remembered earlier in the session.
+
+    Args:
+        key (str): The identifier for the value to retrieve.
+    Returns:
+        str: The stored value, or a warning message if not found. Example:
+            - "🔎 Retrieved value for key: 'foo': bar"
+            - "⚠️ No value found for key: 'notfound'"
+    """
+
+    def call(self, key: str) -> str:
+        self.report_info(f"Retrieving value for key: '{key}'")
+        try:
+            if key in _memory_store:
+                value = _memory_store[key]
+                msg = f"🔎 Retrieved value for key: '{key}': {value}"
+                self.report_success(msg)
+                return msg
+            else:
+                msg = f"⚠️ No value found for key: '{key}'"
+                self.report_warning(msg)
+                return msg
+        except Exception as e:
+            msg = f"❗ Error retrieving value: {e}"
+            self.report_error(msg)
+            return msg

janito/agent/tools/run_bash_command.py

@@ -4,6 +4,7 @@ from janito.agent.tool_registry import register_tool
 import subprocess
 import tempfile
 import sys
+import os
 
 
 @register_tool(name="run_bash_command")
@@ -33,18 +34,6 @@ class RunBashCommandTool(ToolBase):
         """
         Execute a bash command and capture live output.
 
-        Args:
-            command (str): The bash command to execute.
-            timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
-            require_confirmation (bool, optional): If True, require user confirmation before running. Defaults to False.
-            interactive (bool, optional): If True, warns that the command may require user interaction. Defaults to False.
-
-        Returns:
-            str: Output and status message.
-        """
-        """
-        Execute a bash command and capture live output.
-
         Args:
             command (str): The bash command to execute.
             timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
@@ -62,7 +51,6 @@ class RunBashCommandTool(ToolBase):
             self.report_info(
                 "⚠️  Warning: This command might be interactive, require user input, and might hang."
             )
-
             sys.stdout.flush()
 
         try:
@@ -74,81 +62,112 @@ class RunBashCommandTool(ToolBase):
                     mode="w+", prefix="run_bash_stderr_", delete=False, encoding="utf-8"
                 ) as stderr_file,
             ):
-                # Use bash explicitly for command execution
+                env = os.environ.copy()
+                env["PYTHONIOENCODING"] = "utf-8"
+                env["LC_ALL"] = "C.UTF-8"
+                env["LANG"] = "C.UTF-8"
+
                 process = subprocess.Popen(
                     ["bash", "-c", command],
-                    stdout=stdout_file,
-                    stderr=stderr_file,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
                     text=True,
+                    encoding="utf-8",
+                    bufsize=1,  # line-buffered
+                    env=env,
                 )
+
+                stdout_lines = 0
+                stderr_lines = 0
+                stdout_content = []
+                stderr_content = []
+                max_lines = 100
+
+                import threading
+
+                def stream_reader(
+                    stream, file_handle, report_func, content_list, line_counter
+                ):
+                    for line in iter(stream.readline, ""):
+                        file_handle.write(line)
+                        file_handle.flush()
+                        report_func(line)
+                        content_list.append(line)
+                        line_counter[0] += 1
+                    stream.close()
+
+                stdout_counter = [0]
+                stderr_counter = [0]
+                stdout_thread = threading.Thread(
+                    target=stream_reader,
+                    args=(
+                        process.stdout,
+                        stdout_file,
+                        self.report_stdout,
+                        stdout_content,
+                        stdout_counter,
+                    ),
+                )
+                stderr_thread = threading.Thread(
+                    target=stream_reader,
+                    args=(
+                        process.stderr,
+                        stderr_file,
+                        self.report_stderr,
+                        stderr_content,
+                        stderr_counter,
+                    ),
+                )
+                stdout_thread.start()
+                stderr_thread.start()
+
                 try:
-                    return_code = process.wait(timeout=timeout)
+                    process.wait(timeout=timeout)
                 except subprocess.TimeoutExpired:
                     process.kill()
                     self.report_error(f" ❌ Timed out after {timeout} seconds.")
                     return f"Command timed out after {timeout} seconds."
 
-                # Print live output to user
-                stdout_file.flush()
-                stderr_file.flush()
-                with open(
-                    stdout_file.name, "r", encoding="utf-8", errors="replace"
-                ) as out_f:
-                    out_f.seek(0)
-                    for line in out_f:
-                        self.report_stdout(line)
-                with open(
-                    stderr_file.name, "r", encoding="utf-8", errors="replace"
-                ) as err_f:
-                    err_f.seek(0)
-                    for line in err_f:
-                        self.report_stderr(line)
+                stdout_thread.join()
+                stderr_thread.join()
 
                 # Count lines
-                with open(
-                    stdout_file.name, "r", encoding="utf-8", errors="replace"
-                ) as out_f:
-                    stdout_lines = sum(1 for _ in out_f)
-                with open(
-                    stderr_file.name, "r", encoding="utf-8", errors="replace"
-                ) as err_f:
-                    stderr_lines = sum(1 for _ in err_f)
-
-                self.report_success(f" ✅ return code {return_code}")
+                stdout_lines = stdout_counter[0]
+                stderr_lines = stderr_counter[0]
+
+                self.report_success(f" ✅ return code {process.returncode}")
                 warning_msg = ""
                 if interactive:
                     warning_msg = "⚠️  Warning: This command might be interactive, require user input, and might hang.\n"
 
-                # Read output contents
-                with open(
-                    stdout_file.name, "r", encoding="utf-8", errors="replace"
-                ) as out_f:
-                    stdout_content = out_f.read()
-                with open(
-                    stderr_file.name, "r", encoding="utf-8", errors="replace"
-                ) as err_f:
-                    stderr_content = err_f.read()
-
-                # Thresholds
-                max_lines = 100
+                # Read output contents if small
                 if stdout_lines <= max_lines and stderr_lines <= max_lines:
+                    # Read files from disk to ensure all content is included
+                    with open(
+                        stdout_file.name, "r", encoding="utf-8", errors="replace"
+                    ) as out_f:
+                        stdout_content_str = out_f.read()
+                    with open(
+                        stderr_file.name, "r", encoding="utf-8", errors="replace"
+                    ) as err_f:
+                        stderr_content_str = err_f.read()
                     result = (
                         warning_msg
-                        + f"Return code: {return_code}\n--- STDOUT ---\n{stdout_content}"
+                        + f"Return code: {process.returncode}\n--- STDOUT ---\n{stdout_content_str}"
                     )
-                    if stderr_content.strip():
-                        result += f"\n--- STDERR ---\n{stderr_content}"
+                    if stderr_content_str.strip():
+                        result += f"\n--- STDERR ---\n{stderr_content_str}"
                     return result
                 else:
                     result = (
                         warning_msg
-                        + f"stdout_file: {stdout_file.name} (lines: {stdout_lines})\n"
+                        + f"[LARGE OUTPUT]\nstdout_file: {stdout_file.name} (lines: {stdout_lines})\n"
                     )
-                    if stderr_lines > 0 and stderr_content.strip():
+                    if stderr_lines > 0:
                         result += (
                             f"stderr_file: {stderr_file.name} (lines: {stderr_lines})\n"
                         )
-                    result += f"returncode: {return_code}\nUse the get_lines tool to inspect the contents of these files when needed."
+                    result += f"returncode: {process.returncode}\nUse the get_lines tool to inspect the contents of these files when needed."
                     return result
         except Exception as e:
             self.report_error(f" ❌ Error: {e}")

janito/agent/tools/run_powershell_command.py

@@ -0,0 +1,153 @@
+from janito.agent.tool_base import ToolBase
+from janito.agent.tool_registry import register_tool
+
+import subprocess
+import tempfile
+
+
+@register_tool(name="run_powershell_command")
+class RunPowerShellCommandTool(ToolBase):
+    """
+    Execute a non-interactive command using the PowerShell shell and capture live output.
+
+    This tool explicitly invokes 'powershell.exe' (on Windows) or 'pwsh' (on other platforms if available).
+
+    All commands are automatically prepended with UTF-8 output encoding:
+    $OutputEncoding = [Console]::OutputEncoding = [System.Text.Encoding]::UTF8;
+
+    For file output, it is recommended to use -Encoding utf8 in your PowerShell commands (e.g., Out-File -Encoding utf8) to ensure correct file encoding.
+
+    Args:
+        command (str): The PowerShell command to execute. This string is passed directly to PowerShell using the --Command argument (not as a script file).
+        timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
+        require_confirmation (bool, optional): If True, require user confirmation before running. Defaults to False.
+        interactive (bool, optional): If True, warns that the command may require user interaction. Defaults to False. Non-interactive commands are preferred for automation and reliability.
+
+    Returns:
+        str: Output and status message, or file paths/line counts if output is large.
+    """
+
+    def call(
+        self,
+        command: str,
+        timeout: int = 60,
+        require_confirmation: bool = False,
+        interactive: bool = False,
+    ) -> str:
+        if not command.strip():
+            self.report_warning("⚠️ Warning: Empty command provided. Operation skipped.")
+            return "Warning: Empty command provided. Operation skipped."
+        # Prepend UTF-8 output encoding
+        encoding_prefix = "$OutputEncoding = [Console]::OutputEncoding = [System.Text.Encoding]::UTF8; "
+        command_with_encoding = encoding_prefix + command
+        self.report_info(f"🖥️  Running PowerShell command: {command}\n")
+        if interactive:
+            self.report_info(
+                "⚠️  Warning: This command might be interactive, require user input, and might hang."
+            )
+        if require_confirmation:
+            confirmed = self.ask_user_confirmation(
+                f"About to run PowerShell command: {command}\nContinue?"
+            )
+            if not confirmed:
+                self.report_warning("Execution cancelled by user.")
+                return "❌ Command execution cancelled by user."
+        from janito.agent.platform_discovery import is_windows
+
+        shell_exe = "powershell.exe" if is_windows() else "pwsh"
+        try:
+            with (
+                tempfile.NamedTemporaryFile(
+                    mode="w+",
+                    prefix="run_powershell_stdout_",
+                    delete=False,
+                    encoding="utf-8",
+                ) as stdout_file,
+                tempfile.NamedTemporaryFile(
+                    mode="w+",
+                    prefix="run_powershell_stderr_",
+                    delete=False,
+                    encoding="utf-8",
+                ) as stderr_file,
+            ):
+                process = subprocess.Popen(
+                    [
+                        shell_exe,
+                        "-NoProfile",
+                        "-ExecutionPolicy",
+                        "Bypass",
+                        "-Command",
+                        command_with_encoding,
+                    ],
+                    stdout=stdout_file,
+                    stderr=stderr_file,
+                    text=True,
+                )
+                try:
+                    return_code = process.wait(timeout=timeout)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    self.report_error(f" ❌ Timed out after {timeout} seconds.")
+                    return f"Command timed out after {timeout} seconds."
+                # Print live output to user
+                stdout_file.flush()
+                stderr_file.flush()
+                with open(
+                    stdout_file.name, "r", encoding="utf-8", errors="replace"
+                ) as out_f:
+                    out_f.seek(0)
+                    for line in out_f:
+                        self.report_stdout(line)
+                with open(
+                    stderr_file.name, "r", encoding="utf-8", errors="replace"
+                ) as err_f:
+                    err_f.seek(0)
+                    for line in err_f:
+                        self.report_stderr(line)
+                # Count lines
+                with open(
+                    stdout_file.name, "r", encoding="utf-8", errors="replace"
+                ) as out_f:
+                    stdout_lines = sum(1 for _ in out_f)
+                with open(
+                    stderr_file.name, "r", encoding="utf-8", errors="replace"
+                ) as err_f:
+                    stderr_lines = sum(1 for _ in err_f)
+                self.report_success(f" ✅ return code {return_code}")
+                warning_msg = ""
+                if interactive:
+                    warning_msg = "⚠️  Warning: This command might be interactive, require user input, and might hang.\n"
+                # Read output contents
+                with open(
+                    stdout_file.name, "r", encoding="utf-8", errors="replace"
+                ) as out_f:
+                    stdout_content = out_f.read()
+                with open(
+                    stderr_file.name, "r", encoding="utf-8", errors="replace"
+                ) as err_f:
+                    stderr_content = err_f.read()
+                # Thresholds
+                max_lines = 100
+                if stdout_lines <= max_lines and stderr_lines <= max_lines:
+                    result = (
+                        warning_msg
+                        + f"Return code: {return_code}\n--- STDOUT ---\n{stdout_content}"
+                    )
+                    if stderr_content.strip():
+                        result += f"\n--- STDERR ---\n{stderr_content}"
+                    return result
+                else:
+                    result = (
+                        warning_msg
+                        + f"stdout_file: {stdout_file.name} (lines: {stdout_lines})\n"
+                    )
+                    if stderr_lines > 0 and stderr_content.strip():
+                        result += (
+                            f"stderr_file: {stderr_file.name} (lines: {stderr_lines})\n"
+                        )
+                    result += f"returncode: {return_code}\nUse the get_lines tool to inspect the contents of these files when needed."
+                    return result
+        except Exception as e:
+            self.report_error(f" ❌ Error: {e}")
+            return f"Error running command: {e}"
+        # No temp script file to clean up anymore

janito/agent/tools/run_python_command.py

@@ -1,6 +1,7 @@
 import subprocess
 import tempfile
 import sys
+import os
 from janito.agent.tool_base import ToolBase
 from janito.agent.tool_registry import register_tool
 
@@ -64,11 +65,14 @@ class RunPythonCommandTool(ToolBase):
             ):
                 code_file.write(code)
                 code_file.flush()
+                env = os.environ.copy()
+                env["PYTHONIOENCODING"] = "utf-8"
                 process = subprocess.Popen(
                     [sys.executable, code_file.name],
                     stdout=stdout_file,
                     stderr=stderr_file,
                     text=True,
+                    env=env,
                 )
                 try:
                     return_code = process.wait(timeout=timeout)