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

ara_cli/ara_config.py

@@ -10,6 +10,7 @@ import warnings
 
 DEFAULT_CONFIG_LOCATION = "./ara/.araconfig/ara_config.json"
 
+
 class LLMConfigItem(BaseModel):
     provider: str
     model: str
@@ -17,6 +18,7 @@ class LLMConfigItem(BaseModel):
     max_tokens: Optional[int] = None
     max_completion_tokens: Optional[int] = None
 
+
 class ARAconfig(BaseModel):
     ext_code_dirs: List[Dict[str, str]] = Field(default_factory=lambda: [
         {"source_dir": "./src"},
@@ -28,98 +30,104 @@ class ARAconfig(BaseModel):
     local_prompt_templates_dir: str = "./ara/.araconfig"
     custom_prompt_templates_subdir: Optional[str] = "custom-prompt-modules"
     local_ara_templates_dir: str = "./ara/.araconfig/templates/"
-    ara_prompt_given_list_includes: List[str] = Field(default_factory=lambda: [
-        "*.businessgoal",
-        "*.vision",
-        "*.capability",
-        "*.keyfeature",
-        "*.epic",
-        "*.userstory",
-        "*.example",
-        "*.feature",
-        "*.task",
-        "*.py",
-        "*.md",
-        "*.png",
-        "*.jpg",
-        "*.jpeg",
-    ])
-    llm_config: Dict[str, LLMConfigItem] = Field(default_factory=lambda: {
-        "gpt-5": LLMConfigItem(
-            provider="openai",
-            model="openai/gpt-5",
-            temperature=1,
-            max_completion_tokens=16000
-        ),
-        "gpt-5-mini": LLMConfigItem(
-            provider="openai",
-            model="openai/gpt-5-mini-2025-08-07",
-            temperature=1
-        ),
-        "gpt-4o": LLMConfigItem(
-            provider="openai",
-            model="openai/gpt-4o",
-            temperature=0.8,
-            max_tokens=16000
-        ),
-        "gpt-4.1": LLMConfigItem(
-            provider="openai",
-            model="openai/gpt-4.1",
-            temperature=0.8,
-            max_tokens=16000
-        ),
-        "o3-mini": LLMConfigItem(
-            provider="openai",
-            model="openai/o3-mini",
-            temperature=1.0,
-            max_tokens=8000
-        ),
-        "opus-4": LLMConfigItem(
-            provider="anthropic",
-            model="anthropic/claude-opus-4-20250514",
-            temperature=0.5,
-            max_tokens=32000
-        ),
-        "sonnet-4": LLMConfigItem(
-            provider="anthropic",
-            model="anthropic/claude-sonnet-4-20250514",
-            temperature=0.5,
-            max_tokens=32000
-        ),
-        "together-ai-llama-2": LLMConfigItem(
-            provider="together_ai",
-            model="together_ai/togethercomputer/llama-2-70b",
-            temperature=0.8,
-            max_tokens=4000
-        ),
-        "groq-llama-3": LLMConfigItem(
-            provider="groq",
-            model="groq/llama3-70b-8192",
-            temperature=0.8,
-            max_tokens=4000
-        )
-    })
+    ara_prompt_given_list_includes: List[str] = Field(
+        default_factory=lambda: [
+            "*.businessgoal",
+            "*.vision",
+            "*.capability",
+            "*.keyfeature",
+            "*.epic",
+            "*.userstory",
+            "*.example",
+            "*.feature",
+            "*.task",
+            "*.py",
+            "*.md",
+            "*.png",
+            "*.jpg",
+            "*.jpeg",
+        ]
+    )
+    llm_config: Dict[str, LLMConfigItem] = Field(
+        default_factory=lambda: {
+            "gpt-5": LLMConfigItem(
+                provider="openai",
+                model="openai/gpt-5",
+                temperature=1,
+                max_completion_tokens=16000,
+            ),
+            "gpt-5-mini": LLMConfigItem(
+                provider="openai", model="openai/gpt-5-mini-2025-08-07", temperature=1
+            ),
+            "gpt-4o": LLMConfigItem(
+                provider="openai",
+                model="openai/gpt-4o",
+                temperature=0.8,
+                max_tokens=16000,
+            ),
+            "gpt-4.1": LLMConfigItem(
+                provider="openai",
+                model="openai/gpt-4.1",
+                temperature=0.8,
+                max_tokens=16000,
+            ),
+            "o3-mini": LLMConfigItem(
+                provider="openai",
+                model="openai/o3-mini",
+                temperature=1.0,
+                max_tokens=8000,
+            ),
+            "opus-4": LLMConfigItem(
+                provider="anthropic",
+                model="anthropic/claude-opus-4-20250514",
+                temperature=0.5,
+                max_tokens=32000,
+            ),
+            "sonnet-4": LLMConfigItem(
+                provider="anthropic",
+                model="anthropic/claude-sonnet-4-20250514",
+                temperature=0.5,
+                max_tokens=32000,
+            ),
+            "together-ai-llama-2": LLMConfigItem(
+                provider="together_ai",
+                model="together_ai/togethercomputer/llama-2-70b",
+                temperature=0.8,
+                max_tokens=4000,
+            ),
+            "groq-llama-3": LLMConfigItem(
+                provider="groq",
+                model="groq/llama3-70b-8192",
+                temperature=0.8,
+                max_tokens=4000,
+            ),
+        }
+    )
     default_llm: Optional[str] = None
     extraction_llm: Optional[str] = None
 
-    @model_validator(mode='after')
-    def check_critical_fields(self) -> 'ARAconfig':
+    @model_validator(mode="after")
+    def check_critical_fields(self) -> "ARAconfig":
         """Check for empty critical fields and validate default_llm and extraction_llm."""
         critical_fields = {
-            'ext_code_dirs': [{"source_dir": "./src"}, {"source_dir": "./tests"}],
-            'local_ara_templates_dir': "./ara/.araconfig/templates/",
-            'local_prompt_templates_dir': "./ara/.araconfig",
-            'glossary_dir': "./glossary"
+            "ext_code_dirs": [{"source_dir": "./src"}, {"source_dir": "./tests"}],
+            "local_ara_templates_dir": "./ara/.araconfig/templates/",
+            "local_prompt_templates_dir": "./ara/.araconfig",
+            "glossary_dir": "./glossary",
         }
 
         for field, default_value in critical_fields.items():
             current_value = getattr(self, field)
             if not current_value:
-                print(f"Warning: Value for '{field}' is missing or empty. Using default.")
+                print(
+                    f"Warning: Value for '{field}' is missing or empty. Using default."
+                )
                 setattr(self, field, default_value)
-        
+
         if not self.llm_config:
-            print("Warning: 'llm_config' is empty. 'default_llm' and 'extraction_llm' cannot be set.")
+            print(
+                "Warning: 'llm_config' is empty. 'default_llm' and 'extraction_llm' cannot be set."
+            )
             self.default_llm = None
             self.extraction_llm = None
             return self
@@ -127,23 +135,34 @@ class ARAconfig(BaseModel):
         first_available_llm = next(iter(self.llm_config))
 
         if not self.default_llm:
-            print(f"Warning: 'default_llm' is not set. Defaulting to the first available model: '{first_available_llm}'.")
+            print(
+                f"Warning: 'default_llm' is not set. Defaulting to the first available model: '{first_available_llm}'."
+            )
             self.default_llm = first_available_llm
         elif self.default_llm not in self.llm_config:
-            print(f"Warning: The configured 'default_llm' ('{self.default_llm}') does not exist in 'llm_config'.")
-            print(f"-> Reverting to the first available model: '{first_available_llm}'.")
+            print(
+                f"Warning: The configured 'default_llm' ('{self.default_llm}') does not exist in 'llm_config'."
+            )
+            print(
+                f"-> Reverting to the first available model: '{first_available_llm}'."
+            )
             self.default_llm = first_available_llm
 
         if not self.extraction_llm:
-            print(f"Warning: 'extraction_llm' is not set. Setting it to the same as 'default_llm': '{self.default_llm}'.")
+            print(
+                f"Warning: 'extraction_llm' is not set. Setting it to the same as 'default_llm': '{self.default_llm}'."
+            )
             self.extraction_llm = self.default_llm
         elif self.extraction_llm not in self.llm_config:
-            print(f"Warning: The configured 'extraction_llm' ('{self.extraction_llm}') does not exist in 'llm_config'.")
+            print(
+                f"Warning: The configured 'extraction_llm' ('{self.extraction_llm}') does not exist in 'llm_config'."
+            )
             print(f"-> Reverting to the 'default_llm' value: '{self.default_llm}'.")
             self.extraction_llm = self.default_llm
-            
+
         return self
 
+
 # Function to ensure the necessary directories exist
 @lru_cache(maxsize=None)
 def ensure_directory_exists(directory: str):
@@ -153,6 +172,7 @@ def ensure_directory_exists(directory: str):
         print(f"New directory created at {directory}")
     return directory
 
+
 def handle_unrecognized_keys(data: dict) -> dict:
     """Removes unrecognized keys from the data and warns the user."""
     known_fields = set(ARAconfig.model_fields.keys())
@@ -211,13 +231,15 @@ def read_data(filepath: str) -> ARAconfig:
         return config
     except ValidationError as e:
         print("--- Configuration Error Detected ---")
-        print("Some settings in your configuration file are invalid. Attempting to fix them.")
-        
+        print(
+            "Some settings in your configuration file are invalid. Attempting to fix them."
+        )
+
         corrected_data = data.copy()
         defaults = ARAconfig().model_dump()
-        
-        error_fields = {err['loc'][0] for err in e.errors() if err['loc']}
-        
+
+        error_fields = {err["loc"][0] for err in e.errors() if err["loc"]}
+
         for field_name in error_fields:
             print(f"-> Field '{field_name}' is invalid and will be reverted to its default value.")
             if field_name in corrected_data:
@@ -228,15 +250,17 @@ def read_data(filepath: str) -> ARAconfig:
         final_config = ARAconfig(**corrected_data)
         save_data(filepath, final_config)
         print(f"Configuration has been corrected and saved to '{filepath}'.")
-        
+
         return final_config
 
+
 # Function to save the modified configuration back to the JSON file
 def save_data(filepath: str, config: ARAconfig):
     """Saves the Pydantic config model to a JSON file."""
     with open(filepath, "w", encoding="utf-8") as file:
         json.dump(config.model_dump(), file, indent=4)
 
+
 # Singleton for configuration management
 class ConfigManager:
     _config_instance = None
@@ -246,9 +270,9 @@ class ConfigManager:
         if cls._config_instance is None:
             cls._config_instance = read_data(filepath)
         return cls._config_instance
-    
+
     @classmethod
     def reset(cls):
         """Reset the configuration instance (useful for testing)."""
         cls._config_instance = None
-        read_data.cache_clear()
+        read_data.cache_clear()

ara_cli/ara_subcommands/autofix.py

@@ -0,0 +1,26 @@
+import typer
+from .common import MockArgs
+from ara_cli.ara_command_action import autofix_action
+
+
+def autofix_main(
+    single_pass: bool = typer.Option(False, "--single-pass", help="Run the autofix once for every scanned file"),
+    deterministic: bool = typer.Option(False, "-d", "--deterministic", help="Run only deterministic fixes e.g Title-FileName Mismatch fix"),
+    non_deterministic: bool = typer.Option(False, "-nd", "--non-deterministic", help="Run only non-deterministic fixes")
+):
+    """Fix ARA tree with llm models for scanned artefacts with ara scan command."""
+    if deterministic and non_deterministic:
+        typer.echo("Error: --deterministic and --non-deterministic are mutually exclusive", err=True)
+        raise typer.Exit(1)
+    
+    args = MockArgs(
+        single_pass=single_pass,
+        deterministic=deterministic,
+        non_deterministic=non_deterministic
+    )
+    autofix_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Fix ARA tree with llm models for scanned artefacts"
+    parent.command(name="autofix", help=help_text)(autofix_main)

ara_cli/ara_subcommands/chat.py

@@ -0,0 +1,27 @@
+import typer
+from typing import Optional, List
+from .common import MockArgs, ChatNameArgument
+from ara_cli.ara_command_action import chat_action
+
+
+def chat_main(
+    chat_name: Optional[str] = ChatNameArgument("Optional name for a specific chat. Pass the .md file to continue an existing chat", None),
+    reset: Optional[bool] = typer.Option(None, "-r", "--reset/--no-reset", help="Reset the chat file if it exists"),
+    output_mode: bool = typer.Option(False, "--out", help="Output the contents of the chat file instead of entering interactive chat mode"),
+    append: Optional[List[str]] = typer.Option(None, "--append", help="Append strings to the chat file"),
+    restricted: Optional[bool] = typer.Option(None, "--restricted/--no-restricted", help="Start with a limited set of commands")
+):
+    """Command line chatbot. Chat control with SEND/s | RERUN/r | QUIT/q"""
+    args = MockArgs(
+        chat_name=chat_name,
+        reset=reset,
+        output_mode=output_mode,
+        append=append,
+        restricted=restricted
+    )
+    chat_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Command line chatbot. Chat control with SEND/s | RERUN/r | QUIT/q"
+    parent.command(name="chat", help=help_text)(chat_main)

ara_cli/ara_subcommands/classifier_directory.py

@@ -0,0 +1,16 @@
+import typer
+from .common import ClassifierEnum, MockArgs, ClassifierArgument
+from ara_cli.ara_command_action import classifier_directory_action
+
+
+def classifier_directory_main(
+    classifier: ClassifierEnum = ClassifierArgument("Classifier of the artefact type")
+):
+    """Print the ara subdirectory for an artefact classifier."""
+    args = MockArgs(classifier=classifier.value)
+    classifier_directory_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Print the ara subdirectory for an artefact classifier"
+    parent.command(name="classifier-directory", help=help_text)(classifier_directory_main)

ara_cli/ara_subcommands/common.py

@@ -0,0 +1,100 @@
+from typing import Optional
+from enum import Enum
+import typer
+from ara_cli.classifier import Classifier
+from ara_cli.template_manager import SpecificationBreakdownAspects
+from ara_cli.completers import DynamicCompleters
+
+
+# Get classifiers and aspects
+classifiers = Classifier.ordered_classifiers()
+aspects = SpecificationBreakdownAspects.VALID_ASPECTS
+
+
+# Create enums for better type safety
+ClassifierEnum = Enum('ClassifierEnum', {c: c for c in classifiers})
+AspectEnum = Enum('AspectEnum', {a: a for a in aspects})
+TemplateTypeEnum = Enum('TemplateTypeEnum', {
+    'rules': 'rules',
+    'intention': 'intention',
+    'commands': 'commands',
+    'blueprint': 'blueprint'
+})
+
+
+# Create typed arguments and options with autocompletion
+def ClassifierArgument(help_text: str, default=...):
+    """Create a classifier argument with autocompletion."""
+    return typer.Argument(
+        default,
+        help=help_text,
+        autocompletion=DynamicCompleters.create_classifier_completer()
+    )
+
+
+def ClassifierOption(help_text: str, *names):
+    """Create a classifier option with autocompletion."""
+    return typer.Option(
+        None,
+        *names,
+        help=help_text,
+        autocompletion=DynamicCompleters.create_classifier_completer()
+    )
+
+
+def ArtefactNameArgument(help_text: str, default=...):
+    """Create an artefact name argument with autocompletion."""
+    return typer.Argument(
+        default,
+        help=help_text,
+        autocompletion=DynamicCompleters.create_artefact_name_completer()
+    )
+
+
+
+def ParentNameArgument(help_text: str):
+    """Create a parent name argument with autocompletion."""
+    return typer.Argument(
+        help=help_text,
+        autocompletion=DynamicCompleters.create_parent_name_completer()
+    )
+
+
+def AspectArgument(help_text: str):
+    """Create an aspect argument with autocompletion."""
+    return typer.Argument(
+        help=help_text,
+        autocompletion=DynamicCompleters.create_aspect_completer()
+    )
+
+
+def StatusArgument(help_text: str):
+    """Create a status argument with autocompletion."""
+    return typer.Argument(
+        help=help_text,
+        autocompletion=DynamicCompleters.create_status_completer()
+    )
+
+
+def TemplateTypeArgument(help_text: str):
+    """Create a template type argument with autocompletion."""
+    return typer.Argument(
+        help=help_text,
+        autocompletion=DynamicCompleters.create_template_type_completer()
+    )
+
+
+def ChatNameArgument(help_text: str, default=None):
+    """Create a chat name argument with autocompletion."""
+    return typer.Argument(
+        default,
+        help=help_text,
+        autocompletion=DynamicCompleters.create_chat_file_completer()
+    )
+
+
+# Mock args class to maintain compatibility with existing action functions
+class MockArgs:
+    def __init__(self, **kwargs):
+        for key, value in kwargs.items():
+            setattr(self, key, value)

ara_cli/ara_subcommands/create.py

@@ -0,0 +1,75 @@
+import typer
+from typing import Optional
+from .common import (
+    ClassifierEnum, AspectEnum, MockArgs,
+    ClassifierArgument, ArtefactNameArgument, ParentNameArgument, AspectArgument
+)
+from ara_cli.ara_command_action import create_action
+
+
+def create_contributes_to(
+    ctx: typer.Context,
+    parent_classifier: ClassifierEnum = ClassifierArgument("Classifier of the parent"),
+    parent_name: str = ParentNameArgument("Name of a parent artefact"),
+    rule: Optional[str] = typer.Option(None, "-r", "--rule", help="Rule for contribution")
+):
+    """Create an artefact that contributes to a parent artefact."""
+    # Get classifier and parameter from parent context
+    parent_params = ctx.parent.params
+    classifier = parent_params['classifier']
+    parameter = parent_params['parameter']
+
+    args = MockArgs(
+        classifier=classifier,
+        parameter=parameter,
+        option="contributes-to",
+        parent_classifier=parent_classifier.value,
+        parent_name=parent_name,
+        rule=rule
+    )
+    create_action(args)
+
+
+def create_aspect(
+    ctx: typer.Context,
+    aspect: AspectEnum = AspectArgument("Adds additional specification breakdown aspects")
+):
+    """Create an artefact with additional specification breakdown aspects."""
+    # Get classifier and parameter from parent context
+    parent_params = ctx.parent.params
+    classifier = parent_params['classifier']
+    parameter = parent_params['parameter']
+
+    args = MockArgs(
+        classifier=classifier,
+        parameter=parameter,
+        option="aspect",
+        aspect=aspect.value
+    )
+    create_action(args)
+
+
+def create_main(
+    ctx: typer.Context,
+    classifier: ClassifierEnum = ClassifierArgument("Classifier that also serves as file extension"),
+    parameter: str = ArtefactNameArgument("Artefact name that serves as filename")
+):
+    """Create a classified artefact with data directory."""
+    if ctx.invoked_subcommand is None:
+        args = MockArgs(
+            classifier=classifier.value,
+            parameter=parameter,
+            option=None
+        )
+        create_action(args)
+
+
+def register(parent: typer.Typer):
+    create_app = typer.Typer(
+        help="Create a classified artefact with data directory",
+        add_completion=False  # Disable completion on subcommand
+    )
+    create_app.command("contributes-to")(create_contributes_to)
+    create_app.command("aspect")(create_aspect)
+    create_app.callback(invoke_without_command=True)(create_main)
+    parent.add_typer(create_app, name="create")

ara_cli/ara_subcommands/delete.py

@@ -0,0 +1,22 @@
+import typer
+from .common import ClassifierEnum, MockArgs, ClassifierArgument, ArtefactNameArgument
+from ara_cli.ara_command_action import delete_action
+
+
+def delete_main(
+    classifier: ClassifierEnum = ClassifierArgument("Classifier of the artefact to be deleted"),
+    parameter: str = ArtefactNameArgument("Filename of artefact"),
+    force: bool = typer.Option(False, "-f", "--force", help="ignore nonexistent files and arguments, never prompt")
+):
+    """Delete an artefact file including its data directory."""
+    args = MockArgs(
+        classifier=classifier.value,
+        parameter=parameter,
+        force=force
+    )
+    delete_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Delete an artefact file including its data directory"
+    parent.command(name="delete", help=help_text)(delete_main)

ara_cli/ara_subcommands/extract.py

@@ -0,0 +1,22 @@
+import typer
+from .common import MockArgs
+from ara_cli.ara_command_action import extract_action
+
+
+def extract_main(
+    filename: str = typer.Argument(help="Input file to extract from"),
+    force: bool = typer.Option(False, "-f", "--force", help="Answer queries with yes when extracting"),
+    write: bool = typer.Option(False, "-w", "--write", help="Overwrite existing files without using LLM for merging")
+):
+    """Extract blocks of marked content from a given file."""
+    args = MockArgs(
+        filename=filename,
+        force=force,
+        write=write
+    )
+    extract_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Extract blocks of marked content from a given file"
+    parent.command(name="extract", help=help_text)(extract_main)

ara_cli/ara_subcommands/fetch_templates.py

@@ -0,0 +1,14 @@
+import typer
+from .common import MockArgs
+from ara_cli.ara_command_action import fetch_templates_action
+
+
+def fetch_templates_main():
+    """Fetches templates and stores them in .araconfig."""
+    args = MockArgs()
+    fetch_templates_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Fetches templates and stores them in .araconfig"
+    parent.command(name="fetch-templates", help=help_text)(fetch_templates_main)