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

ara_cli/__init__.py

@@ -4,7 +4,6 @@ from .error_handler import ErrorHandler
 
 whitelisted_commands = ["RERUN", "SEND", "EXTRACT", "LOAD_IMAGE", "CHOOSE_MODEL", "CHOOSE_EXTRACTION_MODEL", "CURRENT_MODEL", "CURRENT_EXTRACTION_MODEL", "LIST_MODELS"]
 
-
 error_handler = ErrorHandler()
 
 

ara_cli/__main__.py

@@ -1,9 +1,7 @@
 import typer
-import sys
 import os
 from typing import Optional
 from os import getenv
-from ara_cli.error_handler import AraError
 from ara_cli.version import __version__
 from ara_cli import error_handler
 from ara_cli.ara_subcommands.create import register as register_create_cli
@@ -27,6 +25,8 @@ from ara_cli.ara_subcommands.autofix import register as register_autofix_cli
 from ara_cli.ara_subcommands.extract import register as register_extract_cli
 from ara_cli.ara_subcommands.load import register as register_load_cli
 
+from ara_cli.directory_navigator import DirectoryNavigator
+
 
 def version_callback(value: bool):
     if value:
@@ -45,58 +45,32 @@ def configure_debug_mode(debug: bool, env_debug_mode: bool):
         error_handler.debug_mode = True
 
 
-def find_ara_directory_root():
-    """Find the root ara directory by traversing up the directory tree."""
-    current_dir = os.getcwd()
-    
-    # Check if we're already inside an ara directory structure
-    path_parts = current_dir.split(os.sep)
-    
-    # Look for 'ara' in the path parts
-    if 'ara' in path_parts:
-        ara_index = path_parts.index('ara')
-        # Reconstruct path up to and including 'ara'
-        ara_root_parts = path_parts[:ara_index + 1]
-        potential_ara_root = os.sep.join(ara_root_parts)
-        if os.path.exists(potential_ara_root) and os.path.isdir(potential_ara_root):
-            return potential_ara_root
-    
-    # If not inside ara directory, check current directory and parents
-    check_dir = current_dir
-    while check_dir != os.path.dirname(check_dir):  # Stop at filesystem root
-        ara_path = os.path.join(check_dir, 'ara')
-        if os.path.exists(ara_path) and os.path.isdir(ara_path):
-            return ara_path
-        check_dir = os.path.dirname(check_dir)
-    
-    return None
-
-
 def check_ara_directory_exists():
     """Check if ara directory exists or if we're inside ara directory tree."""
-    return find_ara_directory_root() is not None
+    return DirectoryNavigator.find_ara_directory_root() is not None
 
 
 def prompt_create_ara_directory():
     """Prompt user to create ara directory and create it if confirmed."""
     # Print the prompt message
-    print("No 'ara' directory found. Create one in the current directory? (Y/n)", end=" ", flush=True)
-    
+    print("No 'ara' directory found. Create one in the current directory? (Y/n)",
+          end=" ", flush=True)
+
     # Read user input
     try:
         response = input().strip()
     except (EOFError, KeyboardInterrupt):
         typer.echo("\nOperation cancelled.")
         raise typer.Exit(1)
-    
+
     if response.lower() in ('y', 'yes', ''):
         current_dir = os.getcwd()
         ara_path = os.path.join(current_dir, 'ara')
-        
+
         # Create ara directory structure
         subdirectories = [
             'businessgoals',
-            'capabilities', 
+            'capabilities',
             'epics',
             'examples',
             'features',
@@ -105,35 +79,35 @@ def prompt_create_ara_directory():
             'userstories',
             'vision'
         ]
-        
+
         try:
             # Create main ara directory
             os.makedirs(ara_path, exist_ok=True)
-            
+
             # Create subdirectories for artefact types
             for subdir in subdirectories:
                 os.makedirs(os.path.join(ara_path, subdir), exist_ok=True)
-            
+
             # Create .araconfig directory
             araconfig_path = os.path.join(ara_path, '.araconfig')
             os.makedirs(araconfig_path, exist_ok=True)
-            
+
             # Create default ara_config.json using ConfigManager
             from ara_cli.ara_config import ConfigManager, ARAconfig
             config_file_path = os.path.join(araconfig_path, 'ara_config.json')
-            
+
             # Reset ConfigManager to ensure clean state
             ConfigManager.reset()
-            
+
             # Create default config and save it
             default_config = ARAconfig()
             from ara_cli.ara_config import save_data
             save_data(config_file_path, default_config)
-            
+
             typer.echo(f"Created ara directory structure at {ara_path}")
             typer.echo(f"Created default configuration at {config_file_path}")
             return True
-            
+
         except OSError as e:
             typer.echo(f"Error creating ara directory: {e}", err=True)
             raise typer.Exit(1)
@@ -232,15 +206,15 @@ ara chat examples:
         if ctx.invoked_subcommand is None:
             ctx.get_help()
             ctx.exit()
-        
+
         # Check for ara directory before executing any command
         # Skip check for commands that don't require ara directory
         commands_requiring_ara = {
-            'create', 'delete', 'rename', 'list', 'list-tags', 'prompt', 
-            'read', 'reconnect', 'read-status', 'read-user', 'set-status', 
-            'set-user', 'classifier-directory', 'scan', 'autofix'
+            'create', 'delete', 'rename', 'list', 'list-tags', 'prompt',
+            'read', 'reconnect', 'read-status', 'read-user', 'set-status',
+            'set-user', 'scan', 'autofix'
         }
-        
+
         if ctx.invoked_subcommand in commands_requiring_ara:
             requires_ara_directory()
 
@@ -281,4 +255,4 @@ def cli():
 
 
 if __name__ == "__main__":
-    cli()
+    cli()

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,7 +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("file_name", nargs="?",
+                         default="", help="File to load")
 load_parser.add_argument(
     "--load-images",
     action="store_true",
@@ -36,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
@@ -59,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",
@@ -74,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
@@ -107,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)
@@ -134,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):
@@ -178,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
@@ -232,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)
@@ -359,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
@@ -369,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,
@@ -387,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 = ""
     ):
@@ -401,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,
@@ -477,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]
@@ -493,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
@@ -512,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)
@@ -587,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):
@@ -750,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,
@@ -776,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 = []
@@ -887,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
 
@@ -1053,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)]
@@ -1072,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