microbots 0.0.3__tar.gz → 0.0.4__tar.gz

{microbots-0.0.3 → microbots-0.0.4}/.gitignore

@@ -56,7 +56,6 @@ cover/
 *.pot
 
 # Django stuff:
-*.log
 local_settings.py
 db.sqlite3
 db.sqlite3-journal

{microbots-0.0.3 → microbots-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microbots
-Version: 0.0.3
+Version: 0.0.4
 Summary: container-based autonomous agent framework
 Author-email: xxx <xxx@example.com>
 License: MIT License

{microbots-0.0.3 → microbots-0.0.4}/src/microbots/MicroBot.py

@@ -4,7 +4,6 @@ import time
 from dataclasses import dataclass
 from enum import StrEnum
 from logging import getLogger
-from pathlib import Path
 from typing import Optional
 
 from microbots.constants import ModelProvider, PermissionLabels, PermissionMapping
@@ -15,12 +14,7 @@ from microbots.llm.openai_api import OpenAIApi
 from microbots.tools.tool import Tool, install_tools, setup_tools
 from microbots.utils.logger import LogLevelEmoji, LogTextColor
 from microbots.utils.network import get_free_port
-from microbots.utils.path import (
-    get_absolute_path,
-    get_base_name,
-    is_absolute_path,
-    is_valid_path,
-)
+from microbots.utils.path import get_path_info
 
 logger = getLogger(" MicroBot ")
 
@@ -47,6 +41,7 @@ class BotType(StrEnum):
     WRITING_BOT = "WRITING_BOT"
     BROWSING_BOT = "BROWSING_BOT"
     CUSTOM_BOT = "CUSTOM_BOT"
+    LOG_ANALYSIS_BOT = "LOG_ANALYSIS_BOT"
 
 
 @dataclass
@@ -56,31 +51,6 @@ class BotRunResult:
     error: Optional[str]
 
 
-@dataclass
-class FolderMountInfo:
-    path_valid: bool
-    base_name: str
-    abs_path: str
-
-
-def get_folder_mount_info(folder_to_mount: str) -> FolderMountInfo:
-    return_value = FolderMountInfo(
-        path_valid=False,
-        base_name="",
-        abs_path="",
-    )
-    if is_absolute_path(folder_to_mount):
-        return_value.path_valid = is_valid_path(folder_to_mount)
-        return_value.abs_path = folder_to_mount
-        return_value.base_name = get_base_name(folder_to_mount)
-    else:
-        return_value.abs_path = get_absolute_path(folder_to_mount)
-        return_value.path_valid = is_valid_path(return_value.abs_path)
-        return_value.base_name = folder_to_mount
-
-    return return_value
-
-
 class MicroBot:
 
     def __init__(
@@ -96,7 +66,7 @@ class MicroBot:
         # validate init values before assigning
         self.permission = permission
         if folder_to_mount is not None:
-            folder_mount_info = get_folder_mount_info(folder_to_mount)
+            folder_mount_info = get_path_info(folder_to_mount)
             if folder_mount_info.path_valid is False:
                 raise ValueError(
                     f"Invalid folder to mount: {folder_to_mount} resolved to {folder_mount_info.abs_path}"

microbots-0.0.4/src/microbots/bot/LogAnalysisBot.py

@@ -0,0 +1,66 @@
+import logging
+from typing import Optional
+
+from microbots.constants import DOCKER_WORKING_DIR, LOG_FILE_DIR, PermissionLabels
+from microbots.MicroBot import BotType, MicroBot, system_prompt_common
+from microbots.tools.tool import Tool
+from microbots.utils.path import get_path_info
+
+logger = logging.getLogger(__name__)
+
+
+class LogAnalysisBot(MicroBot):
+
+    def __init__(
+        self,
+        model: str,
+        folder_to_mount: str,
+        environment: Optional[any] = None,
+        additional_tools: Optional[list[Tool]] = [],
+    ):
+        # validate init values before assigning
+        bot_type = BotType.LOG_ANALYSIS_BOT
+        permission = PermissionLabels.READ_ONLY
+
+        folder_mount_info = get_path_info(folder_to_mount)
+        base_name = folder_mount_info.base_name
+
+        system_prompt = f"""
+        {system_prompt_common}
+        You are a helpful log analysis bot. Your job is to analyze a log file and identify the root-cause if there are any failure. You'll be given read-only access to the code from where the log is generated. The read-only code is available at /{DOCKER_WORKING_DIR}/{base_name}.
+
+The log file to analyze will be given in the user prompt. You can find the provided log file under the directory /{LOG_FILE_DIR}/
+
+Only when you have run all necessary commands and identified the root cause, you should give me the final result.
+        """
+
+        super().__init__(
+            bot_type,
+            model,
+            system_prompt,
+            environment,
+            additional_tools,
+            folder_to_mount,
+            permission,
+        )
+
+    def run(self, file_name: str, timeout_in_seconds: int = 300) -> any:
+
+        # Add the logic to copy the file from the user path to /var/log path in container
+        file_mount_info = get_path_info(file_name)
+        if not file_mount_info.path_valid:
+            raise ValueError(f"file name {file_name} is not a valid path")
+
+        # Copy the file to the container
+        copy_to_container_result = self.environment.copy_to_container(
+            file_mount_info.abs_path, f"/var/log/{file_mount_info.base_name}"
+        )
+        if copy_to_container_result is False:
+            raise ValueError(
+                f"Failed to copy file to container: {file_mount_info.base_name}"
+            )
+
+        file_name_prompt = f"""
+        The log file to analyze is {file_name} which is present in {LOG_FILE_DIR} directory.
+        """
+        return super().run(file_name_prompt, timeout_in_seconds)

{microbots-0.0.3 → microbots-0.0.4}/src/microbots/bot/ReadingBot.py

@@ -1,12 +1,7 @@
 from typing import Optional
 
 from microbots.constants import DOCKER_WORKING_DIR, PermissionLabels
-from microbots.MicroBot import (
-    BotType,
-    MicroBot,
-    get_folder_mount_info,
-    system_prompt_common,
-)
+from microbots.MicroBot import BotType, MicroBot, get_path_info, system_prompt_common
 from microbots.tools.tool import Tool
 
 
@@ -23,7 +18,7 @@ class ReadingBot(MicroBot):
         bot_type = BotType.READING_BOT
         permission = PermissionLabels.READ_ONLY
 
-        folder_mount_info = get_folder_mount_info(folder_to_mount)
+        folder_mount_info = get_path_info(folder_to_mount)
         base_name = folder_mount_info.base_name
 
         system_prompt = f"""

{microbots-0.0.3 → microbots-0.0.4}/src/microbots/bot/WritingBot.py

@@ -1,12 +1,7 @@
 from typing import Optional
 
 from microbots.constants import DOCKER_WORKING_DIR, PermissionLabels
-from microbots.MicroBot import (
-    BotType,
-    MicroBot,
-    get_folder_mount_info,
-    system_prompt_common,
-)
+from microbots.MicroBot import BotType, MicroBot, get_path_info, system_prompt_common
 from microbots.tools.tool import Tool
 
 
@@ -23,7 +18,7 @@ class WritingBot(MicroBot):
         bot_type = BotType.WRITING_BOT
         permission = PermissionLabels.READ_WRITE
 
-        folder_mount_info = get_folder_mount_info(folder_to_mount)
+        folder_mount_info = get_path_info(folder_to_mount)
         base_name = folder_mount_info.base_name
 
         system_prompt = f"""

{microbots-0.0.3 → microbots-0.0.4}/src/microbots/constants.py

@@ -29,4 +29,5 @@ class FILE_PERMISSIONS(IntEnum):
 
 
 DOCKER_WORKING_DIR = "workdir"
+LOG_FILE_DIR = "/var/log/"
 TOOL_FILE_BASE_PATH = Path(__file__).parent / "tools" / "tool_definitions"

microbots-0.0.4/src/microbots/environment/Environment.py

@@ -0,0 +1,35 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+from dataclasses import dataclass
+
+@dataclass
+class CmdReturn:
+    stdout: str
+    stderr: str
+    return_code: int
+
+
+class Environment(ABC):
+    @abstractmethod
+    def start(self):
+        pass
+
+    @abstractmethod
+    def stop(self):
+        pass
+
+    @abstractmethod
+    def execute(self, command: str, timeout: Optional[int] = 300) -> CmdReturn:
+        pass
+
+    def copy_to_container(self, src_path: str, dest_path: str) -> bool:
+        raise NotImplementedError(
+            f"{self.__class__.__name__} does not support copying files to container. "
+            f"This is an optional feature - only implement if needed for your use case."
+        )
+
+    def copy_from_container(self, src_path: str, dest_path: str) -> bool:
+        raise NotImplementedError(
+            f"{self.__class__.__name__} does not support copying files from container. "
+            f"This is an optional feature - only implement if needed for your use case."
+        )

{microbots-0.0.3 → microbots-0.0.4}/src/microbots/environment/local_docker/LocalDockerEnvironment.py

@@ -1,5 +1,7 @@
 import logging
 import os
+import shlex
+import subprocess
 import time
 from pathlib import Path
 from typing import Optional
@@ -158,3 +160,133 @@ class LocalDockerEnvironment(Environment):
         except Exception as e:
             logger.exception("❌ Unexpected error while executing command: %s", e)
             return CmdReturn(stdout="", stderr="Unexpected error", return_code=1)
+    def copy_to_container(self, src_path: str, dest_path: str) -> bool:
+        """
+        Copy a file or folder from the host machine to the Docker container.
+        
+        Args:
+            src_path: Path to the source file/folder on the host machine
+            dest_path: Destination path inside the container
+            
+        Returns:
+            bool: True if copy was successful, False otherwise
+        """
+        if not self.container:
+            logger.error("❌ No active container to copy to")
+            return False
+
+        try:
+            # Check if source path exists
+            if not os.path.exists(src_path):
+                logger.error("❌ Source path does not exist: %s", src_path)
+                return False
+            # Ensure destination directory exists inside container
+            dest_dir = os.path.dirname(dest_path)
+            if dest_dir and dest_dir != '/':
+                # Check if directory exists inside the container first
+                check_cmd = f"test -d {shlex.quote(dest_dir)}"
+                check_result = self.execute(check_cmd)
+
+                if check_result.return_code != 0:
+                    logger.debug("📁 Creating destination directory inside container: %s", dest_dir)
+                    mkdir_cmd = f"mkdir -p {shlex.quote(dest_dir)}"
+                    mkdir_result = self.execute(mkdir_cmd)
+
+                    if mkdir_result.return_code != 0:
+                        logger.error("❌ Failed to create destination directory %s: %s", 
+                                   dest_dir, mkdir_result.stderr)
+                        return False
+                    else:
+                        logger.debug("✅ Destination directory created: %s", dest_dir)
+                else:
+                    logger.debug("✅ Destination directory already exists: %s", dest_dir)
+
+            # Use docker cp command to copy files/folders
+            # Escape paths for shell safety
+
+            # Build docker cp command
+            cmd = ["docker", "cp", src_path, f"{self.container.id}:{dest_path}"]
+
+            logger.debug("📁 Copying %s to container:%s", src_path, dest_path)
+
+            # Execute the copy command
+            result = subprocess.run(
+                cmd,
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=300
+            )
+
+            if result.returncode == 0:
+                logger.info("✅ Successfully copied %s to container:%s", src_path, dest_path)
+                return True
+            else:
+                logger.error("❌ Failed to copy file. Error: %s", result.stderr)
+                return False
+
+        except subprocess.TimeoutExpired:
+            logger.error("❌ Copy operation timed out after 300 seconds")
+            return False
+        except Exception as e:
+            logger.exception("❌ Unexpected error during copy operation: %s", e)
+            return False
+
+    def copy_from_container(self, src_path: str, dest_path: str) -> bool:
+        """
+        Copy a file or folder from the Docker container to the host machine.
+        
+        Args:
+            src_path: Path to the source file/folder inside the container
+            dest_path: Destination path on the host machine
+            
+        Returns:
+            bool: True if copy was successful, False otherwise
+        """
+        if not self.container:
+            logger.error("❌ No active container to copy from")
+            return False
+
+        try:
+            # Check if source path exists inside the container
+            check_cmd = f"test -e {shlex.quote(src_path)}"
+            check_result = self.execute(check_cmd)
+
+            if check_result.return_code != 0:
+                logger.error("❌ Source path does not exist in container: %s", src_path)
+                return False
+
+            # Check if destination directory exists on host machine
+            dest_dir = os.path.dirname(dest_path)
+            if not os.path.exists(dest_dir):
+                logger.error("❌ Destination directory does not exist on host: %s", dest_dir)
+                return False
+
+            cmd = ["docker", "cp", f"{self.container.id}:{src_path}", dest_path]
+
+            # Build docker cp command
+
+            logger.debug("📁 Copying container:%s to %s", src_path, dest_path)
+
+            # Execute the copy command
+            result = subprocess.run(
+                cmd,
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=300
+            )
+
+            if result.returncode == 0:
+                logger.info("✅ Successfully copied from container:%s to %s", src_path, dest_path)
+                return True
+            else:
+                logger.error("❌ Failed to copy file. Error: %s", result.stderr)
+                return False
+
+        except subprocess.TimeoutExpired:
+            logger.error("❌ Copy operation timed out after 300 seconds")
+            return False
+        except Exception as e:
+            logger.exception("❌ Unexpected error during copy operation: %s", e)
+            return False

{microbots-0.0.3 → microbots-0.0.4}/src/microbots/environment/local_docker/image_builder/ShellCommunicator.py

@@ -34,10 +34,12 @@ class ShellCommunicator:
         Initialize the shell communicator.
 
         Args:
-            shell_type: Type of shell ("powershell", "cmd", "bash", "python")
+            shell_type: Type of shell (only "bash" is supported)
             encoding: Text encoding for communication
         """
         self.shell_type = shell_type.lower()
+        if self.shell_type != "bash":
+            raise ValueError(f"Unsupported shell type: {shell_type}. Only 'bash' is supported.")
         self.encoding = encoding
         self.process: Optional[subprocess.Popen] = None
         self.output_queue = queue.Queue()
@@ -47,13 +49,9 @@ class ShellCommunicator:
         self.error_thread: Optional[threading.Thread] = None
         self.output_callback: Optional[Callable] = None
 
-        # Define shell commands
+        # Define shell commands - only supporting bash
         self.shell_commands = {
-            "powershell": ["powershell.exe", "-NoLogo", "-NoExit"],
-            "cmd": ["cmd.exe", "/k"],
             "bash": ["bash"],
-            "python": [sys.executable, "-i"],
-            "wsl": ["wsl.exe"],
         }
 
     def start_session(self) -> bool:
@@ -134,7 +132,6 @@ class ShellCommunicator:
         # command = command.replace("&lt;", "<").replace("&gt;", ">")
         return command
 
-   # TODO: Exit code is not properly captured. Need to fix it.
     def send_command(
         self, command: str, wait_for_output: bool = True, timeout: float = 300
     ) -> CmdReturn:
@@ -155,28 +152,24 @@ class ShellCommunicator:
 
         try:
             command = self._re_escape(command)
-            # Send the command
-            self.process.stdin.write(command + "\n")
-            self.process.stdin.flush()
-            logger.debug("➡️ Sent command: %s", command)
-
+            
             if not wait_for_output:
+                # Send the command without marker for async execution
+                self.process.stdin.write(command + "\n")
+                self.process.stdin.flush()
+                logger.debug("➡️ Sent async command: %s", command)
                 return CmdReturn(stdout="ASYNC: Not waiting for completion", stderr="", return_code=0)
 
             # Generate a unique command completion marker
             marker = f"__COMMAND_COMPLETE_{int(time.time() * 1000000)}__"
 
-            # Send the marker command based on shell type
-            if self.shell_type in ["bash", "wsl"]:
-                self.process.stdin.write(f"echo '{marker}'; echo $? > /tmp/last_exit_code\n")
-            elif self.shell_type == "powershell":
-                self.process.stdin.write(f"echo '{marker}'; echo $LASTEXITCODE\n")
-            elif self.shell_type == "cmd":
-                self.process.stdin.write(f"echo {marker} & echo %ERRORLEVEL%\n")
-            elif self.shell_type == "python":
-                self.process.stdin.write(f"print('{marker}')\n")
-
+            # For bash only: Send command + marker in a single line to capture correct exit code
+            combined_command = f"{command}; echo '{marker}' $?"
+            
+            # Send the combined command
+            self.process.stdin.write(combined_command + "\n")
             self.process.stdin.flush()
+            logger.debug("➡️ Sent command: %s", command)
 
             # Collect output until marker is found or timeout
             output_lines = []
@@ -193,23 +186,24 @@ class ShellCommunicator:
                     # Check if this is our completion marker
                     if marker in line:
                         marker_found = True
-                        # For bash/wsl, try to get the exit code from the next line
-                        if self.shell_type in ["bash", "wsl"]:
-                            try:
-                                # Try to get exit code from next output
-                                stream_type, exit_code_line = self.output_queue.get(timeout=0.5)
-                                if exit_code_line.strip().isdigit():
-                                    last_exit_code = int(exit_code_line.strip())
-                            except (queue.Empty, ValueError):
-                                pass
-                        elif self.shell_type in ["powershell", "cmd"]:
-                            try:
-                                # Try to get exit code from next output
-                                stream_type, exit_code_line = self.output_queue.get(timeout=0.5)
-                                if exit_code_line.strip().isdigit():
-                                    last_exit_code = int(exit_code_line.strip())
-                            except (queue.Empty, ValueError):
-                                pass
+                        # For bash, the exit code is on the same line after the marker
+                        try:
+                            # Extract exit code from the same line as the marker
+                            # Format: "__COMMAND_COMPLETE_xxxxx__ exit_code"
+                            parts = line.split()
+                            if len(parts) >= 2:
+                                exit_code_str = parts[-1].strip()
+                                # Handle bash exit codes (0-255 only)
+                                if exit_code_str.isdigit():
+                                    last_exit_code = int(exit_code_str)
+                                else:
+                                    last_exit_code = 1
+                            else:
+                                last_exit_code = 1
+                        except (ValueError, AttributeError, IndexError):
+                            # Default to 1 if parsing fails
+                            last_exit_code = 1
+                        logger.debug("🔍 Found marker with exit code: %s", last_exit_code)
                         continue
 
                     # Add output to appropriate list
@@ -236,7 +230,6 @@ class ShellCommunicator:
                 except queue.Empty:
                     break
 
-            # TODO: Final return code is not correct. Need a fix
             final_return_code = last_exit_code if marker_found else (1 if error_lines else 0)
 
             # Handle timeout case
@@ -295,13 +288,8 @@ class ShellCommunicator:
 
         if self.process:
             try:
-                # Try to terminate gracefully
-                if self.shell_type == "powershell":
-                    self.send_command("exit", wait_for_output=False)
-                elif self.shell_type == "cmd":
-                    self.send_command("exit", wait_for_output=False)
-                else:
-                    self.send_command("exit", wait_for_output=False)
+                # Try to terminate gracefully with bash exit command
+                self.send_command("exit", wait_for_output=False)
 
                 # Wait a bit for graceful shutdown
                 time.sleep(1)

{microbots-0.0.3 → microbots-0.0.4}/src/microbots/environment/local_docker/image_builder/dockerShell.py

@@ -1,10 +1,24 @@
 import os
+import logging
 
 import uvicorn
 from fastapi import FastAPI
 from pydantic import BaseModel
 from ShellCommunicator import ShellCommunicator
 
+# Configure logging to see all logs including ShellCommunicator
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler()  # Ensure logs go to stdout
+    ]
+)
+
+# Set specific logger levels
+logging.getLogger('ShellCommunicator').setLevel(logging.DEBUG)
+logging.getLogger('uvicorn').setLevel(logging.INFO)
+
 shell = ShellCommunicator("bash")
 shell.start_session()
 

microbots-0.0.4/src/microbots/utils/path.py

@@ -0,0 +1,39 @@
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class PathInfo:
+    path_valid: bool
+    base_name: str
+    abs_path: str
+
+
+def is_valid_path(path: str) -> bool:
+    try:
+        return Path(path).exists()
+    except Exception:
+        return False
+
+
+def is_absolute_path(path: str) -> bool:
+    return Path(path).is_absolute()
+
+
+def get_base_name(path: str) -> str:
+    return Path(path).name
+
+
+def get_absolute_path(path: str) -> str:
+    return str(Path(path).resolve(strict=False))
+
+
+def get_path_info(file_or_folder: str) -> PathInfo:
+    if is_valid_path(file_or_folder):
+        return PathInfo(
+            path_valid=True,
+            base_name=os.path.basename(file_or_folder),
+            abs_path=os.path.abspath(file_or_folder),
+        )
+    return PathInfo(path_valid=False, base_name="", abs_path="")

{microbots-0.0.3 → microbots-0.0.4}/src/microbots.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microbots
-Version: 0.0.3
+Version: 0.0.4
 Summary: container-based autonomous agent framework
 Author-email: xxx <xxx@example.com>
 License: MIT License

{microbots-0.0.3 → microbots-0.0.4}/src/microbots.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ src/microbots.egg-info/requires.txt
 src/microbots.egg-info/top_level.txt
 src/microbots/bot/BrowsingBot.py
 src/microbots/bot/CustomBot.py
+src/microbots/bot/LogAnalysisBot.py
 src/microbots/bot/ReadingBot.py
 src/microbots/bot/WritingBot.py
 src/microbots/bot/__init__.py
@@ -39,8 +40,12 @@ src/microbots/utils/logger.py
 src/microbots/utils/network.py
 src/microbots/utils/path.py
 test/bot/browsing_bot_test.py
+test/bot/calculator/calculator.log
+test/bot/calculator/log_analysis_test.py
+test/bot/calculator/code/calculator.py
 test/bot/countries_to_capital/reading_bot_test.py
 test/bot/countries_to_capital/writing_bot_test.py
 test/bot/countries_to_capital/countries_dir/countries.txt
 test/environment/local_docker/LocalDockerEnvironmentTest.py
+test/environment/local_docker/TestFileCopy.py
 test/environment/swe-rex/LocalDockerTest.py

microbots-0.0.4/test/bot/calculator/calculator.log

@@ -0,0 +1,15 @@
+2025-09-23 10:40:24,897 - INFO - Calculator application started.
+2025-09-23 10:40:26,007 - INFO - User selected operation: 1
+2025-09-23 10:40:27,391 - INFO - Numbers entered: 10.0 and 5.0
+2025-09-23 10:40:27,391 - INFO - Result of addition: 15.0
+2025-09-23 10:40:53,096 - INFO - Calculator application finished.
+2025-09-23 10:41:02,897 - INFO - Calculator application started.
+2025-09-23 10:41:03,833 - INFO - User selected operation: 1
+2025-09-23 10:41:05,224 - INFO - Numbers entered: 10.0 and 5.0
+2025-09-23 10:41:05,224 - INFO - Result of addition: 15.0
+2025-09-23 10:43:52,092 - ERROR - A deliberate ZeroDivisionError was encountered.
+Traceback (most recent call last):
+  File "C:\Users\sikannan\codeBase\minions\test\bot\calculator\code\calculator.py", line 21, in divide
+    result = a / b
+             ~~^~~
+ZeroDivisionError: division by zero

microbots-0.0.4/test/bot/calculator/code/calculator.py

@@ -0,0 +1,50 @@
+import logging
+import sys
+
+# Configure logging to write to a file named 'calculator.log'.
+# The 'exception' level is used to capture the full traceback.
+logging.basicConfig(
+    filename="calculator.log",
+    level=logging.ERROR,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+
+
+def divide(a, b):
+    """
+    A calculator function that performs division.
+    It is intentionally designed to cause a ZeroDivisionError
+    when the divisor `b` is zero.
+    """
+    try:
+        logging.info(f"Attempting to divide {a} by {b}.")
+        result = a / b
+        logging.info(f"The result is: {result}")
+        return result
+    except ZeroDivisionError as e:
+        # This block catches the specific ZeroDivisionError.
+        print(
+            "An error occurred during division. Please check calculator.log for details."
+        )
+        # The logging.exception() function logs the error and the full traceback.
+        logging.exception("A deliberate ZeroDivisionError was encountered.")
+        return None
+    except Exception as e:
+        # This is a general catch-all for any other potential errors.
+        logging.error(f"An unexpected error occurred: {e}")
+        return None
+
+
+if __name__ == "__main__":
+    # Example usage: This will work correctly.
+    print("--- First Calculation (will succeed) ---")
+    divide(10, 2)
+    print("\n")
+
+    # This call is intentionally designed to cause a ZeroDivisionError,
+    # and the error will be logged to 'calculator.log'.
+    print("--- Second Calculation (will fail on purpose) ---")
+    divide(5, 0)
+    print("\n")
+
+    print("Program finished. Check 'calculator.log' for the error details.")

microbots-0.0.4/test/bot/calculator/log_analysis_test.py

@@ -0,0 +1,30 @@
+import logging
+import os
+import sys
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+# Add src directory to path to import from local source
+sys.path.insert(
+    0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../../../src"))
+)
+
+from microbots.bot.LogAnalysisBot import LogAnalysisBot
+from microbots.constants import DOCKER_WORKING_DIR, LOG_FILE_DIR
+from microbots.MicroBot import BotRunResult
+
+myBot = LogAnalysisBot(
+    model="azure-openai/mini-swe-agent-gpt5",
+    folder_to_mount=str(Path(__file__).parent / "code"),
+)
+
+response: BotRunResult = myBot.run(
+    str(Path(__file__).parent / "calculator.log"),
+    timeout_in_seconds=300,
+)
+
+print(
+    f"Status: {response.status}\n***Result:***\n{response.result}\n===\nError: {response.error}"
+)

microbots-0.0.4/test/environment/local_docker/TestFileCopy.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""
+Simple test for file copy functionality
+"""
+
+import os
+import sys
+from pathlib import Path
+import logging
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+# Add src directory to path to import from local source
+sys.path.insert(
+    0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../../../src"))
+)
+
+from microbots.environment.local_docker import LocalDockerEnvironment
+
+class TestFileCopy():
+    """Simple test for file copy"""
+
+    def test_copy_file(self):
+        """Test copying a file to container and from container to host"""
+        # Create environment
+        env = LocalDockerEnvironment(port=8081)
+        
+        try:
+            # Copy to container
+            # Get path to countries.txt file specifically
+            countries_file_path = Path(__file__).parent.parent.parent / "bot" / "countries_to_capital" / "countries_dir" / "countries.txt"
+            result = env.copy_to_container(str(countries_file_path), "/var/log/")
+            
+            # Verify
+            print(f"Copy result: {result}")
+            if result:
+                print("✅ Copy succeeded")
+            else:
+                print("❌ Copy failed")
+            
+            # Test copying from container to host
+            # Use /tmp/ which is available and writable on all systems
+            result_back = env.copy_from_container("/var/log/countries.txt", "/tmp/")
+            print(f"Copy back result: {result_back}")
+            if result_back:
+                print("✅ Copy back succeeded")
+            else:
+                print("❌ Copy back failed")
+            
+        finally:
+            # Cleanup
+            # os.unlink(test_file)
+            # env.stop()
+            print("Not stopping environment for debug")
+
+
+if __name__ == "__main__":
+    # Run the tests
+    test_instance = TestFileCopy()
+    test_instance.test_copy_file()

microbots-0.0.3/src/microbots/environment/Environment.py

@@ -1,23 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Optional
-from dataclasses import dataclass
-
-@dataclass
-class CmdReturn:
-    stdout: str
-    stderr: str
-    return_code: int
-
-
-class Environment(ABC):
-    @abstractmethod
-    def start(self):
-        pass
-
-    @abstractmethod
-    def stop(self):
-        pass
-
-    @abstractmethod
-    def execute(self, command: str, timeout: Optional[int] = 300) -> CmdReturn:
-        pass

microbots-0.0.3/src/microbots/utils/path.py

@@ -1,21 +0,0 @@
-import os
-from pathlib import Path
-
-
-def is_valid_path(path: str) -> bool:
-    try:
-        return Path(path).exists()
-    except Exception:
-        return False
-
-
-def is_absolute_path(path: str) -> bool:
-    return Path(path).is_absolute()
-
-
-def get_base_name(path: str) -> str:
-    return Path(path).name
-
-
-def get_absolute_path(path: str) -> str:
-    return str(Path(path).resolve(strict=False))