developer-assistant 0.2.0__py3-none-any.whl

DA/Interface.py

@@ -0,0 +1,241 @@
+import os, sys
+import time
+import platform
+import subprocess
+import shutil
+from pathlib import Path
+from termcolor import colored
+from rich.progress import track
+from rich.console import Console
+from rich.markdown import Markdown
+
+from DA.Modules.projects_manager import ProjectsManager
+from DA.Modules.config_manager import ConfigManager
+from DA.Modules.opener import Opener
+from importlib import resources
+
+class Interface:
+    def __init__(self, color="light_blue"):
+        self.version = "0.2.0"
+        title = f"DA - {self.version}"
+
+        if platform.system() == "Windows":
+            os.system(f'title {title}')
+        else:
+            print(f'\33]0;{title}\a', end='', flush=True)
+
+        self.config = ConfigManager('memory.ini')
+
+        first_run = False
+        if not self.config.memory_ini.exists():
+            self.local_init()
+            self.config = ConfigManager('memory.ini')
+            first_run = True
+
+        self.projects_manager = ProjectsManager()
+
+        self.memory = self.config.load_memory()
+        self.color = self.memory.get('color') or color
+        
+        #==Reusables==
+        self.header = (colored(" Developer Assistant ", f"{self.color}"))
+        self.clear_screen = 'cls' if platform.system() == 'Windows' else 'clear'
+        self.user_path = os.environ.get('USERPROFILE') or os.environ.get('HOME', 'User')
+        
+        if first_run:
+            self.intro()
+
+        self.load()
+    
+    def load(self):
+        temp_log = Path(__file__).parent / "CHANGELOG.tmp"
+
+        if os.path.exists(temp_log):
+            while True:
+                os.system(self.clear_screen)
+                print(colored(f"Temporary changelog detected in:\n{temp_log}\n", "yellow"))
+                print(colored("D", "light_red") + "elete or " + colored("K", "light_red") + "eep?\n")
+                choice = input(f"{self.user_path}> ").lower()
+                if choice == "d":
+                    os.remove(temp_log)
+                    break
+                elif choice == "k":
+                    break
+                else:
+                    print(colored("\nPlease make a valid choice.", "light_red"))
+                    time.sleep(1.5)
+
+        os.system(self.clear_screen)
+        message = (colored("Developer Assistant Ver. ", attrs=["bold"]) + (colored(self.version, f"{self.color}", attrs=["bold"])))
+        status = (colored("Loading, please wait... ", attrs=["blink"]))
+        
+        print(message.center(85))
+        print("")
+        print(status.center(73))
+        
+        for i in track(range(20)):
+            time.sleep(0.10)
+        
+        self.menu()
+        
+    def menu(self):
+        while True:
+            os.system(self.clear_screen)
+            print("Main menu")
+            print(self.header.center(127, "="))
+            print("\nE. Exit\n")
+            print("1. Projects")
+            print("2. Settings\n")
+
+            choice = input(f"{self.user_path}> ").strip()
+
+            if choice.lower() == "e":
+                os.system(self.clear_screen)
+                print(self.header.center(127, "="))
+                print("Bye!")
+                time.sleep(2)
+                raise SystemExit
+
+            elif choice == "1":
+                self.projects()
+
+            elif choice == "2":
+                self.settings()
+            else:
+                print("")
+                print(colored("Unknown option...", "light_red", attrs=["blink"]))
+                time.sleep(2)
+        
+    def projects(self):
+        config = ConfigManager('memory.ini')
+        self.memory = config.load_memory()
+        while True:
+            os.system(self.clear_screen)
+            print("Main menu / Projects")
+            print(self.header.center(127, "="))
+            print("E. Back\n")
+            print(colored("1. The last project:", attrs=["underline"]))
+            print(colored(self.memory.get('last_project'), f"{self.color}"))
+            print("\n2. Start a new project.\n")
+            print(colored("Continue a project.", attrs=["underline"]))
+            print("Pinned:")
+            print("a. " + colored(self.memory.get('pinned_project'), f"{self.color}"))
+            print("b. " + colored(self.memory.get('pinned_project1'), f"{self.color}"))
+            print("c. " + colored(self.memory.get('pinned_project2'), f"{self.color}"))
+
+            print("")
+            choice = input(f"{self.user_path}> ").strip()
+
+            if choice.lower() == "e":
+                return
+
+            elif choice == "1":
+                project = self.memory.get('last_project')
+                if not project:
+                    print(colored("\nLast project has not been defined...", "light_red", attrs=["blink"]))
+                    time.sleep(2)
+                else:
+                    self.projects_manager.load_project(f"{project}")
+
+            elif choice == "2":
+                self.projects_manager.new_project()
+
+            elif choice.lower() in ("a", "b", "c"):
+                #==If the pinned project is empty, return an error message==
+                options_map = {
+                    'a': 'pinned_project',
+                    'b': 'pinned_project1',
+                    'c': 'pinned_project2'
+                }
+                key = options_map.get(choice.lower())
+                project_name = self.memory.get(key)
+                if project_name == "":
+                    print("")
+                    print(colored(f"Project '{choice}' has not been defined...", "light_red", attrs=["blink"]))
+                    time.sleep(2)
+                else:
+                    project = self.memory.get(key)
+                    self.projects_manager.load_project(f"{project}")
+
+            else:
+                print("")
+                print(colored("Unknown option...", "light_red", attrs=["blink"]))
+                time.sleep(2)
+    
+    def settings(self):
+        while True:
+            os.system(self.clear_screen)
+            print("Main menu / Settings")
+            print(self.header.center(127, "="))
+            print("E. Back\n")
+            print(colored("Configuration options", attrs=["underline"]))
+            print("1. Edit pinned projects [WIP]")
+            print("2. Change program's color [WIP]\n")
+            print(colored("Other options", attrs=["underline"]))
+            print("3. Open memory.ini manually")
+            print("4. Open the Projects folder")
+            print("5. Open the Templates folder\n")
+
+            choice = input(f"{self.user_path}> ").strip()
+
+            if choice.lower() == "e":
+                return
+            elif choice == "1":
+                pass
+            elif choice == "2":
+                pass
+            elif choice == "3":
+                Opener.open(self.config.memory_ini)
+            elif choice == "4":
+                Opener.open(self.config.projects_folder)
+            elif choice == "5":
+                Opener.open(self.config.templates_folder)
+            else:
+                print("")
+                print(colored("Unknown option...", "light_red", attrs=["blink"]))
+                time.sleep(2)
+
+    def local_init(self):
+        default_files = resources.files("DA.default")
+        dest = self.config.memory_ini
+
+        for item in default_files.iterdir():
+            if item.name == "default-memory.ini":
+                shutil.copy(item, dest)
+
+        self.config.projects_folder.mkdir(parents=True, exist_ok=True)
+        # Add Test-Project
+        dest = self.config.projects_folder
+        for item in default_files.iterdir():
+            if item.name == "Test-Project.ini":
+                shutil.copy(item, dest)
+
+    def intro(self):
+        os.system(self.clear_screen)
+        print(colored("Welcome to the Developer Assistant\n", f"{self.color}", attrs=["bold"]))
+        print("Here's everything you need to get started:\n")
+
+        time.sleep(2)
+
+        readme_content = resources.files("DA").joinpath("intro.md").read_text()
+
+        MARKDOWN = readme_content
+        console = Console()
+        md = Markdown(MARKDOWN)
+        console.print(md)
+
+        input("\nContinue..." + colored("[Enter]", f"{self.color}"))
+
+        self.menu()
+
+def main():
+    try:
+        app = Interface()
+        app.run()
+    except KeyboardInterrupt:
+        print("\n\n" + colored("Execution interrupted by the user. Exiting...", "magenta", attrs=["bold"]))
+        time.sleep(2)
+        sys.exit(0)
+
+if __name__ == "__main__":
+    main()

DA/Modules/config_manager.py

@@ -0,0 +1,126 @@
+import configparser
+from pathlib import Path
+import shutil
+import time
+
+from platformdirs import user_config_path
+
+from importlib import resources
+
+class ConfigManager:
+    def __init__(self, config_file):
+        self.config = configparser.ConfigParser()
+        
+        #==Path setup==
+        self.internal_dir = Path(__file__).resolve().parents[1]
+        self.global_dir = user_config_path("da-ui")
+        self.global_dir.mkdir(parents=True, exist_ok=True)
+        
+        #==Specific targets==
+        self.memory_ini = self.global_dir / 'memory.ini'
+        self.projects_folder = self.global_dir / "Projects"
+        self.templates_folder = self.global_dir / "Templates"
+        self.new_project_ini = self.projects_folder / config_file
+
+        self.migrate_old_data()
+
+        #==Update last_project in memory.ini==
+        self.update_last_project = Path(config_file).stem
+
+        self.config.read(self.memory_ini)
+
+    def migrate_old_data(self):
+        old_memory = self.internal_dir / "memory.ini"
+        old_projects = self.internal_dir / "Projects"
+
+        if old_memory.exists() and not self.memory_ini.exists():
+            shutil.move(str(old_memory), str(self.memory_ini))
+            print(f"Migrated memory.ini to {self.global_dir}")
+            time.sleep(2)
+
+        if old_projects.exists() and not self.projects_folder.exists():
+            shutil.move(str(old_projects), str(self.projects_folder))
+            print(f"Migrated Projects folder to {self.global_dir}")
+            time.sleep(2)
+
+        if not self.templates_folder.exists():
+            default_templates = resources.files("DA.Templates")
+            user_templates = self.templates_folder
+
+            user_templates.mkdir(parents=True, exist_ok=True)
+
+            for item in default_templates.iterdir():
+                dest = user_templates / item.name
+                if not dest.exists():
+                    shutil.copy(item, dest)
+
+            print(f"Copied default Templates to {self.global_dir}")
+            time.sleep(2)
+
+    def load_memory(self):
+        prj = self.config['ITEMS']
+        return {
+            'last_project': prj.get('last_project'),
+            'pinned_project': prj.get('pinned_project'),
+            'pinned_project1': prj.get('pinned_project1'),
+            'pinned_project2': prj.get('pinned_project2'),
+            'color': self.config.get("CONFIG", "color")
+        }
+
+    def update_memory(self, category: str, variable: str, value: str):
+        memory_parser = configparser.ConfigParser()
+        memory_parser.read(self.memory_ini)
+
+        memory_parser.set(category, variable, value)
+        with open(self.memory_ini, "w", encoding="utf-8") as f:
+            memory_parser.write(f)
+        return
+        
+    def project_ini(self):
+        #==Create new project ini==
+        project_parser = configparser.ConfigParser()
+        project_parser["SETTINGS"] = self.data
+        
+        with open(self.new_project_ini, "w", encoding="utf-8") as f:
+            project_parser.write(f)
+            
+        #==Update last_project in memory.ini==
+        memory_parser = configparser.ConfigParser()
+        memory_parser.read(self.memory_ini)
+        
+        memory_parser.set("ITEMS", "last_project", self.update_last_project)
+        with open(self.memory_ini, "w", encoding="utf-8") as f:
+            memory_parser.write(f)
+        return
+    
+    def load_project(self):
+        #==Return project ini variables==
+        project_parser = configparser.ConfigParser()
+        project_parser.read(self.new_project_ini)
+        '''
+        try:
+            prj = project_parser['SETTINGS']
+        except KeyError:
+            print(f"\nCan't find {self.new_project_ini}")
+            time.sleep(2)
+            return
+        '''
+        prj = project_parser['SETTINGS']
+        return {
+            'path': prj.get('path'),
+            'changelog': prj.get('changelog'),
+            'version': prj.get('version'),
+            'cloud': prj.get('cloud')
+        }
+
+    def update_project(self, variable: str, value: str):
+        project_parser = configparser.ConfigParser()
+        project_parser.read(self.new_project_ini)
+
+        project_parser.set("SETTINGS", variable, value)
+        with open(self.new_project_ini, "w", encoding="utf-8") as f:
+            project_parser.write(f)
+        return
+
+if __name__ == "__main__":
+    ConfigManager()

DA/Modules/opener.py

@@ -0,0 +1,31 @@
+from termcolor import colored
+import subprocess
+import platform
+import os
+import time
+
+class Opener:
+    @staticmethod
+    def open(path):
+        #==Check if path exists==
+        if not os.path.exists(path):
+            print(colored("\nThis path does not exist.", "light_red"))
+            time.sleep(1.5)
+            return
+        #==Open if exists==
+        else:
+            system = platform.system()
+            if system == "Windows":
+                subprocess.Popen(['explorer', path])
+            elif system == "Darwin":
+                subprocess.Popen(['open', path])
+            else:
+                subprocess.Popen(
+                    ['xdg-open', path],
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL
+                )
+            return
+
+if __name__ == "__main__":
+    Opener()

DA/Modules/projects_manager.py

@@ -0,0 +1,120 @@
+import os, sys
+import time
+from termcolor import colored
+import subprocess
+import platform
+from pathlib import Path
+
+from DA.Modules.config_manager import ConfigManager
+from DA.Modules.version_logic import VersionLogic
+from DA.Modules.opener import Opener
+
+class ProjectsManager:
+    def __init__(self, color="light_blue"):
+        os.system('title Developer Assistant')
+        self.version = "1.0.0-alpha"
+        
+        self.config = ConfigManager('memory.ini')
+        self.memory = self.config.load_memory()
+        self.color = self.memory.get('color') or color
+        
+        #==Reusables==
+        self.header = (colored(" Developer Assistant ", f"{self.color}"))
+        self.clear_screen = 'cls' if platform.system() == 'Windows' else 'clear'
+        self.user_path = os.environ.get('USERPROFILE') or os.environ.get('HOME', 'User')
+    
+    def new_project(self):
+        os.system(self.clear_screen)
+        print(self.header.center(127, "="))
+        print("E. Abort/back\n")
+        
+        name = input("Enter new project name: ")
+        if name.lower() == "e":
+            return
+
+        print("")
+        path = input("Enter project path: ")
+
+        print("")
+        changelog = input("Project changelog path: ")
+
+        print("")
+        version = input("Current project version: ")
+
+        print("")
+        cloud = input("Cloud service (OneDrive/Azure/Dropbox/Google Drive): ")
+
+        print("")
+        confirm = input("Confirm(Y) or abort(E): ")
+        if confirm.lower() == "e":
+            return
+            
+        elif confirm.lower() == "y":
+            self.new_manager = ConfigManager(f"{name}.ini")
+            self.new_manager.data = {
+                "path": path,
+                "changelog": changelog,
+                "version": version,
+                "cloud": cloud
+            }
+            self.new_manager.project_ini()
+
+            return
+            
+        else:
+            print("")
+            print(colored("Unknown option, try again...", "light_red", attrs=["blink"]))
+            time.sleep(2)
+            return
+            
+    def load_project(self, project):
+        while True:
+            chosen_project = f"{project}"
+            self.load_manager = ConfigManager(f"{project}.ini")
+            try:
+                self.setting = self.load_manager.load_project()
+            except KeyError:
+                print(colored(f"\nCan't find {chosen_project}.ini", "light_red"))
+                time.sleep(2)
+                return
+
+            self.version_logic = VersionLogic()
+
+            project_ini_path = self.load_manager.projects_folder / f"{chosen_project}.ini"
+
+            os.system(self.clear_screen)
+            print("Main menu / Projects / Project menu")
+            print(self.header.center(127, "="))
+            print("E. Back\n")
+            print(colored("Chosen project:", attrs=["underline"]))
+            print(colored(chosen_project, f"{self.color}"))
+            print("\n1. Open project folder.")
+            print("2. Update the changelog.")
+            print("3. Backup to the cloud. [WIP]")
+            print("4. Open project configurations.\n")
+
+            choice = input(f"{self.user_path}> ").strip()
+
+            if choice.lower() == "e":
+                return
+
+            elif choice == "1":
+                path = self.setting.get('path')
+                folder = Path(path)
+                Opener.open(folder)
+
+            elif choice == "2":
+                self.version_logic.project_menu(chosen_project)
+
+            # elif choice == "3":
+
+            elif choice == "4":
+                Opener.open(project_ini_path)
+
+            else:
+                print("")
+                print(colored("Unknown option...", "light_red", attrs=["blink"]))
+                time.sleep(2)
+        
+if __name__ == "__main__":
+    ProjectsManager()

DA/Modules/version_logic.py

@@ -0,0 +1,315 @@
+import os, sys
+import time
+import subprocess
+import platform
+import shutil
+from datetime import datetime
+from pathlib import Path
+from termcolor import colored
+from prompt_toolkit import prompt
+from rich.console import Console
+from rich.markdown import Markdown
+
+from DA.Modules.config_manager import ConfigManager
+from DA.Modules.opener import Opener
+
+class VersionLogic:
+    def __init__(self, color="light_blue"):
+        self.config = ConfigManager('memory.ini')
+        self.memory = self.config.load_memory()
+        self.color = self.memory.get('color') or color
+        
+        #==Reusables==
+        self.header = (colored(" Developer Assistant ", f"{self.color}"))
+        self.clear_screen = 'cls' if platform.system() == 'Windows' else 'clear'
+        self.user_path = os.environ.get('USERPROFILE') or os.environ.get('HOME', 'User')
+    
+    def project_menu(self, project):
+        self.active_project = project
+
+        self.load_manager = ConfigManager(f"{project}.ini")
+        self.setting = self.load_manager.load_project()
+        self.changelog_path = Path(self.setting.get('changelog'))
+
+        now = datetime.now()
+        self.today = now.strftime("%Y-%m-%d")
+
+        ROOT = Path(__file__).resolve().parents[1]
+        self.templog_path = ROOT / "CHANGELOG.tmp"
+
+        while True:
+            os.system(self.clear_screen)
+            print("Main menu / Projects / Project menu / Changelog")
+            print(self.header.center(127, "="))
+            print("E. Back\n")
+            print(colored("Chosen project:", attrs=["underline"]))
+            print(colored(self.active_project, f"{self.color}"))
+            print("Version: " + colored(self.setting.get('version'), f"{self.color}"))
+            print("\n1. Create a new changelog")
+            print("2. Add new changes")
+            print("3. Open the changelog")
+            print("4. Preview .md changelog\n")
+
+            choice = input(f"{self.user_path}> ").strip()
+
+            if choice.lower() == "e":
+                return
+
+            elif choice == "1":
+                self.create_changelog()
+
+            elif choice == "2":
+                #==Check if the file path exists==
+                if not os.path.exists(self.changelog_path):
+                    print(colored("\nSystem cannot find the changelog path.", "light_red"))
+                    time.sleep(1.5)
+                else:
+                    self.update_changelog()
+
+            elif choice == "3":
+                Opener.open(self.changelog_path)
+
+            elif choice == "4":
+                #==Check if the file path exists==
+                if not os.path.exists(self.changelog_path):
+                    print(colored("\nSystem cannot find the changelog path.", "light_red"))
+                    time.sleep(1.5)
+                else:
+                    self.view_md(self.changelog_path)
+
+            else:
+                print("")
+                print(colored("Unknown option...", "light_red", attrs=["blink"]))
+                time.sleep(2)
+            
+    def create_changelog(self):
+        os.system(self.clear_screen)
+        print(self.header.center(127, "="))
+        print("E. Back/abort\n")
+
+        version = input("Version: ")
+        if version.lower() == "e":
+            return
+        change_type = input("\nChange type: ")
+
+        entry = prompt("\nFirst entry: ")
+
+        comment = prompt("\nOptional comment: ")
+
+        choice = input("\nSave (Enter) Cancel (E).\nAdd further entries with 'Add new changes' in the menu.")
+        if choice.lower() == "e":
+            return
+
+        data = {
+            "date": self.today,
+            "version": version,
+            "type": change_type,
+            "changes": entry,
+            "comments": comment
+        }
+
+        template = self.template_loader("changelog_template.txt")
+
+        rendered = self.template_renderer(template, data)
+
+        mode = "a" if os.path.exists(self.changelog_path) else "w"
+        with open(self.changelog_path, mode, encoding="utf-8") as f:
+            f.write(rendered + "\n")
+        return
+
+    def update_changelog(self):
+        self.change_type = None
+        self.change = None
+        self.comment = None
+        while True:
+            os.system(self.clear_screen)
+            print("Main menu / Projects / Project menu / Changelogs / Add changes")
+            print(self.header.center(127, "="))
+            print("E. Back/abort")
+            print("O. Open templog for fixes.")
+            print("S. Review changes & save\n")
+            print("Version: " + colored(self.setting.get('version'), f"{self.color}"))
+            print(colored("\nChoose the change type:", f"{self.color}"))
+            print("1. Added")
+            print("2. Removed")
+            print("3. Fixed")
+            print("4. Changed")
+            print("5. Deprecated")
+            print("6. Security\n")
+
+            print(colored("Last changelog entry:", f"{self.color}"))
+            if not self.change_type:
+                print("No changes yet.\n")
+            else:
+                print("Type: " + self.change_type)
+                print("Change: " + self.change)
+                print("Comment: " + self.comment + "\n")
+
+            type_choice = input(f"{self.user_path}> ").strip()
+
+            #==Assign change types to keys==
+            type_map = {
+            "1": "Added",
+            "2": "Removed",
+            "3": "Fixed",
+            "4": "Changed",
+            "5": "Deprecated",
+            "6": "Security"
+            }
+
+            self.change_type = type_map.get(type_choice.lower())
+
+            if type_choice.lower() == "e":
+                if os.path.exists(self.templog_path):
+                    os.remove(self.templog_path)
+                return
+            elif type_choice in ("1", "2", "3", "4", "5", "6"):
+                self.prepend_changes()
+            elif type_choice.lower() == "o":
+                Opener.open(self.templog_path)
+            elif type_choice.lower() == "s":
+                self.save_changes()
+            else:
+                print("")
+                print(colored("Unknown option...", "light_red", attrs=["blink"]))
+                time.sleep(2)
+
+    def prepend_changes(self):
+        header = f"### {self.change_type}"
+
+        existing = ""
+        if os.path.exists(self.templog_path):
+            with open(self.templog_path, "r", encoding="utf-8") as f:
+                existing = f.read()
+
+        #==Add the change type header if needed==
+        if header not in existing:
+            with open(self.templog_path, "a", encoding="utf-8") as f:
+                f.write(header + "\n")
+
+        while True:
+            os.system(self.clear_screen)
+            print(self.header.center(127, "="))
+
+            print("Chosen change type:")
+            print(colored(self.change_type, f"{self.color}"))
+
+            self.change = prompt("\nChange entry: ")
+
+            self.comment = prompt("\nOptional comment: ")
+
+            data = {
+                "changes": self.change,
+                "comments": self.comment
+            }
+
+            template = self.template_loader("entry_template.txt")
+
+            rendered = self.template_renderer(template, data)
+
+            with open(self.templog_path, "a", encoding="utf-8") as f:
+                f.write(rendered + "\n")
+
+            choice = input("\nSave & exit [E] or add more [Enter]? ")
+            if choice.lower() == "e":
+                return
+
+    def save_changes(self):
+        os.system(self.clear_screen)
+        print(self.header.center(127, "="))
+        print(colored("Please check the output file:", f"{self.color}", attrs=["underline"]))
+        templog_content = ""
+        if os.path.exists(self.templog_path):
+            with open(self.templog_path, "r", encoding="utf-8") as f:
+                templog_content = f.read()
+            print(colored(f"[version] - {self.today}\n", "magenta", attrs=["underline"]))
+            MARKDOWN = templog_content
+            console = Console()
+            md = Markdown(MARKDOWN)
+            console.print(md)
+        else:
+            print(colored("No changes added.", "light_red"))
+            time.sleep(2)
+            return
+        choice = input("\nContinue" + colored("[Enter]", f"{self.color}") + " or go back" + colored("[E] ", f"{self.color}"))
+        if choice.lower() == "e":
+            return
+
+        version = input("\nNew version number: ").strip()
+
+        print("\nWorking...")
+
+        header_data = {
+        "version": version,
+        "date": self.today
+        }
+
+        header_template = self.template_loader("header_template.txt")
+        header_rendered = self.template_renderer(header_template, header_data)
+
+        old_content = ""
+        if os.path.exists(self.changelog_path):
+            #==Make a duplicate of the old changelog==
+            log_name = f"Changelog-{self.today}.md"
+            project_folder = Path(self.setting.get('path'))
+            duplicate_path = project_folder / log_name
+
+            src = self.changelog_path
+            dest = duplicate_path
+            shutil.copy2(src,dest)
+
+            print("\nOld changelog backed up as: " + colored(f"{log_name}", f"{self.color}"))
+
+            with open(self.changelog_path, "r", encoding="utf-8") as f:
+                old_content = f.read()
+
+        combined = header_rendered + "\n" + templog_content + "\n" + old_content
+
+        with open(self.changelog_path, "w", encoding="utf-8") as f:
+            f.write(combined)
+
+        os.remove(self.templog_path)
+
+        #==Update ini files==
+        config = ConfigManager(f"{self.active_project}.ini")
+        config.update_project("version", version)
+
+        last_project = self.memory.get('last_project')
+        if last_project != self.active_project:
+            self.config.update_memory("ITEMS", "last_project", self.active_project)
+
+        print(colored("\nChangelog updated, returning...", f"{self.color}"))
+        time.sleep(2)
+        return
+
+    def view_md(self, log_path):
+        os.system(self.clear_screen)
+        print(self.header.center(127, "="))
+        print("")
+
+        log_content = ""
+        with open(log_path, "r", encoding="utf-8") as f:
+            log_content = f.read()
+
+        MARKDOWN = log_content
+        console = Console()
+        md = Markdown(MARKDOWN)
+        console.print(md)
+
+        input("\nReturn..." + colored("[Enter]", f"{self.color}"))
+        return
+
+    def template_loader(self, template_file):
+        template_path = self.config.templates_folder / template_file
+
+        with open(template_path, "r", encoding="utf-8") as f:
+            return f.read()
+
+    def template_renderer(self, template: str, data: dict):
+        for key, value in data.items():
+            template = template.replace(f"{{{{{key}}}}}", value)
+
+        return template
+
+if __name__ == "__main__":
+    VersionLogic()

DA/Templates/changelog_template.txt

@@ -0,0 +1,6 @@
+## [{{version}}] - {{date}}
+
+### {{type}}
+- **{{changes}}**
+
+{{comments}}

DA/Templates/entry_template.txt

@@ -0,0 +1,3 @@
+- **{{changes}}**
+
+{{comments}}

DA/Templates/header_template.txt

@@ -0,0 +1 @@
+## [{{version}}] - {{date}}

DA/default/Test-Project.ini

@@ -0,0 +1,5 @@
+[SETTINGS]
+path = C:\Users\...\Developer-Assistant\Test-Project
+changelog = C:\Users\...\Developer-Assistant\Test-Project\CHANGELOG.md
+version = 1.0.0
+cloud = 

DA/default/default-changelog.md

@@ -0,0 +1,6 @@
+## [{{version}}] - {{date}}
+
+### {{type}}
+- **{{changes}}**
+
+{{comments}}

DA/default/default-memory.ini

@@ -0,0 +1,9 @@
+[ITEMS]
+last_project = 
+pinned_project = Test-Project
+pinned_project1 = 
+pinned_project2 = 
+
+[CONFIG]
+color = 
+

DA/intro.md

@@ -0,0 +1,62 @@
+# Developer-Assistant
+
+## Introduction
+
+### Setting up your first project
+For a dummy changelog to experiment with, navigate to `Main menu / Projects`, choose `Test-Project`, then choose option `4.` to start adjusting this projects paths. 
+
+The `Test-Project/` folder is included in the programs root folder for repo clones and is safe to experiment with. If you installed from an URL just make a `CHANGELOG.md` anywhere and point the `.ini` file to it.
+
+Once configured, you can create as many changelog entries as you want by picking that project in the menu.
+
+> *This quick guide is also at the end of the README for future reference*
+
+### Using the program.
+1. **What *not* to do**
+
+Don't change the folder structure or modify variable names inside `.ini` files.
+
+2. **Features and information**
+
+**Your user data (`Templates/`, `Projects/`, `memory.ini`) is stored in standard locations:**
+
+Windows: `C:\Users\...\AppData\Roaming\da-ui\`
+
+Linux: `~/.config/da-ui/`
+
+macOS: `~/Library/Application Support/da-ui/`
+
+**The `da-ui/` folder has been created automatically. Updates won't overwrite it, only you can default it.
+You can access its content quickly when going to: `Main menu / Settings`**
+
+- *Customizable templates*
+
+Explore the `Templates/` folder and modify the template contents to your liking - **just avoid changing the `{{placeholder}}` names**.
+
+- *Linked projects all in one place*
+
+The `Projects/` folder holds the `.ini` files you create when starting a new project with the program. 
+
+- *Safe changelog updates*
+
+Before applying any changes, your previous `CHANGELOG.md` is automatically backed up into your project folder. 
+New changes are first written to a temporary file and only applied to the real changelog after you confirm them.
+This ensures your existing changelog is never overwritten or corrupted, and you always have a fallback copy.
+
+- *Ease of navigation*
+
+You can access files/folders and configuration straight from the menus, so you shouldn't find yourself searching through the program's directory or even your local user data very often.
+
+- *Configuration*
+
+The `memory.ini` file does exactly what you'd expect, it features:
+
+> Last project
+
+> Pinned projects
+
+> Custom colour
+
+Last project gets updated automatically, the rest are up to you.
+
+- *`Ctrl+C` works everywhere to quickly exit DA.*

developer_assistant-0.2.0.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: developer-assistant
+Version: 0.2.0
+Summary: A lightweight TUI designed to simplify formatting of Markdown changelogs.
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: platformdirs>=4.9.4
+Requires-Dist: prompt-toolkit>=3.0.52
+Requires-Dist: rich>=14.3.2
+Requires-Dist: termcolor>=3.3.0
+Dynamic: license-file
+
+# Developer Assistant
+
+> **Setup info:** Start with [SETUP](./SETUP.md) to get started.
+
+> **Latest changes:** Yes, I keep a [CHANGELOG](./CHANGELOG.md)
+
+**Requirements:** Python 3.13 or later.
+
+**Cross-platform:** Windows, Linux, macOS(unverified)
+
+## Appearance
+
+### Coloured, easy-to-use menus
+![Changelog Menu](Documents/images/changelog-menu.png)
+
+### Beautiful changelog previews
+Preview your Markdown changelogs directly in the terminal with Rich rendering:
+
+![Changelog Preview](Documents/images/md-preview.png)
+
+
+## Introduction
+
+### What does this tool do?
+Developer Assistant is a lightweight TUI tool for automating and managing your changelogs. You can customize the templates to match your existing format, and use DA as a central hub to access every changelog and project folder you maintain.
+
+You can manage as many projects as you like. Each project gets its own `.ini` file, created automatically through the menu based on the information you provide. These act as links that tell DA where your changelogs are and what's the last version number.
+
+Your files are kept safe at all times. Before adding new changes, your existing `CHANGELOG.md` is automatically backed up. While editing, all changes are written to a temporary file first and only applied to the real changelog once you confirm them.
+
+
+### Using the program.
+1. **What *not* to do**
+
+Don't change the folder structure or modify variable names inside `.ini` files.
+
+2. **Features and information**
+
+**The user's data (`Templates/`, `Projects/`, `memory.ini`) is stored in standard locations:**
+
+Windows: `C:\Users\...\AppData\Roaming\da-ui\`
+
+Linux: `~/.config/da-ui/`
+
+macOS: `~/Library/Application Support/da-ui/`
+
+The `da-ui/` folder will be created automatically.
+
+You can access its content quickly when going to: `Main menu / Settings`
+
+- *Customizable templates*
+
+In the **local** `Templates/` folder you can modify the template contents to your liking - **just avoid changing the `{{placeholder}}` names**.
+
+- *Linked projects all in one place*
+
+The `Projects/` folder holds the `.ini` files you create when starting a new project with DA. 
+
+- *Safe changelog updates*
+
+Before applying any changes, your previous `CHANGELOG.md` is automatically backed up into your project folder. 
+New changes are first written to a temporary file and only applied to the real changelog after you confirm them.
+This ensures your existing changelog is never overwritten or corrupted, and you always have a fallback copy.
+If the temporary changelog is present on startup you are prompted to remove or keep it.
+
+- *Ease of navigation*
+
+You can access files/folders and configuration straight from the menus, so you shouldn't find yourself searching through the program's directory or even your local user data very often.
+
+- *Configuration*
+
+The `memory.ini` file does exactly what you'd expect, it features:
+
+> Last project
+
+> Pinned projects
+
+> Custom colour
+
+Last project gets updated automatically, the rest are up to you.
+
+- *`Ctrl+C` works everywhere to quickly exit DA.*
+
+
+### Documentation.
+Documentation includes SYSTEM STRUCTURE.txt, example -and default files. If you ever need to replace a file, the example/default files can be used for that.
+
+
+### Setting up your first project
+For a dummy changelog to experiment with, navigate to `Main menu / Projects`, choose `Test-Project`, then choose option `4.` to start adjusting this projects paths. 
+
+The `Test-Project/` folder is included in the programs root folder for repo clones and is safe to experiment with. If you installed from an URL just make a `CHANGELOG.md` anywhere and point the `.ini` file to it.
+
+Once configured, you can create as many changelog entries as you want by picking that project in the menu.
+
+
+## Updating DA
+Two possibilities, depending on how you installed.
+
+### 1. Installed directly from GitHub URL
+A. **Using uv:**
+1. `uv tool install git+https://github.com/Ivory-Hubert/Developer-Assistant`
+
+B. **Using pip:**
+1. `pip install --upgrade git+https://github.com/Ivory-Hubert/Developer-Assistant`
+
+
+### 2. Installed from a local clone
+*Run all terminal commands in the repo folder*
+
+A. **Using uv:**
+1. `git pull`
+2. `uv tool install .`
+
+B. **Using pip:**
+1. `git pull`
+2. `pip install .`
+
+C. **No install, running from repo root:**
+
+Just `git pull`

developer_assistant-0.2.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+DA/Interface.py,sha256=z0P7l0FvcvuVOIw5_rYYyAYLKYyfk5BiXsg4Em7kDFs,8693
+DA/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+DA/intro.md,sha256=e8rnWZF6USGyHC-tOEbnd2cTFUPU9g-kEs7LK7EokYo,2337
+DA/Modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+DA/Modules/config_manager.py,sha256=_fR_D24uDKaHd2k1k5ehzxOjyYlUzgxh-xJe6nmWYUA,4518
+DA/Modules/opener.py,sha256=Ym8BRZQyVjAvBuMBPXhAomfvzdTfFcfqo_3Rbq0Aewo,847
+DA/Modules/projects_manager.py,sha256=RtJOdA2u5WxgHraJJRM_0Iwncab0Vw6Xo2Q5UrHkuMg,3964
+DA/Modules/version_logic.py,sha256=0et-0DuNtjXsdU0OKp7qh_VRBLAlPYG2hfFRz7ky7Ac,11177
+DA/Templates/changelog_template.txt,sha256=6Gpm7KdEpD-gWz7_SehQ7CjryAg218c-uAROIzRnw0g,74
+DA/Templates/entry_template.txt,sha256=o8KvPZPn0AKKks-DcPdMdX4xhR3bvZsXImJfGE7B14c,32
+DA/Templates/header_template.txt,sha256=KUZHDXu4NOIee-aOwkquN74vy1T6Z64a398z_B3JCdE,28
+DA/default/Test-Project.ini,sha256=UhDpxDpHQ4ojbxwFsbhSFfj_XGUuuRvRObIPpe0OS-U,163
+DA/default/default-changelog.md,sha256=PJKhTupBCte6ZSnGroVnDm9qmz68XYvkgmwILoZ4pBY,73
+DA/default/default-memory.ini,sha256=yuFalOgOplzodZffCIJQWyxvbd-NoftCjRfpfiEVGtw,112
+developer_assistant-0.2.0.dist-info/licenses/LICENSE,sha256=g9ya0zNLIfzVTAr5hNvTsy1qE9Toxwnhcw0j7FHPpFg,1083
+developer_assistant-0.2.0.dist-info/METADATA,sha256=yV6eU-bKGDRKLx3n-DFmqNmcEfqErysAc3re-1GhLB8,4697
+developer_assistant-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+developer_assistant-0.2.0.dist-info/entry_points.txt,sha256=-yfEhFvSV4Ms9VmDB8Tw_7Qj1846_cIUjqD9qZEXeAM,44
+developer_assistant-0.2.0.dist-info/top_level.txt,sha256=iFBaOpbsgyNLDxxwfykK-xBJlzOUhDimcmpF1FUUZ6o,3
+developer_assistant-0.2.0.dist-info/RECORD,,

developer_assistant-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

developer_assistant-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+da-ui = DA.Interface:main

developer_assistant-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Ivori Huobolainen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

developer_assistant-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+DA