Feature/edit code

interpreter/cli/cli.py

@@ -1,10 +1,8 @@
 import argparse
-import subprocess
 import os
-import platform
 import pkg_resources
 import appdirs
-from ..utils.display_markdown_message import display_markdown_message
+from ..utils.open_file import open_file
 from ..terminal_interface.conversation_navigator import conversation_navigator
 
 arguments = [
@@ -114,16 +112,9 @@ def cli(interpreter):
         config_dir = appdirs.user_config_dir("Open Interpreter")
         config_path = os.path.join(config_dir, 'config.yaml')
         print(f"Opening `{config_path}`...")
-        # Use the default system editor to open the file
-        if platform.system() == 'Windows':
-            os.startfile(config_path)  # This will open the file with the default application, e.g., Notepad
-        else:
-            try:
-                # Try using xdg-open on non-Windows platforms
-                subprocess.call(['xdg-open', config_path])
-            except FileNotFoundError:
-                # Fallback to using 'open' on macOS if 'xdg-open' is not available
-                subprocess.call(['open', config_path])
+
+        open_file(file_path=config_path)
+
         return
 
     # TODO Implement model explorer

interpreter/code_interpreters/languages/utils/language_tools.py

@@ -0,0 +1,25 @@
+from ...language_map import language_map
+
+
+def get_language_file_extension(language_name):
+    """
+    Get the file extension for a given language
+    """
+    language = language_map[language_name.lower()]
+
+    if language.file_extension:
+        return language.file_extension
+    else:
+        return language
+
+
+def get_language_proper_name(language_name):
+    """
+    Get the proper name for a given language
+    """
+    language = language_map[language_name.lower()]
+
+    if language.proper_name:
+        return language.proper_name
+    else:
+        return language

interpreter/core/respond.py

@@ -90,6 +90,14 @@ def respond(interpreter):
                 print("Running code:", interpreter.messages[-1])
 
             try:
+                # Yield a message, such that the user can stop code execution if they want to
+                try:
+                    yield {"executing": {"code": interpreter.messages[-1]["code"], "language": interpreter.messages[-1]["language"]}}
+                except GeneratorExit:
+                    # The user might exit here.
+                    # We need to tell python what we (the generator) should do if they exit
+                    break
+
                 # What code do you want to run?
                 code = interpreter.messages[-1]["code"]
 
@@ -105,13 +113,6 @@ def respond(interpreter):
                     interpreter._code_interpreters[language] = create_code_interpreter(language)
                 code_interpreter = interpreter._code_interpreters[language]
 
-                # Yield a message, such that the user can stop code execution if they want to
-                try:
-                    yield {"executing": {"code": code, "language": language}}
-                except GeneratorExit:
-                    # The user might exit here.
-                    # We need to tell python what we (the generator) should do if they exit
-                    break
 
                 # Yield each line, also append it to last messages' output
                 interpreter.messages[-1]["output"] = ""

interpreter/terminal_interface/terminal_interface.py

@@ -9,6 +9,7 @@
 from ..utils.display_markdown_message import display_markdown_message
 from ..utils.truncate_output import truncate_output
 from ..utils.scan_code import scan_code
+from ..utils.edit_code import edit_code
 
 
 def terminal_interface(interpreter, message):
@@ -119,10 +120,37 @@ def terminal_interface(interpreter, message):
 
                             scan_code(code, language, interpreter)
 
-                        response = input("  Would you like to run this code? (y/n)\n\n  ")
+                        response = input("  Would you like to run this code? (y/n/%edit)\n\n  ")
                         print("")  # <- Aesthetic choice
 
-                        if response.strip().lower() == "y":
+                        if response.strip().lower() == "%edit":
+                            # open a code editor with this code in a temporary file
+                            # when the user saves and exits, run the code
+                            # Get code language and actual code from the chunk
+                            # We need to give these to our editor to open the file
+                            language = chunk["executing"]["language"]
+                            code = chunk["executing"]["code"]
+
+                            edited_code = edit_code(code, language, interpreter)
+
+                            # Get the last message, so we can extend it with the edited code
+                            old_message = interpreter.messages[-1]
+
+                            # Remove the last message, which is the code we're about to edit
+                            interpreter.messages = interpreter.messages[:-1]
+
+                            ran_code_block = True
+                            render_cursor = False
+
+                            active_block.end()
+
+                            # Add the edited code to the messages
+                            interpreter.messages.append({
+                                **old_message,
+                                "code": edited_code,
+                            })
+
+                        elif response.strip().lower() == "y":
                             # Create a new, identical block where the code will actually be run
                             # Conveniently, the chunk includes everything we need to do this:
                             active_block = CodeBlock()

interpreter/utils/edit_code.py

@@ -0,0 +1,64 @@
+import os
+from yaspin import yaspin
+
+from .temporary_file import create_temporary_file, cleanup_temporary_file
+from .open_file import open_file
+from ..code_interpreters.languages.utils.language_tools import get_language_file_extension, get_language_proper_name
+
+
+def edit_code(code, language, interpreter):
+    """
+    Edit the code and listen for changes with watchdog
+    """
+
+    temp_code = code
+
+    temp_file = create_temporary_file(
+        temp_code, get_language_file_extension(language), verbose=interpreter.debug_mode
+    )
+
+    language_name = get_language_proper_name(language)
+
+    file_name = os.path.basename(temp_file)
+
+    if interpreter.debug_mode:
+        print(f"Editing {language_name} code in {file_name}")
+        print("---")
+
+    # Run semgrep
+    try:
+        print("  Press `ENTER` after you've saved your edits.")
+
+        open_file(temp_file)
+
+        with yaspin(text=f"  Editing {language_name} code...").green.right.dots as loading:
+            # HACK: we're just listening for the user to come back and hit Enter
+            # but we aren't actually doing anything with it and since we're inside
+            # of a yaspin handler, the input prompt doesn't actually render
+            done = input("  Press `ENTER` when you're ready to continue:")
+
+            loading.stop()
+            loading.hide()
+
+        if done == "":
+            print(f"  {language_name} code updated.")
+            print("") # <- Aesthetic choice
+
+            temp_code = open(temp_file).read()
+
+            if interpreter.debug_mode:
+                print(f"Getting updated {language_name} code from {file_name}")
+                print("---")
+
+            cleanup_temporary_file(temp_file, verbose=interpreter.debug_mode)
+
+            if interpreter.debug_mode:
+                print(f"Deleting {file_name}")
+                print("---")
+
+    except Exception as e:
+        print(f"Could not edit {language} code.")
+        print(e)
+        print("")  # <- Aesthetic choice
+
+    return temp_code

interpreter/utils/open_file.py

@@ -0,0 +1,14 @@
+import os
+import platform
+import subprocess
+
+def open_file(file_path):
+    if platform.system() == 'Windows':
+        os.startfile(file_path)  # This will open the file with the default application, e.g., Notepad
+    else:
+        try:
+            # Try using xdg-open on non-Windows platforms
+            subprocess.call(['xdg-open', file_path])
+        except FileNotFoundError:
+            # Fallback to using 'open' on macOS if 'xdg-open' is not available
+            subprocess.call(['open', file_path])

interpreter/utils/scan_code.py

@@ -1,34 +1,9 @@
 import os
 import subprocess
 from yaspin import yaspin
-from yaspin.spinners import Spinners
 
 from .temporary_file import create_temporary_file, cleanup_temporary_file
-from ..code_interpreters.language_map import language_map
-
-
-def get_language_file_extension(language_name):
-    """
-    Get the file extension for a given language
-    """
-    language = language_map[language_name.lower()]
-
-    if language.file_extension:
-        return language.file_extension
-    else:
-        return language
-
-
-def get_language_proper_name(language_name):
-    """
-    Get the proper name for a given language
-    """
-    language = language_map[language_name.lower()]
-
-    if language.proper_name:
-        return language.proper_name
-    else:
-        return language
+from ..code_interpreters.languages.utils.language_tools import get_language_file_extension, get_language_proper_name
 
 
 def scan_code(code, language, interpreter):