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

ara_cli/commands/fetch_agents_command.py

@@ -0,0 +1,106 @@
+import os
+
+from ara_cli.commands.command import Command
+from ara_cli.directory_navigator import DirectoryNavigator
+
+
+class FetchAgentsCommand(Command):
+    """Command to fetch binary agents from a remote URL.
+
+    This command downloads a binary agent from a hardcoded URL and
+    saves it to the project's ara/.araconfig/agents/ directory.
+    """
+
+    AGENT_URL = "https://s3-public.talsen.team/so-agents/feature-creation"
+
+    def __init__(self, output=None):
+        """Initialize the FetchAgentsCommand.
+
+        Parameters
+        ----------
+        output : callable, optional
+            Output function for displaying messages. Defaults to print.
+        """
+        self.output = output or print
+
+    def execute(self):
+        """Execute the fetch-agents command.
+
+        Downloads a binary agent from a remote URL and saves it to the
+        project's .araconfig/agents directory.
+        """
+        navigator = DirectoryNavigator()
+        original_directory = os.getcwd()
+
+        import requests
+        from rich.progress import (
+            BarColumn,
+            DownloadColumn,
+            Progress,
+            TextColumn,
+            TimeRemainingColumn,
+            TransferSpeedColumn,
+        )
+
+        try:
+            # Navigate to ara directory
+            navigator.navigate_to_target()
+
+            dest_dir = self._get_project_agents_dir()
+            os.makedirs(dest_dir, exist_ok=True)
+
+            agent_name = self.AGENT_URL.split("/")[-1]
+            dest_path = os.path.join(dest_dir, agent_name)
+
+            self.output(f"Downloading agent from {self.AGENT_URL}...")
+
+            response = requests.get(self.AGENT_URL, stream=True)
+            response.raise_for_status()
+
+            total_size = int(response.headers.get("content-length", 0))
+            block_size = 1024
+            progress = Progress(
+                TextColumn("[bold blue]{task.description}", justify="right"),
+                BarColumn(bar_width=None),
+                "[progress.percentage]{task.percentage:>3.1f}%",
+                "•",
+                DownloadColumn(),
+                "•",
+                TransferSpeedColumn(),
+                "•",
+                TimeRemainingColumn(),
+            )
+
+            with progress:
+                task_id = progress.add_task(
+                    f"Downloading {agent_name}", total=total_size
+                )
+                with open(dest_path, "wb") as f:
+                    for data in response.iter_content(block_size):
+                        progress.update(task_id, advance=len(data))
+                        f.write(data)
+
+            if total_size != 0 and os.path.getsize(dest_path) != total_size:
+                raise Exception("ERROR, something went wrong during download")
+
+            # Make the binary executable
+            os.chmod(dest_path, 0o755)
+
+            self.output(f"Downloaded {agent_name} to ara/.araconfig/agents/")
+            self.output("Binary agents fetched successfully to ara/.araconfig/agents/")
+
+        except requests.exceptions.RequestException as e:
+            self.output(f"Error downloading agent: {e}")
+        finally:
+            # Return to original directory
+            os.chdir(original_directory)
+
+    def _get_project_agents_dir(self):
+        """Get the path to the project agents directory.
+
+        Returns
+        -------
+        str
+            Path to ara/.araconfig/agents directory.
+        """
+        return os.path.join(".araconfig", "agents")

ara_cli/commands/fetch_scripts_command.py

@@ -0,0 +1,43 @@
+import os
+import shutil
+from ara_cli.commands.command import Command
+from ara_cli.ara_config import ConfigManager
+from ara_cli.directory_navigator import DirectoryNavigator
+
+class FetchScriptsCommand(Command):
+    def __init__(self, output=None):
+        self.output = output or print
+        self.config = ConfigManager.get_config()
+
+    def execute(self):
+        navigator = DirectoryNavigator()
+        original_directory = os.getcwd()
+        navigator.navigate_to_target()
+        os.chdir('..')
+
+        global_scripts_dir = self._get_global_scripts_dir()
+        global_scripts_config_dir = self._get_global_scripts_config_dir()
+
+        if not os.path.exists(global_scripts_dir):
+            self.output("Global scripts directory not found.")
+            os.chdir(original_directory)
+            return
+
+        if not os.path.exists(global_scripts_config_dir):
+            os.makedirs(global_scripts_config_dir)
+
+        for item in os.listdir(global_scripts_dir):
+            source = os.path.join(global_scripts_dir, item)
+            destination = os.path.join(global_scripts_config_dir, item)
+            if os.path.isfile(source):
+                shutil.copy2(source, destination)
+                self.output(f"Copied {item} to global scripts directory.")
+
+        os.chdir(original_directory)
+
+    def _get_global_scripts_dir(self):
+        base_path = os.path.dirname(os.path.dirname(__file__))
+        return os.path.join(base_path, "templates", "global-scripts")
+
+    def _get_global_scripts_config_dir(self):
+        return os.path.join(self.config.local_prompt_templates_dir, "global-scripts")

ara_cli/commands/fetch_templates_command.py

@@ -0,0 +1,39 @@
+from os.path import join
+import os
+import shutil
+from ara_cli.commands.command import Command
+from ara_cli.ara_config import ConfigManager
+from ara_cli.template_manager import TemplatePathManager
+
+
+class FetchTemplatesCommand(Command):
+    def __init__(self, output=None):
+        self.output = output or print
+
+    def execute(self):
+        config = ConfigManager().get_config()
+        prompt_templates_dir = config.local_prompt_templates_dir
+        template_base_path = TemplatePathManager.get_template_base_path()
+        global_prompt_templates_path = join(
+            template_base_path, "prompt-modules")
+
+        subdirs = ["commands", "rules", "intentions", "blueprints"]
+
+        os.makedirs(join(prompt_templates_dir,
+                    "global-prompt-modules"), exist_ok=True)
+        for subdir in subdirs:
+            target_dir = join(prompt_templates_dir,
+                              "global-prompt-modules", subdir)
+            source_dir = join(global_prompt_templates_path, subdir)
+            os.makedirs(target_dir, exist_ok=True)
+            for item in os.listdir(source_dir):
+                source = join(source_dir, item)
+                target = join(target_dir, item)
+                shutil.copy2(source, target)
+
+        custom_prompt_templates_subdir = config.custom_prompt_templates_subdir
+        local_prompt_modules_dir = join(
+            prompt_templates_dir, custom_prompt_templates_subdir)
+        os.makedirs(local_prompt_modules_dir, exist_ok=True)
+        for subdir in subdirs:
+            os.makedirs(join(local_prompt_modules_dir, subdir), exist_ok=True)

ara_cli/commands/fetch_templates_commands.py

@@ -0,0 +1,39 @@
+from os.path import join
+import os
+import shutil
+from ara_cli.commands.command import Command
+from ara_cli.ara_config import ConfigManager
+from ara_cli.template_manager import TemplatePathManager
+
+
+class FetchTemplatesCommand(Command):
+    def __init__(self, output=None):
+        self.output = output or print
+
+    def execute(self):
+        config = ConfigManager().get_config()
+        prompt_templates_dir = config.local_prompt_templates_dir
+        template_base_path = TemplatePathManager.get_template_base_path()
+        global_prompt_templates_path = join(
+            template_base_path, "prompt-modules")
+
+        subdirs = ["commands", "rules", "intentions", "blueprints"]
+
+        os.makedirs(join(prompt_templates_dir,
+                    "global-prompt-modules"), exist_ok=True)
+        for subdir in subdirs:
+            target_dir = join(prompt_templates_dir,
+                              "global-prompt-modules", subdir)
+            source_dir = join(global_prompt_templates_path, subdir)
+            os.makedirs(target_dir, exist_ok=True)
+            for item in os.listdir(source_dir):
+                source = join(source_dir, item)
+                target = join(target_dir, item)
+                shutil.copy2(source, target)
+
+        custom_prompt_templates_subdir = config.custom_prompt_templates_subdir
+        local_prompt_modules_dir = join(
+            prompt_templates_dir, custom_prompt_templates_subdir)
+        os.makedirs(local_prompt_modules_dir, exist_ok=True)
+        for subdir in subdirs:
+            os.makedirs(join(local_prompt_modules_dir, subdir), exist_ok=True)

ara_cli/commands/list_agents_command.py

@@ -0,0 +1,39 @@
+import os
+from ara_cli.commands.command import Command
+
+
+def list_available_binary_agents(chat_instance):
+    """Helper to list executable files in the agents directory."""
+    try:
+        base_dir = chat_instance._find_project_root()
+        if not base_dir:
+            return []  # Can't find project root
+
+        agents_dir = os.path.join(base_dir, "ara", ".araconfig", "agents")
+        if not os.path.isdir(agents_dir):
+            return []
+
+        available_agents = []
+        for f in os.listdir(agents_dir):
+            path = os.path.join(agents_dir, f)
+            if os.path.isfile(path) and os.access(path, os.X_OK):
+                available_agents.append(f)
+        return available_agents
+    except Exception:
+        return []  # Fail silently
+
+
+class ListAgentsCommand(Command):
+    def __init__(self, chat_instance):
+        self.chat_instance = chat_instance
+
+    def execute(self):
+        """Lists all available executable binary agents."""
+        print("Searching for available agents in 'ara/.araconfig/agents/'...")
+        available_agents = list_available_binary_agents(self.chat_instance)
+        if available_agents:
+            print("\nAvailable binary agents:")
+            for agent in available_agents:
+                print(f"  - {agent}")
+        else:
+            print("No executable binary agents found.")

ara_cli/completers.py

@@ -4,18 +4,17 @@ from pathlib import Path
 import typer
 
 from ara_cli.classifier import Classifier
-from ara_cli.template_manager import SpecificationBreakdownAspects
+from ara_cli.constants import VALID_ASPECTS
 
 
 def complete_classifier(incomplete: str) -> List[str]:
     """Complete classifier names."""
-    classifiers = Classifier.ordered_classifiers()
-    return [c for c in classifiers if c.startswith(incomplete)]
+    return [c for c in Classifier.ordered_classifiers() if c.startswith(incomplete)]
 
 
 def complete_aspect(incomplete: str) -> List[str]:
     """Complete aspect names."""
-    aspects = SpecificationBreakdownAspects.VALID_ASPECTS
+    aspects = VALID_ASPECTS
     return [a for a in aspects if a.startswith(incomplete)]
 
 
@@ -31,23 +30,31 @@ def complete_template_type(incomplete: str) -> List[str]:
     return [t for t in template_types if t.startswith(incomplete)]
 
 
-def complete_artefact_name(classifier: str) -> List[str]:
+def complete_artefact_name(classifier: str, incomplete: str = "") -> List[str]:
     """Complete artefact names for a given classifier."""
     try:
         # Get the directory for the classifier
         classifier_dir = f"ara/{Classifier.get_sub_directory(classifier)}"
-        
+
         if not os.path.exists(classifier_dir):
             return []
-        
+
         # Find all files with the classifier extension
         artefacts = []
+        suffix = f".{classifier}"
+
+        # We only care about files that match the incomplete prefix AND the suffix
+        # Since os.listdir gives filenames, we can check startswith(incomplete)
+        # but we must be careful because the file starts with the artefact name, not necessarily the incomplete part + suffix directly unless full match.
+        # Actually, incomplete corresponds to the artefact name part.
+        # So file must start with incomplete AND end with suffix.
+
         for file in os.listdir(classifier_dir):
-            if file.endswith(f'.{classifier}'):
+            if file.startswith(incomplete) and file.endswith(suffix):
                 # Remove the extension to get the artefact name
-                name = file[:-len(f'.{classifier}')]
+                name = file[: -len(suffix)]
                 artefacts.append(name)
-        
+
         return sorted(artefacts)
     except Exception:
         return []
@@ -55,9 +62,10 @@ def complete_artefact_name(classifier: str) -> List[str]:
 
 def complete_artefact_name_for_classifier(classifier: str):
     """Create a completer function for artefact names of a specific classifier."""
+
     def completer(incomplete: str) -> List[str]:
-        artefacts = complete_artefact_name(classifier)
-        return [a for a in artefacts if a.startswith(incomplete)]
+        return complete_artefact_name(classifier, incomplete)
+
     return completer
 
 
@@ -66,13 +74,14 @@ def complete_chat_files(incomplete: str) -> List[str]:
     try:
         chat_files = []
         current_dir = Path.cwd()
-        
-        # Look for .md files in current directory
-        for file in current_dir.glob("*.md"):
-            name = file.stem
-            if name.startswith(incomplete):
-                chat_files.append(name)
-        
+
+        # Optimize by using glob with the incomplete prefix
+        # Note: glob pattern needs to be careful with special chars, but for autocompletion usually fine.
+        pattern = f"{incomplete}*.md" if incomplete else "*.md"
+
+        for file in current_dir.glob(pattern):
+            chat_files.append(file.stem)
+
         return sorted(chat_files)
     except Exception:
         return []
@@ -83,62 +92,89 @@ class DynamicCompleters:
     @staticmethod
     def create_classifier_completer():
         """Create a completer for classifiers."""
+
         def completer(ctx: typer.Context, incomplete: str) -> List[str]:
             return complete_classifier(incomplete)
+
         return completer
-    
+
     @staticmethod
     def create_aspect_completer():
         """Create a completer for aspects."""
+
         def completer(ctx: typer.Context, incomplete: str) -> List[str]:
             return complete_aspect(incomplete)
+
         return completer
-    
+
     @staticmethod
     def create_status_completer():
         """Create a completer for status values."""
+
         def completer(ctx: typer.Context, incomplete: str) -> List[str]:
             return complete_status(incomplete)
+
         return completer
-    
+
     @staticmethod
     def create_template_type_completer():
         """Create a completer for template types."""
+
         def completer(ctx: typer.Context, incomplete: str) -> List[str]:
             return complete_template_type(incomplete)
+
         return completer
-    
+
     @staticmethod
     def create_artefact_name_completer():
         """Create a completer for artefact names based on classifier context."""
+
         def completer(ctx: typer.Context, incomplete: str) -> List[str]:
             # Try to get classifier from context
-            if hasattr(ctx, 'params') and 'classifier' in ctx.params:
-                classifier = ctx.params['classifier']
-                if hasattr(classifier, 'value'):
+            if hasattr(ctx, "params") and "classifier" in ctx.params:
+                classifier = ctx.params["classifier"]
+                if hasattr(classifier, "value"):
                     classifier = classifier.value
-                artefacts = complete_artefact_name(classifier)
-                return [a for a in artefacts if a.startswith(incomplete)]
+                return complete_artefact_name(classifier, incomplete)
             return []
+
         return completer
-    
+
     @staticmethod
     def create_parent_name_completer():
         """Create a completer for parent artefact names based on parent classifier context."""
+
         def completer(ctx: typer.Context, incomplete: str) -> List[str]:
             # Try to get parent_classifier from context
-            if hasattr(ctx, 'params') and 'parent_classifier' in ctx.params:
-                parent_classifier = ctx.params['parent_classifier']
-                if hasattr(parent_classifier, 'value'):
+            if hasattr(ctx, "params") and "parent_classifier" in ctx.params:
+                parent_classifier = ctx.params["parent_classifier"]
+                if hasattr(parent_classifier, "value"):
                     parent_classifier = parent_classifier.value
-                artefacts = complete_artefact_name(parent_classifier)
-                return [a for a in artefacts if a.startswith(incomplete)]
+                return complete_artefact_name(parent_classifier, incomplete)
             return []
+
         return completer
-    
+
     @staticmethod
     def create_chat_file_completer():
         """Create a completer for chat files."""
+
         def completer(ctx: typer.Context, incomplete: str) -> List[str]:
             return complete_chat_files(incomplete)
+
+        return completer
+
+    @staticmethod
+    def create_convert_source_artefact_name_completer():
+        """Create a completer for convert command source artefact names based on old_classifier context."""
+
+        def completer(ctx: typer.Context, incomplete: str) -> List[str]:
+            # Try to get old_classifier from context
+            if hasattr(ctx, "params") and "old_classifier" in ctx.params:
+                old_classifier = ctx.params["old_classifier"]
+                if hasattr(old_classifier, "value"):
+                    old_classifier = old_classifier.value
+                return complete_artefact_name(old_classifier, incomplete)
+            return []
+
         return completer

ara_cli/constants.py

@@ -0,0 +1,2 @@
+
+VALID_ASPECTS = ["technology", "concept", "persona", "customer", "step"]

ara_cli/directory_navigator.py

@@ -1,4 +1,5 @@
 import os
+import sys
 from os.path import join, exists, isdir, dirname, basename
 # from ara_cli.directory_searcher import DirectorySearcher
 
@@ -23,7 +24,8 @@ class DirectoryNavigator:
             return original_directory
 
         current_directory = original_directory
-        while current_directory != dirname(current_directory):  # Ensure loop breaks at root
+        # Ensure loop breaks at root
+        while current_directory != dirname(current_directory):
             potential_path = join(current_directory, self.target_directory)
             if self.exists(potential_path):
                 os.chdir(potential_path)
@@ -31,7 +33,8 @@ class DirectoryNavigator:
             current_directory = dirname(current_directory)
 
         # If the loop completes, the target directory was not found
-        user_input = input(f"Unable to locate the '{self.target_directory}' directory. Do you want to create an 'ara' folder in the working directory? (y/N): ").strip().lower()
+        user_input = input(
+            f"Unable to locate the '{self.target_directory}' directory. Do you want to create an 'ara' folder in the working directory? (y/N): ").strip().lower()
 
         if user_input == '' or user_input == 'y':
             ara_folder_path = join(original_directory, 'ara')
@@ -40,7 +43,8 @@ class DirectoryNavigator:
             os.chdir(ara_folder_path)
             return original_directory
         else:
-            print(f"Unable to locate the '{self.target_directory}' directory and user declined to create 'ara' folder.")
+            print(
+                f"Unable to locate the '{self.target_directory}' directory and user declined to create 'ara' folder.")
             sys.exit(0)
 
     def navigate_to_relative(self, relative_path):
@@ -56,7 +60,36 @@ class DirectoryNavigator:
         if self.exists(path):
             os.chdir(path)
         else:
-            raise Exception(f"Unable to navigate to '{relative_path}' relative to the target directory.")
+            raise Exception(
+                f"Unable to navigate to '{relative_path}' relative to the target directory.")
+
+    @staticmethod
+    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
+        # Stop at filesystem root
+        while check_dir != os.path.dirname(check_dir):
+            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
 
     # debug version
     # def get_ara_directory(self):

ara_cli/llm_utils.py

@@ -0,0 +1,58 @@
+from ara_cli.ara_config import ConfigManager
+from pydantic_ai import Agent
+
+FALLBACK_MODEL = "anthropic:claude-4-sonnet-20250514"
+
+
+def get_configured_conversion_llm_model() -> str:
+    """
+    Retrieves the configured conversion LLM model string, adapted for pydantic_ai.
+    Falls back to a default model if configuration is missing or invalid.
+    """
+    model_name = FALLBACK_MODEL
+    try:
+        config = ConfigManager.get_config()
+        conversion_llm_key = config.conversion_llm
+
+        if conversion_llm_key and conversion_llm_key in config.llm_config:
+            llm_config_item = config.llm_config[conversion_llm_key]
+            raw_model_name = llm_config_item.model
+
+            # Adapt LiteLLM model string to PydanticAI format
+            # LiteLLM: provider/model-name (e.g. openai/gpt-4o)
+            # PydanticAI: provider:model-name (e.g. openai:gpt-4o)
+            if "/" in raw_model_name and ":" not in raw_model_name:
+                parts = raw_model_name.split("/", 1)
+                if len(parts) == 2:
+                    model_name = f"{parts[0]}:{parts[1]}"
+                else:
+                    model_name = raw_model_name
+            else:
+                model_name = raw_model_name
+        else:
+            print(
+                f"Warning: Conversion LLM configuration issue. Using fallback model: {FALLBACK_MODEL}"
+            )
+    except Exception as e:
+        print(
+            f"Warning: Error resolving LLM config ({e}). Using fallback model: {FALLBACK_MODEL}"
+        )
+        model_name = FALLBACK_MODEL
+
+    return model_name
+
+
+def create_pydantic_ai_agent(
+    output_type, model_name: str = None, instrument: bool = True
+) -> Agent:
+    """
+    Creates a pydantic_ai Agent with the specified or configured model.
+    """
+    if not model_name:
+        model_name = get_configured_conversion_llm_model()
+
+    return Agent(
+        model=model_name,
+        output_type=output_type,
+        instrument=instrument,
+    )

ara_cli/prompt_chat.py

@@ -6,9 +6,18 @@ from ara_cli.update_config_prompt import update_artefact_config_prompt_files
 from ara_cli.output_suppressor import suppress_stdout
 
 
-def initialize_prompt_chat_mode(classifier, param, chat_name, reset=None, output_mode=False, append_strings=[], restricted=False):
+def initialize_prompt_chat_mode(
+    classifier,
+    param,
+    chat_name,
+    reset=None,
+    output_mode=False,
+    append_strings=[],
+    restricted=False,
+):
     sub_directory = Classifier.get_sub_directory(classifier)
-    artefact_data_path = os.path.join("ara", sub_directory, f"{param}.data") # f"ara/{sub_directory}/{parameter}.data"
+    # f"ara/{sub_directory}/{parameter}.data"
+    artefact_data_path = os.path.join("ara", sub_directory, f"{param}.data")
 
     if chat_name is None:
         chat_name = classifier
@@ -17,11 +26,18 @@ def initialize_prompt_chat_mode(classifier, param, chat_name, reset=None, output
         update_artefact_config_prompt_files(classifier, param, automatic_update=True)
 
     classifier_chat_file = os.path.join(artefact_data_path, f"{chat_name}")
-    start_chat_session(classifier_chat_file, reset, output_mode, append_strings, restricted)
+    start_chat_session(
+        classifier_chat_file, reset, output_mode, append_strings, restricted
+    )
+
 
 def start_chat_session(chat_file, reset, output_mode, append_strings, restricted):
     with suppress_stdout(suppress=output_mode):
-        chat = Chat(chat_file, reset=reset) if not restricted else Chat(chat_file, reset=reset, enable_commands=whitelisted_commands)
+        chat = (
+            Chat(chat_file, reset=reset)
+            if not restricted
+            else Chat(chat_file, reset=reset, enable_commands=whitelisted_commands)
+        )
     if append_strings:
         chat.append_strings(append_strings)
     if output_mode: