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

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,
@@ -214,7 +222,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
 

ara_cli/chat.py

@@ -13,25 +13,6 @@ from ara_cli.file_loaders.binary_file_loader import BinaryFileLoader
 from ara_cli.file_loaders.text_file_loader import TextFileLoader
 
 
-extract_parser = argparse.ArgumentParser()
-extract_parser.add_argument(
-    "-f", "--force", action="store_true", help="Force extraction"
-)
-extract_parser.add_argument(
-    "-w",
-    "--write",
-    action="store_true",
-    help="Overwrite existing files without using LLM for merging.",
-)
-
-load_parser = argparse.ArgumentParser()
-load_parser.add_argument("file_name", nargs="?", default="", help="File to load")
-load_parser.add_argument(
-    "--load-images",
-    action="store_true",
-    help="Extract and describe images from documents",
-)
-
 extract_parser = argparse.ArgumentParser()
 extract_parser.add_argument(
     "-f", "--force", action="store_true", help="Force extraction"
@@ -763,6 +744,7 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
             return
         self.create_empty_chat_file(self.chat_name)
         self.chat_history = self.load_chat_history(self.chat_name)
+        self.message_buffer.clear()
         print(f"Cleared content of {self.chat_name}")
 
     @cmd2.with_category(CATEGORY_CHAT_CONTROL)

ara_cli/commands/read_command.py

@@ -30,6 +30,11 @@ class ReadCommand(Command):
         """Execute the read command and return success status."""
         file_classifier = FileClassifier(os)
         classified_artefacts = ArtefactReader.read_artefacts()
+
+        if not self.classifier or not self.artefact_name:
+            self._filter_and_print(classified_artefacts, file_classifier)
+            return True
+
         artefacts = classified_artefacts.get(self.classifier, [])
         all_artefact_names = [a.title for a in artefacts]
 
@@ -62,10 +67,11 @@ class ReadCommand(Command):
                     )
 
             # Apply filtering and print results
-            filtered_artefacts = self._apply_filtering(artefacts_by_classifier)
-            file_classifier.print_classified_files(
-                filtered_artefacts, print_content=True
-            )
+            self._filter_and_print(artefacts_by_classifier, file_classifier)
+            # filtered_artefacts = self._apply_filtering(artefacts_by_classifier)
+            # file_classifier.print_classified_files(
+            #     filtered_artefacts, print_content=True
+            # )
             return True
 
         except Exception as e:
@@ -102,3 +108,10 @@ class ReadCommand(Command):
             file_path_retrieval=artefact_path_retrieval,
             tag_retrieval=artefact_tags_retrieval
         )
+
+    def _filter_and_print(self, artefacts_by_classifier, file_classifier):
+        """Apply list filtering and print results"""
+        filtered_artefacts = self._apply_filtering(artefacts_by_classifier)
+        file_classifier.print_classified_files(
+            filtered_artefacts, print_content=True
+        )

ara_cli/completers.py

@@ -0,0 +1,144 @@
+import os
+from typing import List, Optional
+from pathlib import Path
+import typer
+
+from ara_cli.classifier import Classifier
+from ara_cli.template_manager import SpecificationBreakdownAspects
+
+
+def complete_classifier(incomplete: str) -> List[str]:
+    """Complete classifier names."""
+    classifiers = Classifier.ordered_classifiers()
+    return [c for c in classifiers if c.startswith(incomplete)]
+
+
+def complete_aspect(incomplete: str) -> List[str]:
+    """Complete aspect names."""
+    aspects = SpecificationBreakdownAspects.VALID_ASPECTS
+    return [a for a in aspects if a.startswith(incomplete)]
+
+
+def complete_status(incomplete: str) -> List[str]:
+    """Complete task status values."""
+    statuses = ["to-do", "in-progress", "review", "done", "closed"]
+    return [s for s in statuses if s.startswith(incomplete)]
+
+
+def complete_template_type(incomplete: str) -> List[str]:
+    """Complete template type values."""
+    template_types = ["rules", "intention", "commands", "blueprint"]
+    return [t for t in template_types if t.startswith(incomplete)]
+
+
+def complete_artefact_name(classifier: str) -> List[str]:
+    """Complete artefact names for a given classifier."""
+    try:
+        # Get the directory for the classifier
+        classifier_dir = f"ara/{Classifier.get_sub_directory(classifier)}"
+        
+        if not os.path.exists(classifier_dir):
+            return []
+        
+        # Find all files with the classifier extension
+        artefacts = []
+        for file in os.listdir(classifier_dir):
+            if file.endswith(f'.{classifier}'):
+                # Remove the extension to get the artefact name
+                name = file[:-len(f'.{classifier}')]
+                artefacts.append(name)
+        
+        return sorted(artefacts)
+    except Exception:
+        return []
+
+
+def complete_artefact_name_for_classifier(classifier: str):
+    """Create a completer function for artefact names of a specific classifier."""
+    def completer(incomplete: str) -> List[str]:
+        artefacts = complete_artefact_name(classifier)
+        return [a for a in artefacts if a.startswith(incomplete)]
+    return completer
+
+
+def complete_chat_files(incomplete: str) -> List[str]:
+    """Complete chat file names (without .md extension)."""
+    try:
+        chat_files = []
+        current_dir = Path.cwd()
+        
+        # Look for .md files in current directory
+        for file in current_dir.glob("*.md"):
+            name = file.stem
+            if name.startswith(incomplete):
+                chat_files.append(name)
+        
+        return sorted(chat_files)
+    except Exception:
+        return []
+
+
+# Dynamic completers that need context
+class DynamicCompleters:
+    @staticmethod
+    def create_classifier_completer():
+        """Create a completer for classifiers."""
+        def completer(ctx: typer.Context, incomplete: str) -> List[str]:
+            return complete_classifier(incomplete)
+        return completer
+    
+    @staticmethod
+    def create_aspect_completer():
+        """Create a completer for aspects."""
+        def completer(ctx: typer.Context, incomplete: str) -> List[str]:
+            return complete_aspect(incomplete)
+        return completer
+    
+    @staticmethod
+    def create_status_completer():
+        """Create a completer for status values."""
+        def completer(ctx: typer.Context, incomplete: str) -> List[str]:
+            return complete_status(incomplete)
+        return completer
+    
+    @staticmethod
+    def create_template_type_completer():
+        """Create a completer for template types."""
+        def completer(ctx: typer.Context, incomplete: str) -> List[str]:
+            return complete_template_type(incomplete)
+        return completer
+    
+    @staticmethod
+    def create_artefact_name_completer():
+        """Create a completer for artefact names based on classifier context."""
+        def completer(ctx: typer.Context, incomplete: str) -> List[str]:
+            # Try to get classifier from context
+            if hasattr(ctx, 'params') and 'classifier' in ctx.params:
+                classifier = ctx.params['classifier']
+                if hasattr(classifier, 'value'):
+                    classifier = classifier.value
+                artefacts = complete_artefact_name(classifier)
+                return [a for a in artefacts if a.startswith(incomplete)]
+            return []
+        return completer
+    
+    @staticmethod
+    def create_parent_name_completer():
+        """Create a completer for parent artefact names based on parent classifier context."""
+        def completer(ctx: typer.Context, incomplete: str) -> List[str]:
+            # Try to get parent_classifier from context
+            if hasattr(ctx, 'params') and 'parent_classifier' in ctx.params:
+                parent_classifier = ctx.params['parent_classifier']
+                if hasattr(parent_classifier, 'value'):
+                    parent_classifier = parent_classifier.value
+                artefacts = complete_artefact_name(parent_classifier)
+                return [a for a in artefacts if a.startswith(incomplete)]
+            return []
+        return completer
+    
+    @staticmethod
+    def create_chat_file_completer():
+        """Create a completer for chat files."""
+        def completer(ctx: typer.Context, incomplete: str) -> List[str]:
+            return complete_chat_files(incomplete)
+        return completer

ara_cli/file_loaders/text_file_loader.py

@@ -19,14 +19,14 @@ class TextFileLoader(FileLoader):
 
         if is_md_file and extract_images:
             reader = MarkdownReader(file_path)
-            file_content = reader.read(extract_images=True)
+            file_content = reader.read(extract_images=True).replace('\r\n', '\n')
         else:
             # Use charset-normalizer to detect encoding
             encoded_content = from_path(file_path).best()
             if not encoded_content:
                 print(f"Failed to detect encoding for {file_path}")
                 return False
-            file_content = str(encoded_content)
+            file_content = str(encoded_content).replace('\r\n', '\n')
 
         if block_delimiter:
             file_content = f"{block_delimiter}\n{file_content}\n{block_delimiter}"