ara-cli 0.1.10.0__py3-none-any.whl → 0.1.13.3__py3-none-any.whl

ara_cli/artefact_converter.py

@@ -0,0 +1,256 @@
+import os
+import logging
+from ara_cli.prompt_handler import LLMSingleton
+from langfuse.api.resources.commons.errors import Error as LangfuseError, NotFoundError
+from ara_cli.classifier import Classifier
+from ara_cli.artefact_reader import ArtefactReader
+from ara_cli.artefact_creator import ArtefactCreator
+from ara_cli.error_handler import AraError
+from ara_cli.directory_navigator import DirectoryNavigator
+from ara_cli.artefact_deleter import ArtefactDeleter
+
+
+class AraArtefactConverter:
+    def __init__(self, file_system=None):
+        self.file_system = file_system or os
+        self.reader = ArtefactReader()
+        self.creator = ArtefactCreator(self.file_system)
+
+    def convert(
+        self,
+        old_classifier: str,
+        artefact_name: str,
+        new_classifier: str,
+        merge: bool = False,
+        override: bool = False,
+    ):
+        try:
+            self._validate_classifiers(old_classifier, new_classifier)
+
+            content, artefact_info = self.reader.read_artefact_data(
+                artefact_name, old_classifier
+            )
+            if not content or not artefact_info:
+                raise AraError(
+                    f"Artefact '{artefact_name}' of type '{old_classifier}' not found"
+                )
+
+            target_content_existing = self._resolve_target_content(
+                artefact_name, new_classifier, merge, override
+            )
+
+            target_class = self._get_target_class(new_classifier)
+
+            prompt = self._get_prompt(
+                old_classifier=old_classifier,
+                new_classifier=new_classifier,
+                artefact_name=artefact_name,
+                content=content,
+                target_content_existing=target_content_existing,
+                merge=merge,
+            )
+
+            print(
+                f"{'Merging' if merge and target_content_existing else 'Converting'} '{artefact_name}' from {old_classifier} to {new_classifier}..."
+            )
+
+            converted_artefact = self._run_conversion_agent(prompt, target_class)
+            artefact_content = converted_artefact.serialize()
+
+            self._write_artefact(
+                new_classifier,
+                artefact_name,
+                artefact_content,
+                merge=merge,
+                override=override,
+            )
+
+            if old_classifier != new_classifier:
+                self._move_data_folder_content(
+                    old_classifier, new_classifier, artefact_name
+                )
+                deleter = ArtefactDeleter(self.file_system)
+                deleter.delete(artefact_name, old_classifier, force=True)
+
+        except ValueError as e:
+            raise e
+        except AraError as e:
+            raise e
+        except Exception as e:
+            raise e
+
+    def _validate_classifiers(self, old_classifier: str, new_classifier: str):
+        if not Classifier.is_valid_classifier(old_classifier):
+            raise ValueError(f"Invalid classifier: {old_classifier}")
+        if not Classifier.is_valid_classifier(new_classifier):
+            raise ValueError(f"Invalid classifier: {new_classifier}")
+
+    def _move_data_folder_content(self, old_classifier, new_classifier, artefact_name):
+        import shutil
+
+        navigator = DirectoryNavigator()
+        navigator.navigate_to_target()
+
+        sub_directory_old = Classifier.get_sub_directory(old_classifier)
+        dir_path_old = self.file_system.path.join(
+            sub_directory_old, f"{artefact_name}.data"
+        )
+
+        sub_directory_new = Classifier.get_sub_directory(new_classifier)
+        dir_path_new = self.file_system.path.join(
+            sub_directory_new, f"{artefact_name}.data"
+        )
+
+        if self.file_system.path.exists(dir_path_old):
+            backup_folder_name = f"{artefact_name}.data.old"
+            destination_path = self.file_system.path.join(
+                dir_path_new, backup_folder_name
+            )
+
+            if not self.file_system.path.exists(dir_path_new):
+                os.makedirs(dir_path_new, exist_ok=True)
+
+            if self.file_system.path.exists(destination_path):
+                shutil.rmtree(destination_path)
+
+            try:
+                shutil.move(dir_path_old, destination_path)
+                print(f"Moved old data to {destination_path}")
+            except Exception as e:
+                print(f"Error moving data directory: {e}")
+
+    def _resolve_target_content(
+        self, artefact_name: str, new_classifier: str, merge: bool, override: bool
+    ):
+        target_content_existing = None
+        if not merge and not override:
+            _, new_artefact_info = self.reader.read_artefact_data(
+                artefact_name, new_classifier
+            )
+            if new_artefact_info:
+                raise ValueError(
+                    f"Found already exiting {new_classifier} {artefact_name}. Rerun the command with --override or --merge."
+                )
+        elif merge:
+            target_content_existing, _ = self.reader.read_artefact_data(
+                artefact_name, new_classifier
+            )
+        return target_content_existing
+
+    def _get_target_class(self, new_classifier: str):
+        from ara_cli.artefact_models.artefact_mapping import artefact_type_mapping
+        from ara_cli.artefact_models.artefact_model import ArtefactType
+
+        target_type = ArtefactType(new_classifier)
+        target_class = artefact_type_mapping.get(target_type)
+
+        if not target_class:
+            raise AraError(f"No artefact class found for classifier: {new_classifier}")
+        return target_class
+
+    def _get_prompt(
+        self,
+        old_classifier,
+        new_classifier,
+        artefact_name,
+        content,
+        target_content_existing,
+        merge,
+    ):
+        try:
+            langfuse = LLMSingleton.get_instance().langfuse
+            if langfuse is None:
+                # This mimics the behavior if authentication failed or env vars missing in Singleton
+                raise Exception("Langfuse not initialized in Singleton")
+
+            if merge and target_content_existing:
+                prompt_template = langfuse.get_prompt("ara-cli/artefact-convert/merge")
+                return prompt_template.compile(
+                    old_classifier=old_classifier,
+                    new_classifier=new_classifier,
+                    artefact_name=artefact_name,
+                    content=content,
+                    target_content_existing=target_content_existing,
+                )
+            else:
+                prompt_template = langfuse.get_prompt(
+                    "ara-cli/artefact-convert/default"
+                )
+                return prompt_template.compile(
+                    old_classifier=old_classifier,
+                    new_classifier=new_classifier,
+                    artefact_name=artefact_name,
+                    content=content,
+                )
+
+        except (LangfuseError, NotFoundError, Exception) as e:
+            logging.info(f"Could not fetch Langfuse prompt: {e}. Using fallback.")
+            # Fallback prompts
+            formatting_instructions = (
+                "### Data Extraction Rules:\n"
+                "- **Users**: Extract usernames ONLY. Do NOT add '@' or 'user_' prefixes. "
+                "The system adds these automatically. (e.g., return 'hans', NOT '@user_hans').\n"
+                "- **Author**: Extract the author as 'creator_<name>'. Do NOT add the '@' symbol. "
+                "(e.g., return 'creator_unknown', NOT '@creator_unknown').\n"
+                f"- **Artefact Name**: Use strictly '{artefact_name}'.\n"
+                "- **Content**: Adapt the content to the target schema fields."
+            )
+
+            if merge and target_content_existing:
+                return (
+                    f"Merge the following {old_classifier} artefact into the existing {new_classifier} artefact. "
+                    "Combine the information from both, prioritizing the structure of the target artefact schema. "
+                    "Ensure no critical information is lost. "
+                    "\n\n"
+                    f"{formatting_instructions}"
+                    "\n\n"
+                    f"Source Artefact ({old_classifier}):\n```\n{content}\n```"
+                    f"\n\nTarget Artefact ({new_classifier}):\n```\n{target_content_existing}\n```"
+                )
+            else:
+                return (
+                    f"Convert the following {old_classifier} artefact to a {new_classifier} artefact. "
+                    "Preserve the core meaning, business value, and description. "
+                    "Map the content to the fields required by the target schema. "
+                    "\n\n"
+                    f"{formatting_instructions}"
+                    "\n\n"
+                    f"Source Artefact Content:\n```\n{content}\n```"
+                )
+
+    def _run_conversion_agent(self, prompt, target_class):
+        from ara_cli.llm_utils import create_pydantic_ai_agent
+
+        agent = create_pydantic_ai_agent(output_type=target_class, instrument=True)
+        try:
+            result = agent.run_sync(prompt)
+            return result.output
+        except Exception as e:
+            raise AraError(f"LLM conversion failed: {e}")
+
+    def _write_artefact(
+        self, new_classifier, artefact_name, artefact_content, merge, override
+    ):
+        from shutil import rmtree
+
+        navigator = DirectoryNavigator()
+        navigator.navigate_to_target()
+
+        sub_directory = Classifier.get_sub_directory(new_classifier)
+        file_path = self.file_system.path.join(
+            sub_directory, f"{artefact_name}.{new_classifier}"
+        )
+        dir_path = self.file_system.path.join(sub_directory, f"{artefact_name}.data")
+
+        if self.file_system.path.exists(file_path) and not (override or merge):
+            raise ValueError(f"Target file {file_path} already exists.")
+
+        if not merge:
+            rmtree(dir_path, ignore_errors=True)
+
+        os.makedirs(dir_path, exist_ok=True)
+
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(artefact_content)
+
+        print(f"Conversion successful. Created: {file_path}")

ara_cli/artefact_models/artefact_model.py

@@ -184,6 +184,10 @@ class Artefact(BaseModel, ABC):
         default=[],
         description="Optional list of tags (0-many)",
     )
+    author: Optional[str] = Field(
+        default="creator_unknown",
+        description="Author of the artefact, must be a single entry of the form 'creator_<someone>'."
+    )
     title: str = Field(
         ...,
         description="Descriptive Artefact title (mandatory)",
@@ -252,6 +256,17 @@ class Artefact(BaseModel, ABC):
                 raise ValueError(f"Tag '{tag}' has the form of a status tag. Set `status` field instead of passing it with other tags")
             if tag.startswith("user_"):
                 raise ValueError(f"Tag '{tag} has the form of a user tag. Set `users` field instead of passing it with other tags")
+            if tag.startswith("creator_"):
+                raise ValueError(f"Tag '{tag}' has the form of an author tag. Set `author` field instead of passing it with other tags")
+        return v
+
+    @field_validator('author')
+    def validate_author(cls, v):
+        if v:
+            if not v.startswith("creator_"):
+                raise ValueError(f"Author '{v}' must start with 'creator_'.")
+            if len(v) <= len("creator_"):
+                raise ValueError("Creator name cannot be empty in author tag.")
         return v
 
     @field_validator('title')
@@ -291,32 +306,81 @@ class Artefact(BaseModel, ABC):
         tag_line = lines[0]
         if not tag_line.startswith('@'):
             return {}, lines
+
         tags = tag_line.split()
+        tag_dict = cls._process_tags(tags)
+        return tag_dict, lines[1:]
+
+    @classmethod
+    def _process_tags(cls, tags) -> Dict[str, str]:
+        """Process a list of tags and return a dictionary with categorized tags."""
         status = None
         regular_tags = []
         users = []
-        status_list = ["@to-do", "@in-progress", "@review", "@done", "@closed"]
-        user_prefix = "@user_"
-        user_prefix_length = len(user_prefix)
-
+        author = None
+        
         for tag in tags:
-            if not tag.startswith('@'):
-                raise ValueError(f"Tag '{tag}' should start with '@' but started with '{tag[0]}'")
-            if tag in status_list and status is not None:
-                raise ValueError(f"Multiple status tags found: '@{status}' and '{tag}'")
-            if tag in status_list:
-                status = tag[1:]
-                continue
-            if tag.startswith("@user_") and len(tag) > user_prefix_length + 1:
-                users.append(tag[user_prefix_length:])
-                continue
-            regular_tags.append(tag[1:])
-        tag_dict = {
+            cls._validate_tag_format(tag)
+            
+            if cls._is_status_tag(tag):
+                status = cls._process_status_tag(tag, status)
+            elif cls._is_user_tag(tag):
+                users.append(cls._extract_user_from_tag(tag))
+            elif cls._is_author_tag(tag):
+                author = cls._process_author_tag(tag, author)
+            else:
+                regular_tags.append(tag[1:])
+        
+        return {
             "status": status,
             "users": users,
-            "tags": regular_tags
+            "tags": regular_tags,
+            "author": author
         }
-        return tag_dict, lines[1:]
+
+    @classmethod
+    def _validate_tag_format(cls, tag):
+        """Validate that tag starts with @."""
+        if not tag.startswith('@'):
+            raise ValueError(f"Tag '{tag}' should start with '@' but started with '{tag[0]}'")
+
+    @classmethod
+    def _is_status_tag(cls, tag) -> bool:
+        """Check if tag is a status tag."""
+        status_list = ["@to-do", "@in-progress", "@review", "@done", "@closed"]
+        return tag in status_list
+
+    @classmethod
+    def _process_status_tag(cls, tag, current_status):
+        """Process status tag and check for duplicates."""
+        if current_status is not None:
+            raise ValueError(f"Multiple status tags found: '@{current_status}' and '{tag}'")
+        return tag[1:]  # Remove @ prefix
+
+    @classmethod
+    def _is_user_tag(cls, tag) -> bool:
+        """Check if tag is a user tag."""
+        user_prefix = "@user_"
+        return tag.startswith(user_prefix) and len(tag) > len(user_prefix)
+
+    @classmethod
+    def _extract_user_from_tag(cls, tag) -> str:
+        """Extract username from user tag."""
+        user_prefix = "@user_"
+        return tag[len(user_prefix):]
+
+    @classmethod
+    def _is_author_tag(cls, tag) -> bool:
+        """Check if tag is an author tag."""
+        creator_prefix = "@creator_"
+        return tag.startswith(creator_prefix) and len(tag) > len(creator_prefix)
+
+    @classmethod
+    def _process_author_tag(cls, tag, current_author):
+        """Process author tag and check for duplicates."""
+        if current_author is not None:
+            raise ValueError(f"Multiple author tags found: '@{current_author}' and '@{tag[1:]}'")
+        return tag[1:] 
 
     @classmethod
     def _deserialize_title(cls, lines) -> (str, List[str]):
@@ -346,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:
@@ -367,7 +443,7 @@ class Artefact(BaseModel, ABC):
         contribution, remaining_lines = cls._deserialize_contribution(remaining_lines)
         description, remaining_lines = cls._deserialize_description(remaining_lines)
 
-        return {
+        fields = {
             'artefact_type': cls._artefact_type(),
             'tags': tags.get('tags', []),
             'users': tags.get('users', []),
@@ -376,6 +452,9 @@ class Artefact(BaseModel, ABC):
             'contribution': contribution,
             'description': description,
         }
+        if tags.get("author"):
+            fields["author"] = tags.get("author")
+        return fields
 
     @classmethod
     def deserialize(cls, text: str) -> 'Artefact':
@@ -407,6 +486,8 @@ class Artefact(BaseModel, ABC):
             tags.append(f"@{self.status}")
         for user in self.users:
             tags.append(f"@user_{user}")
+        if self.author:
+            tags.append(f"@{self.author}")
         for tag in self.tags:
             tags.append(f"@{tag}")
         return ' '.join(tags)
@@ -430,4 +511,4 @@ class Artefact(BaseModel, ABC):
             classifier=classifier,
             rule=rule
         )
-        self.contribution = contribution
+        self.contribution = contribution

ara_cli/artefact_models/artefact_templates.py

@@ -29,7 +29,8 @@ def _default_vision(title: str, use_default_contribution: bool) -> VisionArtefac
         our_product="<statement of primary differentiation>"
     )
     return VisionArtefact(
-        tags=["sample_tag"],
+        tags=[],
+        author="creator_unknown",
         title=title,
         description="<further optional description to understand the vision, markdown capable text formatting>",
         intent=intent,
@@ -44,7 +45,8 @@ def _default_businessgoal(title: str, use_default_contribution: bool) -> Busines
         i_want="<something that helps me to reach my monetary goal>"
     )
     return BusinessgoalArtefact(
-        tags=["sample_tag"],
+        tags=[],
+        author="creator_unknown",
         title=title,
         description="<further optional description to understand the businessgoal, markdown capable text formatting>",
         intent=intent,
@@ -57,7 +59,8 @@ def _default_capability(title: str, use_default_contribution: bool) -> Capabilit
         to_be_able_to="<needed capability for stakeholders that are the enablers/relevant for reaching the business goal>"
     )
     return CapabilityArtefact(
-        tags=["sample_tag"],
+        tags=[],
+        author="creator_unknown",
         title=title,
         description="<further optional description to understand the capability, markdown capable text formatting>",
         intent=intent,
@@ -77,7 +80,8 @@ def _default_epic(title: str, use_default_contribution: bool) -> EpicArtefact:
         "<rule needed to fulfill the wanted product behavior>"
     ]
     return EpicArtefact(
-        tags=["sample_tag"],
+        tags=[],
+        author="creator_unknown",
         title=title,
         description="<further optional description to understand the epic, markdown capable text formatting>",
         intent=intent,
@@ -98,7 +102,8 @@ def _default_userstory(title: str, use_default_contribution: bool) -> UserstoryA
         "<rule needed to fulfill the wanted product behavior>"
     ]
     return UserstoryArtefact(
-        tags=["sample_tag"],
+        tags=[],
+        author="creator_unknown",
         title=title,
         description="<further optional description to understand the userstory, markdown capable text formatting>",
         intent=intent,
@@ -110,7 +115,8 @@ def _default_userstory(title: str, use_default_contribution: bool) -> UserstoryA
 
 def _default_example(title: str, use_default_contribution: bool) -> ExampleArtefact:
     return ExampleArtefact(
-        tags=["sample_tag"],
+        tags=[],
+        author="creator_unknown",
         title=title,
         description="<further optional description to understand the example, markdown capable text formatting>",
         contribution=default_contribution() if use_default_contribution else None
@@ -130,7 +136,8 @@ def _default_keyfeature(title: str, use_default_contribution: bool) -> Keyfeatur
     THEN some result is to be expected
     AND some other result is to be expected>"""
     return KeyfeatureArtefact(
-        tags=["sample_tag"],
+        tags=[],
+        author="creator_unknown",
         title=title,
         description=description,
         intent=intent,
@@ -185,7 +192,8 @@ def _default_feature(title: str, use_default_contribution: bool) -> FeatureArtef
     description = """<further optional description to understand the feature, no format defined, the example artefact is only a placeholder>"""
 
     return FeatureArtefact(
-        tags=["sample_tag"],
+        tags=[],
+        author="creator_unknown",
         title=title,
         description=description,
         intent=intent,
@@ -196,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
@@ -214,7 +223,8 @@ def _default_issue(title: str, use_default_contribution: bool) -> IssueArtefact:
     *or optional free text description*"""
 
     return IssueArtefact(
-        tags=["sample_tag"],
+        tags=[],
+        author="creator_unknown",
         title=title,
         description=description,
         additional_description=additional_description,

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/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/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:
@@ -171,7 +183,7 @@ class UserstoryArtefact(Artefact):
         rules = self._serialize_rules()
 
         lines = []
-        if self.tags:
+        if tags:  # Changed from self.tags to tags to include all tag types
             lines.append(tags)
         lines.append(title)
         lines.append("")
@@ -188,4 +200,4 @@ class UserstoryArtefact(Artefact):
         lines.append(description)
         lines.append("")
 
-        return '\n'.join(lines)
+        return '\n'.join(lines)

ara_cli/artefact_scan.py

@@ -25,10 +25,10 @@ def is_rule_valid(contribution, classified_artefact_info) -> bool:
     if not rule:
         return True
     parent = ArtefactReader.read_artefact(contribution.artefact_name, contribution.classifier)
-    if not parent or not parent.rules:
+    if not parent:
         return True
     rules = parent.rules
-    if rule not in rules:
+    if not rules or rule not in rules:
         return False
     return True