ara-cli 0.1.10.1__py3-none-any.whl → 0.1.11.0__py3-none-any.whl

ara_cli/chat.py

@@ -1,5 +1,4 @@
 import os
-import errno
 import argparse
 import cmd2
 
@@ -11,6 +10,7 @@ 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()
@@ -25,26 +25,8 @@ extract_parser.add_argument(
 )
 
 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",
-)
-
-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("file_name", nargs="?",
+                         default="", help="File to load")
 load_parser.add_argument(
     "--load-images",
     action="store_true",
@@ -55,6 +37,7 @@ load_parser.add_argument(
 class Chat(cmd2.Cmd):
     CATEGORY_CHAT_CONTROL = "Chat control commands"
     CATEGORY_LLM_CONTROL = "Language model controls"
+    CATEGORY_AGENT_CONTROL = "Agent control commands"
 
     INTRO = """/***************************************/
                  araarar
@@ -78,6 +61,14 @@ 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",
@@ -93,6 +84,7 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         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
@@ -126,6 +118,9 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         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)
@@ -153,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):
@@ -197,6 +197,7 @@ 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
@@ -251,7 +252,8 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         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)
@@ -378,6 +380,7 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
     def add_prompt_tag_if_needed(self, chat_file: str):
         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
@@ -388,7 +391,6 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         with open(chat_file, "a", encoding="utf-8") as file:
             file.write(append)
 
-    # @file_exists_check
     def load_text_file(
         self,
         file_path,
@@ -406,7 +408,6 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
             extract_images=extract_images,
         )
 
-    # @file_exists_check
     def load_binary_file(
         self, file_path, mime_type: str, prefix: str = "", suffix: str = ""
     ):
@@ -420,7 +421,6 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         reader = MarkdownReader(file_path)
         return reader.read(extract_images=extract_images)
 
-    # @file_exists_check
     def load_document_file(
         self,
         file_path: str,
@@ -496,7 +496,8 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
                     return None
                 file_path = files[choice_index]
             except ValueError as e:
-                error_handler.report_error(ValueError("Invalid input. Aborting load."))
+                error_handler.report_error(
+                    ValueError("Invalid input. Aborting load."))
                 return None
         else:
             file_path = files[0]
@@ -512,6 +513,7 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
 
     def do_quit(self, _):
         """Exit ara-cli"""
+        self.agent_manager.cleanup_agent_process()
         print("Chat ended")
         self.last_result = True
         return True
@@ -531,7 +533,16 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         )
 
     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)
     @cmd2.with_argparser(load_parser)
@@ -606,7 +617,8 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
                 file_path=file_name, mime_type=file_type, prefix=prefix, suffix=suffix
             )
         error_handler.report_error(
-            AraError(f"File {file_name} not recognized as image, could not load")
+            AraError(
+                f"File {file_name} not recognized as image, could not load")
         )
 
     def _verify_llm_choice(self, model_name):
@@ -769,22 +781,29 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
     @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.template_loader.load_template(rules_name, "rules", self.chat_name, "*.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.template_loader.load_template(intention_name, "intention", self.chat_name, "*.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.template_loader.load_template(commands_name, "commands", self.chat_name, "*.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.template_loader.load_template(blueprint_name, "blueprint", self.chat_name)
+        self.template_loader.load_template(
+            blueprint_name, "blueprint", self.chat_name)
 
     def _load_helper(
         self,
@@ -795,7 +814,8 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
     ):
         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 = []
@@ -906,12 +926,14 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
 
         # 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_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)]
+        existing_defaults = [
+            f for f in default_files_to_check if os.path.exists(f)]
         if existing_defaults:
             return existing_defaults
 
@@ -1072,7 +1094,9 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
 
     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))
+        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)]
@@ -1091,4 +1115,85 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
 
     def complete_LOAD_BLUEPRINT(self, text, line, begidx, endidx):
         """Completer for the LOAD_BLUEPRINT command."""
-        return self._template_completer(text, "blueprint")
+        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 []

ara_cli/chat_agent/agent_communicator.py

@@ -0,0 +1,62 @@
+import re
+import queue
+
+
+class AgentCommunicator:
+    def __init__(self, agent_process_manager):
+        self.agent_process_manager = agent_process_manager
+        self.agent_process = agent_process_manager.agent_process
+        self.agent_output_queue = agent_process_manager.agent_output_queue
+        self.chat_instance = agent_process_manager.chat_instance
+        self.status_manager = agent_process_manager.status_manager
+
+    def read_agent_output(self):
+        try:
+            for line in iter(self.agent_process.stdout.readline, ""):
+                if not line:
+                    break
+                self.agent_output_queue.put(line)
+        except Exception as e:
+            self.agent_output_queue.put(f"Error reading agent output: {e}\n")
+
+    def _handle_agent_answer(self, lines, answer_index):
+        for j in range(answer_index + 1, len(lines) - 1):
+            print(lines[j], flush=True)
+        print(flush=True)
+
+        self.agent_process_manager.agent_mode = True
+        self.chat_instance.prompt = "ara-agent> "
+        self.status_manager.update_status_file(mode="waiting for input")
+
+    def _process_lines(self, lines):
+        for i, line_text in enumerate(lines[:-1]):
+            print(line_text, flush=True)
+            if re.match(r'^\s*Answer:', line_text):
+                self._handle_agent_answer(lines, i)
+                return True, lines[-1]
+        return False, lines[-1]
+
+    def process_agent_output(self):
+        buffer = ""
+        while True:
+            try:
+                line = self.agent_output_queue.get(timeout=0.1)
+                buffer += line
+
+                if "\n" in buffer:
+                    lines = buffer.split("\n")
+                    found_answer, buffer = self._process_lines(lines)
+                    if found_answer:
+                        return
+
+            except queue.Empty:
+                if self.agent_process and self.agent_process.poll() is not None:
+                    if buffer:
+                        print(buffer, flush=True)
+                    self.agent_process_manager.cleanup_agent_process()
+                    return
+                continue
+            except Exception as e:
+                print(f"Error processing agent output: {e}", flush=True)
+                self.agent_process_manager.cleanup_agent_process()
+                return

ara_cli/chat_agent/agent_process_manager.py

@@ -0,0 +1,211 @@
+from ara_cli.chat_agent.agent_workspace_manager import AgentWorkspaceManager
+from ara_cli.error_handler import AraError, ErrorLevel
+from ara_cli.chat_agent.agent_status_manager import AgentStatusManager
+from ara_cli.chat_agent.agent_communicator import AgentCommunicator
+import os
+import subprocess
+import threading
+import psutil
+import queue
+
+
+class AgentProcessManager:
+    _instance = None
+
+    def __new__(cls, chat_instance=None):
+        if cls._instance is None:
+            cls._instance = super(AgentProcessManager, cls).__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self, chat_instance=None):
+        if hasattr(self, "_initialized") and self._initialized:
+            if chat_instance:
+                self.chat_instance = chat_instance
+            return
+        if chat_instance is None:
+            raise ValueError(
+                "chat_instance must be provided for the first instantiation"
+            )
+
+        self.chat_instance = chat_instance
+        self.agent_process = None
+        self.agent_reader_thread = None
+        self.agent_output_queue = queue.Queue()
+        self.agent_mode = False
+        self.agent_name = None
+        self.status_manager = AgentStatusManager()
+        self._initialized = True
+
+    def cleanup_agent_process(self):
+        pid = self.status_manager.get_agent_pid()
+        if pid and psutil.pid_exists(pid):
+            try:
+                p = psutil.Process(pid)
+                p.terminate()
+                p.wait(timeout=3)
+            except (psutil.NoSuchProcess, psutil.TimeoutExpired):
+                pass
+
+        self.status_manager.clear_status()
+
+        if self.agent_process:
+            try:
+                self.agent_process.terminate()
+            except:
+                pass
+            self.agent_process = None
+
+        if self.agent_reader_thread and self.agent_reader_thread.is_alive():
+            self.agent_reader_thread = None
+
+        self.agent_mode = False
+        self.agent_name = None
+        if hasattr(self, "chat_instance"):
+            self.chat_instance.prompt = "ara> "
+
+    def start_agent(
+        self, agent_name, initial_prompt, artefact_classifier=None, artefact_name=None
+    ):
+        if self.get_agent_status() != "No agent is currently running.":
+            raise AraError(
+                "An agent is already running. Use AGENT_STOP to stop it first."
+            )
+
+        if agent_name not in self.chat_instance.AVAILABLE_AGENTS:
+            raise AraError(f"Unknown agent: {agent_name}")
+
+        base_work_dir = AgentWorkspaceManager.determine_base_work_dir(
+            self.chat_instance
+        )
+        agent_workspace_dir = AgentWorkspaceManager.determine_agent_workspace(
+            self.chat_instance, artefact_classifier, artefact_name
+        )
+
+        cmd = [
+            "ara-agents",
+            agent_name,
+            "-u",
+            initial_prompt,
+            "-g",
+            "roundrobin",
+            "-b",
+            ".",
+            "-s",
+        ]
+
+        if artefact_classifier and artefact_name:
+            try:
+                artefact_path = self._find_artefact_path(
+                    artefact_classifier, artefact_name
+                )
+                cmd.extend(["-r", artefact_path])
+                print(f"Starting {agent_name} with artefact: {artefact_path}")
+                print(f"Base work directory: {base_work_dir}")
+                print(f"Agent logs directory: {agent_workspace_dir}")
+            except AraError as e:
+                raise AraError(f"Error: {e}")
+        else:
+            print(f"Starting {agent_name}...")
+            print(f"Base work directory: {base_work_dir}")
+            print(f"Agent logs directory: {agent_workspace_dir}")
+
+        env = os.environ.copy()
+        env["CENTRAL_LOG_PATH"] = os.path.join(
+            agent_workspace_dir, "io_context.log")
+
+        try:
+            self.agent_process = subprocess.Popen(
+                cmd,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1,
+                cwd=base_work_dir,
+                env=env,
+            )
+            self.agent_name = agent_name
+            self.status_manager.write_status(
+                self.agent_process.pid, self.agent_name, "processing"
+            )
+
+            communicator = AgentCommunicator(self)
+            self.agent_reader_thread = threading.Thread(
+                target=communicator.read_agent_output, daemon=True
+            )
+            self.agent_reader_thread.start()
+
+            print(f"Agent {agent_name} started. Waiting for response...\n")
+            communicator.process_agent_output()
+
+        except FileNotFoundError:
+            raise AraError(
+                "Agent could not started."
+                "\nReason: 'ara-agents' command not found. Make sure ara-agents is locally installed.",
+                level=ErrorLevel.CRITICAL,
+            )
+        except Exception as e:
+            self.cleanup_agent_process()
+            raise AraError(f"Error starting agent: {e}")
+
+    def _find_artefact_path(self, artefact_classifier, artefact_name):
+        from ara_cli.classifier import Classifier
+
+        classifier_dir = Classifier.get_sub_directory(artefact_classifier)
+        if not classifier_dir:
+            raise AraError(f"Unknown classifier: {artefact_classifier}")
+
+        chat_dir = os.path.dirname(self.chat_instance.chat_name)
+        ara_dir = os.path.join(chat_dir, "ara", classifier_dir)
+
+        for ext in [artefact_classifier, "md"]:
+            artefact_path = os.path.join(ara_dir, f"{artefact_name}.{ext}")
+            if os.path.exists(artefact_path):
+                return artefact_path
+
+        raise AraError(
+            f"Artefact not found: {artefact_name}.{artefact_classifier}")
+
+    def send_to_agent(self, text):
+        if not self.agent_process or self.agent_process.poll() is not None:
+            print("Error: Agent process is not running")
+            self.cleanup_agent_process()
+            return
+
+        try:
+            self.agent_process.stdin.write(text + "\n")
+            self.agent_process.stdin.flush()
+
+            self.agent_mode = False
+            self.chat_instance.prompt = "ara> "
+            self.status_manager.update_status_file(mode="processing")
+
+            communicator = AgentCommunicator(self)
+            communicator.process_agent_output()
+
+        except Exception as e:
+            print(f"Error sending to agent: {e}")
+            self.cleanup_agent_process()
+
+    def continue_agent(self):
+        status = self.get_agent_status()
+        if "No agent" in status:
+            print("No agent is currently running.")
+            return
+
+        if not self.agent_process or self.agent_process.poll() is not None:
+            print(
+                "AGENT_CONTINUE can only be used from the chat interface that started the agent."
+            )
+            return
+
+        if not self.agent_mode:
+            print("Agent is not waiting for input. Wait for 'ara-agent>' prompt.")
+            return
+
+        print("Continuing agent with empty input...")
+        self.send_to_agent("")
+
+    def get_agent_status(self):
+        return self.status_manager.get_agent_status()

ara_cli/chat_agent/agent_status_manager.py

@@ -0,0 +1,73 @@
+import os
+import json
+import psutil
+from ara_cli.directory_navigator import DirectoryNavigator
+
+
+class AgentStatusManager:
+    def get_status_file_path(self):
+        ara_root = DirectoryNavigator.find_ara_directory_root()
+        if not ara_root:
+            return None
+        return os.path.join(ara_root, ".araconfig", "agent_status.json")
+
+    def get_agent_pid(self):
+        status_file = self.get_status_file_path()
+        if not status_file or not os.path.exists(status_file):
+            return None
+
+        with open(status_file, "r") as f:
+            try:
+                status = json.load(f)
+                return status.get("pid")
+            except json.JSONDecodeError:
+                return None
+
+    def update_status_file(self, mode):
+        status_file = self.get_status_file_path()
+        if not status_file or not os.path.exists(status_file):
+            return
+
+        try:
+            with open(status_file, "r") as f:
+                status = json.load(f)
+        except (FileNotFoundError, json.JSONDecodeError):
+            return
+
+        status["mode"] = mode
+
+        with open(status_file, "w") as f:
+            json.dump(status, f)
+
+    def get_agent_status(self):
+        status_file = self.get_status_file_path()
+        if not status_file or not os.path.exists(status_file):
+            return "No agent is currently running."
+
+        with open(status_file, "r") as f:
+            try:
+                status = json.load(f)
+            except json.JSONDecodeError:
+                return "No agent is currently running."
+
+        pid = status.get("pid")
+        if not pid or not psutil.pid_exists(pid):
+            if os.path.exists(status_file):
+                os.remove(status_file)
+            return "No agent is currently running."
+
+        name = status.get("name")
+        mode = status.get("mode")
+        return f"Agent: {name} (running - {mode})"
+
+    def write_status(self, pid, name, mode):
+        status = {"pid": pid, "name": name, "mode": mode}
+        status_file = self.get_status_file_path()
+        if status_file:
+            with open(status_file, "w") as f:
+                json.dump(status, f)
+
+    def clear_status(self):
+        status_file = self.get_status_file_path()
+        if status_file and os.path.exists(status_file):
+            os.remove(status_file)