ara-cli 0.1.4.30__tar.gz

ara_cli-0.1.4.30/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include ara_cli/templates *

ara_cli-0.1.4.30/PKG-INFO

@@ -0,0 +1,3 @@
+Metadata-Version: 2.1
+Name: ara_cli
+Version: 0.1.4.30

ara_cli-0.1.4.30/README.md

@@ -0,0 +1,67 @@
+- [ara-tool](#ara-tool)
+  - [best practices commit and merge and recreate workspace](#best-practices-commit-and-merge-and-recreate-workspace)
+  - [test and run during development](#test-and-run-during-development)
+  - [set version and build and install locally for testing outside of container](#set-version-and-build-and-install-locally-for-testing-outside-of-container)
+  - [upload to test pypi with test pypi API key](#upload-to-test-pypi-with-test-pypi-api-key)
+  - [upload to live pypi with talsen team production API key (from main branch)](#upload-to-live-pypi-with-talsen-team-production-api-key-from-main-branch)
+
+
+# ara-tool
+## best practices commit and merge and recreate workspace
+1. commit and publish everything in the branch
+2. go to git and merge
+3. destroy old workspace from merged branch from within the working directory
+   > workspace destroy
+4. go back in to top level working directory and check which repos are available for branching
+   > workspace repos
+5. create new workspacce with workspace command: workspace new <repo> <new-workspace-name>
+   > workspace new ara-cmd hans-ara-cmd
+6. switch to new workspace 
+   
+## test and run during development
+1. run `bash deploy.sh`
+2. run `bash login.sh`
+3. --> in container --> for behave BDD tests `bash test-feature.sh` 
+3. a) --> in container --> for only 1 test: behave ara/features/<name>.feature
+3. b) --> in container --> for unit tests and (if successful) feature tests: `bash test-all.sh` 
+4. --> in container --> for unit tests in folder ara_cli `pytest --cov=. --cov-report term-missing tests/ `
+5. --> in container --> example for running a single unit test in ara_cli folder `pytest tests/test_template_manager.py::test_files_created_from_template`
+6. if change is successfull always commit before proceeding with next change
+7. if change was successfully reviewd merge in gitlab: https://git.talsen.team/talsen-products/ara-tool/-/merge_requests/new
+
+## set version and build and install locally for testing outside of container
+1. set the new verion in the ara_cli/version.py file
+2. adapt the version number in the 'local_install.sh' file
+3. use `bash local_install.sh` to control local setup procedure
+4. Test the functionality
+
+## upload to test pypi with test pypi API key
+1. run `bash deploy.sh`
+2. run `login.sh`
+3. in `setup.py` and `local_install.sh` increment `version` otherwise upload will fail! 
+3. a) merge to staging and continue from a new workspace
+4. from inside container run `python setup.py sdist bdist_wheel`
+5. run the following command: 
+
+```bash
+twine upload --repository testpypi dist/* --verbose -u __token__ -p pypi-AgENdGVzdC5weXBpLm9yZwIkZGI5YzUyZTUtNDhjMy00NmI3LTgxNmMtY2QwMTRjYjZmZjlmAAIqWzMsImM3ZTM0MDRmLWU1MzUtNDliMi05ZDhiLWQ0NGUyNzlmYTU0MiJdAAAGID-dX7aQZZimTyUQeKPzbP0TlqMEpLQlzRW7VJr1JKab
+```
+
+this will upload to a test pypi account.
+
+
+6. run `python3 -m pip install --index-url https://test.pypi.org/simple/ ara_cli==<VERSION>`
+7. run `ara -h`
+8. if everything has worked (upload, installation and usage) you can now continue to upload the package to pypi (live)
+
+
+## upload to live pypi with talsen team production API key (from main branch)
+1. run `bash deploy.sh`
+2. run `login.sh`
+3. `dist` folder should still be there from the testupload (otherwise do `python setup.py sdist bdist_wheel` inside the container again), do NOT upload to live without previously testing in test pypi!
+4. Get the API-Key from [nextcloud](https://cloud.talsen.team/apps/keeweb/?open=%2Finfrastructure%2Fpublic-services%2Fapi-keys.kdbx)
+5. Get the Password from Hans or DevOps
+6. run the following command: 
+```bash
+twine upload dist/* --verbose -u __token__ -p <API-Key>
+``` 

ara_cli-0.1.4.30/ara_cli/__init__.py

@@ -0,0 +1 @@
+from .version import __version__

ara_cli-0.1.4.30/ara_cli/__main__.py

@@ -0,0 +1,259 @@
+from os.path import join, dirname
+import os
+import sys
+import argparse
+from ara_cli.version import __version__
+from ara_cli.artefact_creator import ArtefactCreator
+from ara_cli.artefact_renamer import ArtefactRenamer
+from ara_cli.classifier import Classifier
+from ara_cli.filename_validator import is_valid_filename
+from ara_cli.classifier_validator import is_valid_classifier
+from ara_cli.template_manager import SpecificationBreakdownAspects, TemplatePathManager
+from ara_cli.artefact_deleter import ArtefactDeleter
+from ara_cli.artefact_lister import ArtefactLister
+from ara_cli.vectorDB import create_DB, add_paths, reset_config, reset_DB, search_DB, update_DB
+from ara_cli.prompt_handler import read_prompt, send_prompt, append_headings, write_prompt_result, default_prompt_creation, initialize_prompt_templates, load_selected_prompt_templates, create_and_send_custom_prompt
+from ara_cli.prompt_extractor import extract_and_save_prompt_results
+
+from ara_cli.chat import Chat
+
+def check_validity(condition, error_message):
+    if not condition:
+        print(error_message)
+        sys.exit(1)
+
+def create_action(args):
+    if args.parameter and args.classifier and args.aspect:
+        sba = SpecificationBreakdownAspects()
+        try:
+            sba.create(args.parameter, args.classifier, args.aspect)
+        except ValueError as ve:
+            print(f"Error: {ve}")
+            sys.exit(1)
+
+    check_validity(is_valid_filename(args.parameter), "Invalid filename provided. Please provide a valid filename.")
+    check_validity(is_valid_classifier(args.classifier), "Invalid classifier provided. Please provide a valid classifier.")
+
+    template_path = join(dirname(__file__), 'templates')
+    artefact_creator = ArtefactCreator()
+    artefact_creator.run(args.parameter, args.classifier, template_path)
+
+def delete_action(args):
+    artefact_deleter = ArtefactDeleter()
+    artefact_deleter.delete(args.parameter, args.classifier)
+
+
+def rename_action(args):
+    check_validity(is_valid_filename(args.parameter), "Invalid filename provided. Please provide a valid filename.")
+    check_validity(is_valid_classifier(args.classifier), "Invalid classifier provided. Please provide a valid classifier.")
+    check_validity(is_valid_filename(args.aspect), "Invalid new filename provided. Please provide a valid filename.")
+
+    artefact_renamer = ArtefactRenamer()
+    artefact_renamer.rename(args.parameter, args.aspect, args.classifier)
+
+def list_action(args):
+    artefact_lister = ArtefactLister()
+    if args.tags:
+        artefact_lister.list_files(tags=args.tags)
+    else:
+        artefact_lister.list_files()
+    
+
+def prompt_action(args):
+    check_validity(is_valid_classifier(args.classifier), "Invalid classifier provided. Please provide a valid classifier.")
+    check_validity(is_valid_filename(args.parameter), "Invalid filename provided. Please provide a valid filename.")
+
+    classifier = args.classifier
+    param = args.parameter
+    init = args.init
+    
+    if (init == 'init'):
+        initialize_prompt_templates(classifier, param)
+    elif (init == 'load'):
+        load_selected_prompt_templates(classifier, param)
+    elif (init == 'send'):
+        create_and_send_custom_prompt(classifier, param)  # Use the new method when the 'send' command is used
+    elif (init == 'extract'):
+        extract_and_save_prompt_results(classifier, param)  # Use the new method when the 'send' command is used    
+    
+    else: # default rules.md, givens.md, prompt.md and commands.md files are used
+        default_prompt_creation(classifier, param)
+        prompt = read_prompt(classifier, param)
+        
+        if(prompt):
+            append_headings(classifier, param, "prompt")
+            write_prompt_result(classifier, param, prompt)
+            
+            response = send_prompt(prompt)
+            append_headings(classifier, param, "result")
+            write_prompt_result(classifier, param, response)
+
+
+def chat_action(args):
+    if args.name:
+        # Start or continue specific chat
+        chat_name = args.name
+    else:
+        # Start or continue default chat
+        chat_name = "chat"
+    chat = Chat(chat_name)
+    chat.start()
+
+def vector_action(args): 
+    match args.vector_command:
+        case 'init':
+            create_DB()
+
+        case 'update':
+            if args.path:
+                add_paths(args.path)
+            if not args.path:
+                update_DB()
+
+        case 'reset':
+            if args.config:
+                reset_config()
+            if not args.config:
+                reset_DB()
+
+        case 'search':
+            search_DB(args.amount, args.user_input)
+
+def template_action(args):
+    check_validity(is_valid_classifier(args.classifier), "Invalid classifier provided. Please provide a valid classifier.")
+    check_validity(Classifier.is_valid_classifier(args.classifier), "Invalid classifier provided. Please provide a valid classifier.")
+
+    template_manager = TemplatePathManager()
+    content = template_manager.get_template_content(args.classifier)
+
+def handle_invalid_action(args):
+    sys.exit("Invalid action provided. Type ara -h for help")
+
+def create_parser(subparsers):
+    create_parser = subparsers.add_parser("create", help="Create a file with a classifier and aspect")
+    create_parser.add_argument("parameter", help="Filename for create action")
+    create_parser.add_argument("classifier", help="Classifier for the file to be created")
+    create_parser.add_argument("aspect", help="Specification breakdown aspect", nargs='?', default=None)
+
+def delete_parser(subparsers):
+    delete_parser = subparsers.add_parser("delete", help="Delete a file with a classifier")
+    delete_parser.add_argument("parameter", help="Filename for delete action")
+    delete_parser.add_argument("classifier", help="Classifier for the file to be deleted")
+
+def rename_parser(subparsers):
+    rename_parser = subparsers.add_parser("rename", help="Rename a file with a classifier and new filename")
+    rename_parser.add_argument("parameter", help="Current filename for rename action")
+    rename_parser.add_argument("classifier", help="Classifier for the file to be renamed")
+    rename_parser.add_argument("aspect", help="New filename for the file")
+
+def list_parser(subparsers):
+    list_parser = subparsers.add_parser("list", help="List files with optional tags")
+    list_parser.add_argument("tags", nargs="*", help="Tags for listing files")
+
+def prompt_parser(subparsers):
+    prompt_parser = subparsers.add_parser("prompt", help="Creates a prompt and sends it to ChatGPT and save the result")
+    prompt_parser.add_argument("parameter", help="Filename for prompt action")
+    prompt_parser.add_argument("classifier", help="Classifier for the file to be prompted")
+    prompt_parser.add_argument("init", help="initialize | load | send the prompt template config selection file in the prompt directory", nargs='?', default=None)
+
+def vector_init_parser(vector_subparsers):
+    init_parser = vector_subparsers.add_parser("init", help="Initialize vectorDB")
+
+def vector_update_parser(vector_subparsers):
+    update_parser = vector_subparsers.add_parser("update", help="Update vectorDB")
+    update_parser.add_argument("path", nargs='*', help="Path(s) to add to config file", default=None)
+
+def vector_reset_parser(vector_subparsers):
+    reset_parser = vector_subparsers.add_parser("reset", help="Reset vectorDB")
+    reset_parser.add_argument("config", nargs="?", help="Optional config to reset", default=None)
+
+def vector_search_parser(vector_subparsers):
+    search_parser = vector_subparsers.add_parser("search", help="Search vectorDB")
+    search_parser.add_argument("amount", nargs="?", help="Amount of paths to return from search", default=4, type=int)
+    search_parser.add_argument("user_input", help="Required query to be executed on vectorDB")
+
+def vector_parser(subparsers):
+    vector_parser = subparsers.add_parser("vector")
+    vector_subparsers = vector_parser.add_subparsers(dest='vector_command')
+
+    vector_init_parser(vector_subparsers)
+    vector_update_parser(vector_subparsers)
+    vector_reset_parser(vector_subparsers)
+    vector_search_parser(vector_subparsers)
+
+def chat_parser(subparsers):
+    chat_parser = subparsers.add_parser("chat", help="Command line chatbot")
+    chat_parser.add_argument("name", help="Optional name for a specific chat. Pass the .md file to continue an existing chat", nargs='?', default=None)
+
+def template_parser(subparsers):
+    template_parser = subparsers.add_parser("template", help="Output ara template")
+    template_parser.add_argument("classifier", help="Classifier for ara artefact type")
+
+# TODO hack for ara-list command for listing python files
+def crawl_directory(start_dir):
+    python_files = []
+    for root, dirs, files in os.walk(start_dir):
+        for file in files:
+            if file.endswith(".py"):
+                python_files.append(os.path.join(root, file))
+    return python_files
+
+def format_output(files):
+    formatted_output = "Source files\n"
+    for file in files:
+        formatted_output += f"  - [ ] {file}\n"
+    return formatted_output
+
+def save_to_file(output, filename):
+    with open(filename, "w") as f:
+        f.write(output)
+
+def list():
+    if len(sys.argv) != 3:
+        print("Usage: python script.py <start_directory> <output_filename>")
+        sys.exit(1)
+
+    start_dir = sys.argv[1]
+    output_filename = sys.argv[2]
+
+    python_files = crawl_directory(start_dir)
+    output = format_output(python_files)
+    save_to_file(output, output_filename)
+    print(f"File list saved to {output_filename}")
+
+def cli():
+    parser = argparse.ArgumentParser(description="Ara tools for creating files and directories.")
+    # Add version argument
+    parser.add_argument('-v', '--version', action='version', version=f'%(prog)s {__version__}')
+
+    subparsers = parser.add_subparsers(dest="action", help="Action to perform")
+
+    create_parser(subparsers)
+    delete_parser(subparsers)
+    rename_parser(subparsers)
+    list_parser(subparsers)
+    prompt_parser(subparsers)
+    vector_parser(subparsers)
+    chat_parser(subparsers)
+    template_parser(subparsers)
+
+    action_mapping = {
+        "create": create_action,
+        "delete": delete_action,
+        "rename": rename_action,
+        "list": list_action,
+        "prompt": prompt_action,
+        "vector": vector_action,
+        "chat": chat_action,
+        "template": template_action
+    }
+
+    args = parser.parse_args()
+    if hasattr(args, 'action') and args.action:
+        action = action_mapping.get(args.action, handle_invalid_action)
+        action(args)
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    cli()

ara_cli-0.1.4.30/ara_cli/ara_config.py

@@ -0,0 +1,52 @@
+from typing import List, Dict
+from pydantic import BaseModel
+import json
+import os
+
+# Updated Pydantic model for ARA configuration
+class ARAconfig(BaseModel):
+    ext_code_dirs: List[Dict[str, str]] = [{"source_dir": "./src"}, {"tests_dir": "./tests"}]
+    glossary_dir: str = "./glossary"
+    doc_dir: str = "./docs"
+    local_prompt_templates_dir: str = "./ara/.araconfig/prompt-modules"
+    local_ara_templates_dir: str = "./ara/.araconfig/templates/"
+    ara_prompt_given_list_includes: List[str] = [
+        "*.businessgoal", "*.vision", "*.capability", "*.keyfeature", 
+        "*.epic", "*.userstory", "*.example", "*.feature", "*.task", "*.py", "*.md"
+    ]
+
+# Function to ensure the necessary directories exist
+def ensure_directory_exists(directory: str):
+    if not os.path.exists(directory):
+        os.makedirs(directory)
+        print(f"New directory created at {directory}")
+    return directory
+
+# Function to read the JSON file and return an ARAconfig model
+def read_data(filepath: str) -> ARAconfig:
+    if not os.path.exists(filepath):
+        # If file does not exist, create it with default values
+        default_config = ARAconfig()
+        with open(filepath, 'w') as file:
+            json.dump(default_config.dict(), file, indent=4)
+        print(f"ara-tool configuration file '{filepath}' created with default configuration. Please modify it as needed and re-run your command")
+        exit()  # Exit the application
+
+    with open(filepath, 'r') as file:
+        data = json.load(file)
+    return ARAconfig(**data)
+
+# Function to save the modified configuration back to the JSON file
+def save_data(filepath: str, config: ARAconfig):
+    with open(filepath, 'w') as file:
+        json.dump(config.dict(), file, indent=4)
+
+# Singleton for configuration management
+class ConfigManager:
+    _config_instance = None
+
+    @classmethod
+    def get_config(cls, filepath='./ara/.araconfig/ara_config.json'):
+        if cls._config_instance is None:
+            cls._config_instance = read_data(filepath)
+        return cls._config_instance

ara_cli-0.1.4.30/ara_cli/artefact.py

@@ -0,0 +1,47 @@
+from ara_cli.classifier import Classifier 
+import subprocess
+
+def execute_command(command, mock_input=None):
+    # print(f"DEBUG: Executing command: {command}")
+    if mock_input:
+        # print(f"DEBUG: Mock input provided: {mock_input}")
+        process = subprocess.Popen(command, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        stdout_data, stderr_data = process.communicate(input=mock_input.encode())
+    
+        # print(f"DEBUG: Command stdout: {stdout_data.decode().strip()}")
+        # print(f"DEBUG: Command stderr: {stderr_data.decode().strip()}")
+    else:
+        # print(f"DEBUG: No Mock input provided")
+        process = subprocess.run(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+     
+    return process
+
+class Artefact:
+    def __init__(self, name, classifier):
+        self.name = name
+        self.classifier = classifier
+        # print(f"DEBUG: Initialized Artefact with name='{name}' and classifier='{classifier}'")
+
+    def create(self):
+        command = f"ara create {self.name} {self.classifier}"
+        # print(f"DEBUG: Creating artefact with command: {command}")
+        result = execute_command(command, mock_input="y")
+        if result.returncode != 0:
+            # print(f"DEBUG: Error encountered during artefact creation.")
+            pass
+        else:
+            # print(f"DEBUG: Artefact created successfully.")
+            pass
+        return result
+
+    def delete(self):
+        command = f"ara delete {self.name} {self.classifier}"
+        # print(f"DEBUG: Deleting artefact with command: {command}")
+        result = execute_command(command, mock_input="y")
+        if result.returncode != 0:
+            # print(f"DEBUG: Error encountered during artefact deletion.")
+            pass
+        else:
+            # print(f"DEBUG: Artefact deleted successfully.")
+            pass
+        return result

ara_cli-0.1.4.30/ara_cli/artefact_creator.py

@@ -0,0 +1,120 @@
+import os
+from ara_cli.classifier import Classifier
+from ara_cli.file_classifier import FileClassifier
+from ara_cli.template_manager import DirectoryNavigator
+from pathlib import Path
+import shutil
+from shutil import rmtree
+from shutil import copyfile
+
+class ArtefactCreator:
+        
+    def __init__(self, file_system=None):
+        self.file_system = file_system or os
+
+    def create_artefact(self, dir_path, template_path, classifier):
+        if not template_path:
+            raise ValueError("template_path must not be None or empty!")
+
+        if not classifier:
+            raise ValueError("classifier must not be None or empty!")
+
+        # Standard exploration artefact
+        self._copy_template_file(dir_path, template_path, f"template.{classifier}_exploration.md", f"{classifier}_exploration.md")
+
+        # Additional exploration artefact for 'feature' classifier
+        if classifier == 'feature':
+            self._copy_template_file(dir_path, template_path, "template.steps_exploration.md", "steps_exploration.md")
+
+    def _copy_template_file(self, dir_path, template_path, source_name, dest_name):
+        source = Path(template_path) / source_name
+        destination = Path(dir_path) / dest_name
+
+        if not source.exists():
+            print("[ERROR] Source file does not exist!")
+            raise FileNotFoundError(f"Source file {source} not found!")
+        
+        if not destination.parent.exists():
+            print("[ERROR] Destination directory does not exist!")
+            raise NotADirectoryError(f"Destination directory {destination.parent} does not exist!")
+
+        copyfile(source, destination)
+
+
+    def create_file(self, file_path, template_path=None, classifier=None, filename=None):
+        if template_path and classifier:
+            template_file_path = self.file_system.path.join(template_path, f"template.{classifier}")
+            if self.file_system.path.exists(template_file_path):
+                with open(template_file_path, "r") as template_file:
+                    template_content = template_file.read()
+
+                formatted_filename = filename.replace("-", " ").replace("_", " ")
+                capitalized_filename = formatted_filename.capitalize()
+
+                template_content = template_content.replace("<descriptive title>", capitalized_filename)
+
+                with open(file_path, "w") as file:
+                    file.write(template_content)
+            else:
+                with open(file_path, "w") as file:
+                    pass
+        else:
+            with open(file_path, "w") as file:
+                pass
+
+    def create_directory(self, dir_path):
+        self.file_system.makedirs(dir_path, exist_ok=True)
+
+    def template_exists(self, template_path, template_name):
+        if not template_path:
+            return False
+
+        full_path = self.file_system.path.join(template_path, template_name)
+
+        if not self.file_system.path.isfile(full_path):
+            print(f"Template file '{template_name}' not found at: {full_path}")
+            return False
+
+        return True
+
+
+    def run(self, filename, classifier, template_path=None):
+        # make sure this function is always called from the ara top level directory
+        navigator = DirectoryNavigator()
+        navigator.navigate_to_target()
+
+        if not Classifier.is_valid_classifier(classifier):
+            print("Invalid classifier provided. Please provide a valid classifier.")
+            return
+
+        sub_directory = Classifier.get_sub_directory(classifier)
+        self.file_system.makedirs(sub_directory, exist_ok=True)
+
+        file_path = self.file_system.path.join(sub_directory, f"{filename}.{classifier}")
+        dir_path = self.file_system.path.join(sub_directory, f"{filename}.data")
+
+        if self.file_system.path.exists(file_path) or self.file_system.path.exists(dir_path):
+            user_choice = input("File or directory already exists. Do you want to overwrite the existing file and directory? (Y/N): ")
+
+            if user_choice.lower() != "y":
+                print("No changes were made to the existing file and directory.")
+                return
+
+        template_name = f"template.{classifier}"
+        if template_path and not self.template_exists(template_path, template_name):
+            print(f"Template file '{template_name}' not found in the specified template path.")
+            return
+
+        
+
+        self.create_file(file_path, template_path, classifier, filename)
+        self.create_directory(dir_path)
+        self.create_artefact(dir_path, template_path, classifier)
+
+        print(f"Created file: {file_path}")
+        print(f"Created directory: {dir_path}")
+        print(f"Created artefact exploration: {dir_path}/{classifier}_exploration.md")
+
+
+
+   

ara_cli-0.1.4.30/ara_cli/artefact_deleter.py

@@ -0,0 +1,42 @@
+# artefact_deleter.py
+import os
+import shutil
+from ara_cli.template_manager import DirectoryNavigator
+from ara_cli.classifier import Classifier
+from ara_cli.artefact_link_updater import ArtefactLinkUpdater
+
+class ArtefactDeleter:
+    def __init__(self, file_system=None):
+        self.file_system = file_system or os
+        self.link_updater = ArtefactLinkUpdater()
+
+    def delete(self, filename, classifier):
+        navigator = DirectoryNavigator()
+        navigator.navigate_to_target()
+
+        if not Classifier.is_valid_classifier(classifier):
+            print("Invalid classifier provided. Please provide a valid classifier.")
+            return
+
+        sub_directory = Classifier.get_sub_directory(classifier)
+        file_path = self.file_system.path.join(sub_directory, f"{filename}.{classifier}")
+        dir_path = self.file_system.path.join(sub_directory, f"{filename}.data")
+
+        if not self.file_system.path.exists(file_path) or not self.file_system.path.exists(dir_path):
+            print("File or directory not found.")
+            return
+
+        user_choice = input("Are you sure you want to delete the file and directory? (Y/N): ")
+
+        if user_choice.lower() != "y":
+            print("No changes were made.")
+            return
+
+        # Remove references to this artefact in other artefacts before deletion
+        self.link_updater.remove_links_in_related_artefacts(filename)
+
+        self.file_system.remove(file_path)
+        shutil.rmtree(dir_path)
+
+        print(f"Deleted file: {file_path}")
+        print(f"Deleted directory: {dir_path}")

ara_cli-0.1.4.30/ara_cli/artefact_link_updater.py

@@ -0,0 +1,72 @@
+# artefact_link_updater.py
+import os
+import re
+from ara_cli.classifier import Classifier
+
+class ArtefactLinkUpdater:
+
+    def __init__(self, file_system=None):
+        self.file_system = file_system or os
+
+    def update_links_in_related_artefacts(self, old_name, new_name, dir_path='.'):
+        new_name_formatted = new_name.replace('_', ' ').capitalize()
+        old_name_pattern = re.compile(f"\\b{old_name.replace(' ', '[ _]').replace('_', '[ _]')}\\b", re.IGNORECASE)
+
+        patterns = {
+            re.compile(f"^(\\s*)Contributes to[ ]+([A-Za-z ]+)?{old_name_pattern.pattern}", re.IGNORECASE | re.MULTILINE): r"\1Contributes to \2" + new_name_formatted,
+            re.compile(f"^(\\s*)Illustrates[ ]+([A-Za-z ]+)?{old_name_pattern.pattern}", re.IGNORECASE | re.MULTILINE): r"\1Illustrates \2" + new_name_formatted
+        }
+
+        # Iterate over all items in the directory
+        for item in self.file_system.listdir(dir_path):
+            item_path = self.file_system.path.join(dir_path, item)
+            extension = os.path.splitext(item)[-1][1:]
+            
+            # Check if it's a directory, then recurse
+            if self.file_system.path.isdir(item_path):
+                self.update_links_in_related_artefacts(old_name, new_name, item_path)
+            
+            # Check if it's a file and not a directory
+            elif self.file_system.path.isfile(item_path) and Classifier.is_valid_classifier(extension):
+                # Read the content of the file
+                with open(item_path, 'r') as file:
+                    content = file.read()
+                
+                # Replace all occurrences of the old name with the new name using regular expressions
+                for pattern, replacement in patterns.items():
+                    content = pattern.sub(replacement, content)
+                
+                # Write the updated content back to the file
+                with open(item_path, 'w') as file:
+                    file.write(content)
+
+    def remove_links_in_related_artefacts(self, artefact_name, dir_path="."):
+        artefact_name_pattern = re.compile(rf"\b{re.escape(artefact_name)}\b", re.IGNORECASE)
+
+        # Pattern for removing the artefact name from 'Contributes to' lines
+        contribute_pattern = re.compile(rf"^(Contributes to).*{artefact_name_pattern.pattern}.*$", re.IGNORECASE | re.MULTILINE)
+        
+        # Pattern for removing the artefact name from 'Illustrates' lines (no colon)
+        illustrates_pattern = re.compile(rf"^(Illustrates).*{artefact_name_pattern.pattern}.*$", re.IGNORECASE | re.MULTILINE)
+
+        # Iterate over all items in the directory
+        for item in self.file_system.listdir(dir_path):
+            item_path = self.file_system.path.join(dir_path, item)
+            extension = os.path.splitext(item)[-1][1:]
+            
+            # Check if it's a directory, then recurse
+            if self.file_system.path.isdir(item_path):
+                self.remove_links_in_related_artefacts(artefact_name, item_path)
+            
+            # Check if it's a file and not a directory, and if extension is a valid artefact classifier
+            elif self.file_system.path.isfile(item_path) and Classifier.is_valid_classifier(extension):
+                with open(item_path, 'r') as file:
+                    content = file.read()
+                
+                # Remove the artefact name from 'Contributes to' and 'Illustrates' lines
+                content = contribute_pattern.sub("Contributes to", content)
+                content = illustrates_pattern.sub("Illustrates", content)
+                
+                with open(item_path, 'w') as file:
+                    file.write(content)
+