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

ara_cli/ara_config.py

@@ -1,119 +1,264 @@
-from typing import List, Dict, Union, Optional
-from pydantic import BaseModel
+from typing import List, Dict, Optional, Any
+from pydantic import BaseModel, ValidationError, Field, model_validator
 import json
 import os
 from os.path import exists, dirname
 from os import makedirs
 from functools import lru_cache
-
+import sys
+import warnings
 
 DEFAULT_CONFIG_LOCATION = "./ara/.araconfig/ara_config.json"
 
 
+class LLMConfigItem(BaseModel):
+    provider: str
+    model: str
+    temperature: float = Field(ge=0.0, le=1.0)
+    max_tokens: Optional[int] = None
+    max_completion_tokens: Optional[int] = None
+
+
 class ARAconfig(BaseModel):
-    ext_code_dirs: List[Dict[str, str]] = [
-        {"source_dir_1": "./src"},
-        {"source_dir_2": "./tests"},
-    ]
+    ext_code_dirs: List[Dict[str, str]] = Field(default_factory=lambda: [
+        {"source_dir": "./src"},
+        {"source_dir": "./tests"}
+    ])
+    global_dirs: Optional[List[Dict[str, str]]] = Field(default=[])
     glossary_dir: str = "./glossary"
     doc_dir: str = "./docs"
     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] = [
-        "*.businessgoal",
-        "*.vision",
-        "*.capability",
-        "*.keyfeature",
-        "*.epic",
-        "*.userstory",
-        "*.example",
-        "*.feature",
-        "*.task",
-        "*.py",
-        "*.md",
-        "*.png",
-        "*.jpg",
-        "*.jpeg",
-    ]
-    llm_config: Dict[str, Dict[str, Union[str, float]]] = {
-        "gpt-4o": {
-            "provider": "openai",
-            "model": "openai/gpt-4o",
-            "temperature": 0.8
-        },
-        "gpt-4.1": {
-            "provider": "openai",
-            "model": "openai/gpt-4.1",
-            "temperature": 0.8,
-        },
-        "o3-mini": {
-            "provider": "openai",
-            "model": "openai/o3-mini",
-            "temperature": 1.0,
-        },
-        "opus-4": {
-            "provider": "anthropic",
-            "model": "anthropic/claude-opus-4-20250514",
-            "temperature": 0.8,
-        },
-        "sonnet-4": {
-            "provider": "anthropic",
-            "model": "anthropic/claude-sonnet-4-20250514",
-            "temperature": 0.8,
-        },
-        "together-ai-llama-2": {
-            "provider": "together_ai",
-            "model": "together_ai/togethercomputer/llama-2-70b",
-            "temperature": 0.8,
-        },
-        "groq-llama-3": {
-            "provider": "groq",
-            "model": "groq/llama3-70b-8192",
-            "temperature": 0.8,
-        },
-    }
-    default_llm: Optional[str] = "gpt-4o"
+    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":
+        """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",
+        }
+
+        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."
+                )
+                setattr(self, field, default_value)
+
+        if not self.llm_config:
+            print(
+                "Warning: 'llm_config' is empty. 'default_llm' and 'extraction_llm' cannot be set."
+            )
+            self.default_llm = None
+            self.extraction_llm = None
+            return self
+
+        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}'."
+            )
+            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}'."
+            )
+            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}'."
+            )
+            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"-> 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):
+    """Creates a directory if it doesn't exist."""
     if not exists(directory):
         os.makedirs(directory)
         print(f"New directory created at {directory}")
     return directory
 
 
-def validate_config_data(filepath: str):
-    with open(filepath, "r") as file:
-        data = json.load(file)
-    return data
+def handle_unrecognized_keys(data: dict) -> dict:
+    """Removes unrecognized keys from the data and warns the user."""
+    known_fields = set(ARAconfig.model_fields.keys())
+    cleaned_data = {}
+    for key, value in data.items():
+        if key not in known_fields:
+            print(f"Warning: Unrecognized configuration key '{key}' will be ignored.")
+        else:
+            cleaned_data[key] = value
+    return cleaned_data
 
 
 # Function to read the JSON file and return an ARAconfig model
 @lru_cache(maxsize=1)
 def read_data(filepath: str) -> ARAconfig:
+    """
+    Reads, validates, and repairs the configuration file.
+    If the file doesn't exist, it creates a default one.
+    If the file is invalid, it corrects only the broken parts.
+    """
+
+    def warn_on_duplicate_llm_dict_key(ordered_pairs):
+        """Reject duplicate keys."""
+        d = {}
+        for k, v in ordered_pairs:
+            if k in d:
+                warnings.warn(f"Duplicate LLM configuration identifier '{k}'. The previous entry will be removed.", UserWarning)
+            d[k] = v
+        return d
+
+    ensure_directory_exists(dirname(filepath))
+
     if not exists(filepath):
-        # If file does not exist, create it with default values
+        print(f"Configuration file not found. Creating a default one at '{filepath}'.")
+        default_config = ARAconfig()
+        save_data(filepath, default_config)
+        print("Please review the default configuration and re-run your command.")
+        sys.exit(0)
+
+    try:
+        with open(filepath, "r", encoding="utf-8") as file:
+            content = file.read()
+            data = json.loads(content, object_pairs_hook=warn_on_duplicate_llm_dict_key)
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON in configuration file: {e}")
+        print("Creating a new configuration with defaults...")
         default_config = ARAconfig()
+        save_data(filepath, default_config)
+        return default_config
 
-        with open(filepath, "w") as file:
-            json.dump(default_config.model_dump(), file, indent=4)
+    data = handle_unrecognized_keys(data)
 
+    try:
+        config = ARAconfig(**data)
+        save_data(filepath, config)
+        return config
+    except ValidationError as e:
+        print("--- Configuration Error Detected ---")
         print(
-            f"ara-cli configuration file '{filepath}' created with default configuration. Please modify it as needed and re-run your command"
+            "Some settings in your configuration file are invalid. Attempting to fix them."
         )
-        exit()  # Exit the application
 
-    data = validate_config_data(filepath)
-    return ARAconfig(**data)
+        corrected_data = data.copy()
+        defaults = ARAconfig().model_dump()
+
+        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:
+                corrected_data[field_name] = defaults.get(field_name)
+
+        print("--- End of Error Report ---")
+
+        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):
-    with open(filepath, "w") as file:
-        json.dump(config.dict(), file, indent=4)
+    """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
@@ -121,12 +266,13 @@ class ConfigManager:
     _config_instance = None
 
     @classmethod
-    def get_config(cls, filepath=DEFAULT_CONFIG_LOCATION):
+    def get_config(cls, filepath=DEFAULT_CONFIG_LOCATION) -> ARAconfig:
         if cls._config_instance is None:
-            config_dir = dirname(filepath)
-
-            if not exists(config_dir):
-                makedirs(config_dir)
-
             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()

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)