ara-cli 0.1.10.1__tar.gz → 0.1.10.5__tar.gz

{ara_cli-0.1.10.1 → ara_cli-0.1.10.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ara_cli
-Version: 0.1.10.1
+Version: 0.1.10.5
 Summary: Powerful, open source command-line tool for managing, structuring and automating software development artifacts in line with Business-Driven Development (BDD) and AI-assisted processes
 Description-Content-Type: text/markdown
 Requires-Dist: langfuse

{ara_cli-0.1.10.1 → ara_cli-0.1.10.5}/ara_cli/__main__.py

@@ -1,5 +1,6 @@
 import typer
 import sys
+import os
 from typing import Optional
 from os import getenv
 from ara_cli.error_handler import AraError
@@ -44,6 +45,113 @@ def configure_debug_mode(debug: bool, env_debug_mode: bool):
         error_handler.debug_mode = True
 
 
+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
+    while check_dir != os.path.dirname(check_dir):  # Stop at filesystem root
+        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
+
+
+def check_ara_directory_exists():
+    """Check if ara directory exists or if we're inside ara directory tree."""
+    return find_ara_directory_root() is not None
+
+
+def prompt_create_ara_directory():
+    """Prompt user to create ara directory and create it if confirmed."""
+    # Print the prompt message
+    print("No 'ara' directory found. Create one in the current directory? (Y/n)", end=" ", flush=True)
+    
+    # Read user input
+    try:
+        response = input().strip()
+    except (EOFError, KeyboardInterrupt):
+        typer.echo("\nOperation cancelled.")
+        raise typer.Exit(1)
+    
+    if response.lower() in ('y', 'yes', ''):
+        current_dir = os.getcwd()
+        ara_path = os.path.join(current_dir, 'ara')
+        
+        # Create ara directory structure
+        subdirectories = [
+            'businessgoals',
+            'capabilities', 
+            'epics',
+            'examples',
+            'features',
+            'keyfeatures',
+            'tasks',
+            'userstories',
+            'vision'
+        ]
+        
+        try:
+            # Create main ara directory
+            os.makedirs(ara_path, exist_ok=True)
+            
+            # Create subdirectories for artefact types
+            for subdir in subdirectories:
+                os.makedirs(os.path.join(ara_path, subdir), exist_ok=True)
+            
+            # Create .araconfig directory
+            araconfig_path = os.path.join(ara_path, '.araconfig')
+            os.makedirs(araconfig_path, exist_ok=True)
+            
+            # Create default ara_config.json using ConfigManager
+            from ara_cli.ara_config import ConfigManager, ARAconfig
+            config_file_path = os.path.join(araconfig_path, 'ara_config.json')
+            
+            # Reset ConfigManager to ensure clean state
+            ConfigManager.reset()
+            
+            # Create default config and save it
+            default_config = ARAconfig()
+            from ara_cli.ara_config import save_data
+            save_data(config_file_path, default_config)
+            
+            typer.echo(f"Created ara directory structure at {ara_path}")
+            typer.echo(f"Created default configuration at {config_file_path}")
+            return True
+            
+        except OSError as e:
+            typer.echo(f"Error creating ara directory: {e}", err=True)
+            raise typer.Exit(1)
+        except Exception as e:
+            typer.echo(f"Error creating configuration file: {e}", err=True)
+            raise typer.Exit(1)
+    else:
+        typer.echo("Ara directory creation cancelled.")
+        raise typer.Exit(0)
+
+
+def requires_ara_directory():
+    """Check if ara directory exists and prompt to create if not."""
+    if not check_ara_directory_exists():
+        return prompt_create_ara_directory()
+    return True
+
+
 def create_app():
     app = typer.Typer(
         help="""The ara cli terminal tool is a management tool for classified ara artefacts.
@@ -124,6 +232,17 @@ ara chat examples:
         if ctx.invoked_subcommand is None:
             ctx.get_help()
             ctx.exit()
+        
+        # Check for ara directory before executing any command
+        # Skip check for commands that don't require ara directory
+        commands_requiring_ara = {
+            'create', 'delete', 'rename', 'list', 'list-tags', 'prompt', 
+            'read', 'reconnect', 'read-status', 'read-user', 'set-status', 
+            'set-user', 'classifier-directory', 'scan', 'autofix'
+        }
+        
+        if ctx.invoked_subcommand in commands_requiring_ara:
+            requires_ara_directory()
 
     # Register all commands
     register_create_cli(app)
@@ -162,4 +281,4 @@ def cli():
 
 
 if __name__ == "__main__":
-    cli()
+    cli()

{ara_cli-0.1.10.1 → ara_cli-0.1.10.5}/ara_cli/artefact_autofix.py

@@ -487,7 +487,7 @@ def _convert_to_scenario_outline(scenario_lines: list, placeholders: set, indent
 def _create_examples_table(placeholders: set, base_indentation: str) -> list:
     """Create the Examples table for the scenario outline."""
     examples_indentation = base_indentation + "    "
-    table_indentation = examples_indentation + "  "
+    table_indentation = examples_indentation + " "
     
     sorted_placeholders = sorted(placeholders)
     header = "| " + " | ".join(sorted_placeholders) + " |"
@@ -576,6 +576,42 @@ def fix_rule(
     return artefact.serialize()
 
 
+def fix_misplaced_content(file_path: str, artefact_text: str, **kwargs) -> str:
+    """
+    Deterministically fixes content like 'Rule:' or 'Estimate:' misplaced in the description.
+    """
+    lines = artefact_text.splitlines()
+
+    desc_start_idx = -1
+    for i, line in enumerate(lines):
+        if line.strip().startswith("Description:"):
+            desc_start_idx = i
+            break
+
+    if desc_start_idx == -1:
+        return artefact_text  # No description, nothing to fix.
+
+    pre_desc_lines = lines[:desc_start_idx]
+    desc_line = lines[desc_start_idx]
+    post_desc_lines = lines[desc_start_idx+1:]
+
+    misplaced_content = []
+    new_post_desc_lines = []
+
+    for line in post_desc_lines:
+        if line.strip().startswith("Rule:") or line.strip().startswith("Estimate:"):
+            misplaced_content.append(line)
+        else:
+            new_post_desc_lines.append(line)
+
+    if not misplaced_content:
+        return artefact_text
+
+    # Rebuild the file content
+    final_lines = pre_desc_lines + misplaced_content + [""] + [desc_line] + new_post_desc_lines
+    return "\n".join(final_lines)
+
+
 def should_skip_issue(deterministic_issue, deterministic, non_deterministic, file_path) -> bool:
     if not non_deterministic and not deterministic_issue:
         print(f"Skipping non-deterministic fix for {file_path} as per request.")
@@ -622,7 +658,7 @@ def apply_non_deterministic_fix(
             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}")
+            print(f"    ❌ LLM agent failed to fix artefact at {file_path}: {e}")
             return None
     return corrected_text
 
@@ -651,7 +687,7 @@ def attempt_autofix_loop(
         print(
             f"Attempting to fix {file_path} (Attempt {attempt + 1}/{max_attempts})..."
         )
-        print(f"   Reason: {current_reason}")
+        print(f"    Reason: {current_reason}")
 
         artefact_text = read_artefact(file_path)
         if artefact_text is None:
@@ -683,13 +719,13 @@ def attempt_autofix_loop(
 
         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."
+                "    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...")
+        print("    File modified. Re-classifying artefact information for next check...")
         classified_artefact_info = populate_classified_artefact_info(classified_artefact_info, force=True)
 
     print(f"❌ Failed to fix {file_path} after {max_attempts} attempts.")
@@ -713,6 +749,8 @@ def apply_autofix(
         "Invalid Contribution Reference": fix_contribution,
         "Rule Mismatch": fix_rule,
         "Scenario Contains Placeholders": fix_scenario_placeholder_mismatch,
+        "Found 'Rule:' inside description": fix_misplaced_content,
+        "Found 'Estimate:' inside description": fix_misplaced_content,
     }
 
     artefact_type, artefact_class = determine_artefact_type_and_class(classifier)
@@ -731,4 +769,4 @@ def apply_autofix(
         deterministic=deterministic,
         non_deterministic=non_deterministic,
         classified_artefact_info=classified_artefact_info,
-    )
+    )

{ara_cli-0.1.10.1 → ara_cli-0.1.10.5}/ara_cli/artefact_models/artefact_model.py

@@ -410,14 +410,26 @@ class Artefact(BaseModel, ABC):
         return contribution, lines
 
     @classmethod
-    def _deserialize_description(cls, lines) -> (Optional[str], List[str]):
+    def _deserialize_description(cls, lines: List[str]) -> (Optional[str], List[str]):
         description_start = cls._description_starts_with()
+        start_index = -1
         for i, line in enumerate(lines):
             if line.startswith(description_start):
-                description = line[len(description_start):].strip()
-                del lines[i]
-                return description, lines
-        return None, lines
+                start_index = i
+                break
+
+        if start_index == -1:
+            return None, lines
+
+        first_line_content = lines[start_index][len(description_start):].strip()
+
+        description_lines = ([first_line_content] if first_line_content else []) + lines[start_index + 1:]
+
+        description = "\n".join(description_lines)
+
+        remaining_lines = lines[:start_index]
+
+        return (description if description else None), remaining_lines
 
     @classmethod
     def _parse_common_fields(cls, text: str) -> dict:
@@ -499,4 +511,4 @@ class Artefact(BaseModel, ABC):
             classifier=classifier,
             rule=rule
         )
-        self.contribution = contribution
+        self.contribution = contribution

{ara_cli-0.1.10.1 → ara_cli-0.1.10.5}/ara_cli/artefact_models/artefact_templates.py

@@ -204,7 +204,8 @@ def _default_feature(title: str, use_default_contribution: bool) -> FeatureArtef
 
 def _default_task(title: str, use_default_contribution: bool) -> TaskArtefact:
     return TaskArtefact(
-        status="to-do",
+        tags=[],
+        status=None,
         title=title,
         description="<further optional description to understand the task, no format defined>",
         contribution=default_contribution() if use_default_contribution else None

{ara_cli-0.1.10.1 → ara_cli-0.1.10.5}/ara_cli/artefact_models/epic_artefact_model.py

@@ -1,5 +1,5 @@
 from ara_cli.artefact_models.artefact_model import Artefact, ArtefactType, Intent
-from pydantic import Field, field_validator
+from pydantic import Field, field_validator, model_validator
 from typing import List, Tuple, Optional
 
 
@@ -91,6 +91,15 @@ class EpicArtefact(Artefact):
         description="Rules the epic defines. It is recommended to create rules to clarify the desired outcome"
     )
 
+    @model_validator(mode='after')
+    def check_for_misplaced_rules(self) -> 'EpicArtefact':
+        if self.description:
+            desc_lines = self.description.split('\n')
+            for line in desc_lines:
+                if line.strip().startswith("Rule:"):
+                    raise ValueError("Found 'Rule:' inside description. Rules must be defined before the 'Description:' section.")
+        return self
+
     @field_validator('artefact_type')
     def validate_artefact_type(cls, v):
         if v != ArtefactType.epic:
@@ -166,4 +175,4 @@ class EpicArtefact(Artefact):
             lines.append("")
         lines.append(description)
         lines.append("")
-        return "\n".join(lines)
+        return "\n".join(lines)

{ara_cli-0.1.10.1 → ara_cli-0.1.10.5}/ara_cli/artefact_models/feature_artefact_model.py

@@ -301,6 +301,36 @@ class FeatureArtefact(Artefact):
                 f"FeatureArtefact must have artefact_type of '{ArtefactType.feature}', not '{v}'")
         return v
 
+    @classmethod
+    def _deserialize_description(cls, lines: List[str]) -> (Optional[str], List[str]):
+        description_start = cls._description_starts_with()
+        scenario_markers = ["Scenario:", "Scenario Outline:"]
+
+        start_index = -1
+        for i, line in enumerate(lines):
+            if line.startswith(description_start):
+                start_index = i
+                break
+
+        if start_index == -1:
+            return None, lines
+
+        end_index = len(lines)
+        for i in range(start_index + 1, len(lines)):
+            if any(lines[i].startswith(marker) for marker in scenario_markers):
+                end_index = i
+                break
+
+        first_line_content = lines[start_index][len(description_start):].strip()
+
+        description_lines_list = [first_line_content] if first_line_content else []
+        description_lines_list.extend(lines[start_index+1:end_index])
+
+        description = "\n".join(description_lines_list).strip() or None
+
+        remaining_lines = lines[:start_index] + lines[end_index:]
+
+        return description, remaining_lines
 
     @classmethod
     def _title_prefix(cls) -> str:
@@ -519,4 +549,4 @@ class FeatureArtefact(Artefact):
                     # or the placeholder is at the end of a line (e.g., "Then I see... __PLACEHOLDER__").
                     step = step.replace(key, value)
             rehydrated_steps.append(step)
-        return rehydrated_steps
+        return rehydrated_steps

{ara_cli-0.1.10.1 → ara_cli-0.1.10.5}/ara_cli/artefact_models/userstory_artefact_model.py

@@ -1,5 +1,5 @@
 from ara_cli.artefact_models.artefact_model import Artefact, ArtefactType, Intent
-from pydantic import Field, field_validator
+from pydantic import Field, field_validator, model_validator
 from typing import List, Tuple
 
 
@@ -92,6 +92,18 @@ class UserstoryArtefact(Artefact):
         default_factory=list,
         description="Rules the userstory defines. It is recommended to create rules to clarify the desired outcome")
 
+    @model_validator(mode='after')
+    def check_for_misplaced_content(self) -> 'UserstoryArtefact':
+        if self.description:
+            desc_lines = self.description.split('\n')
+            for line in desc_lines:
+                stripped_line = line.strip()
+                if stripped_line.startswith("Rule:"):
+                    raise ValueError("Found 'Rule:' inside description. Rules must be defined before the 'Description:' section.")
+                if stripped_line.startswith("Estimate:"):
+                    raise ValueError("Found 'Estimate:' inside description. Estimate must be defined before the 'Description:' section.")
+        return self
+
     @field_validator('artefact_type')
     def validate_artefact_type(cls, v):
         if v != ArtefactType.userstory:

{ara_cli-0.1.10.1 → ara_cli-0.1.10.5}/ara_cli/chat.py

@@ -13,25 +13,6 @@ from ara_cli.file_loaders.binary_file_loader import BinaryFileLoader
 from ara_cli.file_loaders.text_file_loader import TextFileLoader
 
 
-extract_parser = argparse.ArgumentParser()
-extract_parser.add_argument(
-    "-f", "--force", action="store_true", help="Force extraction"
-)
-extract_parser.add_argument(
-    "-w",
-    "--write",
-    action="store_true",
-    help="Overwrite existing files without using LLM for merging.",
-)
-
-load_parser = argparse.ArgumentParser()
-load_parser.add_argument("file_name", nargs="?", default="", help="File to load")
-load_parser.add_argument(
-    "--load-images",
-    action="store_true",
-    help="Extract and describe images from documents",
-)
-
 extract_parser = argparse.ArgumentParser()
 extract_parser.add_argument(
     "-f", "--force", action="store_true", help="Force extraction"

{ara_cli-0.1.10.1 → ara_cli-0.1.10.5}/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-0.1.10.1 → ara_cli-0.1.10.5}/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)