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

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
 
 
@@ -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"]
         )
 
 
@@ -92,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:
@@ -167,4 +175,4 @@ class EpicArtefact(Artefact):
             lines.append("")
         lines.append(description)
         lines.append("")
-        return "\n".join(lines)
+        return "\n".join(lines)

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"]
         )
 
 
@@ -138,6 +135,7 @@ class Scenario(BaseModel):
     @field_validator('title')
     def validate_title(cls, v: str) -> str:
         v = v.strip()
+        v = v.replace('_', ' ')
         if not v:
             raise ValueError("title must not be empty")
         return v
@@ -150,6 +148,30 @@ class Scenario(BaseModel):
             raise ValueError("steps list must not be empty")
         return steps
 
+    @model_validator(mode='after')
+    def check_no_placeholders(cls, values: 'Scenario') -> 'Scenario':
+        """Ensure regular scenarios don't contain placeholders that should be in scenario outlines."""
+        placeholders = set()
+        for step in values.steps:
+            # Skip validation if step contains docstring placeholders (during parsing)
+            if '__DOCSTRING_PLACEHOLDER_' in step:
+                continue
+            
+            # Skip validation if step contains docstring markers (after reinjection)
+            if '"""' in step:
+                continue
+                
+            found = re.findall(r'<([^>]+)>', step)
+            placeholders.update(found)
+        
+        if placeholders:
+            placeholder_list = ', '.join(f"<{p}>" for p in sorted(placeholders))
+            raise ValueError(
+                f"Scenario Contains Placeholders ({placeholder_list}) but is not a Scenario Outline. "
+                f"Use 'Scenario Outline:' instead of 'Scenario:' and provide an Examples table."
+            )
+        return values
+
     @classmethod
     def from_lines(cls, lines: List[str], start_idx: int) -> Tuple['Scenario', int]:
         """Parse a Scenario from a list of lines starting at start_idx."""
@@ -181,6 +203,7 @@ class ScenarioOutline(BaseModel):
     def validate_title(cls, v: str) -> str:
         if not v:
             raise ValueError("title must not be empty in a ScenarioOutline")
+        v = v.replace('_', ' ')
         return v
 
     @field_validator('steps', mode='before')
@@ -213,28 +236,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
 
 
@@ -252,6 +301,37 @@ 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:
         return "Feature:"
@@ -289,12 +369,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]
@@ -320,6 +398,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):
@@ -363,27 +448,43 @@ class FeatureArtefact(Artefact):
 
     @classmethod
     def deserialize(cls, text: str) -> 'FeatureArtefact':
-        fields = super()._parse_common_fields(text)
-
-        intent = FeatureIntent.deserialize(text)
-        background = cls.deserialize_background(text)
-        scenarios = cls.deserialize_scenarios(text)
+        """
+        Deserializes the feature file using a robust extract-and-reinject strategy.
+        1. Hides all docstrings by replacing them with placeholders.
+        2. Parses the sanitized text using the original, simple parsing logic.
+        3. Re-injects the original docstring content back into the parsed objects.
+        This prevents the parser from ever being confused by content within docstrings.
+        """
+        # 1. Hide all docstrings from the entire file text first.
+        sanitized_text, docstrings = cls._hide_docstrings(text)
+
+        # 2. Perform the original parsing logic on the SANITIZED text.
+        # This part of the code is now "safe" because it will never see a docstring.
+        fields = super()._parse_common_fields(sanitized_text)
+        intent = FeatureIntent.deserialize(sanitized_text)
+        background = cls.deserialize_background(sanitized_text)
+        scenarios = cls.deserialize_scenarios(sanitized_text)
 
-        fields['scenarios'] = scenarios
-        fields['background'] = background
         fields['intent'] = intent
+        fields['background'] = background
+        fields['scenarios'] = scenarios
+
+        # 3. Re-inject the docstrings back into the parsed scenarios.
+        if fields['scenarios'] and docstrings:
+            for scenario in fields['scenarios']:
+                if isinstance(scenario, (Scenario, ScenarioOutline)):
+                    scenario.steps = cls._reinject_docstrings_into_steps(scenario.steps, docstrings)
 
         return cls(**fields)
 
     @classmethod
     def deserialize_scenarios(cls, text):
-        lines = [line.strip()
-                 for line in text.strip().splitlines() if line.strip()]
-
+        if not text: return []
+        lines = [line.strip() for line in text.strip().splitlines() if line.strip()]
         scenarios = []
         idx = 0
         while idx < len(lines):
-            line = lines[idx].strip()
+            line = lines[idx]
             if line.startswith('Scenario:'):
                 scenario, next_idx = Scenario.from_lines(lines, idx)
                 scenarios.append(scenario)
@@ -398,16 +499,54 @@ class FeatureArtefact(Artefact):
 
     @classmethod
     def deserialize_background(cls, text):
-        lines = [line.strip()
-                 for line in text.strip().splitlines() if line.strip()]
-
+        if not text: return None
+        lines = [line.strip() for line in text.strip().splitlines() if line.strip()]
         background = None
         idx = 0
         while idx < len(lines):
-            line = lines[idx].strip()
+            line = lines[idx]
             if line.startswith('Background:'):
-                background, next_idx = Background.from_lines(lines, idx)
+                background, _ = Background.from_lines(lines, idx)
                 break
-            else:
-                idx += 1
+            idx += 1
         return background
+
+
+    @staticmethod
+    def _hide_docstrings(text: str) -> Tuple[str, Dict[str, str]]:
+        """
+        Finds all docstring blocks ('''...''') in the text,
+        replaces them with a unique placeholder, and returns the sanitized
+        text and a dictionary mapping placeholders to the original docstrings.
+        """
+        docstrings = {}
+        placeholder_template = "__DOCSTRING_PLACEHOLDER_{}__"
+
+        def replacer(match):
+            # This function is called for each found docstring.
+            key = placeholder_template.format(len(docstrings))
+            docstrings[key] = match.group(0)  # Store the full matched docstring
+            return key
+
+        # The regex finds ''' followed by any character (including newlines)
+        # in a non-greedy way (.*?) until the next '''.
+        sanitized_text = re.sub(r'"""[\s\S]*?"""', replacer, text)
+
+        return sanitized_text, docstrings
+
+    @staticmethod
+    def _reinject_docstrings_into_steps(steps: List[str], docstrings: Dict[str, str]) -> List[str]:
+        """
+        Iterates through a list of steps, finds any placeholders,
+        and replaces them with their original docstring content.
+        """
+        rehydrated_steps = []
+        for step in steps:
+            for key, value in docstrings.items():
+                if key in step:
+                    # Replace the placeholder with the original, full docstring block.
+                    # This handles cases where the step is just the placeholder,
+                    # 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

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/serialize_helper.py

@@ -15,4 +15,4 @@ def as_a_serializer(as_a):
     else:
         as_a_prefix = "As a"
 
-    return f"{as_a_prefix} {role}"
+    return f"{as_a_prefix} {role}".strip()

ara_cli/artefact_models/task_artefact_model.py

@@ -33,34 +33,100 @@ 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):
     artefact_type: ArtefactType = ArtefactType.task
     action_items: List[ActionItem] = Field(default_factory=list)
 
+    @classmethod
+    def _is_action_item_start(cls, line: str) -> bool:
+        return line.startswith('[@')
+
+    @classmethod
+    def _is_section_start(cls, line: str, description_marker: str, contribution_marker: str) -> bool:
+        return (
+            line.startswith(description_marker) or
+            line.startswith(contribution_marker)
+        )
+
+    @classmethod
+    def _collect_action_item_lines(cls, lines, start_idx, description_marker, contribution_marker):
+        action_item_lines = [lines[start_idx]]
+        j = start_idx + 1
+        while j < len(lines):
+            next_line = lines[j]
+            if (
+                cls._is_action_item_start(next_line) or 
+                cls._is_section_start(next_line, description_marker, contribution_marker)
+            ):
+                break
+            action_item_lines.append(next_line)
+            j += 1
+        return action_item_lines, j
+
     @classmethod
     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:
-            if line.startswith('[@'):
-                action_items.append(ActionItem.deserialize(line))
-                continue
-            remaining_lines.append(line)
+        remaining_lines = []
+        i = 0
+        contribution_marker = cls._contribution_starts_with()
+        description_marker = cls._description_starts_with()
+
+        while i < len(lines):
+            line = lines[i]
+            if cls._is_action_item_start(line):
+                action_item_lines, next_idx = cls._collect_action_item_lines(
+                    lines, i, description_marker, contribution_marker
+                )
+                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:
+                    raise ValueError(f"Error parsing action item: {e}")
+                i = next_idx
+            else:
+                remaining_lines.append(line)
+                i += 1
+
         return action_items, remaining_lines
 
     @classmethod
@@ -82,7 +148,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 +174,4 @@ class TaskArtefact(Artefact):
         lines.append(description)
         lines.append("")
 
-        return "\n".join(lines)
+        return "\n".join(lines)