ara-cli 0.1.9.77__py3-none-any.whl → 0.1.10.8__py3-none-any.whl

ara_cli/chat.py

@@ -1,11 +1,43 @@
 import os
+import argparse
 import cmd2
+
 from ara_cli.prompt_handler import send_prompt
 
+from . import error_handler
+from ara_cli.error_handler import AraError, AraConfigurationError
+
+from ara_cli.file_loaders.document_file_loader import DocumentFileLoader
+from ara_cli.file_loaders.binary_file_loader import BinaryFileLoader
+from ara_cli.file_loaders.text_file_loader import TextFileLoader
+from ara_cli.chat_agent.agent_process_manager import AgentProcessManager
+
+
+extract_parser = argparse.ArgumentParser()
+extract_parser.add_argument(
+    "-f", "--force", action="store_true", help="Force extraction"
+)
+extract_parser.add_argument(
+    "-w",
+    "--write",
+    action="store_true",
+    help="Overwrite existing files without using LLM for merging.",
+)
+
+load_parser = argparse.ArgumentParser()
+load_parser.add_argument("file_name", nargs="?",
+                         default="", help="File to load")
+load_parser.add_argument(
+    "--load-images",
+    action="store_true",
+    help="Extract and describe images from documents",
+)
+
 
 class Chat(cmd2.Cmd):
     CATEGORY_CHAT_CONTROL = "Chat control commands"
     CATEGORY_LLM_CONTROL = "Language model controls"
+    CATEGORY_AGENT_CONTROL = "Agent control commands"
 
     INTRO = """/***************************************/
                  araarar
@@ -29,37 +61,50 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
     ROLE_PROMPT = "ara prompt"
     ROLE_RESPONSE = "ara response"
 
+    # Available agents
+    AVAILABLE_AGENTS = [
+        "interview_agent",
+        "autocoder_v2_agent",
+        "question_and_answer_agent",
+        "feature_creation_guide_agent",
+    ]
+
     BINARY_TYPE_MAPPING = {
-            ".png": "image/png",
-            ".jpg": "image/jpeg",
-            ".jpeg": "image/jpeg",
-        }
-    
+        ".png": "image/png",
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+    }
+
     DOCUMENT_TYPE_EXTENSIONS = [".docx", ".doc", ".odt", ".pdf"]
 
     def __init__(
         self,
         chat_name: str,
         reset: bool | None = None,
-        enable_commands: list[str] | None = None
+        enable_commands: list[str] | None = None,
     ):
+        from ara_cli.template_loader import TemplateLoader
+
         shortcuts = dict(cmd2.DEFAULT_SHORTCUTS)
         if enable_commands:
             enable_commands.append("quit")  # always allow quitting
             enable_commands.append("eof")  # always allow quitting with ctrl-D
             enable_commands.append("help")  # always allow help
 
-            shortcuts = {key: value for key, value in shortcuts.items() if value in enable_commands}
+            shortcuts = {
+                key: value
+                for key, value in shortcuts.items()
+                if value in enable_commands
+            }
 
-        super().__init__(
-            allow_cli_args=False,
-            shortcuts=shortcuts
-        )
+        super().__init__(allow_cli_args=False, shortcuts=shortcuts)
         self.create_default_aliases()
 
         if enable_commands:
             all_commands = self.get_all_commands()
-            commands_to_disable = [command for command in all_commands if command not in enable_commands]
+            commands_to_disable = [
+                command for command in all_commands if command not in enable_commands
+            ]
             self.disable_commands(commands_to_disable)
 
         self.prompt = "ara> "
@@ -71,12 +116,18 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         self.chat_history = []
         self.message_buffer = []
         self.config = self._retrieve_ara_config()
+        self.template_loader = TemplateLoader(chat_instance=self)
+
+        # Initialize agent process manager
+        self.agent_manager = AgentProcessManager(self)
 
     def disable_commands(self, commands: list[str]):
         for command in commands:
-            setattr(self, f'do_{command}', self.default)
+            setattr(self, f"do_{command}", self.default)
             self.hidden_commands.append(command)
-        aliases_to_remove = [alias for alias, cmd in self.aliases.items() if cmd in commands]
+        aliases_to_remove = [
+            alias for alias, cmd in self.aliases.items() if cmd in commands
+        ]
         for alias in aliases_to_remove:
             del self.aliases[alias]
 
@@ -97,6 +148,11 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         self.aliases["lg"] = "LOAD_GIVENS"
         self.aliases["lb"] = "LOAD_BLUEPRINT"
         self.aliases["lt"] = "LOAD_TEMPLATE"
+        # Agent control aliases
+        self.aliases["a"] = "AGENT_RUN"
+        self.aliases["as"] = "AGENT_STOP"
+        self.aliases["ac"] = "AGENT_CONTINUE"
+        self.aliases["astat"] = "AGENT_STATUS"
 
     def setup_chat(self, chat_name, reset: bool = None):
         if os.path.exists(chat_name):
@@ -111,8 +167,10 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         chat_file_short = os.path.split(chat_file)[-1]
 
         if reset is None:
-            user_input = input(f"{chat_file_short} already exists. Do you want to reset the chat? (y/N): ")
-            if user_input.lower() == 'y':
+            user_input = input(
+                f"{chat_file_short} already exists. Do you want to reset the chat? (y/N): "
+            )
+            if user_input.lower() == "y":
                 self.create_empty_chat_file(chat_file)
         if reset:
             self.create_empty_chat_file(chat_file)
@@ -139,16 +197,14 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
                 print(f"File {file_name} not found.")
                 return False
             return method(self, file_path, *args, **kwargs)
+
         return wrapper
 
     @staticmethod
     def get_last_role_marker(lines):
         if not lines:
             return
-        role_markers = [
-            f"# {Chat.ROLE_PROMPT}:",
-            f"# {Chat.ROLE_RESPONSE}"
-        ]
+        role_markers = [f"# {Chat.ROLE_PROMPT}:", f"# {Chat.ROLE_RESPONSE}"]
         for line in reversed(lines):
             stripped_line = line.strip()
             if stripped_line.startswith(tuple(role_markers)):
@@ -156,7 +212,7 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         return None
 
     def start_non_interactive(self):
-        with open(self.chat_name, 'r', encoding='utf-8') as file:
+        with open(self.chat_name, "r", encoding="utf-8") as file:
             content = file.read()
         print(content)
 
@@ -191,23 +247,19 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         text_content = []
         image_data_list = []
 
-        image_pattern = re.compile(r'\((data:image/[^;]+;base64,.*?)\)')
+        image_pattern = re.compile(r"\((data:image/[^;]+;base64,.*?)\)")
 
         for line in message.splitlines():
             match = image_pattern.search(line)
             if match:
-                image_data = {"type": "image_url", "image_url": {"url": match.group(1)}}
+                image_data = {"type": "image_url",
+                              "image_url": {"url": match.group(1)}}
                 image_data_list.append(image_data)
             else:
                 text_content.append(line)
 
-        message_content = {
-            "type": "text",
-            "text": '\n'.join(text_content)}
-        message = {
-            "role": role,
-            "content": [message_content]
-        }
+        message_content = {"type": "text", "text": "\n".join(text_content)}
+        message = {"role": role, "content": [message_content]}
         message = append_images_to_message(message, image_data_list)
         return message
 
@@ -220,7 +272,7 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
 
         split_pattern = re.compile(f"({prompt_marker}|{response_marker})")
 
-        parts = re.split(split_pattern, '\n'.join(self.chat_history))
+        parts = re.split(split_pattern, "\n".join(self.chat_history))
 
         all_prompts_and_responses = []
         current = ""
@@ -254,7 +306,7 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         prompt_to_send = self.assemble_prompt()
         role_marker = f"# {Chat.ROLE_RESPONSE}:"
 
-        with open(self.chat_name, 'a+', encoding='utf-8') as file:
+        with open(self.chat_name, "a+", encoding="utf-8") as file:
             last_line = self.get_last_line(file)
 
             print(role_marker)
@@ -277,24 +329,24 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
 
     def save_message(self, role: str, message: str):
         role_marker = f"# {role}:"
-        with open(self.chat_name, 'r', encoding='utf-8') as file:
+        with open(self.chat_name, "r", encoding="utf-8") as file:
             stripped_line = self.get_last_non_empty_line(file)
         line_to_write = f"{message}\n\n"
         if stripped_line != role_marker:
             line_to_write = f"\n{role_marker}\n{message}\n"
 
-        with open(self.chat_name, 'a', encoding='utf-8') as file:
+        with open(self.chat_name, "a", encoding="utf-8") as file:
             file.write(line_to_write)
         self.chat_history.append(line_to_write)
 
     def resend_message(self):
-        with open(self.chat_name, 'r', encoding='utf-8') as file:
+        with open(self.chat_name, "r", encoding="utf-8") as file:
             lines = file.readlines()
         if not lines:
             return
         index_to_remove = self.find_last_reply_index(lines)
         if index_to_remove is not None:
-            with open(self.chat_name, 'w', encoding='utf-8') as file:
+            with open(self.chat_name, "w", encoding="utf-8") as file:
                 file.writelines(lines[:index_to_remove])
         self.send_message()
 
@@ -309,114 +361,91 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         return index_to_remove
 
     def append_strings(self, strings: list[str]):
-        output = '\n'.join(strings)
-        with open(self.chat_name, 'a') as file:
-            file.write(output + '\n')
+        output = "\n".join(strings)
+        with open(self.chat_name, "a") as file:
+            file.write(output + "\n")
 
     def load_chat_history(self, chat_file: str):
         chat_history = []
         if os.path.exists(chat_file):
-            with open(chat_file, 'r', encoding='utf-8') as file:
+            with open(chat_file, "r", encoding="utf-8") as file:
                 chat_history = file.readlines()
         return chat_history
 
     def create_empty_chat_file(self, chat_file: str):
-        with open(chat_file, 'w', encoding='utf-8') as file:
+        with open(chat_file, "w", encoding="utf-8") as file:
             file.write(self.default_chat_content)
         self.chat_history = []
 
     def add_prompt_tag_if_needed(self, chat_file: str):
-        with open(chat_file, 'r', encoding='utf-8') as file:
+        with open(chat_file, "r", encoding="utf-8") as file:
             lines = file.readlines()
+
         prompt_tag = f"# {Chat.ROLE_PROMPT}:"
         if Chat.get_last_role_marker(lines) == prompt_tag:
             return
         append = prompt_tag
         last_line = lines[-1].strip()
-        if last_line != "" and last_line != '\n':
+        if last_line != "" and last_line != "\n":
             append = f"\n{append}"
-        with open(chat_file, 'a', encoding='utf-8') as file:
+        with open(chat_file, "a", encoding="utf-8") as file:
             file.write(append)
 
-    def determine_file_path(self, file_name: str):
-        current_directory = os.path.dirname(self.chat_name)
-        file_path = os.path.join(current_directory, file_name)
-        if not os.path.exists(file_path):
-            file_path = file_name
-        if not os.path.exists(file_path):
-            print(f"File {file_name} not found")
-            return None
-        return file_path
-
-    @file_exists_check
-    def load_text_file(self, file_path, prefix: str = "", suffix: str = "", block_delimiter: str = ""):
-        with open(file_path, 'r', encoding='utf-8', errors="replace") as file:
-            file_content = file.read()
-            if block_delimiter:
-                file_content = f"{block_delimiter}\n{file_content}\n{block_delimiter}"
-        write_content = f"{prefix}{file_content}{suffix}\n"
-
-        with open(self.chat_name, 'a', encoding='utf-8') as chat_file:
-            chat_file.write(write_content)
-            return True
-
-    @file_exists_check
-    def load_binary_file(self, file_path, mime_type: str, prefix: str = "", suffix: str = ""):
-        import base64
-
-        with open(file_path, 'rb') as file:
-            file_content = file.read()
-        base64_image = base64.b64encode(file_content).decode("utf-8")
-
-        write_content = f"{prefix}![{os.path.basename(file_path)}](data:{mime_type};base64,{base64_image}){suffix}\n"
+    def load_text_file(
+        self,
+        file_path,
+        prefix: str = "",
+        suffix: str = "",
+        block_delimiter: str = "",
+        extract_images: bool = False,
+    ):
+        loader = TextFileLoader(self)
+        return loader.load(
+            file_path,
+            prefix=prefix,
+            suffix=suffix,
+            block_delimiter=block_delimiter,
+            extract_images=extract_images,
+        )
 
-        with open(self.chat_name, 'a', encoding='utf-8') as chat_file:
-            chat_file.write(write_content)
-            return True
-    
-    def read_docx(self, file_path):
-        import docx
-        doc = docx.Document(file_path)
-        return '\n'.join(para.text for para in doc.paragraphs)
-
-    def read_pdf(self, file_path):
-        import pymupdf4llm
-        return pymupdf4llm.to_markdown(file_path, write_images=False)
-
-    def read_odt(self, file_path):
-        import pymupdf4llm
-        return pymupdf4llm.to_markdown(file_path, write_images=False)
-
-    @file_exists_check
-    def load_document_file(self, file_path: str, prefix: str = "", suffix: str = "", block_delimiter: str = "```"):
-        import os
-
-        _, ext = os.path.splitext(file_path)
-        ext = ext.lower()
-
-        text_content = ""
-        match ext:
-            case ".docx":
-                text_content = self.read_docx(file_path)
-            case ".pdf":
-                text_content = self.read_pdf(file_path)
-            case ".odt":
-                text_content = self.read_odt(file_path)
-            # Add more cases if needed.
-            case _:
-                print("Unsupported document type.")
-                return False
+    def load_binary_file(
+        self, file_path, mime_type: str, prefix: str = "", suffix: str = ""
+    ):
+        loader = BinaryFileLoader(self)
+        return loader.load(file_path, mime_type=mime_type, prefix=prefix, suffix=suffix)
 
-        if block_delimiter:
-            text_content = f"{block_delimiter}\n{text_content}\n{block_delimiter}"
+    def read_markdown(self, file_path: str, extract_images: bool = False) -> str:
+        """Read markdown file and optionally extract/describe images"""
+        from ara_cli.file_loaders.text_file_loader import MarkdownReader
 
-        write_content = f"{prefix}{text_content}{suffix}\n"
+        reader = MarkdownReader(file_path)
+        return reader.read(extract_images=extract_images)
 
-        with open(self.chat_name, 'a', encoding='utf-8') as chat_file:
-            chat_file.write(write_content)
-        return True
+    def load_document_file(
+        self,
+        file_path: str,
+        prefix: str = "",
+        suffix: str = "",
+        block_delimiter: str = "```",
+        extract_images: bool = False,
+    ):
+        loader = DocumentFileLoader(self)
+        return loader.load(
+            file_path,
+            prefix=prefix,
+            suffix=suffix,
+            block_delimiter=block_delimiter,
+            extract_images=extract_images,
+        )
 
-    def load_file(self, file_name: str, prefix: str = "", suffix: str = "", block_delimiter: str = ""):
+    def load_file(
+        self,
+        file_name: str,
+        prefix: str = "",
+        suffix: str = "",
+        block_delimiter: str = "",
+        extract_images: bool = False,
+    ):
         binary_type_mapping = Chat.BINARY_TYPE_MAPPING
         document_type_extensions = Chat.DOCUMENT_TYPE_EXTENSIONS
 
@@ -427,28 +456,29 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
                 file_type = mime_type
                 break
 
-        is_file_document = any(file_name_lower.endswith(ext) for ext in document_type_extensions)
+        is_file_document = any(
+            file_name_lower.endswith(ext) for ext in document_type_extensions
+        )
 
         if is_file_document:
             return self.load_document_file(
-                file_name=file_name,
+                file_path=file_name,
                 prefix=prefix,
                 suffix=suffix,
-                block_delimiter=block_delimiter
+                block_delimiter=block_delimiter,
+                extract_images=extract_images,
             )
         elif file_type:
             return self.load_binary_file(
-                file_name=file_name,
-                mime_type=file_type,
-                prefix=prefix,
-                suffix=suffix
+                file_path=file_name, mime_type=file_type, prefix=prefix, suffix=suffix
             )
         else:
             return self.load_text_file(
-                file_name=file_name,
+                file_path=file_name,
                 prefix=prefix,
                 suffix=suffix,
-                block_delimiter=block_delimiter
+                block_delimiter=block_delimiter,
+                extract_images=extract_images,
             )
 
     def choose_file_to_load(self, files: list[str], pattern: str):
@@ -460,11 +490,14 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
             try:
                 choice_index = int(choice) - 1
                 if choice_index < 0 or choice_index >= len(files):
-                    print("Invalid choice. Aborting load.")
+                    error_handler.report_error(
+                        ValueError("Invalid choice. Aborting load.")
+                    )
                     return None
                 file_path = files[choice_index]
-            except ValueError:
-                print("Invalid input. Aborting load.")
+            except ValueError as e:
+                error_handler.report_error(
+                    ValueError("Invalid input. Aborting load."))
                 return None
         else:
             file_path = files[0]
@@ -473,26 +506,53 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
     def _help_menu(self, verbose: bool = False):
         super()._help_menu(verbose)
         if self.aliases:
-            aliases = [f"{alias} -> {command}" for alias, command in self.aliases.items()]
+            aliases = [
+                f"{alias} -> {command}" for alias, command in self.aliases.items()
+            ]
             self._print_topics("Aliases", aliases, verbose)
 
     def do_quit(self, _):
         """Exit ara-cli"""
+        self.agent_manager.cleanup_agent_process()
         print("Chat ended")
         self.last_result = True
         return True
 
+    def onecmd(self, *args, **kwargs):
+        try:
+            return super().onecmd(*args, **kwargs)
+        except Exception as e:
+            error_handler.report_error(e)
+        return False
+
     def onecmd_plus_hooks(self, line, orig_rl_history_length):
         # store the full line for use with default()
         self.full_input = line
-        return super().onecmd_plus_hooks(line, orig_rl_history_length=orig_rl_history_length)
+        return super().onecmd_plus_hooks(
+            line, orig_rl_history_length=orig_rl_history_length
+        )
 
     def default(self, line):
-        self.message_buffer.append(self.full_input)
+        if self.agent_manager.agent_mode:
+            if self.full_input.lower() in ["quit", "exit"]:
+                self.agent_manager.cleanup_agent_process()
+                print("Agent stopped.")
+            else:
+                # In agent mode, send input directly to agent
+                self.agent_manager.send_to_agent(self.full_input)
+        else:
+            # In normal chat mode, buffer the message
+            self.message_buffer.append(self.full_input)
 
     @cmd2.with_category(CATEGORY_CHAT_CONTROL)
-    def do_LOAD(self, file_name):
-        """Load a file and append its contents to chat file. Can be given the file name in-line. Will attempt to find the file relative to chat file first, then treat the given path as absolute"""
+    @cmd2.with_argparser(load_parser)
+    def do_LOAD(self, args):
+        """Load a file and append its contents to chat file. Can be given the file name in-line. Will attempt to find the file relative to chat file first, then treat the given path as absolute. Use --load-images flag to extract and describe images from documents."""
+        from ara_cli.commands.load_command import LoadCommand
+
+        file_name = args.file_name
+        load_images = args.load_images
+
         matching_files = self.find_matching_files_to_load(file_name)
         if not matching_files:
             return
@@ -501,16 +561,26 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
             block_delimiter = "```"
             prefix = f"\nFile: {file_path}\n"
             self.add_prompt_tag_if_needed(self.chat_name)
-            if not os.path.isdir(file_path) and self.load_file(file_path, prefix=prefix, block_delimiter=block_delimiter):
-                print(f"Loaded contents of file {file_path}")
+
+            if not os.path.isdir(file_path):
+                command = LoadCommand(
+                    chat_instance=self,
+                    file_path=file_path,
+                    prefix=prefix,
+                    block_delimiter=block_delimiter,
+                    extract_images=load_images,
+                    output=self.poutput,
+                )
+                command.execute()
 
     def complete_LOAD(self, text, line, begidx, endidx):
         import glob
 
-        return [x for x in glob.glob(text + '*')]
+        return [x for x in glob.glob(text + "*")]
 
     def _retrieve_ara_config(self):
         from ara_cli.prompt_handler import ConfigManager
+
         return ConfigManager().get_config()
 
     def _retrieve_llm_config(self):
@@ -526,7 +596,9 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         file_pattern = os.path.join(os.path.dirname(self.chat_name), file_name)
         matching_files = glob.glob(file_pattern)
         if not matching_files:
-            print(f"No files matching pattern {file_name} found.")
+            error_handler.report_error(
+                AraError(f"No files matching pattern '{file_name}' found.")
+            )
             return
         return matching_files
 
@@ -542,37 +614,30 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
 
         if file_type:
             return self.load_binary_file(
-                file_name=file_name,
-                mime_type=file_type,
-                prefix=prefix,
-                suffix=suffix
+                file_path=file_name, mime_type=file_type, prefix=prefix, suffix=suffix
             )
-        print(f"File {file_name} not recognized as image, could not load")
+        error_handler.report_error(
+            AraError(
+                f"File {file_name} not recognized as image, could not load")
+        )
 
     def _verify_llm_choice(self, model_name):
         llm_config = self._retrieve_llm_config()
         models = [name for name in llm_config.keys()]
         if model_name not in models:
-            print(f"Model {model_name} unavailable. Retrieve the list of available models using the LIST_MODELS command.")
+            error_handler.report_error(
+                AraConfigurationError(
+                    f"Model {model_name} unavailable. Retrieve the list of available models using the LIST_MODELS command."
+                )
+            )
             return False
         return True
 
-    @cmd2.with_category(CATEGORY_CHAT_CONTROL)
-    def do_LOAD_DOCUMENT(self, file_name):
-        """Load a document file (PDF, DOCX, DOC, ODT) and append its text content to chat file. Can be given the file name in-line. Will attempt to find the file relative to chat file first, then treat the given path as absolute"""
-        matching_files = self.find_matching_files_to_load(file_name)
-        if not matching_files:
-            return
-
-        for file_path in matching_files:
-            prefix = f"\nFile: {file_path}\n"
-            self.add_prompt_tag_if_needed(self.chat_name)
-            if not os.path.isdir(file_path) and self.load_document_file(file_path, prefix=prefix):
-                print(f"Loaded document file {file_path}")
-
     @cmd2.with_category(CATEGORY_CHAT_CONTROL)
     def do_LOAD_IMAGE(self, file_name):
         """Load an image file and append it to chat file. Can be given the file name in-line. Will attempt to find the file relative to chat file first, then treat the given path as absolute"""
+        from ara_cli.commands.load_image_command import LoadImageCommand
+
         matching_files = self.find_matching_files_to_load(file_name)
         if not matching_files:
             return
@@ -580,8 +645,31 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         for file_path in matching_files:
             prefix = f"\nFile: {file_path}\n"
             self.add_prompt_tag_if_needed(self.chat_name)
-            if not os.path.isdir(file_path) and self.load_image(file_path, prefix=prefix):
-                print(f"Loaded image file {file_path}")
+
+            if not os.path.isdir(file_path):
+                # Determine mime type
+                file_type = None
+                file_path_lower = file_path.lower()
+                for extension, mime_type in Chat.BINARY_TYPE_MAPPING.items():
+                    if file_path_lower.endswith(extension):
+                        file_type = mime_type
+                        break
+
+                if file_type:
+                    command = LoadImageCommand(
+                        chat_instance=self,
+                        file_path=file_path,
+                        mime_type=file_type,
+                        prefix=prefix,
+                        output=self.poutput,
+                    )
+                    command.execute()
+                else:
+                    error_handler.report_error(
+                        AraError(
+                            f"File {file_path} not recognized as image, could not load"
+                        )
+                    )
 
     @cmd2.with_category(CATEGORY_LLM_CONTROL)
     def do_LIST_MODELS(self, _):
@@ -600,14 +688,38 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         original_dir = os.getcwd()
         navigator = DirectoryNavigator()
         navigator.navigate_to_target()
-        os.chdir('..')
+        os.chdir("..")
 
         if not self._verify_llm_choice(model_name):
             return
+
         self.config.default_llm = model_name
         save_data(filepath=DEFAULT_CONFIG_LOCATION, config=self.config)
 
-        LLMSingleton.set_model(model_name)
+        LLMSingleton.set_default_model(model_name)
+        print(f"Language model switched to '{model_name}'")
+
+        os.chdir(original_dir)
+
+    @cmd2.with_category(CATEGORY_LLM_CONTROL)
+    def do_CHOOSE_EXTRACTION_MODEL(self, model_name):
+        from ara_cli.prompt_handler import LLMSingleton
+        from ara_cli.ara_config import DEFAULT_CONFIG_LOCATION, save_data
+        from ara_cli.directory_navigator import DirectoryNavigator
+
+        original_dir = os.getcwd()
+        navigator = DirectoryNavigator()
+        navigator.navigate_to_target()
+        os.chdir("..")
+
+        if not self._verify_llm_choice(model_name):
+            return
+
+        self.config.extraction_llm = model_name
+        save_data(filepath=DEFAULT_CONFIG_LOCATION, config=self.config)
+
+        LLMSingleton.set_extraction_model(model_name)
+        print(f"Extraction model switched to '{model_name}'")
 
         os.chdir(original_dir)
 
@@ -615,7 +727,14 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
     def do_CURRENT_MODEL(self, _):
         from ara_cli.prompt_handler import LLMSingleton
 
-        print(LLMSingleton.get_model())
+        print(LLMSingleton.get_default_model())
+
+    @cmd2.with_category(CATEGORY_LLM_CONTROL)
+    def do_CURRENT_EXTRACTION_MODEL(self, _):
+        """Displays the current extraction language model."""
+        from ara_cli.prompt_handler import LLMSingleton
+
+        print(LLMSingleton.get_extraction_model())
 
     def _complete_llms(self, text, line, begidx, endidx):
         llm_config = self._retrieve_llm_config()
@@ -631,6 +750,9 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
     def complete_CHOOSE_MODEL(self, text, line, begidx, endidx):
         return self._complete_llms(text, line, begidx, endidx)
 
+    def complete_CHOOSE_EXTRACTION_MODEL(self, text, line, begidx, endidx):
+        return self._complete_llms(text, line, begidx, endidx)
+
     @cmd2.with_category(CATEGORY_CHAT_CONTROL)
     def do_NEW(self, chat_name):
         """Create a new chat. Optionally provide a chat name in-line: NEW new_chat"""
@@ -649,36 +771,51 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
     def do_CLEAR(self, _):
         """Clear the chat and the file containing it"""
         user_input = input("Are you sure you want to clear the chat? (y/N): ")
-        if user_input.lower() != 'y':
+        if user_input.lower() != "y":
             return
         self.create_empty_chat_file(self.chat_name)
         self.chat_history = self.load_chat_history(self.chat_name)
+        self.message_buffer.clear()
         print(f"Cleared content of {self.chat_name}")
 
     @cmd2.with_category(CATEGORY_CHAT_CONTROL)
     def do_LOAD_RULES(self, rules_name):
         """Load rules from ./prompt.data/*.rules.md or from a specified template directory if an argument is given. Specify global/<rules_template> to access globally defined rules templates"""
-        self._load_template_helper(rules_name, "rules", "*.rules.md")
+        self.template_loader.load_template(
+            rules_name, "rules", self.chat_name, "*.rules.md"
+        )
 
     @cmd2.with_category(CATEGORY_CHAT_CONTROL)
     def do_LOAD_INTENTION(self, intention_name):
         """Load intention from ./prompt.data/*.intention.md or from a specified template directory if an argument is given. Specify global/<intention_template> to access globally defined intention templates"""
-        self._load_template_helper(intention_name, "intention", "*.intention.md")
+        self.template_loader.load_template(
+            intention_name, "intention", self.chat_name, "*.intention.md"
+        )
 
     @cmd2.with_category(CATEGORY_CHAT_CONTROL)
     def do_LOAD_COMMANDS(self, commands_name):
         """Load commands from ./prompt.data/*.commands.md or from a specified template directory if an argument is given. Specify global/<commands_template> to access globally defined commands templates"""
-        self._load_template_helper(commands_name, "commands", "*.commands.md")
+        self.template_loader.load_template(
+            commands_name, "commands", self.chat_name, "*.commands.md"
+        )
 
     @cmd2.with_category(CATEGORY_CHAT_CONTROL)
     def do_LOAD_BLUEPRINT(self, blueprint_name):
         """Load specified blueprint. Specify global/<blueprint_name> to access globally defined blueprints"""
-        self._load_template_from_global_or_local(blueprint_name, "blueprint")
+        self.template_loader.load_template(
+            blueprint_name, "blueprint", self.chat_name)
 
-    def _load_helper(self, directory: str, pattern: str, file_type: str, exclude_pattern: str | None = None):
+    def _load_helper(
+        self,
+        directory: str,
+        pattern: str,
+        file_type: str,
+        exclude_pattern: str | None = None,
+    ):
         import glob
 
-        directory_path = os.path.join(os.path.dirname(self.chat_name), directory)
+        directory_path = os.path.join(
+            os.path.dirname(self.chat_name), directory)
         file_pattern = os.path.join(directory_path, pattern)
 
         exclude_files = []
@@ -688,7 +825,7 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
             matching_files = list(set(matching_files) - set(exclude_files))
 
         if not matching_files:
-            print(f"No {file_type} file found.")
+            error_handler.report_error(AraError(f"No {file_type} file found."))
             return
 
         file_path = self.choose_file_to_load(matching_files, pattern)
@@ -705,10 +842,7 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         from ara_cli.ara_config import ConfigManager
         from ara_cli.directory_navigator import DirectoryNavigator
 
-        plurals = {
-            "commands": "commands",
-            "rules": "rules"
-        }
+        plurals = {"commands": "commands", "rules": "rules"}
 
         plural = f"{template_type}s"
         if template_type in plurals:
@@ -716,7 +850,9 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
 
         if template_name.startswith("global/"):
             directory = f"{TemplatePathManager.get_template_base_path()}/prompt-modules/{plural}/"
-            self._load_helper(directory, template_name.removeprefix("global/"), template_type)
+            self._load_helper(
+                directory, template_name.removeprefix("global/"), template_type
+            )
             return
 
         ara_config = ConfigManager.get_config()
@@ -730,7 +866,9 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         os.chdir(original_directory)
 
         custom_prompt_templates_subdir = self.config.custom_prompt_templates_subdir
-        template_directory = f"{local_templates_path}/{custom_prompt_templates_subdir}/{plural}"
+        template_directory = (
+            f"{local_templates_path}/{custom_prompt_templates_subdir}/{plural}"
+        )
         self._load_helper(template_directory, template_name, template_type)
 
     def _load_template_helper(self, template_name, template_type, default_pattern):
@@ -738,55 +876,100 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
             self._load_helper("prompt.data", default_pattern, template_type)
             return
 
-        self._load_template_from_global_or_local(template_name=template_name, template_type=template_type)
+        self._load_template_from_global_or_local(
+            template_name=template_name, template_type=template_type
+        )
 
     @cmd2.with_category(CATEGORY_CHAT_CONTROL)
-    def do_EXTRACT(self, _):
-        """Search for markdown code blocks containing \"# [x] extract\" as first line and \"# filename: <path/filename>\" as second line and copy the content of the code block to the specified file. The extracted code block is then marked with \"# [v] extract\""""
-        from ara_cli.prompt_extractor import extract_responses
+    @cmd2.with_argparser(extract_parser)
+    def do_EXTRACT(self, args):
+        """Search for markdown code blocks containing "# [x] extract" as first line and "# filename: <path/filename>" as second line and copy the content of the code block to the specified file. The extracted code block is then marked with "# [v] extract"."""
+        from ara_cli.commands.extract_command import ExtractCommand
+
+        command = ExtractCommand(
+            file_name=self.chat_name,
+            force=args.force,
+            write=args.write,
+            output=self.poutput,
+        )
+        command.execute()
+
+    def _find_givens_files(self, file_name: str) -> list[str]:
+        """
+        Finds the givens files to be processed.
+        - If file_name is provided, it resolves that path.
+        - Otherwise, it looks for default givens files.
+        - If no defaults are found, it prompts the user.
+        Returns a list of absolute file paths or an empty list if none are found.
+        """
+        base_directory = os.path.dirname(self.chat_name)
 
-        extract_responses(self.chat_name, True)
-        print("End of extraction")
+        def resolve_path(name):
+            """Inner helper to resolve a path relative to chat, then absolute."""
+            relative_path = os.path.join(base_directory, name)
+            if os.path.exists(relative_path):
+                return relative_path
+            if os.path.exists(name):
+                return name
+            return None
+
+        if file_name:
+            path = resolve_path(file_name)
+            if path:
+                return [path]
+            relative_path_for_error = os.path.join(base_directory, file_name)
+            error_handler.report_error(
+                AraError,
+                f"No givens file found at {relative_path_for_error} or {file_name}",
+            )
+            return []
+
+        # If no file_name, check for defaults
+        default_files_to_check = [
+            os.path.join(base_directory, "prompt.data",
+                         "config.prompt_givens.md"),
+            os.path.join(
+                base_directory, "prompt.data", "config.prompt_global_givens.md"
+            ),
+        ]
+        existing_defaults = [
+            f for f in default_files_to_check if os.path.exists(f)]
+        if existing_defaults:
+            return existing_defaults
+
+        # No defaults found, prompt user
+        user_input = input("Please specify a givens file: ")
+        if not user_input:
+            self.poutput("Aborting.")
+            return []
+
+        path = resolve_path(user_input)
+        if path:
+            return [path]
+        error_handler.report_error(
+            AraError(f"No givens file found at {user_input}. Aborting.")
+        )
+        return []
 
     @cmd2.with_category(CATEGORY_CHAT_CONTROL)
     def do_LOAD_GIVENS(self, file_name):
-        """Load all files listed in a ./prompt.data/config.prompt_givens.md"""
-        from ara_cli.directory_navigator import DirectoryNavigator
+        """Load all files listed in a ./prompt.data/config.prompt_givens.md and ./prompt.data/config.prompt_global_givens.md"""
         from ara_cli.prompt_handler import load_givens
 
-        base_directory = os.path.dirname(self.chat_name)
+        givens_files_to_process = self._find_givens_files(file_name)
+        if not givens_files_to_process:
+            error_handler.report_error(AraError("No givens files to load."))
+            return
 
-        if file_name == "":
-            file_name = f"{base_directory}/prompt.data/config.prompt_givens.md"
-
-        # Check the relative path first
-        relative_givens_path = os.path.join(base_directory, file_name)
-        if os.path.exists(relative_givens_path):
-            givens_path = relative_givens_path
-        elif os.path.exists(file_name):  # Check the absolute path
-            givens_path = file_name
-        else:
-            print(f"No givens file found at {relative_givens_path} or {file_name}")
-            user_input = input("Please specify a givens file: ")
-            if os.path.exists(os.path.join(base_directory, user_input)):
-                givens_path = os.path.join(base_directory, user_input)
-            elif os.path.exists(user_input):
-                givens_path = user_input
-            else:
-                print(f"No givens file found at {user_input}. Aborting.")
-                return
+        for givens_path in givens_files_to_process:
+            # The givens_path is absolute, and load_givens reconstructs absolute paths
+            # from the markdown file. No directory change is needed.
+            content, _ = load_givens(givens_path)
 
-        cwd = os.getcwd()
-        navigator = DirectoryNavigator()
-        navigator.navigate_to_target()
-        os.chdir('..')
-        content, image_data = load_givens(givens_path)
-        os.chdir(cwd)
-
-        with open(self.chat_name, 'a', encoding='utf-8') as chat_file:
-            chat_file.write(content)
+            with open(self.chat_name, "a", encoding="utf-8") as chat_file:
+                chat_file.write(content)
 
-        print(f"Loaded files listed and marked in {givens_path}")
+            self.poutput(f"Loaded files listed and marked in {givens_path}")
 
     @cmd2.with_category(CATEGORY_CHAT_CONTROL)
     def do_SEND(self, _):
@@ -800,17 +983,20 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         """Load artefact template"""
         from ara_cli.artefact_models.artefact_templates import template_artefact_of_type
 
-        artefact = template_artefact_of_type(''.join(template_name))
+        artefact = template_artefact_of_type("".join(template_name))
         if not artefact:
+            error_handler.report_error(
+                ValueError(f"No template for '{template_name}' found.")
+            )
             return
         write_content = artefact.serialize()
         self.add_prompt_tag_if_needed(self.chat_name)
-        with open(self.chat_name, 'a', encoding='utf-8') as chat_file:
+        with open(self.chat_name, "a", encoding="utf-8") as chat_file:
             chat_file.write(write_content)
         print(f"Loaded {template_name} artefact template")
 
     def complete_LOAD_TEMPLATE(self, text, line, begidx, endidx):
-        return self._complete_classifiers(self, text, line, begidx, endidx)
+        return self._complete_classifiers(text, line, begidx, endidx)
 
     def _complete_classifiers(self, text, line, begidx, endidx):
         from ara_cli.classifier import Classifier
@@ -819,6 +1005,195 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         if not text:
             completions = classifiers
         else:
-            completions = [classifier for classifier in classifiers if classifier.startswith(text)]
+            completions = [
+                classifier for classifier in classifiers if classifier.startswith(text)
+            ]
 
         return completions
+
+    def _get_plural_template_type(self, template_type: str) -> str:
+        """Determines the plural form of a template type."""
+        plurals = {"commands": "commands", "rules": "rules"}
+        return plurals.get(template_type, f"{template_type}s")
+
+    def _find_project_root(self) -> str | None:
+        """
+        Finds the project root by searching for an 'ara' directory,
+        starting from the chat file's directory and moving upwards.
+        """
+        current_dir = os.path.dirname(self.chat_name)
+        while True:
+            if os.path.isdir(os.path.join(current_dir, "ara")):
+                return current_dir
+            parent_dir = os.path.dirname(current_dir)
+            if parent_dir == current_dir:  # Reached the filesystem root
+                return None
+            current_dir = parent_dir
+
+    def _gather_templates_from_path(
+        self, search_path: str, templates_set: set, prefix: str = ""
+    ):
+        """
+        Scans a given path for items and adds them to the provided set,
+        optionally prepending a prefix.
+        """
+        import glob
+
+        if not os.path.isdir(search_path):
+            return
+        for path in glob.glob(os.path.join(search_path, "*")):
+            templates_set.add(f"{prefix}{os.path.basename(path)}")
+
+    def _get_available_templates(self, template_type: str) -> list[str]:
+        """
+        Scans for available global and project-local custom templates.
+        This method safely searches for template files without changing the
+        current directory, making it safe for use in autocompleters.
+
+        Args:
+            template_type: The type of template to search for (e.g., 'rules').
+
+        Returns:
+            A sorted list of unique template names. Global templates are
+            prefixed with 'global/'.
+        """
+        from ara_cli.template_manager import TemplatePathManager
+
+        plural_type = self._get_plural_template_type(template_type)
+        templates = set()
+
+        # 1. Find Global Templates
+        try:
+            global_base_path = TemplatePathManager.get_template_base_path()
+            global_template_dir = os.path.join(
+                global_base_path, "prompt-modules", plural_type
+            )
+            self._gather_templates_from_path(
+                global_template_dir, templates, prefix="global/"
+            )
+        except Exception:
+            pass  # Silently ignore if global templates are not found
+
+        # 2. Find Local Custom Templates
+        try:
+            project_root = self._find_project_root()
+            if project_root:
+                local_templates_base = os.path.join(
+                    project_root, self.config.local_prompt_templates_dir
+                )
+                custom_dir = os.path.join(
+                    local_templates_base,
+                    self.config.custom_prompt_templates_subdir,
+                    plural_type,
+                )
+                self._gather_templates_from_path(custom_dir, templates)
+        except Exception:
+            pass  # Silently ignore if local templates cannot be resolved
+
+        return sorted(list(templates))
+
+    def _template_completer(self, text: str, template_type: str) -> list[str]:
+        """Generic completer for different template types."""
+        available_templates = self.template_loader.get_available_templates(
+            template_type, os.path.dirname(self.chat_name)
+        )
+        if not text:
+            return available_templates
+        return [t for t in available_templates if t.startswith(text)]
+
+    def complete_LOAD_RULES(self, text, line, begidx, endidx):
+        """Completer for the LOAD_RULES command."""
+        return self._template_completer(text, "rules")
+
+    def complete_LOAD_INTENTION(self, text, line, begidx, endidx):
+        """Completer for the LOAD_INTENTION command."""
+        return self._template_completer(text, "intention")
+
+    def complete_LOAD_COMMANDS(self, text, line, begidx, endidx):
+        """Completer for the LOAD_COMMANDS command."""
+        return self._template_completer(text, "commands")
+
+    def complete_LOAD_BLUEPRINT(self, text, line, begidx, endidx):
+        """Completer for the LOAD_BLUEPRINT command."""
+        return self._template_completer(text, "blueprint")
+
+    # ===== AGENT CONTROL COMMANDS =====
+
+    @cmd2.with_category(CATEGORY_AGENT_CONTROL)
+    def do_AGENT_RUN(self, args):
+        """Run an agent. Usage: AGENT_RUN <agent_name> [artefact_classifier artefact_name]
+
+        Examples:
+          AGENT_RUN interview_agent
+          AGENT_RUN interview_agent feature my_feature
+        """
+        parts = args.split()
+        if not parts:
+            print(f"Available agents: {', '.join(self.AVAILABLE_AGENTS)}")
+            print(
+                "Usage: AGENT_RUN <agent_name> [artefact_classifier artefact_name]")
+            return
+
+        agent_name = parts[0]
+        if agent_name not in self.AVAILABLE_AGENTS:
+            print(f"Unknown agent: {agent_name}")
+            print(f"Available agents: {', '.join(self.AVAILABLE_AGENTS)}")
+            return
+
+        # Get initial prompt
+        initial_prompt = input(
+            "Enter initial prompt (or press Enter for default): "
+        ).strip()
+        if not initial_prompt:
+            initial_prompt = "Let's begin the interview."
+
+        # Extract artefact info if provided
+        artefact_classifier = None
+        artefact_name = None
+        if len(parts) >= 3:
+            artefact_classifier = parts[1]
+            artefact_name = parts[2]
+
+        try:
+            self.agent_manager.start_agent(
+                agent_name, initial_prompt, artefact_classifier, artefact_name
+            )
+        except AraError as e:
+            print(f"Error: {e}")
+
+    @cmd2.with_category(CATEGORY_AGENT_CONTROL)
+    def do_AGENT_STOP(self, _):
+        """Stop the currently running agent gracefully (sends termination signal)."""
+        if not self.agent_manager.agent_process:
+            print("No agent is currently running.")
+            return
+
+        print(f"Stopping agent {self.agent_manager.agent_name}...")
+        self.agent_manager.cleanup_agent_process()
+        print("Agent stopped.")
+
+    @cmd2.with_category(CATEGORY_AGENT_CONTROL)
+    def do_AGENT_CONTINUE(self, _):
+        """Continue with the agent without providing new input (sends empty line)."""
+        self.agent_manager.continue_agent()
+
+    @cmd2.with_category(CATEGORY_AGENT_CONTROL)
+    def do_AGENT_STATUS(self, _):
+        """Show status of the current agent."""
+        print(self.agent_manager.get_agent_status())
+
+    def complete_AGENT_RUN(self, text, line, begidx, endidx):
+        """Completer for AGENT_RUN command."""
+        parts = line.split()
+
+        # Complete agent name
+        if len(parts) <= 2:
+            if not text:
+                return self.AVAILABLE_AGENTS
+            return [a for a in self.AVAILABLE_AGENTS if a.startswith(text)]
+
+        # Complete classifier
+        if len(parts) == 3:
+            return self._complete_classifiers(text, line, begidx, endidx)
+
+        return []