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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ara_cli
-Version: 0.1.10.4
+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.4 → 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.4 → 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)

{ara_cli-0.1.10.4 → ara_cli-0.1.10.5}/ara_cli/prompt_extractor.py

@@ -8,6 +8,7 @@ from ara_cli.classifier import Classifier
 from ara_cli.directory_navigator import DirectoryNavigator
 from ara_cli.artefact_models.artefact_mapping import title_prefix_to_artefact_class
 
+
 def _find_extract_token(tokens):
     """Find the first token that needs to be processed."""
     for token in tokens:
@@ -15,6 +16,7 @@ def _find_extract_token(tokens):
             return token
     return None
 
+
 def _extract_file_path(content_lines):
     """Extract file path from content lines."""
     if not content_lines:
@@ -22,6 +24,7 @@ def _extract_file_path(content_lines):
     file_path_search = re.search(r"# filename: (.+)", content_lines[0])
     return file_path_search.group(1).strip() if file_path_search else None
 
+
 def _find_artefact_class(content_lines):
     """Find the appropriate artefact class from content lines."""
     for line in content_lines[:2]:
@@ -33,11 +36,13 @@ def _find_artefact_class(content_lines):
             return title_prefix_to_artefact_class[first_word]
     return None
 
+
 def _process_file_extraction(file_path, code_content, force, write):
     """Process file extraction logic."""
     print(f"Filename extracted: {file_path}")
     handle_existing_file(file_path, code_content, force, write)
 
+
 def _process_artefact_extraction(artefact_class, content_lines, force, write):
     """Process artefact extraction logic."""
     artefact = artefact_class.deserialize('\n'.join(content_lines))
@@ -54,14 +59,13 @@ def _process_artefact_extraction(artefact_class, content_lines, force, write):
 
     os.chdir(original_directory)
 
-def _process_extraction_block(token_to_process, updated_content, force, write):
-    """Process a single extraction block."""
-    # Get the original block text for later replacement
-    source_lines = updated_content.split('\n')
-    start_line, end_line = token_to_process.map
-    original_block_text = '\n'.join(source_lines[start_line:end_line])
 
-    block_content = token_to_process.content
+def _perform_extraction_for_block(source_lines, block_start, block_end, force, write):
+    """Helper function to process a single, identified block."""
+    original_block_text = '\n'.join(source_lines[block_start:block_end + 1])
+    block_content_lines = source_lines[block_start + 1:block_end]
+    block_content = '\n'.join(block_content_lines)
+
     block_lines = block_content.split('\n')
     content_lines_after_extract = block_lines[1:]
 
@@ -76,49 +80,129 @@ def _process_extraction_block(token_to_process, updated_content, force, write):
             _process_artefact_extraction(artefact_class, content_lines_after_extract, force, write)
         else:
             print("No filename or valid artefact found, skipping processing for this block.")
+            return None, None
 
-    # Update the main content by replacing the processed block text with a modified version
     modified_block_text = original_block_text.replace("# [x] extract", "# [v] extract", 1)
-    return updated_content.replace(original_block_text, modified_block_text, 1)
+    return original_block_text, modified_block_text
+
+
+class FenceDetector:
+    """Helper class to detect and match fence blocks."""
+    
+    def __init__(self, source_lines):
+        self.source_lines = source_lines
+    
+    def is_extract_fence(self, line_num):
+        """Check if line is a fence with extract marker."""
+        line = self.source_lines[line_num]
+        stripped_line = line.strip()
+        
+        is_fence = stripped_line.startswith('```') or stripped_line.startswith('~~~')
+        if not is_fence:
+            return False
+            
+        if not (line_num + 1 < len(self.source_lines)):
+            return False
+            
+        return self.source_lines[line_num + 1].strip().startswith("# [x] extract")
+    
+    def find_matching_fence_end(self, start_line):
+        """Find the matching end fence for a given start fence."""
+        fence_line = self.source_lines[start_line]
+        indentation = len(fence_line) - len(fence_line.lstrip())
+        stripped_fence_line = fence_line.strip()
+        fence_char = stripped_fence_line[0]
+        fence_length = len(stripped_fence_line) - len(stripped_fence_line.lstrip(fence_char))
+
+        for i in range(start_line + 1, len(self.source_lines)):
+            scan_line = self.source_lines[i]
+            stripped_scan_line = scan_line.strip()
+
+            if not stripped_scan_line or stripped_scan_line[0] != fence_char:
+                continue
+            
+            if not all(c == fence_char for c in stripped_scan_line):
+                continue
+
+            candidate_indentation = len(scan_line) - len(scan_line.lstrip())
+            candidate_length = len(stripped_scan_line)
+            
+            if candidate_length == fence_length and candidate_indentation == indentation:
+                return i
+        
+        return -1
+
+
+def _process_document_blocks(source_lines, force, write):
+    """Process all extract blocks in the document."""
+    fence_detector = FenceDetector(source_lines)
+    replacements = []
+    line_num = 0
+    
+    while line_num < len(source_lines):
+        if not fence_detector.is_extract_fence(line_num):
+            line_num += 1
+            continue
 
-def extract_responses(document_path, relative_to_ara_root=False, force=False, write=False):
-    print(f"Starting extraction from '{document_path}'")
-    block_extraction_counter = 0
+        block_start_line = line_num
+        block_end_line = fence_detector.find_matching_fence_end(block_start_line)
+        
+        if block_end_line != -1:
+            print(f"Block found and processed starting on line {block_start_line + 1}.")
+            original, modified = _perform_extraction_for_block(
+                source_lines, block_start_line, block_end_line, force, write
+            )
+            if original and modified:
+                replacements.append((original, modified))
+            line_num = block_end_line + 1
+        else:
+            line_num += 1
+    
+    return replacements
+
+
+def _apply_replacements(content, replacements):
+    """Apply all replacements to the content."""
+    updated_content = content
+    for original, modified in replacements:
+        updated_content = updated_content.replace(original, modified, 1)
+    return updated_content
 
-    try:
-        with open(document_path, 'r', encoding='utf-8', errors='replace') as file:
-            content = file.read()
-    except FileNotFoundError:
-        print(f"Error: File not found at '{document_path}'. Skipping extraction.")
-        return
 
+def _setup_working_directory(relative_to_ara_root):
+    """Setup working directory and return original cwd."""
     cwd = os.getcwd()
     if relative_to_ara_root:
         navigator = DirectoryNavigator()
         navigator.navigate_to_target()
         os.chdir('..')
+    return cwd
 
-    updated_content = content
-
-    while True:
-        md = MarkdownIt()
-        tokens = md.parse(updated_content)
-
-        token_to_process = _find_extract_token(tokens)
-        if not token_to_process:
-            break  # No more blocks to process
 
-        block_extraction_counter += 1
-        print("Block found and processed.")
+def extract_responses(document_path, relative_to_ara_root=False, force=False, write=False):
+    print(f"Starting extraction from '{document_path}'")
+    
+    try:
+        with open(document_path, 'r', encoding='utf-8', errors='replace') as file:
+            content = file.read()
+    except FileNotFoundError:
+        print(f"Error: File not found at '{document_path}'. Skipping extraction.")
+        return
 
-        updated_content = _process_extraction_block(token_to_process, updated_content, force, write)
+    cwd = _setup_working_directory(relative_to_ara_root)
+    
+    source_lines = content.split('\n')
+    replacements = _process_document_blocks(source_lines, force, write)
+    
+    updated_content = _apply_replacements(content, replacements)
 
     os.chdir(cwd)
     with open(document_path, 'w', encoding='utf-8') as file:
         file.write(updated_content)
 
-    if block_extraction_counter > 0:
-        print(f"End of extraction. Found and processed {block_extraction_counter} blocks in '{os.path.basename(document_path)}'.")
+    if replacements:
+        print(f"End of extraction. Found and processed {len(replacements)} blocks in '{os.path.basename(document_path)}'.")
+
 
 def modify_and_save_file(response, file_path):
     print(f"Debug: Modifying and saving file {file_path}")
@@ -144,9 +228,11 @@ def modify_and_save_file(response, file_path):
     except json.JSONDecodeError as ex:
         print(f"ERROR: Failed to decode JSON response: {ex}")
 
+
 def prompt_user_decision(prompt):
     return input(prompt)
 
+
 def determine_should_create(skip_query=False):
     if skip_query:
         return True
@@ -155,6 +241,7 @@ def determine_should_create(skip_query=False):
         return True
     return False
 
+
 def create_file_if_not_exist(filename, content, skip_query=False):
     try:
         if not os.path.exists(filename):
@@ -174,6 +261,7 @@ def create_file_if_not_exist(filename, content, skip_query=False):
         print(f"Error: {e}")
         print(f"Failed to create file {filename} due to an OS error")
 
+
 def create_prompt_for_file_modification(content_str, filename):
     if not os.path.exists(filename):
         print(f"WARNING: {filename} for merge prompt creation does not exist.")
@@ -204,6 +292,7 @@ def create_prompt_for_file_modification(content_str, filename):
 
     return prompt_text
 
+
 def handle_existing_file(filename, block_content, skip_query=False, write=False):
     if not os.path.isfile(filename):
         print(f"File {filename} does not exist, attempting to create")
@@ -240,6 +329,7 @@ def handle_existing_file(filename, block_content, skip_query=False, write=False)
                 response += content
         modify_and_save_file(response, filename)
 
+
 def extract_and_save_prompt_results(classifier, param, write=False):
     sub_directory = Classifier.get_sub_directory(classifier)
     prompt_log_file = f"ara/{sub_directory}/{param}.data/{classifier}.prompt_log.md"

ara_cli-0.1.10.5/ara_cli/templates/prompt-modules/blueprints/pytest_unittest_prompt.blueprint.md

@@ -0,0 +1,32 @@
+MODE: STRICT_GENERATION
+TASK: Produce one complete pytest file for a given Python module.
+
+REQUIREMENTS:
+- Output only valid Python code (no text, no markdown).
+- Target: full behavioral + branch coverage (100%).
+- Tests follow AAA pattern (# Arrange, # Act, # Assert).
+- Exactly ONE assert or ONE pytest.raises() per test.
+- Use tmp_path fixture for filesystem isolation.
+- Include an autouse=True fixture for global patching if needed.
+- No external I/O or network calls.
+- All tests independent, self-contained.
+
+STYLE:
+- File starts with module docstring describing AAA, single assert rule, autouse fixture.
+- Group tests with comment headers: 
+  # --- Success paths --- / # --- Error paths --- / # --- Edge cases ---
+- Function names: test_<function>_<expected_behavior>_<condition>
+- Variables descriptive (rel, path, new_content, etc.).
+- Use direct asserts (assert result is True, assert path.read_text() == "x").
+- For errors: 
+  with pytest.raises(ExceptionType, match=r"text"): function_call()
+
+COVERAGE:
+- Include success, failure, and rare edge branches (e.g., conditional exceptions).
+- Ensure 100% of conditional branches executed.
+
+OUTPUT:
+- Single .py file, runnable via: pytest -v --disable-warnings --maxfail=1 --cov=<target_module>
+- No explanations or prose, only the test code.
+
+END

{ara_cli-0.1.10.4 → ara_cli-0.1.10.5}/ara_cli/version.py

@@ -1,2 +1,2 @@
 # version.py
-__version__ = "0.1.10.4"   # fith parameter like .0 for local install test purposes only. official numbers should be 4 digit numbers
+__version__ = "0.1.10.5"   # fith parameter like .0 for local install test purposes only. official numbers should be 4 digit numbers

{ara_cli-0.1.10.4 → ara_cli-0.1.10.5}/ara_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ara_cli
-Version: 0.1.10.4
+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.4 → ara_cli-0.1.10.5}/ara_cli.egg-info/SOURCES.txt

@@ -113,6 +113,7 @@ ara_cli/templates/template.userstory.prompt_log.md
 ara_cli/templates/template.vision.prompt_log.md
 ara_cli/templates/prompt-modules/blueprints/complete_pytest_unittest.blueprint.md
 ara_cli/templates/prompt-modules/blueprints/empty.blueprint.md
+ara_cli/templates/prompt-modules/blueprints/pytest_unittest_prompt.blueprint.md
 ara_cli/templates/prompt-modules/blueprints/task_todo_list_C4_architecture_analysis.blueprint.md
 ara_cli/templates/prompt-modules/blueprints/task_todo_list_implement_feature_BDD_way.blueprint.md
 ara_cli/templates/prompt-modules/commands/architecture_C4_analysis.commands.md

{ara_cli-0.1.10.4 → ara_cli-0.1.10.5}/tests/test_global_file_lister.py

@@ -120,7 +120,7 @@ class TestGenerateGlobalMarkdownListing:
         abs_path = os.path.abspath(non_existent_dir)
         
         assert f"# {non_existent_dir}\n" in content
-        assert f"    - !! UYARI: Dizin bulunamadı: {abs_path}" in content
+        assert f"    - !! Warning: Global directory not found: {abs_path}" in content
 
     def test_generate_listing_with_no_matching_files(self, temp_dir_structure, tmp_path):
         """Tests that the output file is empty if no files match the patterns."""