ara-cli 0.1.9.74__py3-none-any.whl → 0.1.9.75__py3-none-any.whl

ara_cli/ara_config.py

@@ -1,33 +1,43 @@
-from typing import List, Dict, Optional
-from pydantic import BaseModel
+from typing import List, Dict, Optional, Any
+from pydantic import BaseModel, ValidationError, Field, field_validator, model_validator
 import json
 import os
 from os.path import exists, dirname
 from os import makedirs
 from functools import lru_cache
-
+import sys
 
 DEFAULT_CONFIG_LOCATION = "./ara/.araconfig/ara_config.json"
 
-
 class LLMConfigItem(BaseModel):
     provider: str
     model: str
-    temperature: float
+    temperature: float = Field(ge=0.0, le=1.0)
     max_tokens: Optional[int] = None
+    
+    @field_validator('temperature')
+    @classmethod
+    def validate_temperature(cls, v: float, info) -> float:
+        if not 0.0 <= v <= 1.0:
+            print(f"Warning: Temperature is outside the 0.0 to 1.0 range")
+            # Return a valid default
+            return 0.8
+        return v
 
+class ExtCodeDirItem(BaseModel):
+    source_dir: str
 
 class ARAconfig(BaseModel):
-    ext_code_dirs: List[Dict[str, str]] = [
-        {"source_dir_1": "./src"},
-        {"source_dir_2": "./tests"},
-    ]
+    ext_code_dirs: List[ExtCodeDirItem] = Field(default_factory=lambda: [
+        ExtCodeDirItem(source_dir="./src"),
+        ExtCodeDirItem(source_dir="./tests")
+    ])
     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] = [
+    ara_prompt_given_list_includes: List[str] = Field(default_factory=lambda: [
         "*.businessgoal",
         "*.vision",
         "*.capability",
@@ -42,53 +52,76 @@ class ARAconfig(BaseModel):
         "*.png",
         "*.jpg",
         "*.jpeg",
-    ]
-    llm_config: Dict[str, LLMConfigItem] = {
-        "gpt-4o": {
-            "provider": "openai",
-            "model": "openai/gpt-4o",
-            "temperature": 0.8,
-            "max_tokens": 16384
-        },
-        "gpt-4.1": {
-            "provider": "openai",
-            "model": "openai/gpt-4.1",
-            "temperature": 0.8,
-            "max_tokens": 1024
-        },
-        "o3-mini": {
-            "provider": "openai",
-            "model": "openai/o3-mini",
-            "temperature": 1.0,
-            "max_tokens": 1024
-        },
-        "opus-4": {
-            "provider": "anthropic",
-            "model": "anthropic/claude-opus-4-20250514",
-            "temperature": 0.8,
-            "max_tokens": 32000
-        },
-        "sonnet-4": {
-            "provider": "anthropic",
-            "model": "anthropic/claude-sonnet-4-20250514",
-            "temperature": 0.8,
-            "max_tokens": 1024
-        },
-        "together-ai-llama-2": {
-            "provider": "together_ai",
-            "model": "together_ai/togethercomputer/llama-2-70b",
-            "temperature": 0.8,
-            "max_tokens": 1024
-        },
-        "groq-llama-3": {
-            "provider": "groq",
-            "model": "groq/llama3-70b-8192",
-            "temperature": 0.8,
-            "max_tokens": 1024
-        }
-    }
+    ])
+    llm_config: Dict[str, LLMConfigItem] = Field(default_factory=lambda: {
+        "gpt-4o": LLMConfigItem(
+            provider="openai",
+            model="openai/gpt-4o",
+            temperature=0.8,
+            max_tokens=16384
+        ),
+        "gpt-4.1": LLMConfigItem(
+            provider="openai",
+            model="openai/gpt-4.1",
+            temperature=0.8,
+            max_tokens=1024
+        ),
+        "o3-mini": LLMConfigItem(
+            provider="openai",
+            model="openai/o3-mini",
+            temperature=1.0,
+            max_tokens=1024
+        ),
+        "opus-4": LLMConfigItem(
+            provider="anthropic",
+            model="anthropic/claude-opus-4-20250514",
+            temperature=0.8,
+            max_tokens=32000
+        ),
+        "sonnet-4": LLMConfigItem(
+            provider="anthropic",
+            model="anthropic/claude-sonnet-4-20250514",
+            temperature=0.8,
+            max_tokens=1024
+        ),
+        "together-ai-llama-2": LLMConfigItem(
+            provider="together_ai",
+            model="together_ai/togethercomputer/llama-2-70b",
+            temperature=0.8,
+            max_tokens=1024
+        ),
+        "groq-llama-3": LLMConfigItem(
+            provider="groq",
+            model="groq/llama3-70b-8192",
+            temperature=0.8,
+            max_tokens=1024
+        )
+    })
     default_llm: Optional[str] = "gpt-4o"
+    
+    model_config = {
+        "extra": "forbid"  # This will help identify unrecognized keys
+    }
 
+    @model_validator(mode='after')
+    def check_critical_fields(self) -> 'ARAconfig':
+        """Check for empty critical fields and use defaults if needed"""
+        critical_fields = {
+            'ext_code_dirs': [ExtCodeDirItem(source_dir="./src"), ExtCodeDirItem(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 or 
+                (isinstance(current_value, list) and len(current_value) == 0) or
+                (isinstance(current_value, str) and current_value.strip() == "")):
+                print(f"Warning: Value for '{field}' is missing or empty.")
+                setattr(self, field, default_value)
+        
+        return self
 
 # Function to ensure the necessary directories exist
 @lru_cache(maxsize=None)
@@ -98,37 +131,106 @@ def ensure_directory_exists(directory: str):
         print(f"New directory created at {directory}")
     return directory
 
-
-def validate_config_data(filepath: str):
-    with open(filepath, "r", encoding="utf-8") as file:
-        data = json.load(file)
+def handle_unrecognized_keys(data: dict, known_fields: set) -> dict:
+    """Remove unrecognized keys and warn the user"""
+    cleaned_data = {}
+    for key, value in data.items():
+        if key not in known_fields:
+            print(f"Warning: {key} is not recognized as a valid configuration option.")
+        else:
+            cleaned_data[key] = value
+    return cleaned_data
+
+def fix_llm_temperatures(data: dict) -> dict:
+    """Fix invalid temperatures in LLM configurations"""
+    if 'llm_config' in data:
+        for model_key, model_config in data['llm_config'].items():
+            if isinstance(model_config, dict) and 'temperature' in model_config:
+                temp = model_config['temperature']
+                if not 0.0 <= temp <= 1.0:
+                    print(f"Warning: Temperature for model '{model_key}' is outside the 0.0 to 1.0 range")
+                    model_config['temperature'] = 0.8
     return data
 
+def validate_and_fix_config_data(filepath: str) -> dict:
+    """Load, validate, and fix configuration data"""
+    try:
+        with open(filepath, "r", encoding="utf-8") as file:
+            data = json.load(file)
+        
+        # Get known fields from the ARAconfig model
+        known_fields = set(ARAconfig.model_fields.keys())
+        
+        # Handle unrecognized keys
+        data = handle_unrecognized_keys(data, known_fields)
+        
+        # Fix LLM temperatures before validation
+        data = fix_llm_temperatures(data)
+        
+        return data
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON in configuration file: {e}")
+        print("Creating new configuration with defaults...")
+        return {}
+    except Exception as e:
+        print(f"Error reading configuration file: {e}")
+        return {}
 
 # Function to read the JSON file and return an ARAconfig model
 @lru_cache(maxsize=1)
 def read_data(filepath: str) -> ARAconfig:
+    # Ensure the directory for the config file exists
+    config_dir = dirname(filepath)
+    ensure_directory_exists(config_dir)
+
     if not exists(filepath):
-        # If file does not exist, create it with default values
+        # If the file does not exist, create it with default values
         default_config = ARAconfig()
-
-        with open(filepath, "w", encoding="utf-8") as file:
-            json.dump(default_config.model_dump(mode='json'), file, indent=4)
-
+        save_data(filepath, default_config)
         print(
-            f"ara-cli configuration file '{filepath}' created with default configuration. Please modify it as needed and re-run your command"
+            f"ara-cli configuration file '{filepath}' created with default configuration."
+            f" Please modify it as needed and re-run your command"
         )
-        exit()  # Exit the application
-
-    data = validate_config_data(filepath)
-    return ARAconfig(**data)
-
+        sys.exit(0)  # Exit the application
+
+    # Validate and load the existing configuration
+    data = validate_and_fix_config_data(filepath)
+    
+    try:
+        # Try to create the config with the loaded data
+        config = ARAconfig(**data)
+        
+        # Save the potentially fixed configuration back
+        save_data(filepath, config)
+        
+        return config
+    except ValidationError as e:
+        print(f"ValidationError: {e}")
+        print("Correcting configuration with default values...")
+        
+        # Create a default config
+        default_config = ARAconfig()
+        
+        # Try to preserve valid fields from the original data
+        for field_name, field_value in data.items():
+            if field_name in ARAconfig.model_fields:
+                try:
+                    # Attempt to set the field value
+                    setattr(default_config, field_name, field_value)
+                except:
+                    # If it fails, keep the default
+                    pass
+        
+        # Save the corrected configuration
+        save_data(filepath, default_config)
+        print("Fixed configuration saved to file.")
+        
+        return default_config
 
 # Function to save the modified configuration back to the JSON file
 def save_data(filepath: str, config: ARAconfig):
     with open(filepath, "w", encoding="utf-8") as file:
-        json.dump(config.model_dump(mode='json'), file, indent=4)
-
+        json.dump(config.model_dump(), file, indent=4)
 
 # Singleton for configuration management
 class ConfigManager:
@@ -143,4 +245,10 @@ class ConfigManager:
                 makedirs(config_dir)
 
             cls._config_instance = read_data(filepath)
-        return cls._config_instance
+        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/artefact_autofix.py

@@ -30,36 +30,45 @@ def parse_report(content: str) -> Dict[str, List[Tuple[str, str]]]:
     Parses the incompatible artefacts report and returns structured data.
     Returns a dictionary where keys are artefact classifiers, and values are lists of (file_path, reason) tuples.
     """
+    def is_valid_report(lines: List[str]) -> bool:
+        return bool(lines) and lines[0] == "# Artefact Check Report"
+
+    def has_no_problems(lines: List[str]) -> bool:
+        return len(lines) >= 3 and lines[2] == "No problems found."
+
+    def parse_classifier(line: str) -> Optional[str]:
+        if line.startswith("## "):
+            return line[3:].strip()
+        return None
+
+    def parse_issue(line: str) -> Optional[Tuple[str, str]]:
+        if not line.startswith("- "):
+            return None
+        parts = line.split("`", 2)
+        if len(parts) < 3:
+            return None
+        file_path = parts[1]
+        reason = parts[2].split(":", 1)[1].strip() if ":" in parts[2] else ""
+        return file_path, reason
+
     lines = content.splitlines()
+    if not is_valid_report(lines) or has_no_problems(lines):
+        return {}
+
     issues = {}
     current_classifier = None
 
-    if not lines or lines[0] != "# Artefact Check Report":
-        return issues
-        return issues
-
-    if len(lines) >= 3 and lines[2] == "No problems found.":
-        return issues
-        return issues
-
-    for line in lines[1:]:
-        line = line.strip()
+    for line in map(str.strip, lines[1:]):
         if not line:
             continue
-
-        if line.startswith("## "):
-            current_classifier = line[3:].strip()
+        classifier = parse_classifier(line)
+        if classifier is not None:
+            current_classifier = classifier
             issues[current_classifier] = []
-
-        elif line.startswith("- ") and current_classifier is not None:
-            parts = line.split("`", 2)
-            if len(parts) < 3:
-                continue
-
-            file_path = parts[1]
-            reason = parts[2].split(":", 1)[1].strip() if ":" in parts[2] else ""
-            issues[current_classifier].append((file_path, reason))
-
+            continue
+        issue = parse_issue(line)
+        if issue and current_classifier is not None:
+            issues[current_classifier].append(issue)
     return issues
 
 
@@ -391,19 +400,69 @@ def apply_autofix(
     Applies fixes to a single artefact file iteratively until it is valid
     or a fix cannot be applied. If single_pass is True, it runs for only one attempt.
     """
+    deterministic_markers_to_functions = {
+        "Filename-Title Mismatch": fix_title_mismatch,
+        "Invalid Contribution Reference": fix_contribution,
+    }
+
+    def populate_classified_artefact_info(force: bool = False):
+        nonlocal classified_artefact_info
+        if force or classified_artefact_info is None:
+            file_classifier = FileClassifier(os)
+            classified_artefact_info = file_classifier.classify_files()
+
+    def determine_attempt_count() -> int:
+        nonlocal single_pass, file_path
+        if single_pass:
+            print(f"Single-pass mode enabled for {file_path}. Running for 1 attempt.")
+            return 1
+        return 3
+
+    def apply_deterministic_fix() -> str:
+        nonlocal deterministic, deterministic_issue, corrected_text, file_path, artefact_text, artefact_class, classified_artefact_info
+        if deterministic and deterministic_issue:
+            print(f"Applying deterministic fix for '{deterministic_issue}'...")
+            fix_function = deterministic_markers_to_functions[deterministic_issue]
+            return fix_function(
+                file_path=file_path,
+                artefact_text=artefact_text,
+                artefact_class=artefact_class,
+                classified_artefact_info=classified_artefact_info,
+            )
+        return corrected_text
+
+    def apply_non_deterministic_fix() -> Optional[str]:
+        """
+        Applies LLM fix. Return None in case of an exception
+        """
+        nonlocal non_deterministic, deterministic_issue, corrected_text, artefact_type, current_reason, file_path, artefact_text
+        if non_deterministic and not deterministic_issue:
+            print("Applying non-deterministic (LLM) fix...")
+            prompt = construct_prompt(artefact_type, current_reason, file_path, artefact_text)
+            try:
+                corrected_artefact = run_agent(prompt, artefact_class)
+                corrected_text = corrected_artefact.serialize()
+            except Exception as e:
+                print(f"   ❌ LLM agent failed to fix artefact at {file_path}: {e}")
+                return None
+        return corrected_text
+
+    def should_skip() -> bool:
+        nonlocal deterministic_issue, deterministic, non_deterministic
+        if not non_deterministic and not deterministic_issue:
+            print(f"Skipping non-deterministic fix for {file_path} as per request.")
+            return True
+        if not deterministic and deterministic_issue:
+            print(f"Skipping fix for {file_path} as per request flags.")
+            return True
+        return False
+
     artefact_type, artefact_class = determine_artefact_type_and_class(classifier)
     if artefact_type is None or artefact_class is None:
         return False
 
-    if classified_artefact_info is None:
-        file_classifier = FileClassifier(os)
-        classified_artefact_info = file_classifier.classify_files()
-
-    if single_pass:
-        max_attempts = 1
-        print(f"Single-pass mode enabled for {file_path}. Running for 1 attempt.")
-    else:
-        max_attempts = 3
+    populate_classified_artefact_info()
+    max_attempts = determine_attempt_count()
 
     for attempt in range(max_attempts):
         is_valid, current_reason = check_file(file_path, artefact_class, classified_artefact_info)
@@ -411,7 +470,7 @@ def apply_autofix(
         if is_valid:
             print(f"✅ Artefact at {file_path} is now valid.")
             return True
-        
+
         print(f"Attempting to fix {file_path} (Attempt {attempt + 1}/{max_attempts})...")
         print(f"   Reason: {current_reason}")
 
@@ -419,11 +478,6 @@ def apply_autofix(
         if artefact_text is None:
             return False
 
-        deterministic_markers_to_functions = {
-            "Filename-Title Mismatch": fix_title_mismatch,
-            "Invalid Contribution Reference": fix_contribution,
-        }
-
         deterministic_issue = next(
             (
                 marker
@@ -433,45 +487,22 @@ def apply_autofix(
             None,
         )
 
-        corrected_text = None
-
-        if deterministic and deterministic_issue:
-            print(f"Applying deterministic fix for '{deterministic_issue}'...")
-            fix_function = deterministic_markers_to_functions[deterministic_issue]
-            corrected_text = fix_function(
-                file_path=file_path,
-                artefact_text=artefact_text,
-                artefact_class=artefact_class,
-                classified_artefact_info=classified_artefact_info,
-            )
-
-        elif non_deterministic and not deterministic_issue:
-            print("Applying non-deterministic (LLM) fix...")
-            prompt = construct_prompt(artefact_type, current_reason, file_path, artefact_text)
-            try:
-                corrected_artefact = run_agent(prompt, artefact_class)
-                corrected_text = corrected_artefact.serialize()
-            except Exception as e:
-                print(f"   ❌ LLM agent failed to fix artefact at {file_path}: {e}")
-                return False
-        
-        else:
-            if not non_deterministic and not deterministic_issue:
-                print(f"Skipping non-deterministic fix for {file_path} as per request.")
-            else:
-                print(f"Skipping fix for {file_path} as per request flags.")
+        if should_skip():
             return False
 
-        if corrected_text is not None and corrected_text.strip() != artefact_text.strip():
-            write_corrected_artefact(file_path, corrected_text)
+        corrected_text = None
 
-            print("   File modified. Re-classifying artefact information for next check...")
-            file_classifier = FileClassifier(os)
-            classified_artefact_info = file_classifier.classify_files()
+        corrected_text = apply_deterministic_fix()
+        corrected_text = apply_non_deterministic_fix()
 
-        else:
+        if corrected_text is None or corrected_text.strip() == artefact_text.strip():
             print("   Fixing attempt did not alter the file. Stopping to prevent infinite loop.")
             return False
 
+        write_corrected_artefact(file_path, corrected_text)
+
+        print("   File modified. Re-classifying artefact information for next check...")
+        populate_classified_artefact_info(force=True)
+
     print(f"❌ Failed to fix {file_path} after {max_attempts} attempts.")
-    return False
+    return False

ara_cli/artefact_models/businessgoal_artefact_model.py

@@ -38,7 +38,7 @@ class BusinessgoalIntent(Intent):
         lines = []
 
         as_a_line = as_a_serializer(self.as_a)
-        
+
         lines.append(f"In order to {self.in_order_to}")
         lines.append(as_a_line)
         lines.append(f"I want {self.i_want}")
@@ -47,39 +47,37 @@ class BusinessgoalIntent(Intent):
 
     @classmethod
     def deserialize_from_lines(cls, lines: List[str], start_index: int = 0) -> 'BusinessgoalIntent':
-        in_order_to = None
-        as_a = None
-        i_want = None
-
-        in_order_to_prefix = "In order to "
-        as_a_prefix = "As a "
-        as_a_prefix_alt = "As an "
-        i_want_prefix = "I want "
+        prefixes = [
+            ("In order to ", "in_order_to"),
+            ("As a ", "as_a"),
+            ("As an ", "as_a"),
+            ("I want ", "i_want"),
+        ]
+        found = {"in_order_to": None, "as_a": None, "i_want": None}
+
+        def match_and_store(line):
+            for prefix, field in prefixes:
+                if line.startswith(prefix) and found[field] is None:
+                    found[field] = line[len(prefix):].strip()
+                    return True
+            return False
 
         index = start_index
-        while index < len(lines) and (not in_order_to or not as_a or not i_want):
-            line = lines[index]
-            if line.startswith(in_order_to_prefix) and not in_order_to:
-                in_order_to = line[len(in_order_to_prefix):].strip()
-            elif line.startswith(as_a_prefix) and not as_a:
-                as_a = line[len(as_a_prefix):].strip()
-            elif line.startswith(as_a_prefix_alt) and not as_a:
-                as_a = line[len(as_a_prefix_alt):].strip()
-            elif line.startswith(i_want_prefix) and not i_want:
-                i_want = line[len(i_want_prefix):].strip()
+        while index < len(lines) and any(v is None for v in found.values()):
+            match_and_store(lines[index])
             index += 1
 
-        if not in_order_to:
+        if not found["in_order_to"]:
             raise ValueError("Could not find 'In order to' line")
-        if not as_a:
+        if not found["as_a"]:
             raise ValueError("Could not find 'As a' line")
-        if not i_want:
+        if not found["i_want"]:
             raise ValueError("Could not find 'I want' line")
 
         return cls(
-            in_order_to=in_order_to,
-            as_a=as_a,
-            i_want=i_want
+            in_order_to=found["in_order_to"],
+            as_a=found["as_a"],
+            i_want=found["i_want"]
         )
 
 

ara_cli/artefact_models/epic_artefact_model.py

@@ -48,39 +48,38 @@ class EpicIntent(Intent):
 
     @classmethod
     def deserialize_from_lines(cls, lines: List[str], start_index: int = 0) -> 'EpicIntent':
-        in_order_to = None
-        as_a = None
-        i_want = None
-
-        in_order_to_prefix = "In order to "
-        as_a_prefix = "As a "
-        as_a_prefix_alt = "As an "
-        i_want_prefix = "I want "
+        prefixes = [
+            ("In order to ", "in_order_to"),
+            ("As a ", "as_a"),
+            ("As an ", "as_a"),
+            ("I want ", "i_want"),
+        ]
+
+        found = {"in_order_to": None, "as_a": None, "i_want": None}
+
+        def match_and_store(line):
+            for prefix, field in prefixes:
+                if line.startswith(prefix) and found[field] is None:
+                    found[field] = line[len(prefix):].strip()
+                    return True
+            return False
 
         index = start_index
-        while index < len(lines) and (not in_order_to or not as_a or not i_want):
-            line = lines[index]
-            if line.startswith(in_order_to_prefix) and not in_order_to:
-                in_order_to = line[len(in_order_to_prefix):].strip()
-            elif line.startswith(as_a_prefix) and not as_a:
-                as_a = line[len(as_a_prefix):].strip()
-            elif line.startswith(as_a_prefix_alt) and not as_a:
-                as_a = line[len(as_a_prefix_alt):].strip()
-            elif line.startswith(i_want_prefix) and not i_want:
-                i_want = line[len(i_want_prefix):].strip()
+        while index < len(lines) and any(v is None for v in found.values()):
+            match_and_store(lines[index])
             index += 1
 
-        if not in_order_to:
+        if not found["in_order_to"]:
             raise ValueError("Could not find 'In order to' line")
-        if not as_a:
+        if not found["as_a"]:
             raise ValueError("Could not find 'As a' line")
-        if not i_want:
+        if not found["i_want"]:
             raise ValueError("Could not find 'I want' line")
 
         return cls(
-            in_order_to=in_order_to,
-            as_a=as_a,
-            i_want=i_want
+            in_order_to=found["in_order_to"],
+            as_a=found["as_a"],
+            i_want=found["i_want"]
         )