update autogpt

autogpt/agent/agent.py

@@ -1,14 +1,15 @@
 from colorama import Fore, Style
 
 from autogpt.app import execute_command, get_command
-from autogpt.chat import chat_with_ai, create_chat_message
 from autogpt.config import Config
 from autogpt.json_utils.json_fix_llm import fix_json_using_multiple_techniques
-from autogpt.json_utils.utilities import validate_json
+from autogpt.json_utils.utilities import LLM_DEFAULT_RESPONSE_FORMAT, validate_json
+from autogpt.llm import chat_with_ai, create_chat_completion, create_chat_message
 from autogpt.logs import logger, print_assistant_thoughts
 from autogpt.speech import say_text
 from autogpt.spinner import Spinner
 from autogpt.utils import clean_input
+from autogpt.workspace import Workspace
 
 
 class Agent:
@@ -19,18 +20,25 @@ class Agent:
         memory: The memory object to use.
         full_message_history: The full message history.
         next_action_count: The number of actions to execute.
-        system_prompt: The system prompt is the initial prompt that defines everything the AI needs to know to achieve its task successfully.
-        Currently, the dynamic and customizable information in the system prompt are ai_name, description and goals.
+        system_prompt: The system prompt is the initial prompt that defines everything
+          the AI needs to know to achieve its task successfully.
+        Currently, the dynamic and customizable information in the system prompt are
+          ai_name, description and goals.
 
-        triggering_prompt: The last sentence the AI will see before answering. For Auto-GPT, this prompt is:
-            Determine which next command to use, and respond using the format specified above:
-            The triggering prompt is not part of the system prompt because between the system prompt and the triggering
-            prompt we have contextual information that can distract the AI and make it forget that its goal is to find the next task to achieve.
+        triggering_prompt: The last sentence the AI will see before answering.
+            For Auto-GPT, this prompt is:
+            Determine which next command to use, and respond using the format specified
+              above:
+            The triggering prompt is not part of the system prompt because between the
+              system prompt and the triggering
+            prompt we have contextual information that can distract the AI and make it
+              forget that its goal is to find the next task to achieve.
             SYSTEM PROMPT
             CONTEXTUAL INFORMATION (memory, previous conversations, anything relevant)
             TRIGGERING PROMPT
 
-        The triggering prompt reminds the AI about its short term meta task (defining the next task)
+        The triggering prompt reminds the AI about its short term meta task
+        (defining the next task)
     """
 
     def __init__(
@@ -39,15 +47,26 @@ class Agent:
         memory,
         full_message_history,
         next_action_count,
+        command_registry,
+        config,
         system_prompt,
         triggering_prompt,
+        workspace_directory,
     ):
+        cfg = Config()
         self.ai_name = ai_name
         self.memory = memory
+        self.summary_memory = (
+            "I was created."  # Initial memory necessary to avoid hilucination
+        )
+        self.last_memory_index = 0
         self.full_message_history = full_message_history
         self.next_action_count = next_action_count
+        self.command_registry = command_registry
+        self.config = config
         self.system_prompt = system_prompt
         self.triggering_prompt = triggering_prompt
+        self.workspace = Workspace(workspace_directory, cfg.restrict_to_workspace)
 
     def start_interaction_loop(self):
         # Interaction Loop
@@ -69,10 +88,10 @@ class Agent:
                     "Continuous Limit Reached: ", Fore.YELLOW, f"{cfg.continuous_limit}"
                 )
                 break
-
             # Send message to AI, get response
             with Spinner("Thinking... "):
                 assistant_reply = chat_with_ai(
+                    self,
                     self.system_prompt,
                     self.triggering_prompt,
                     self.full_message_history,
@@ -81,60 +100,92 @@ class Agent:
                 )  # TODO: This hardcodes the model to use GPT3.5. Make this an argument
 
             assistant_reply_json = fix_json_using_multiple_techniques(assistant_reply)
+            for plugin in cfg.plugins:
+                if not plugin.can_handle_post_planning():
+                    continue
+                assistant_reply_json = plugin.post_planning(self, assistant_reply_json)
 
             # Print Assistant thoughts
             if assistant_reply_json != {}:
-                validate_json(assistant_reply_json, "llm_response_format_1")
+                validate_json(assistant_reply_json, LLM_DEFAULT_RESPONSE_FORMAT)
                 # Get command name and arguments
                 try:
-                    print_assistant_thoughts(self.ai_name, assistant_reply_json)
+                    print_assistant_thoughts(
+                        self.ai_name, assistant_reply_json, cfg.speak_mode
+                    )
                     command_name, arguments = get_command(assistant_reply_json)
-                    # command_name, arguments = assistant_reply_json_valid["command"]["name"], assistant_reply_json_valid["command"]["args"]
                     if cfg.speak_mode:
                         say_text(f"I want to execute {command_name}")
+
+                    arguments = self._resolve_pathlike_command_args(arguments)
+
                 except Exception as e:
                     logger.error("Error: \n", str(e))
 
             if not cfg.continuous_mode and self.next_action_count == 0:
-                ### GET USER AUTHORIZATION TO EXECUTE COMMAND ###
+                # ### GET USER AUTHORIZATION TO EXECUTE COMMAND ###
                 # Get key press: Prompt the user to press enter to continue or escape
                 # to exit
+                self.user_input = ""
                 logger.typewriter_log(
                     "NEXT ACTION: ",
                     Fore.CYAN,
                     f"COMMAND = {Fore.CYAN}{command_name}{Style.RESET_ALL}  "
                     f"ARGUMENTS = {Fore.CYAN}{arguments}{Style.RESET_ALL}",
                 )
-                print(
-                    "Enter 'y' to authorise command, 'y -N' to run N continuous "
-                    "commands, 'n' to exit program, or enter feedback for "
-                    f"{self.ai_name}...",
-                    flush=True,
+
+                logger.info(
+                    "Enter 'y' to authorise command, 'y -N' to run N continuous commands, 's' to run self-feedback commands"
+                    "'n' to exit program, or enter feedback for "
+                    f"{self.ai_name}..."
                 )
                 while True:
-                    console_input = clean_input(
-                        Fore.MAGENTA + "Input:" + Style.RESET_ALL
-                    )
-                    if console_input.lower().strip() == "y":
+                    if cfg.chat_messages_enabled:
+                        console_input = clean_input("Waiting for your response...")
+                    else:
+                        console_input = clean_input(
+                            Fore.MAGENTA + "Input:" + Style.RESET_ALL
+                        )
+                    if console_input.lower().strip() == cfg.authorise_key:
                         user_input = "GENERATE NEXT COMMAND JSON"
                         break
+                    elif console_input.lower().strip() == "s":
+                        logger.typewriter_log(
+                            "-=-=-=-=-=-=-= THOUGHTS, REASONING, PLAN AND CRITICISM WILL NOW BE VERIFIED BY AGENT -=-=-=-=-=-=-=",
+                            Fore.GREEN,
+                            "",
+                        )
+                        thoughts = assistant_reply_json.get("thoughts", {})
+                        self_feedback_resp = self.get_self_feedback(
+                            thoughts, cfg.fast_llm_model
+                        )
+                        logger.typewriter_log(
+                            f"SELF FEEDBACK: {self_feedback_resp}",
+                            Fore.YELLOW,
+                            "",
+                        )
+                        if self_feedback_resp[0].lower().strip() == cfg.authorise_key:
+                            user_input = "GENERATE NEXT COMMAND JSON"
+                        else:
+                            user_input = self_feedback_resp
+                        break
                     elif console_input.lower().strip() == "":
-                        print("Invalid input format.")
+                        logger.warn("Invalid input format.")
                         continue
-                    elif console_input.lower().startswith("y -"):
+                    elif console_input.lower().startswith(f"{cfg.authorise_key} -"):
                         try:
                             self.next_action_count = abs(
                                 int(console_input.split(" ")[1])
                             )
                             user_input = "GENERATE NEXT COMMAND JSON"
                         except ValueError:
-                            print(
+                            logger.warn(
                                 "Invalid input format. Please enter 'y -n' where n is"
                                 " the number of continuous tasks."
                             )
                             continue
                         break
-                    elif console_input.lower() == "n":
+                    elif console_input.lower() == cfg.exit_key:
                         user_input = "EXIT"
                         break
                     else:
@@ -149,7 +200,7 @@ class Agent:
                         "",
                     )
                 elif user_input == "EXIT":
-                    print("Exiting...", flush=True)
+                    logger.info("Exiting...")
                     break
             else:
                 # Print command
@@ -168,21 +219,27 @@ class Agent:
             elif command_name == "human_feedback":
                 result = f"Human feedback: {user_input}"
             else:
-                result = (
-                    f"Command {command_name} returned: "
-                    f"{execute_command(command_name, arguments)}"
+                for plugin in cfg.plugins:
+                    if not plugin.can_handle_pre_command():
+                        continue
+                    command_name, arguments = plugin.pre_command(
+                        command_name, arguments
+                    )
+                command_result = execute_command(
+                    self.command_registry,
+                    command_name,
+                    arguments,
+                    self.config.prompt_generator,
                 )
+                result = f"Command {command_name} returned: " f"{command_result}"
+
+                for plugin in cfg.plugins:
+                    if not plugin.can_handle_post_command():
+                        continue
+                    result = plugin.post_command(command_name, result)
                 if self.next_action_count > 0:
                     self.next_action_count -= 1
 
-            memory_to_add = (
-                f"Assistant Reply: {assistant_reply} "
-                f"\nResult: {result} "
-                f"\nHuman Feedback: {user_input} "
-            )
-
-            self.memory.add(memory_to_add)
-
             # Check if there's a result from the command append it to the message
             # history
             if result is not None:
@@ -195,3 +252,39 @@ class Agent:
                 logger.typewriter_log(
                     "SYSTEM: ", Fore.YELLOW, "Unable to execute command"
                 )
+
+    def _resolve_pathlike_command_args(self, command_args):
+        if "directory" in command_args and command_args["directory"] in {"", "/"}:
+            command_args["directory"] = str(self.workspace.root)
+        else:
+            for pathlike in ["filename", "directory", "clone_path"]:
+                if pathlike in command_args:
+                    command_args[pathlike] = str(
+                        self.workspace.get_path(command_args[pathlike])
+                    )
+        return command_args
+
+    def get_self_feedback(self, thoughts: dict, llm_model: str) -> str:
+        """Generates a feedback response based on the provided thoughts dictionary.
+        This method takes in a dictionary of thoughts containing keys such as 'reasoning',
+        'plan', 'thoughts', and 'criticism'. It combines these elements into a single
+        feedback message and uses the create_chat_completion() function to generate a
+        response based on the input message.
+        Args:
+            thoughts (dict): A dictionary containing thought elements like reasoning,
+            plan, thoughts, and criticism.
+        Returns:
+            str: A feedback response generated using the provided thoughts dictionary.
+        """
+        ai_role = self.config.ai_role
+
+        feedback_prompt = f"Below is a message from an AI agent with the role of {ai_role}. Please review the provided Thought, Reasoning, Plan, and Criticism. If these elements accurately contribute to the successful execution of the assumed role, respond with the letter 'Y' followed by a space, and then explain why it is effective. If the provided information is not suitable for achieving the role's objectives, please provide one or more sentences addressing the issue and suggesting a resolution."
+        reasoning = thoughts.get("reasoning", "")
+        plan = thoughts.get("plan", "")
+        thought = thoughts.get("thoughts", "")
+        criticism = thoughts.get("criticism", "")
+        feedback_thoughts = thought + reasoning + plan + criticism
+        return create_chat_completion(
+            [{"role": "user", "content": feedback_prompt + feedback_thoughts}],
+            llm_model,
+        )

autogpt/agent/agent_manager.py

@@ -1,10 +1,11 @@
 """Agent manager for managing GPT agents"""
 from __future__ import annotations
 
-from typing import Union
+from typing import List
 
-from autogpt.config.config import Singleton
-from autogpt.llm_utils import create_chat_completion
+from autogpt.config.config import Config
+from autogpt.llm import Message, create_chat_completion
+from autogpt.singleton import Singleton
 
 
 class AgentManager(metaclass=Singleton):
@@ -13,6 +14,7 @@ class AgentManager(metaclass=Singleton):
     def __init__(self):
         self.next_key = 0
         self.agents = {}  # key, (task, full_message_history, model)
+        self.cfg = Config()
 
     # Create new GPT agent
     # TODO: Centralise use of create_chat_completion() to globally enforce token limit
@@ -28,19 +30,32 @@ class AgentManager(metaclass=Singleton):
         Returns:
             The key of the new agent
         """
-        messages = [
+        messages: List[Message] = [
             {"role": "user", "content": prompt},
         ]
-
+        for plugin in self.cfg.plugins:
+            if not plugin.can_handle_pre_instruction():
+                continue
+            if plugin_messages := plugin.pre_instruction(messages):
+                messages.extend(iter(plugin_messages))
         # Start GPT instance
         agent_reply = create_chat_completion(
             model=model,
             messages=messages,
         )
 
-        # Update full message history
         messages.append({"role": "assistant", "content": agent_reply})
 
+        plugins_reply = ""
+        for i, plugin in enumerate(self.cfg.plugins):
+            if not plugin.can_handle_on_instruction():
+                continue
+            if plugin_result := plugin.on_instruction(messages):
+                sep = "\n" if i else ""
+                plugins_reply = f"{plugins_reply}{sep}{plugin_result}"
+
+        if plugins_reply and plugins_reply != "":
+            messages.append({"role": "assistant", "content": plugins_reply})
         key = self.next_key
         # This is done instead of len(agents) to make keys unique even if agents
         # are deleted
@@ -48,6 +63,11 @@ class AgentManager(metaclass=Singleton):
 
         self.agents[key] = (task, messages, model)
 
+        for plugin in self.cfg.plugins:
+            if not plugin.can_handle_post_instruction():
+                continue
+            agent_reply = plugin.post_instruction(agent_reply)
+
         return key, agent_reply
 
     def message_agent(self, key: str | int, message: str) -> str:
@@ -65,15 +85,37 @@ class AgentManager(metaclass=Singleton):
         # Add user message to message history before sending to agent
         messages.append({"role": "user", "content": message})
 
+        for plugin in self.cfg.plugins:
+            if not plugin.can_handle_pre_instruction():
+                continue
+            if plugin_messages := plugin.pre_instruction(messages):
+                for plugin_message in plugin_messages:
+                    messages.append(plugin_message)
+
         # Start GPT instance
         agent_reply = create_chat_completion(
             model=model,
             messages=messages,
         )
 
-        # Update full message history
         messages.append({"role": "assistant", "content": agent_reply})
 
+        plugins_reply = agent_reply
+        for i, plugin in enumerate(self.cfg.plugins):
+            if not plugin.can_handle_on_instruction():
+                continue
+            if plugin_result := plugin.on_instruction(messages):
+                sep = "\n" if i else ""
+                plugins_reply = f"{plugins_reply}{sep}{plugin_result}"
+        # Update full message history
+        if plugins_reply and plugins_reply != "":
+            messages.append({"role": "assistant", "content": plugins_reply})
+
+        for plugin in self.cfg.plugins:
+            if not plugin.can_handle_post_instruction():
+                continue
+            agent_reply = plugin.post_instruction(agent_reply)
+
         return agent_reply
 
     def list_agents(self) -> list[tuple[str | int, str]]:
@@ -86,7 +128,7 @@ class AgentManager(metaclass=Singleton):
         # Return a list of agent keys and their tasks
         return [(key, task) for key, (task, _, _) in self.agents.items()]
 
-    def delete_agent(self, key: Union[str, int]) -> bool:
+    def delete_agent(self, key: str | int) -> bool:
         """Delete an agent from the agent manager
 
         Args:

autogpt/commands/analyze_code.py

@@ -1,9 +1,15 @@
 """Code evaluation module."""
 from __future__ import annotations
 
-from autogpt.llm_utils import call_ai_function
+from autogpt.commands.command import command
+from autogpt.llm import call_ai_function
 
 
+@command(
+    "analyze_code",
+    "Analyze Code",
+    '"code": "<full_code_string>"',
+)
 def analyze_code(code: str) -> list[str]:
     """
     A function that takes in a string and returns a response from create chat
@@ -16,10 +22,10 @@ def analyze_code(code: str) -> list[str]:
             improve the code.
     """
 
-    function_string = "def analyze_code(code: str) -> List[str]:"
+    function_string = "def analyze_code(code: str) -> list[str]:"
     args = [code]
     description_string = (
-        "Analyzes the given code and returns a list of suggestions" " for improvements."
+        "Analyzes the given code and returns a list of suggestions for improvements."
     )
 
     return call_ai_function(function_string, args, description_string)

autogpt/commands/command.py

@@ -0,0 +1,156 @@
+import functools
+import importlib
+import inspect
+from typing import Any, Callable, Optional
+
+# Unique identifier for auto-gpt commands
+AUTO_GPT_COMMAND_IDENTIFIER = "auto_gpt_command"
+
+
+class Command:
+    """A class representing a command.
+
+    Attributes:
+        name (str): The name of the command.
+        description (str): A brief description of what the command does.
+        signature (str): The signature of the function that the command executes. Defaults to None.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        description: str,
+        method: Callable[..., Any],
+        signature: str = "",
+        enabled: bool = True,
+        disabled_reason: Optional[str] = None,
+    ):
+        self.name = name
+        self.description = description
+        self.method = method
+        self.signature = signature if signature else str(inspect.signature(self.method))
+        self.enabled = enabled
+        self.disabled_reason = disabled_reason
+
+    def __call__(self, *args, **kwargs) -> Any:
+        if not self.enabled:
+            return f"Command '{self.name}' is disabled: {self.disabled_reason}"
+        return self.method(*args, **kwargs)
+
+    def __str__(self) -> str:
+        return f"{self.name}: {self.description}, args: {self.signature}"
+
+
+class CommandRegistry:
+    """
+    The CommandRegistry class is a manager for a collection of Command objects.
+    It allows the registration, modification, and retrieval of Command objects,
+    as well as the scanning and loading of command plugins from a specified
+    directory.
+    """
+
+    def __init__(self):
+        self.commands = {}
+
+    def _import_module(self, module_name: str) -> Any:
+        return importlib.import_module(module_name)
+
+    def _reload_module(self, module: Any) -> Any:
+        return importlib.reload(module)
+
+    def register(self, cmd: Command) -> None:
+        self.commands[cmd.name] = cmd
+
+    def unregister(self, command_name: str):
+        if command_name in self.commands:
+            del self.commands[command_name]
+        else:
+            raise KeyError(f"Command '{command_name}' not found in registry.")
+
+    def reload_commands(self) -> None:
+        """Reloads all loaded command plugins."""
+        for cmd_name in self.commands:
+            cmd = self.commands[cmd_name]
+            module = self._import_module(cmd.__module__)
+            reloaded_module = self._reload_module(module)
+            if hasattr(reloaded_module, "register"):
+                reloaded_module.register(self)
+
+    def get_command(self, name: str) -> Callable[..., Any]:
+        return self.commands[name]
+
+    def call(self, command_name: str, **kwargs) -> Any:
+        if command_name not in self.commands:
+            raise KeyError(f"Command '{command_name}' not found in registry.")
+        command = self.commands[command_name]
+        return command(**kwargs)
+
+    def command_prompt(self) -> str:
+        """
+        Returns a string representation of all registered `Command` objects for use in a prompt
+        """
+        commands_list = [
+            f"{idx + 1}. {str(cmd)}" for idx, cmd in enumerate(self.commands.values())
+        ]
+        return "\n".join(commands_list)
+
+    def import_commands(self, module_name: str) -> None:
+        """
+        Imports the specified Python module containing command plugins.
+
+        This method imports the associated module and registers any functions or
+        classes that are decorated with the `AUTO_GPT_COMMAND_IDENTIFIER` attribute
+        as `Command` objects. The registered `Command` objects are then added to the
+        `commands` dictionary of the `CommandRegistry` object.
+
+        Args:
+            module_name (str): The name of the module to import for command plugins.
+        """
+
+        module = importlib.import_module(module_name)
+
+        for attr_name in dir(module):
+            attr = getattr(module, attr_name)
+            # Register decorated functions
+            if hasattr(attr, AUTO_GPT_COMMAND_IDENTIFIER) and getattr(
+                attr, AUTO_GPT_COMMAND_IDENTIFIER
+            ):
+                self.register(attr.command)
+            # Register command classes
+            elif (
+                inspect.isclass(attr) and issubclass(attr, Command) and attr != Command
+            ):
+                cmd_instance = attr()
+                self.register(cmd_instance)
+
+
+def command(
+    name: str,
+    description: str,
+    signature: str = "",
+    enabled: bool = True,
+    disabled_reason: Optional[str] = None,
+) -> Callable[..., Any]:
+    """The command decorator is used to create Command objects from ordinary functions."""
+
+    def decorator(func: Callable[..., Any]) -> Command:
+        cmd = Command(
+            name=name,
+            description=description,
+            method=func,
+            signature=signature,
+            enabled=enabled,
+            disabled_reason=disabled_reason,
+        )
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs) -> Any:
+            return func(*args, **kwargs)
+
+        wrapper.command = cmd
+
+        setattr(wrapper, AUTO_GPT_COMMAND_IDENTIFIER, True)
+
+        return wrapper
+
+    return decorator

autogpt/commands/execute_code.py

@@ -1,36 +1,38 @@
 """Execute code in a Docker container"""
 import os
 import subprocess
+from pathlib import Path
 
 import docker
 from docker.errors import ImageNotFound
 
-from autogpt.workspace import WORKSPACE_PATH, path_in_workspace
+from autogpt.commands.command import command
+from autogpt.config import Config
+from autogpt.logs import logger
 
+CFG = Config()
 
-def execute_python_file(file: str) -> str:
+@command("execute_python_file", "Execute Python File", '"filename": "<filename>"')
+def execute_python_file(filename: str) -> str:
     """Execute a Python file in a Docker container and return the output
 
     Args:
-        file (str): The name of the file to execute
+        filename (str): The name of the file to execute
 
     Returns:
         str: The output of the file
     """
+    logger.info(f"Executing file '{filename}'")
 
-    print(f"Executing file '{file}' in workspace '{WORKSPACE_PATH}'")
-
-    if not file.endswith(".py"):
+    if not filename.endswith(".py"):
         return "Error: Invalid file type. Only .py files are allowed."
 
-    file_path = path_in_workspace(file)
-
-    if not os.path.isfile(file_path):
-        return f"Error: File '{file}' does not exist."
+    if not os.path.isfile(filename):
+        return f"Error: File '{filename}' does not exist."
 
     if we_are_running_in_a_docker_container():
         result = subprocess.run(
-            f"python {file_path}", capture_output=True, encoding="utf8", shell=True
+            f"python {filename}", capture_output=True, encoding="utf8", shell=True
         )
         if result.returncode == 0:
             return result.stdout
@@ -39,16 +41,17 @@ def execute_python_file(file: str) -> str:
 
     try:
         client = docker.from_env()
-
         # You can replace this with the desired Python image/version
         # You can find available Python images on Docker Hub:
         # https://hub.docker.com/_/python
         image_name = "python:3-alpine"
         try:
             client.images.get(image_name)
-            print(f"Image '{image_name}' found locally")
+            logger.warn(f"Image '{image_name}' found locally")
         except ImageNotFound:
-            print(f"Image '{image_name}' not found locally, pulling from Docker Hub")
+            logger.info(
+                f"Image '{image_name}' not found locally, pulling from Docker Hub"
+            )
             # Use the low-level API to stream the pull response
             low_level_client = docker.APIClient()
             for line in low_level_client.pull(image_name, stream=True, decode=True):
@@ -56,15 +59,14 @@ def execute_python_file(file: str) -> str:
                 status = line.get("status")
                 progress = line.get("progress")
                 if status and progress:
-                    print(f"{status}: {progress}")
+                    logger.info(f"{status}: {progress}")
                 elif status:
-                    print(status)
-
+                    logger.info(status)
         container = client.containers.run(
             image_name,
-            f"python {file}",
+            f"python {Path(filename).relative_to(CFG.workspace_path)}",
             volumes={
-                os.path.abspath(WORKSPACE_PATH): {
+                CFG.workspace_path: {
                     "bind": "/workspace",
                     "mode": "ro",
                 }
@@ -85,7 +87,7 @@ def execute_python_file(file: str) -> str:
         return logs
 
     except docker.errors.DockerException as e:
-        print(
+        logger.warn(
             "Could not run the script in a container. If you haven't already, please install Docker https://docs.docker.com/get-docker/"
         )
         return f"Error: {str(e)}"
@@ -94,6 +96,15 @@ def execute_python_file(file: str) -> str:
         return f"Error: {str(e)}"
 
 
+@command(
+    "execute_shell",
+    "Execute Shell Command, non-interactive commands only",
+    '"command_line": "<command_line>"',
+    CFG.execute_local_commands,
+    "You are not allowed to run local shell commands. To execute"
+    " shell commands, EXECUTE_LOCAL_COMMANDS must be set to 'True' "
+    "in your config. Do not attempt to bypass the restriction.",
+)
 def execute_shell(command_line: str) -> str:
     """Execute a shell command and return the output
 
@@ -103,12 +114,15 @@ def execute_shell(command_line: str) -> str:
     Returns:
         str: The output of the command
     """
-    current_dir = os.getcwd()
+
+    current_dir = Path.cwd()
     # Change dir into workspace if necessary
-    if str(WORKSPACE_PATH) not in current_dir:
-        os.chdir(WORKSPACE_PATH)
+    if not current_dir.is_relative_to(CFG.workspace_path):
+        os.chdir(CFG.workspace_path)
 
-    print(f"Executing command '{command_line}' in working directory '{os.getcwd()}'")
+    logger.info(
+        f"Executing command '{command_line}' in working directory '{os.getcwd()}'"
+    )
 
     result = subprocess.run(command_line, capture_output=True, shell=True)
     output = f"STDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
@@ -116,10 +130,18 @@ def execute_shell(command_line: str) -> str:
     # Change back to whatever the prior working dir was
 
     os.chdir(current_dir)
-
     return output
 
 
+@command(
+    "execute_shell_popen",
+    "Execute Shell Command, non-interactive commands only",
+    '"command_line": "<command_line>"',
+    CFG.execute_local_commands,
+    "You are not allowed to run local shell commands. To execute"
+    " shell commands, EXECUTE_LOCAL_COMMANDS must be set to 'True' "
+    "in your config. Do not attempt to bypass the restriction.",
+)
 def execute_shell_popen(command_line) -> str:
     """Execute a shell command with Popen and returns an english description
     of the event and the process id
@@ -130,12 +152,15 @@ def execute_shell_popen(command_line) -> str:
     Returns:
         str: Description of the fact that the process started and its id
     """
+
     current_dir = os.getcwd()
     # Change dir into workspace if necessary
-    if str(WORKSPACE_PATH) not in current_dir:
-        os.chdir(WORKSPACE_PATH)
+    if CFG.workspace_path not in current_dir:
+        os.chdir(CFG.workspace_path)
 
-    print(f"Executing command '{command_line}' in working directory '{os.getcwd()}'")
+    logger.info(
+        f"Executing command '{command_line}' in working directory '{os.getcwd()}'"
+    )
 
     do_not_show_output = subprocess.DEVNULL
     process = subprocess.Popen(

autogpt/commands/file_operations.py

@@ -9,12 +9,13 @@ import requests
 from colorama import Back, Fore
 from requests.adapters import HTTPAdapter, Retry
 
+from autogpt.commands.command import command
+from autogpt.config import Config
+from autogpt.logs import logger
 from autogpt.spinner import Spinner
 from autogpt.utils import readable_file_size
-from autogpt.workspace import WORKSPACE_PATH, path_in_workspace
 
-LOG_FILE = "file_logger.txt"
-LOG_FILE_PATH = WORKSPACE_PATH / LOG_FILE
+CFG = Config()
 
 
 def check_duplicate_operation(operation: str, filename: str) -> bool:
@@ -27,7 +28,7 @@ def check_duplicate_operation(operation: str, filename: str) -> bool:
     Returns:
         bool: True if the operation has already been performed on the file
     """
-    log_content = read_file(LOG_FILE)
+    log_content = read_file(CFG.file_logger_path)
     log_entry = f"{operation}: {filename}\n"
     return log_entry in log_content
 
@@ -40,13 +41,7 @@ def log_operation(operation: str, filename: str) -> None:
         filename (str): The name of the file the operation was performed on
     """
     log_entry = f"{operation}: {filename}\n"
-
-    # Create the log file if it doesn't exist
-    if not os.path.exists(LOG_FILE_PATH):
-        with open(LOG_FILE_PATH, "w", encoding="utf-8") as f:
-            f.write("File Operation Logger ")
-
-    append_to_file(LOG_FILE, log_entry, shouldLog=False)
+    append_to_file(CFG.file_logger_path, log_entry, should_log=False)
 
 
 def split_file(
@@ -81,6 +76,7 @@ def split_file(
         start += max_length - overlap
 
 
+@command("read_file", "Read file", '"filename": "<filename>"')
 def read_file(filename: str) -> str:
     """Read a file and return the contents
 
@@ -91,8 +87,7 @@ def read_file(filename: str) -> str:
         str: The contents of the file
     """
     try:
-        filepath = path_in_workspace(filename)
-        with open(filepath, "r", encoding="utf-8") as f:
+        with open(filename, "r", encoding="utf-8") as f:
             content = f.read()
         return content
     except Exception as e:
@@ -112,27 +107,28 @@ def ingest_file(
     :param overlap: The number of overlapping characters between chunks, default is 200
     """
     try:
-        print(f"Working with file {filename}")
+        logger.info(f"Working with file {filename}")
         content = read_file(filename)
         content_length = len(content)
-        print(f"File length: {content_length} characters")
+        logger.info(f"File length: {content_length} characters")
 
         chunks = list(split_file(content, max_length=max_length, overlap=overlap))
 
         num_chunks = len(chunks)
         for i, chunk in enumerate(chunks):
-            print(f"Ingesting chunk {i + 1} / {num_chunks} into memory")
+            logger.info(f"Ingesting chunk {i + 1} / {num_chunks} into memory")
             memory_to_add = (
                 f"Filename: {filename}\n" f"Content part#{i + 1}/{num_chunks}: {chunk}"
             )
 
             memory.add(memory_to_add)
 
-        print(f"Done ingesting {num_chunks} chunks from {filename}.")
+        logger.info(f"Done ingesting {num_chunks} chunks from {filename}.")
     except Exception as e:
-        print(f"Error while ingesting file '{filename}': {str(e)}")
+        logger.info(f"Error while ingesting file '{filename}': {str(e)}")
 
 
+@command("write_to_file", "Write to file", '"filename": "<filename>", "text": "<text>"')
 def write_to_file(filename: str, text: str) -> str:
     """Write text to a file
 
@@ -146,11 +142,9 @@ def write_to_file(filename: str, text: str) -> str:
     if check_duplicate_operation("write", filename):
         return "Error: File has already been updated."
     try:
-        filepath = path_in_workspace(filename)
-        directory = os.path.dirname(filepath)
-        if not os.path.exists(directory):
-            os.makedirs(directory)
-        with open(filepath, "w", encoding="utf-8") as f:
+        directory = os.path.dirname(filename)
+        os.makedirs(directory, exist_ok=True)
+        with open(filename, "w", encoding="utf-8") as f:
             f.write(text)
         log_operation("write", filename)
         return "File written to successfully."
@@ -158,22 +152,27 @@ def write_to_file(filename: str, text: str) -> str:
         return f"Error: {str(e)}"
 
 
-def append_to_file(filename: str, text: str, shouldLog: bool = True) -> str:
+@command(
+    "append_to_file", "Append to file", '"filename": "<filename>", "text": "<text>"'
+)
+def append_to_file(filename: str, text: str, should_log: bool = True) -> str:
     """Append text to a file
 
     Args:
         filename (str): The name of the file to append to
         text (str): The text to append to the file
+        should_log (bool): Should log output
 
     Returns:
         str: A message indicating success or failure
     """
     try:
-        filepath = path_in_workspace(filename)
-        with open(filepath, "a") as f:
+        directory = os.path.dirname(filename)
+        os.makedirs(directory, exist_ok=True)
+        with open(filename, "a") as f:
             f.write(text)
 
-        if shouldLog:
+        if should_log:
             log_operation("append", filename)
 
         return "Text appended successfully."
@@ -181,6 +180,7 @@ def append_to_file(filename: str, text: str, shouldLog: bool = True) -> str:
         return f"Error: {str(e)}"
 
 
+@command("delete_file", "Delete file", '"filename": "<filename>"')
 def delete_file(filename: str) -> str:
     """Delete a file
 
@@ -193,14 +193,14 @@ def delete_file(filename: str) -> str:
     if check_duplicate_operation("delete", filename):
         return "Error: File has already been deleted."
     try:
-        filepath = path_in_workspace(filename)
-        os.remove(filepath)
+        os.remove(filename)
         log_operation("delete", filename)
         return "File deleted successfully."
     except Exception as e:
         return f"Error: {str(e)}"
 
 
+@command("search_files", "Search Files", '"directory": "<directory>"')
 def search_files(directory: str) -> list[str]:
     """Search for files in a directory
 
@@ -212,29 +212,34 @@ def search_files(directory: str) -> list[str]:
     """
     found_files = []
 
-    if directory in {"", "/"}:
-        search_directory = WORKSPACE_PATH
-    else:
-        search_directory = path_in_workspace(directory)
-
-    for root, _, files in os.walk(search_directory):
+    for root, _, files in os.walk(directory):
         for file in files:
             if file.startswith("."):
                 continue
-            relative_path = os.path.relpath(os.path.join(root, file), WORKSPACE_PATH)
+            relative_path = os.path.relpath(
+                os.path.join(root, file), CFG.workspace_path
+            )
             found_files.append(relative_path)
 
     return found_files
 
 
+@command(
+    "download_file",
+    "Download File",
+    '"url": "<url>", "filename": "<filename>"',
+    CFG.allow_downloads,
+    "Error: You do not have user authorization to download files locally.",
+)
 def download_file(url, filename):
     """Downloads a file
     Args:
         url (str): URL of the file to download
         filename (str): Filename to save the file as
     """
-    safe_filename = path_in_workspace(filename)
     try:
+        directory = os.path.dirname(filename)
+        os.makedirs(directory, exist_ok=True)
         message = f"{Fore.YELLOW}Downloading file from {Back.LIGHTBLUE_EX}{url}{Back.RESET}{Fore.RESET}"
         with Spinner(message) as spinner:
             session = requests.Session()
@@ -251,7 +256,7 @@ def download_file(url, filename):
                 total_size = int(r.headers.get("Content-Length", 0))
                 downloaded_size = 0
 
-                with open(safe_filename, "wb") as f:
+                with open(filename, "wb") as f:
                     for chunk in r.iter_content(chunk_size=8192):
                         f.write(chunk)
                         downloaded_size += len(chunk)
@@ -260,7 +265,7 @@ def download_file(url, filename):
                         progress = f"{readable_file_size(downloaded_size)} / {readable_file_size(total_size)}"
                         spinner.update_message(f"{message} {progress}")
 
-            return f'Successfully downloaded and locally stored file: "{filename}"! (Size: {readable_file_size(total_size)})'
+            return f'Successfully downloaded and locally stored file: "{filename}"! (Size: {readable_file_size(downloaded_size)})'
     except requests.HTTPError as e:
         return f"Got an HTTP Error whilst trying to download file: {e}"
     except Exception as e:

scripts/check_requirements.py

@@ -1,3 +1,4 @@
+import re
 import sys
 
 import pkg_resources
@@ -16,7 +17,7 @@ def main():
     for package in required_packages:
         if not package:  # Skip empty lines
             continue
-        package_name = package.strip().split("==")[0]
+        package_name = re.split("[<>=@ ]+", package.strip())[0]
         if package_name.lower() not in installed_packages:
             missing_packages.append(package_name)
 

scripts/install_plugin_deps.py

@@ -0,0 +1,35 @@
+import os
+import subprocess
+import sys
+import zipfile
+from pathlib import Path
+
+
+def install_plugin_dependencies():
+    """
+    Installs dependencies for all plugins in the plugins dir.
+
+    Args:
+        None
+
+    Returns:
+        None
+    """
+    plugins_dir = Path(os.getenv("PLUGINS_DIR", "plugins"))
+    for plugin in plugins_dir.glob("*.zip"):
+        with zipfile.ZipFile(str(plugin), "r") as zfile:
+            try:
+                basedir = zfile.namelist()[0]
+                basereqs = os.path.join(basedir, "requirements.txt")
+                extracted = zfile.extract(basereqs, path=plugins_dir)
+                subprocess.check_call(
+                    [sys.executable, "-m", "pip", "install", "-r", extracted]
+                )
+                os.remove(extracted)
+                os.rmdir(os.path.join(plugins_dir, basedir))
+            except KeyError:
+                continue
+
+
+if __name__ == "__main__":
+    install_plugin_dependencies()