ara-cli 0.1.9.73__py3-none-any.whl → 0.1.9.75__py3-none-any.whl

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,27 +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
-            )
-            
-            # Check if the referenced artefact exists
-            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/chat.py

@@ -731,9 +731,27 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
     @cmd2.with_category(CATEGORY_CHAT_CONTROL)
     def do_LOAD_TEMPLATE(self, template_name):
         """Load artefact template"""
-        directory = os.path.join(os.path.dirname(__file__), 'templates')
-        pattern = f"template.{template_name}"
-        file_type = "template"
-        exclude_pattern = os.path.join(directory, "template.*.prompt_log.md")
+        from ara_cli.artefact_models.artefact_templates import template_artefact_of_type
 
-        self._load_helper(directory, pattern, file_type, exclude_pattern)
+        artefact = template_artefact_of_type(''.join(template_name))
+        if not artefact:
+            return
+        write_content = artefact.serialize()
+        self.add_prompt_tag_if_needed(self.chat_name)
+        with open(self.chat_name, 'a', encoding='utf-8') as chat_file:
+            chat_file.write(write_content)
+        print(f"Loaded {template_name} artefact template")
+
+    def complete_LOAD_TEMPLATE(self, text, line, begidx, endidx):
+        return self._complete_classifiers(self, text, line, begidx, endidx)
+
+    def _complete_classifiers(self, text, line, begidx, endidx):
+        from ara_cli.classifier import Classifier
+
+        classifiers = Classifier.ordered_classifiers()
+        if not text:
+            completions = classifiers
+        else:
+            completions = [classifier for classifier in classifiers if classifier.startswith(text)]
+
+        return completions

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)

ara_cli/tag_extractor.py

@@ -7,6 +7,47 @@ class TagExtractor:
     def __init__(self, file_system=None):
         self.file_system = file_system or os
 
+    def filter_column(self, tags_set, filtered_artefacts):
+        status_tags = {"to-do", "in-progress", "review", "done", "closed"}
+
+        artefacts_to_process = self._get_artefacts_without_status_tags(filtered_artefacts, status_tags)
+        self._add_non_status_tags_to_set(tags_set, artefacts_to_process, status_tags)
+
+    def _get_artefacts_without_status_tags(self, filtered_artefacts, status_tags):
+        artefacts_to_process = []
+        for artefact_list in filtered_artefacts.values():
+            for artefact in artefact_list:
+                tag_set = self._get_tag_set(artefact)
+                if not tag_set & status_tags:
+                    artefacts_to_process.append(artefact)
+        return artefacts_to_process
+
+    def _get_tag_set(self, artefact):
+        tags = artefact.tags + [artefact.status] if artefact.status else artefact.tags
+        return set(tag for tag in tags if tag is not None)
+
+    def _add_non_status_tags_to_set(self, tags_set, artefacts, status_tags):
+        for artefact in artefacts:
+            tags = [tag for tag in (artefact.tags + [artefact.status]) if tag is not None]
+            for tag in tags:
+                if self._is_skipped_tag(tag, status_tags):
+                    continue
+                tags_set.add(tag)
+
+    def _is_skipped_tag(self, tag, status_tags):
+        return (
+            tag in status_tags
+            or tag.startswith("priority_")
+            or tag.startswith("user_")
+        )
+
+    def add_to_tags_set(self, tags_set, filtered_artefacts):
+        for artefact_list in filtered_artefacts.values():
+            for artefact in artefact_list:
+                user_tags = [f"user_{tag}" for tag in artefact.users]
+                tags = [tag for tag in (artefact.tags + [artefact.status] + user_tags) if tag is not None]
+                tags_set.update(tags)
+
     def extract_tags(
         self,
         navigate_to_target=False,
@@ -33,35 +74,9 @@ class TagExtractor:
         unique_tags = set()
 
         if filtered_extra_column:
-            status_tags = {"to-do", "in-progress", "review", "done", "closed"}
-            artefacts_to_process = []
-
-            for artefact_list in filtered_artefacts.values():
-                for artefact in artefact_list:
-                    tags = artefact.tags + \
-                        [artefact.status] if artefact.status else artefact.tags
-                    tag_set = set(tag for tag in tags if tag is not None)
-                    if not tag_set & status_tags:
-                        artefacts_to_process.append(artefact)
-
-            for artefact in artefacts_to_process:
-                tags = [tag for tag in (
-                    artefact.tags + [artefact.status]) if tag is not None]
-                for tag in tags:
-                    if (
-                        tag in status_tags
-                        or tag.startswith("priority_")
-                        or tag.startswith("user_")
-                    ):
-                        continue
-                    unique_tags.add(tag)
-
+            self.filter_column(unique_tags, filtered_artefacts)
         else:
-            for artefact_list in filtered_artefacts.values():
-                for artefact in artefact_list:
-                    user_tags = [f"user_{tag}" for tag in artefact.users]
-                    tags = [tag for tag in (artefact.tags + [artefact.status] + user_tags) if tag is not None]
-                    unique_tags.update(tags)
+            self.add_to_tags_set(unique_tags, filtered_artefacts)
 
         sorted_tags = sorted(unique_tags)
         return sorted_tags

ara_cli/template_manager.py

@@ -4,6 +4,7 @@ from pathlib import Path
 from shutil import copy
 from ara_cli.classifier import Classifier
 from ara_cli.directory_navigator import DirectoryNavigator
+from ara_cli.artefact_models.artefact_templates import template_artefact_of_type
 
 
 class TemplatePathManager:
@@ -30,14 +31,8 @@ class TemplatePathManager:
         ]
 
     def get_template_content(self, classifier):
-        base_path = self.get_template_base_path()
-
-        template_path = (base_path / f"template.{classifier}")
-
-        with template_path.open('r', encoding='utf-8') as file:
-            content = file.read()
-
-        return content
+        artefact = template_artefact_of_type(classifier)
+        return artefact.serialize()
 
 
 class ArtefactFileManager:

ara_cli/version.py

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

{ara_cli-0.1.9.73.dist-info → ara_cli-0.1.9.75.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ara_cli
-Version: 0.1.9.73
+Version: 0.1.9.75
 Requires-Dist: litellm
 Requires-Dist: llama-index
 Requires-Dist: llama-index-llms-openai