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

ara_cli/artefact_models/feature_artefact_model.py

@@ -48,39 +48,36 @@ class FeatureIntent(Intent):
 
     @classmethod
     def deserialize_from_lines(cls, lines: List[str], start_index: int = 0) -> 'FeatureIntent':
-        as_a = None
-        i_want_to = None
-        so_that = None
-
-        as_a_prefix = "As a "
-        as_a_prefix_alt = "As an "
-        i_want_to_prefix = "I want to "
-        so_that_prefix = "So that "
+        prefixes = [
+            ("As a ", "as_a"),
+            ("As an ", "as_a"),
+            ("I want to ", "i_want_to"),
+            ("So that ", "so_that"),
+        ]
+        found = {"as_a": None, "i_want_to": None, "so_that": 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
 
         index = start_index
-        while index < len(lines) and (not as_a or not i_want_to or not so_that):
-            line = lines[index]
-            if line.startswith(as_a_prefix) and not as_a:
-                as_a = line[len(as_a_prefix):].strip()
-            if line.startswith(as_a_prefix_alt) and not as_a:
-                as_a = line[len(as_a_prefix_alt):].strip()
-            if line.startswith(i_want_to_prefix) and not i_want_to:
-                i_want_to = line[len(i_want_to_prefix):].strip()
-            if line.startswith(so_that_prefix) and not so_that:
-                so_that = line[len(so_that_prefix):].strip()
+        while index < len(lines) and any(v is None for v in found.values()):
+            match_and_store(lines[index].strip())
             index += 1
 
-        if not as_a:
+        if not found["as_a"]:
             raise ValueError("Could not find 'As a' line")
-        if not i_want_to:
+        if not found["i_want_to"]:
             raise ValueError("Could not find 'I want to' line")
-        if not so_that:
+        if not found["so_that"]:
             raise ValueError("Could not find 'So that' line")
 
         return cls(
-            as_a=as_a,
-            i_want_to=i_want_to,
-            so_that=so_that
+            as_a=found["as_a"],
+            i_want_to=found["i_want_to"],
+            so_that=found["so_that"]
         )
 
 
@@ -215,28 +212,54 @@ class ScenarioOutline(BaseModel):
     def from_lines(cls, lines: List[str], start_idx: int) -> Tuple['ScenarioOutline', int]:
         """Parse a ScenarioOutline from a list of lines starting at start_idx."""
 
-        if not lines[start_idx].startswith('Scenario Outline:'):
-            raise ValueError("Expected 'Scenario Outline:' at start index")
-        title = lines[start_idx][len('Scenario Outline:'):].strip()
-        steps = []
-        idx = start_idx + 1
-        while idx < len(lines) and not lines[idx].strip().startswith('Examples:'):
-            if lines[idx].strip():
-                steps.append(lines[idx].strip())
-            idx += 1
-        examples = []
-        if idx < len(lines) and lines[idx].strip() == 'Examples:':
+        def extract_title(line: str) -> str:
+            if not line.startswith('Scenario Outline:'):
+                raise ValueError("Expected 'Scenario Outline:' at start index")
+            return line[len('Scenario Outline:'):].strip()
+
+        def extract_steps(lines: List[str], idx: int) -> Tuple[List[str], int]:
+            steps = []
+            while idx < len(lines) and not lines[idx].strip().startswith('Examples:'):
+                if lines[idx].strip():
+                    steps.append(lines[idx].strip())
+                idx += 1
+            return steps, idx
+
+        def extract_headers(line: str) -> List[str]:
+            return [h.strip() for h in line.split('|') if h.strip()]
+
+        def extract_row(line: str) -> List[str]:
+            return [cell.strip() for cell in line.split('|') if cell.strip()]
+
+        def is_scenario_line(line: str) -> bool:
+            return line.startswith("Scenario:") or line.startswith("Scenario Outline:")
+
+        def extract_examples(lines: List[str], idx: int) -> Tuple[List['Example'], int]:
+            examples = []
+
+            if idx >= len(lines) or lines[idx].strip() != 'Examples:':
+                return examples, idx
+
             idx += 1
-            headers = [h.strip() for h in lines[idx].split('|') if h.strip()]
+            headers = extract_headers(lines[idx])
             idx += 1
-            while idx < len(lines) and lines[idx].strip():
-                if lines[idx].strip().startswith("Scenario:") or lines[idx].strip().startswith("Scenario Outline:"):
+
+            while idx < len(lines):
+                current_line = lines[idx].strip()
+                if not current_line or is_scenario_line(current_line):
                     break
-                row = [cell.strip()
-                       for cell in lines[idx].split('|') if cell.strip()]
+
+                row = extract_row(lines[idx])
                 example = Example.from_row(headers, row)
                 examples.append(example)
                 idx += 1
+
+            return examples, idx
+
+        title = extract_title(lines[start_idx])
+        steps, idx = extract_steps(lines, start_idx + 1)
+        examples, idx = extract_examples(lines, idx)
+
         return cls(title=title, steps=steps, examples=examples), idx
 
 
@@ -291,12 +314,10 @@ class FeatureArtefact(Artefact):
 
     def _serialize_scenario_outline(self, scenario: ScenarioOutline) -> str:
         """Serialize a ScenarioOutline with aligned examples."""
-        lines = []
-        lines.append(f"  Scenario Outline: {scenario.title}")
-        for step in scenario.steps:
-            lines.append(f"    {step}")
-
-        if scenario.examples:
+        def serialize_scenario_examples():
+            nonlocal lines, scenario
+            if not scenario:
+                return
             headers = self._extract_placeholders(scenario.steps)
 
             rows = [headers]
@@ -322,6 +343,13 @@ class FeatureArtefact(Artefact):
             for formatted_row in formatted_rows:
                 lines.append(f"      {formatted_row}")
 
+        lines = []
+        lines.append(f"  Scenario Outline: {scenario.title}")
+        for step in scenario.steps:
+            lines.append(f"    {step}")
+
+        serialize_scenario_examples()
+
         return "\n".join(lines)
 
     def _extract_placeholders(self, steps):

ara_cli/artefact_models/keyfeature_artefact_model.py

@@ -47,39 +47,36 @@ class KeyfeatureIntent(Intent):
 
     @classmethod
     def deserialize_from_lines(cls, lines: List[str], start_index: int = 0) -> 'KeyfeatureIntent':
-        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
 
         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/task_artefact_model.py

@@ -33,17 +33,41 @@ class ActionItem(BaseModel):
         return v
 
     @classmethod
-    def deserialize(cls, line: str) -> Optional['ActionItem']:
-        if not line:
+    def deserialize(cls, text: str) -> Optional['ActionItem']:
+        if not text:
             return None
-        match = re.match(r'\[@(to-do|in-progress|done)\]\s+(.*)', line.strip())
+        
+        lines = text.strip().split('\n')
+        first_line = lines[0]
+        
+        match = re.match(r'\[@(.*?)\]\s+(.*)', first_line)
         if not match:
             return None
-        status, text = match.groups()
-        return cls(status=status, text=text)
+
+        status, first_line_text = match.groups()
+        
+        # Validate the status before creating the ActionItem
+        if status not in ["to-do", "in-progress", "done"]:
+            raise ValueError(f"invalid status '{status}' in action item. Allowed values are 'to-do', 'in-progress', 'done'")
+
+        # If there are multiple lines, join them
+        if len(lines) > 1:
+            all_text = '\n'.join([first_line_text] + lines[1:])
+        else:
+            all_text = first_line_text
+
+        return cls(status=status, text=all_text)
 
     def serialize(self) -> str:
-        return f"[@{self.status}] {self.text}"
+        lines = self.text.split('\n')
+        # First line includes the status marker
+        first_line = f"[@{self.status}] {lines[0]}"
+        if len(lines) == 1:
+            return first_line
+        
+        # Additional lines follow without status marker
+        result_lines = [first_line] + lines[1:]
+        return '\n'.join(result_lines)
 
 
 class TaskArtefact(Artefact):
@@ -54,13 +78,47 @@ class TaskArtefact(Artefact):
     def _deserialize_action_items(cls, text) -> Tuple[List[ActionItem], List[str]]:
         lines = [line.strip() for line in text.strip().splitlines() if line.strip()]
 
-        remaining_lines = []
         action_items = []
-        for line in lines:
+        remaining_lines = []
+        i = 0
+
+        contribution_marker = cls._contribution_starts_with()
+        description_marker = cls._description_starts_with()
+
+        while i < len(lines):
+            line = lines[i]
+
             if line.startswith('[@'):
-                action_items.append(ActionItem.deserialize(line))
-                continue
-            remaining_lines.append(line)
+                # Collect all lines for this action item
+                action_item_lines = [line]
+                j = i + 1
+                # Collect lines until we hit another action item or a known section
+                while j < len(lines):
+                    next_line = lines[j]
+                    # Check if next line is a new action item or a known section
+                    if (next_line.startswith('[@') or 
+                        next_line.startswith(description_marker) or
+                        next_line.startswith(contribution_marker)):
+                        break
+                    action_item_lines.append(next_line)
+                    j += 1
+
+                # Join all lines and pass as a single string to deserialize
+                action_item_text = '\n'.join(action_item_lines)
+                try:
+                    action_item = ActionItem.deserialize(action_item_text)
+                    if action_item:
+                        action_items.append(action_item)
+                except ValueError as e:
+                    # Re-raise with more context about where the error occurred
+                    raise ValueError(f"Error parsing action item: {e}")
+
+                # Move index to the next unprocessed line
+                i = j
+            else:
+                remaining_lines.append(line)
+                i += 1
+
         return action_items, remaining_lines
 
     @classmethod
@@ -82,7 +140,9 @@ class TaskArtefact(Artefact):
         return ArtefactType.task
 
     def _serialize_action_items(self) -> str:
-        action_item_lines = [action_item.serialize() for action_item in self.action_items]
+        action_item_lines = []
+        for action_item in self.action_items:
+            action_item_lines.append(action_item.serialize())
         return "\n".join(action_item_lines)
 
     def serialize(self) -> str:
@@ -106,4 +166,4 @@ class TaskArtefact(Artefact):
         lines.append(description)
         lines.append("")
 
-        return "\n".join(lines)
+        return "\n".join(lines)

ara_cli/artefact_models/userstory_artefact_model.py

@@ -47,39 +47,37 @@ class UserstoryIntent(Intent):
 
     @classmethod
     def deserialize_from_lines(cls, lines: List[str], start_index: int = 0) -> 'UserstoryIntent':
-        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].strip()
-            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].strip())
             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/vision_artefact_model.py

@@ -76,54 +76,35 @@ class VisionIntent(Intent):
 
     @classmethod
     def deserialize_from_lines(cls, lines: List[str], start_index: int = 0) -> 'VisionIntent':
+        prefixes = [
+            ("For ", "for_"),
+            ("Who ", "who"),
+            ("The ", "the"),
+            ("That ", "that"),
+            ("Unlike ", "unlike"),
+            ("Our product ", "our_product"),
+        ]
+        found = {field: "" for _, field in prefixes}
+
+        # Find the first "For " line, if it exists
         intent_start_index = start_index
-
-        for_ = ""
-        who = ""
-        the = ""
-        that = ""
-        unlike = ""
-        our_product = ""
-
-        for_prefix = "For "
-        who_prefix = "Who "
-        the_prefix = "The "
-        that_prefix = "That "
-        unlike_prefix = "Unlike "
-        our_product_prefix = "Our product "
-
         for i in range(start_index, len(lines)):
-            if lines[i].startswith(for_prefix):
+            if lines[i].startswith("For "):
                 intent_start_index = i
                 break
 
+        def match_and_store(line):
+            for prefix, field in prefixes:
+                if line.startswith(prefix) and not found[field]:
+                    found[field] = line[len(prefix):].strip()
+                    return
+
         index = intent_start_index
-        if index < len(lines) and lines[index].startswith(for_prefix):
-            for_ = lines[index][len(for_prefix):]
-            index = index + 1
-        if index < len(lines) and lines[index].startswith(who_prefix):
-            who = lines[index][len(who_prefix):]
-            index = index + 1
-        if index < len(lines) and lines[index].startswith(the_prefix):
-            the = lines[index][len(the_prefix):]
-            index = index + 1
-        if index < len(lines) and lines[index].startswith(that_prefix):
-            that = lines[index][len(that_prefix):]
-            index = index + 1
-        if index < len(lines) and lines[index].startswith(unlike_prefix):
-            unlike = lines[index][len(unlike_prefix):]
-            index = index + 1
-        if index < len(lines) and lines[index].startswith(our_product_prefix):
-            our_product = lines[index][len(our_product_prefix):]
-
-        return cls(
-            for_=for_,
-            who=who,
-            the=the,
-            that=that,
-            unlike=unlike,
-            our_product=our_product,
-        )
+        while index < len(lines) and any(not v for v in found.values()):
+            match_and_store(lines[index])
+            index += 1
+
+        return cls(**found)
 
 
 class VisionArtefact(Artefact):

ara_cli/artefact_scan.py

@@ -2,9 +2,57 @@ from textwrap import indent
 import os
 
 
+def is_contribution_valid(contribution, classified_artefact_info) -> bool:
+    from ara_cli.artefact_fuzzy_search import extract_artefact_names_of_classifier
+    if not contribution or not contribution.artefact_name or not contribution.classifier:
+        return True
+
+    all_artefact_names = extract_artefact_names_of_classifier(
+        classified_files=classified_artefact_info,
+        classifier=contribution.classifier
+    )
+    if contribution.artefact_name not in all_artefact_names:
+        return False
+    return True
+
+
+def is_rule_valid(contribution, classified_artefact_info) -> bool:
+    from ara_cli.artefact_reader import ArtefactReader
+
+    if not contribution or not contribution.artefact_name or not contribution.classifier:
+        return True
+    rule = contribution.rule
+    if not rule:
+        return True
+    parent = ArtefactReader.read_artefact(contribution.artefact_name, contribution.classifier)
+    if not parent or not parent.rules:
+        return True
+    rules = parent.rules
+    if rule not in rules:
+        return False
+    return True
+
+
+def check_contribution(contribution, classified_artefact_info, file_path) -> tuple[bool, str]:
+    if not contribution:
+        return True, None
+
+    if not is_contribution_valid(contribution, classified_artefact_info):
+        reason = (f"Invalid Contribution Reference: The contribution references "
+                  f"'{contribution.classifier}' artefact '{contribution.artefact_name}' "
+                  f"which does not exist.")
+        return False, reason
+
+    if not is_rule_valid(contribution, classified_artefact_info):
+        reason = (f"Rule Mismatch: The contribution references "
+                  f"rule '{contribution.rule}' which the parent "
+                  f"{contribution.classifier} '{contribution.artefact_name}' does not have.")
+        return False, reason
+    return True, None
+
+
 def check_file(file_path, artefact_class, classified_artefact_info=None):
     from pydantic import ValidationError
-    from ara_cli.artefact_fuzzy_search import extract_artefact_names_of_classifier
     from ara_cli.file_classifier import FileClassifier
 
     try:
@@ -23,26 +71,17 @@ def check_file(file_path, artefact_class, classified_artefact_info=None):
         base_name = os.path.basename(file_path)
         file_name_without_ext, _ = os.path.splitext(base_name)
 
+        # Check title and file name matching
         if artefact_instance.title != file_name_without_ext:
             reason = (f"Filename-Title Mismatch: The file name '{file_name_without_ext}' "
                       f"does not match the artefact title '{artefact_instance.title}'.")
             return False, reason
-        
-        # Check contribution reference validity
+
         contribution = artefact_instance.contribution
-        if contribution and contribution.artefact_name and contribution.classifier:
-            
-            # Find all artefact names of the referenced classifier
-            all_artefact_names = extract_artefact_names_of_classifier(
-                classified_files=classified_artefact_info,
-                classifier=contribution.classifier
-            )
-            
-            if contribution.artefact_name not in all_artefact_names:
-                reason = (f"Invalid Contribution Reference: The contribution references "
-                          f"'{contribution.classifier}' artefact '{contribution.artefact_name}' "
-                          f"which does not exist.")
-                return False, reason
+
+        contribution_valid, reason = check_contribution(contribution, classified_artefact_info, file_path)
+        if not contribution_valid:
+            return False, reason
 
         return True, None
     except (ValidationError, ValueError, AssertionError) as e:

ara_cli/prompt_handler.py

@@ -239,7 +239,7 @@ def move_and_copy_files(source_path, prompt_data_path, prompt_archive_path):
         file_name = os.path.basename(source_path)
 
         # Check the name ending and extension of source path
-        endings = [".commands.md", ".rules.md", ".intention.md"]
+        endings = [".blueprint.md", ".commands.md", ".rules.md", ".intention.md"]
         if any(file_name.endswith(ext) for ext in endings):
             for ext in endings:
                 if file_name.endswith(ext):
@@ -394,7 +394,7 @@ def create_and_send_custom_prompt(classifier, parameter):
     prompt_data_path = f"ara/{sub_directory}/{parameter}.data/prompt.data"
     prompt_file_path_markdown = join(prompt_data_path, f"{classifier}.prompt.md")
 
-    extensions = [".rules.md", ".prompt_givens.md", ".intention.md", ".commands.md"]
+    extensions = [".blueprint.md", ".rules.md", ".prompt_givens.md", ".intention.md", ".commands.md"]
     combined_content_markdown, image_data_list = collect_file_content_by_extension(prompt_data_path, extensions)
 
     with open(prompt_file_path_markdown, 'w', encoding='utf-8') as file:
@@ -430,7 +430,7 @@ def generate_config_prompt_template_file(prompt_data_path, config_prompt_templat
     config = ConfigManager.get_config()
     global_prompt_template_path = TemplatePathManager.get_template_base_path()
     dir_list = ["ara/.araconfig/custom-prompt-modules"] + [f"{os.path.join(global_prompt_template_path,'prompt-modules')}"]
-    file_list = ['*.rules.md','*.intention.md', '*.commands.md']
+    file_list = ['*.blueprint.md','*.rules.md','*.intention.md', '*.commands.md']
 
     print(f"used {dir_list} for prompt templates file listing")
     generate_markdown_listing(dir_list, file_list, config_prompt_templates_path)
@@ -439,7 +439,7 @@ def generate_config_prompt_template_file(prompt_data_path, config_prompt_templat
 def generate_config_prompt_givens_file(prompt_data_path, config_prompt_givens_name, artefact_to_mark=None):
     config_prompt_givens_path = os.path.join(prompt_data_path, config_prompt_givens_name)
     config = ConfigManager.get_config()
-    dir_list = ["ara"] + [item for ext in config.ext_code_dirs for key, item in ext.items()] + [config.doc_dir] + [config.glossary_dir]
+    dir_list = ["ara"] + [ext.source_dir for ext in config.ext_code_dirs] + [config.doc_dir] + [config.glossary_dir]
 
     print(f"used {dir_list} for prompt givens file listing")
     generate_markdown_listing(dir_list, config.ara_prompt_given_list_includes, config_prompt_givens_path)