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

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)

ara_cli/chat_agent/agent_workspace_manager.py

@@ -0,0 +1,76 @@
+from ara_cli.error_handler import AraError
+
+import os
+
+
+class AgentWorkspaceManager:
+    """Manages workspace directories for agent execution."""
+
+    @staticmethod
+    def determine_agent_workspace(chat_instance, artefact_classifier=None, artefact_name=None):
+        """
+        Determines the appropriate workspace directory for agent logs and data.
+
+        Args:
+            chat_instance: The Chat instance
+            artefact_classifier: Optional artefact classifier (e.g., 'feature')
+            artefact_name: Optional artefact name
+
+        Returns:
+            str: Absolute path to the agent workspace directory (for logs)
+        """
+        base_directory = os.path.dirname(chat_instance.chat_name)
+
+        if artefact_classifier and artefact_name:
+            # Use artefact-specific workspace for logs
+            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}")
+
+            workspace_dir = os.path.join(
+                base_directory,
+                "ara",
+                classifier_dir,
+                f"{artefact_name}.data"
+            )
+        else:
+            # Use chat-specific workspace for logs
+            chat_name_without_ext = os.path.splitext(
+                os.path.basename(chat_instance.chat_name))[0]
+            workspace_dir = os.path.join(
+                base_directory,
+                "ara",
+                f"{chat_name_without_ext}"
+            )
+
+        # Ensure workspace directory exists
+        os.makedirs(workspace_dir, exist_ok=True)
+        return os.path.abspath(workspace_dir)
+
+    @staticmethod
+    def determine_base_work_dir(chat_instance):
+        """
+        Determines the base working directory (project root).
+
+        Args:
+            chat_instance: The Chat instance
+
+        Returns:
+            str: Absolute path to the project root directory
+        """
+
+        return os.path.dirname("./")
+        # The bwd should be the project root, not inside ara/
+        chat_dir = os.path.dirname(chat_instance.chat_name)
+
+        # Find project root by looking for 'ara' directory
+        current_dir = chat_dir
+        while True:
+            if os.path.isdir(os.path.join(current_dir, "ara")):
+                return os.path.abspath(current_dir)
+            parent_dir = os.path.dirname(current_dir)
+            if parent_dir == current_dir:  # Reached filesystem root
+                # Fallback to chat directory if no 'ara' folder found
+                return os.path.abspath(chat_dir)
+            current_dir = parent_dir

ara_cli/commands/command.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class Command(ABC):
+    @abstractmethod
+    def execute(self, *args, **kwargs):     # pragma: no cover
+        pass

ara_cli/commands/extract_command.py

@@ -0,0 +1,15 @@
+from ara_cli.commands.command import Command
+from ara_cli.prompt_extractor import extract_responses
+import os
+
+class ExtractCommand(Command):
+    def __init__(self, file_name, force=False, write=False, output=None):
+        self.file_name = file_name
+        self.force = force
+        self.write = write
+        self.output = output    # Callable for standard output (optional)
+
+    def execute(self, *args, **kwargs):
+        extract_responses(self.file_name, True, force=self.force, write=self.write)
+        if self.output:
+            self.output("End of extraction")

ara_cli/commands/load_command.py

@@ -0,0 +1,65 @@
+from ara_cli.commands.command import Command
+from ara_cli.file_loaders.file_loader import FileLoaderFactory
+from ara_cli.file_loaders.binary_file_loader import BinaryFileLoader
+
+
+class LoadCommand(Command):
+    def __init__(
+        self,
+        chat_instance,
+        file_path: str,
+        prefix: str = "",
+        suffix: str = "",
+        block_delimiter: str = "",
+        extract_images: bool = False,
+        output=None
+    ):
+        self.chat = chat_instance
+        self.file_path = file_path
+        self.prefix = prefix
+        self.suffix = suffix
+        self.block_delimiter = block_delimiter
+        self.extract_images = extract_images
+        self.output = output or print
+
+    def execute(self) -> bool:
+        loader = FileLoaderFactory.create_loader(self.file_path, self.chat)
+
+        if isinstance(loader, BinaryFileLoader):
+            # Determine mime type for binary files
+            file_name_lower = self.file_path.lower()
+            mime_type = None
+            for extension, mt in FileLoaderFactory.BINARY_TYPE_MAPPING.items():
+                if file_name_lower.endswith(extension):
+                    mime_type = mt
+                    break
+
+            if not mime_type:
+                self.output(
+                    f"Could not determine mime type for {self.file_path}")
+                return False
+
+            success = loader.load(
+                self.file_path,
+                mime_type=mime_type,
+                prefix=self.prefix,
+                suffix=self.suffix
+            )
+        elif hasattr(loader, 'load'):
+            success = loader.load(
+                self.file_path,
+                prefix=self.prefix,
+                suffix=self.suffix,
+                block_delimiter=self.block_delimiter,
+                extract_images=self.extract_images
+            )
+        else:
+            return False
+
+        if success:
+            if self.extract_images and not isinstance(loader, BinaryFileLoader):
+                self.output(
+                    f"Loaded contents of file {self.file_path} with images extracted")
+            else:
+                self.output(f"Loaded contents of file {self.file_path}")
+        return success

ara_cli/commands/load_image_command.py

@@ -0,0 +1,34 @@
+from ara_cli.commands.command import Command
+from ara_cli.file_loaders.binary_file_loader import BinaryFileLoader
+
+
+class LoadImageCommand(Command):
+    def __init__(
+        self,
+        chat_instance,
+        file_path: str,
+        mime_type: str,
+        prefix: str = "",
+        suffix: str = "",
+        output=None
+    ):
+        self.chat = chat_instance
+        self.file_path = file_path
+        self.mime_type = mime_type
+        self.prefix = prefix
+        self.suffix = suffix
+        self.output = output or print
+
+    def execute(self) -> bool:
+        loader = BinaryFileLoader(self.chat)
+        success = loader.load(
+            self.file_path,
+            mime_type=self.mime_type,
+            prefix=self.prefix,
+            suffix=self.suffix
+        )
+
+        if success:
+            self.output(f"Loaded image file {self.file_path}")
+
+        return success

ara_cli/commands/read_command.py

@@ -0,0 +1,117 @@
+from ara_cli.commands.command import Command
+from ara_cli.artefact_reader import ArtefactReader
+from ara_cli.file_classifier import FileClassifier
+from ara_cli.list_filter import ListFilter, filter_list
+from ara_cli.artefact_models.artefact_data_retrieval import (
+    artefact_content_retrieval, 
+    artefact_path_retrieval, 
+    artefact_tags_retrieval
+)
+from ara_cli.artefact_fuzzy_search import suggest_close_name_matches
+import os
+
+
+class ReadCommand(Command):
+    def __init__(
+        self,
+        classifier: str,
+        artefact_name: str,
+        read_mode: str = "default",
+        list_filter: ListFilter = None,
+        output=None
+    ):
+        self.classifier = classifier
+        self.artefact_name = artefact_name
+        self.read_mode = read_mode
+        self.list_filter = list_filter or ListFilter()
+        self.output = output or print
+
+    def execute(self) -> bool:
+        """Execute the read command and return success status."""
+        file_classifier = FileClassifier(os)
+        classified_artefacts = ArtefactReader.read_artefacts()
+
+        if not self.classifier or not self.artefact_name:
+            self._filter_and_print(classified_artefacts, file_classifier)
+            return True
+
+        artefacts = classified_artefacts.get(self.classifier, [])
+        all_artefact_names = [a.title for a in artefacts]
+
+        if self.artefact_name not in all_artefact_names:
+            suggest_close_name_matches(
+                self.artefact_name,
+                all_artefact_names
+            )
+            return False
+
+        target_artefact = next(filter(
+            lambda x: x.title == self.artefact_name, artefacts
+        ))
+
+        artefacts_by_classifier = {self.classifier: []}
+
+        try:
+            match self.read_mode:
+                case "branch":
+                    self._handle_branch_mode(
+                        classified_artefacts, artefacts_by_classifier
+                    )
+                case "children":
+                    artefacts_by_classifier = self._handle_children_mode(
+                        classified_artefacts
+                    )
+                case _:
+                    self._handle_default_mode(
+                        target_artefact, artefacts_by_classifier
+                    )
+
+            # Apply filtering and print results
+            self._filter_and_print(artefacts_by_classifier, file_classifier)
+            # filtered_artefacts = self._apply_filtering(artefacts_by_classifier)
+            # file_classifier.print_classified_files(
+            #     filtered_artefacts, print_content=True
+            # )
+            return True
+
+        except Exception as e:
+            self.output(f"Error reading artefact: {e}")
+            return False
+
+    def _handle_branch_mode(self, classified_artefacts, artefacts_by_classifier):
+        """Handle branch read mode."""
+        ArtefactReader.step_through_value_chain(
+            artefact_name=self.artefact_name,
+            classifier=self.classifier,
+            artefacts_by_classifier=artefacts_by_classifier,
+            classified_artefacts=classified_artefacts
+        )
+
+    def _handle_children_mode(self, classified_artefacts):
+        """Handle children read mode."""
+        return ArtefactReader.find_children(
+            artefact_name=self.artefact_name,
+            classifier=self.classifier,
+            classified_artefacts=classified_artefacts
+        )
+
+    def _handle_default_mode(self, target_artefact, artefacts_by_classifier):
+        """Handle default read mode."""
+        artefacts_by_classifier[self.classifier].append(target_artefact)
+
+    def _apply_filtering(self, artefacts_by_classifier):
+        """Apply list filtering to artefacts."""
+        return filter_list(
+            list_to_filter=artefacts_by_classifier,
+            list_filter=self.list_filter,
+            content_retrieval_strategy=artefact_content_retrieval,
+            file_path_retrieval=artefact_path_retrieval,
+            tag_retrieval=artefact_tags_retrieval
+        )
+
+    def _filter_and_print(self, artefacts_by_classifier, file_classifier):
+        """Apply list filtering and print results"""
+        filtered_artefacts = self._apply_filtering(artefacts_by_classifier)
+        file_classifier.print_classified_files(
+            filtered_artefacts, print_content=True
+        )