ara-cli 0.1.10.0__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/commands/read_command.py

@@ -30,6 +30,11 @@ class ReadCommand(Command):
         """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]
 
@@ -62,10 +67,11 @@ class ReadCommand(Command):
                     )
 
             # Apply filtering and print results
-            filtered_artefacts = self._apply_filtering(artefacts_by_classifier)
-            file_classifier.print_classified_files(
-                filtered_artefacts, print_content=True
-            )
+            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:
@@ -102,3 +108,10 @@ class ReadCommand(Command):
             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
+        )

ara_cli/completers.py

@@ -0,0 +1,180 @@
+import os
+from typing import List, Optional
+from pathlib import Path
+import typer
+
+from ara_cli.classifier import Classifier
+from ara_cli.constants import VALID_ASPECTS
+
+
+def complete_classifier(incomplete: str) -> List[str]:
+    """Complete classifier names."""
+    return [c for c in Classifier.ordered_classifiers() if c.startswith(incomplete)]
+
+
+def complete_aspect(incomplete: str) -> List[str]:
+    """Complete aspect names."""
+    aspects = VALID_ASPECTS
+    return [a for a in aspects if a.startswith(incomplete)]
+
+
+def complete_status(incomplete: str) -> List[str]:
+    """Complete task status values."""
+    statuses = ["to-do", "in-progress", "review", "done", "closed"]
+    return [s for s in statuses if s.startswith(incomplete)]
+
+
+def complete_template_type(incomplete: str) -> List[str]:
+    """Complete template type values."""
+    template_types = ["rules", "intention", "commands", "blueprint"]
+    return [t for t in template_types if t.startswith(incomplete)]
+
+
+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.startswith(incomplete) and file.endswith(suffix):
+                # Remove the extension to get the artefact name
+                name = file[: -len(suffix)]
+                artefacts.append(name)
+
+        return sorted(artefacts)
+    except Exception:
+        return []
+
+
+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]:
+        return complete_artefact_name(classifier, incomplete)
+
+    return completer
+
+
+def complete_chat_files(incomplete: str) -> List[str]:
+    """Complete chat file names (without .md extension)."""
+    try:
+        chat_files = []
+        current_dir = Path.cwd()
+
+        # 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 []
+
+
+# Dynamic completers that need context
+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"):
+                    classifier = classifier.value
+                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"):
+                    parent_classifier = parent_classifier.value
+                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/file_loaders/text_file_loader.py

@@ -19,14 +19,14 @@ class TextFileLoader(FileLoader):
 
         if is_md_file and extract_images:
             reader = MarkdownReader(file_path)
-            file_content = reader.read(extract_images=True)
+            file_content = reader.read(extract_images=True).replace('\r\n', '\n')
         else:
             # Use charset-normalizer to detect encoding
             encoded_content = from_path(file_path).best()
             if not encoded_content:
                 print(f"Failed to detect encoding for {file_path}")
                 return False
-            file_content = str(encoded_content)
+            file_content = str(encoded_content).replace('\r\n', '\n')
 
         if block_delimiter:
             file_content = f"{block_delimiter}\n{file_content}\n{block_delimiter}"

ara_cli/global_file_lister.py

@@ -2,22 +2,19 @@ import os
 import fnmatch
 from typing import List, Dict, Any
 
-# Ağaç yapımız için bir tip tanımı yapalım
 DirTree = Dict[str, Any]
 
 def _build_tree(root_path: str, patterns: List[str]) -> DirTree:
-    """Belirtilen yoldaki dizin yapısını temsil eden iç içe bir sözlük oluşturur."""
+    """Creates a nested dictionary representing the directory structure in the specified path."""
     tree: DirTree = {'files': [], 'dirs': {}}
     try:
         for item in os.listdir(root_path):
             item_path = os.path.join(root_path, item)
             if os.path.isdir(item_path):
                 subtree = _build_tree(item_path, patterns)
-                # Sadece içinde dosya olan veya dosyası olan alt klasörleri ekle
                 if subtree['files'] or subtree['dirs']:
                     tree['dirs'][item] = subtree
             elif os.path.isfile(item_path):
-                # Dosyanın verilen desenlerden herhangi biriyle eşleşip eşleşmediğini kontrol et
                 if any(fnmatch.fnmatch(item, pattern) for pattern in patterns):
                     tree['files'].append(item)
     except OSError as e:
@@ -25,23 +22,17 @@ def _build_tree(root_path: str, patterns: List[str]) -> DirTree:
     return tree
 
 def _write_tree_to_markdown(md_file, tree: DirTree, level: int):
-    """Ağaç veri yapısını markdown formatında dosyaya yazar."""
-    # Dosyaları girintili olarak yaz
+    """Writes the tree data structure to the file in markdown format."""
     indent = '    ' * level
     for filename in sorted(tree['files']):
         md_file.write(f"{indent}- [] {filename}\n")
     
-    # Alt dizinler için başlık oluştur ve recursive olarak devam et
     for dirname, subtree in sorted(tree['dirs'].items()):
-        # Alt başlıklar için girinti yok, sadece başlık seviyesi artıyor
         md_file.write(f"{'    ' * (level -1)}{'#' * (level + 1)} {dirname}\n")
         _write_tree_to_markdown(md_file, subtree, level + 1)
 
 def generate_global_markdown_listing(directories: List[str], file_patterns: List[str], output_file: str):
-    """
-    Global dizinler için hiyerarşik bir markdown dosya listesi oluşturur.
-    En üst başlık olarak mutlak yolu kullanır, alt öğeler için göreceli isimler kullanır.
-    """
+    """Creates a hierarchical list of markdown files for global directories. Uses the absolute path as the top heading and relative names for children."""
     with open(output_file, 'w', encoding='utf-8') as md_file:
         for directory in directories:
             abs_dir = os.path.abspath(directory)
@@ -49,12 +40,11 @@ def generate_global_markdown_listing(directories: List[str], file_patterns: List
             if not os.path.isdir(abs_dir):
                 print(f"Warning: Global directory not found: {abs_dir}")
                 md_file.write(f"# {directory}\n")
-                md_file.write(f"    - !! UYARI: Dizin bulunamadı: {abs_dir}\n\n")
+                md_file.write(f"    - !! Warning: Global directory not found: {abs_dir}\n\n")
                 continue
 
             tree = _build_tree(abs_dir, file_patterns)
-            
-            # Sadece ağaç boş değilse yaz
+
             if tree['files'] or tree['dirs']:
                 md_file.write(f"# {abs_dir}\n")
                 _write_tree_to_markdown(md_file, tree, 1)