Merge pull request #5 from gmbrax/feat-TUI

Feat t UI

.gitignore

@@ -1,2 +1,3 @@
 database.db
 __pycache__
+/.idea/

.idea/workspace.xml

@@ -6,10 +6,8 @@
   <component name="ChangeListManager">
     <list default="true" id="0a7f92e2-b44a-4dfe-8e01-136d1c0c18be" name="Changes" comment="Added the travel_diary id as foreign key to the photos and add a check on the creation to avoid leaving it empty or bad referenced">
       <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/pilgrim/models/entry.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/pilgrim/models/entry.py" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/pilgrim/models/photo.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/pilgrim/models/photo.py" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/pilgrim/models/photo_in_entry.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/pilgrim/models/photo_in_entry.py" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/pilgrim/service/entry_service.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/pilgrim/service/entry_service.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/pilgrim/service/photo_service.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/pilgrim/service/photo_service.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/pilgrim/ui/screens/diary_list_screen.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/pilgrim/ui/screens/diary_list_screen.py" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
@@ -52,24 +50,24 @@
     <option name="hideEmptyMiddlePackages" value="true" />
     <option name="showLibraryContents" value="true" />
   </component>
-  <component name="PropertiesComponent">{
-  &quot;keyToString&quot;: {
-    &quot;ModuleVcsDetector.initialDetectionPerformed&quot;: &quot;true&quot;,
-    &quot;Python.Database.executor&quot;: &quot;Run&quot;,
-    &quot;Python.command.executor&quot;: &quot;Run&quot;,
-    &quot;Python.main.executor&quot;: &quot;Run&quot;,
-    &quot;Python.pilgrim.executor&quot;: &quot;Run&quot;,
-    &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
-    &quot;RunOnceActivity.git.unshallow&quot;: &quot;true&quot;,
-    &quot;git-widget-placeholder&quot;: &quot;master&quot;,
-    &quot;node.js.detected.package.eslint&quot;: &quot;true&quot;,
-    &quot;node.js.detected.package.tslint&quot;: &quot;true&quot;,
-    &quot;node.js.selected.package.eslint&quot;: &quot;(autodetect)&quot;,
-    &quot;node.js.selected.package.tslint&quot;: &quot;(autodetect)&quot;,
-    &quot;nodejs_package_manager_path&quot;: &quot;npm&quot;,
-    &quot;vue.rearranger.settings.migration&quot;: &quot;true&quot;
+  <component name="PropertiesComponent"><![CDATA[{
+  "keyToString": {
+    "ModuleVcsDetector.initialDetectionPerformed": "true",
+    "Python.Database.executor": "Run",
+    "Python.command.executor": "Run",
+    "Python.main.executor": "Run",
+    "Python.pilgrim.executor": "Run",
+    "RunOnceActivity.ShowReadmeOnStart": "true",
+    "RunOnceActivity.git.unshallow": "true",
+    "git-widget-placeholder": "feat-TUI",
+    "node.js.detected.package.eslint": "true",
+    "node.js.detected.package.tslint": "true",
+    "node.js.selected.package.eslint": "(autodetect)",
+    "node.js.selected.package.tslint": "(autodetect)",
+    "nodejs_package_manager_path": "npm",
+    "vue.rearranger.settings.migration": "true"
   }
-}</component>
+}]]></component>
   <component name="RunManager">
     <configuration name="pilgrim" type="PythonConfigurationType" factoryName="Python" temporary="true" nameIsGenerated="true">
       <module name="Pilgrim" />
@@ -117,6 +115,7 @@
       <updated>1748985568579</updated>
       <workItem from="1748985569621" duration="2124000" />
       <workItem from="1748992451560" duration="312000" />
+      <workItem from="1749508687224" duration="371000" />
     </task>
     <task id="LOCAL-00001" summary="Added a Back Relationship in Entry to list all the photos">
       <option name="closed" value="true" />

pyproject.toml

@@ -18,7 +18,9 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-  "sqlalchemy"
+  "sqlalchemy",
+    "textual",
+    "textual-dev"
 ]
 [template.plugins.default]
 src-layout = true

requirements.txt

@@ -2,3 +2,5 @@ greenlet==3.2.3
 SQLAlchemy==2.0.41
 typing_extensions==4.14.0
 
+
+textual~=3.3.0

src/pilgrim/application.py

@@ -1,13 +1,17 @@
 from pilgrim.database import Database
+from pilgrim.service.mocks.service_manager_mock import ServiceManagerMock
 from pilgrim.service.servicemanager import ServiceManager
+from pilgrim.ui.ui import UIApp
 
 
 class Application:
     def __init__(self):
         self.database = Database()
+        self.ui = UIApp(ServiceManagerMock())
 
     def run(self):
         self.database.create()
+        self.ui.run()
 
     def get_service_manager(self):
         session = self.database.session()

src/pilgrim/command.py

@@ -4,3 +4,6 @@ from pilgrim.application import Application
 def main():
     app = Application()
     app.run()
+
+if __name__ == "__main__":
+    main()

src/pilgrim/service/mocks/entry_service_mock.py

@@ -0,0 +1,123 @@
+from typing import List, Tuple
+import asyncio
+from pilgrim.service.entry_service import EntryService
+from pilgrim.models.entry import Entry
+
+
+class EntryServiceMock(EntryService):
+    def __init__(self):
+        super().__init__(None)
+
+        self.mock_data = {
+            1: Entry(title="The Adventure Begins", text="I'm hopping in the Plane to finally visit canadian lands",
+                     date="26/07/2025", travel_diary_id=1, id=1,
+                     photos=[]),
+            2: Entry(title="The Landing", text="Finally on Canadian Soil", date="27/07/2025",
+                     travel_diary_id=1, id=2,photos=[]),
+            3: Entry(title="The Mount Royal", text="The Mount Royal is fucking awesome", date="28/07/2025",
+                     travel_diary_id=1, id=3, photos=[]),
+            4: Entry(title="Old Montreal", text="Exploring the historic district", date="29/07/2025",
+                     travel_diary_id=1, id=4, photos=[]),
+            5: Entry(title="Notre-Dame Basilica", text="Beautiful architecture", date="30/07/2025",
+                     travel_diary_id=1, id=5, photos=[]),
+            6: Entry(title="Parc Jean-Drapeau", text="Great views of the city", date="31/07/2025",
+                     travel_diary_id=1, id=6, photos=[]),
+            7: Entry(title="La Ronde", text="Amusement park fun", date="01/08/2025",
+                     travel_diary_id=1, id=7, photos=[]),
+            8: Entry(title="Biodome", text="Nature and science", date="02/08/2025",
+                     travel_diary_id=1, id=8, photos=[]),
+            9: Entry(title="Botanical Gardens", text="Peaceful walk", date="03/08/2025",
+                     travel_diary_id=1, id=9, photos=[]),
+            10: Entry(title="Olympic Stadium", text="Historic venue", date="04/08/2025",
+                     travel_diary_id=1, id=10, photos=[]),
+        }
+        self._next_id = 11
+
+    # Synchronous methods (kept for compatibility)
+    def create(self, travel_diary_id: int, title: str, text: str, date: str) -> Entry:
+        """Synchronous version"""
+        new_entry = Entry(title, text, date, travel_diary_id, id=self._next_id)
+        self.mock_data[self._next_id] = new_entry
+        self._next_id += 1
+        return new_entry
+
+    def read_by_id(self, entry_id: int) -> Entry | None:
+        """Synchronous version"""
+        return self.mock_data.get(entry_id)
+
+    def read_all(self) -> List[Entry]:
+        """Synchronous version"""
+        return list(self.mock_data.values())
+
+    def read_by_travel_diary_id(self, travel_diary_id: int) -> List[Entry]:
+        """Synchronous version - reads entries by diary"""
+        return [entry for entry in self.mock_data.values() if entry.fk_travel_diary_id == travel_diary_id]
+
+    def read_paginated(self, travel_diary_id: int, page: int = 1, page_size: int = 5) -> Tuple[List[Entry], int, int]:
+        """Synchronous version - reads paginated entries by diary"""
+        entries = self.read_by_travel_diary_id(travel_diary_id)
+        entries.sort(key=lambda x: x.id, reverse=True)  # Most recent first
+        
+        total_entries = len(entries)
+        total_pages = (total_entries + page_size - 1) // page_size
+        
+        start_index = (page - 1) * page_size
+        end_index = start_index + page_size
+        
+        page_entries = entries[start_index:end_index]
+        
+        return page_entries, total_pages, total_entries
+
+    def update(self, entry_src: Entry, entry_dst: Entry) -> Entry | None:
+        """Synchronous version"""
+        item_to_update = self.mock_data.get(entry_src.id)
+        if item_to_update:
+            item_to_update.title = entry_dst.title if entry_dst.title is not None else item_to_update.title
+            item_to_update.text = entry_dst.text if entry_dst.text is not None else item_to_update.text
+            item_to_update.date = entry_dst.date if entry_dst.date is not None else item_to_update.date
+            item_to_update.fk_travel_diary_id = entry_dst.fk_travel_diary_id if (entry_dst.fk_travel_diary_id
+                                                                                 is not None) else entry_dst.id
+            item_to_update.photos.extend(entry_dst.photos)
+
+            return item_to_update
+        return None
+
+    def delete(self, entry_src: Entry) -> Entry | None:
+        """Synchronous version"""
+        return self.mock_data.pop(entry_src.id, None)
+
+    # Async methods (main)
+    async def async_create(self, travel_diary_id: int, title: str, text: str, date: str) -> Entry:
+        """Async version"""
+        await asyncio.sleep(0.01)  # Simulates I/O
+        return self.create(travel_diary_id, title, text, date)
+
+    async def async_read_by_id(self, entry_id: int) -> Entry | None:
+        """Async version"""
+        await asyncio.sleep(0.01)  # Simulates I/O
+        return self.read_by_id(entry_id)
+
+    async def async_read_all(self) -> List[Entry]:
+        """Async version"""
+        await asyncio.sleep(0.01)  # Simulates I/O
+        return self.read_all()
+
+    async def async_read_by_travel_diary_id(self, travel_diary_id: int) -> List[Entry]:
+        """Async version - reads entries by diary"""
+        await asyncio.sleep(0.01)  # Simulates I/O
+        return self.read_by_travel_diary_id(travel_diary_id)
+
+    async def async_read_paginated(self, travel_diary_id: int, page: int = 1, page_size: int = 5) -> Tuple[List[Entry], int, int]:
+        """Async version - reads paginated entries by diary"""
+        await asyncio.sleep(0.01)  # Simulates I/O
+        return self.read_paginated(travel_diary_id, page, page_size)
+
+    async def async_update(self, entry_src: Entry, entry_dst: Entry) -> Entry | None:
+        """Async version"""
+        await asyncio.sleep(0.01)  # Simulates I/O
+        return self.update(entry_src, entry_dst)
+
+    async def async_delete(self, entry_src: Entry) -> Entry | None:
+        """Async version"""
+        await asyncio.sleep(0.01)  # Simulates I/O
+        return self.delete(entry_src)

src/pilgrim/service/mocks/photo_service_mock.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+from typing import List
+
+from pilgrim.models.photo import Photo
+from pilgrim.service.photo_service import PhotoService
+
+
+class PhotoServiceMock(PhotoService):
+    def __init__(self):
+        super().__init__(None)
+        self.mock_data = {}
+        self._next_id = 1
+
+    def create(self, filepath: Path, name: str, travel_diary_id, addition_date=None, caption=None) -> Photo | None:
+        new_photo = Photo(filepath, name, addition_date=addition_date, caption=caption)
+        self.mock_data[self._next_id] = new_photo
+        self._next_id += 1
+        return new_photo
+
+
+    def read_by_id(self, photo_id: int) -> Photo:
+        return self.mock_data.get(photo_id)
+
+    def read_all(self) -> List[Photo]:
+        return list(self.mock_data.values())
+
+    def update(self, photo_id: Photo, photo_dst: Photo) -> Photo | None:
+        item_to_update:Photo = self.mock_data.get(photo_id)
+        if item_to_update:
+            item_to_update.filepath = photo_dst.filepath if photo_dst.filepath else item_to_update.filepath
+            item_to_update.name = photo_dst.name if photo_dst.name else item_to_update.name
+            item_to_update.caption = photo_dst.caption if photo_dst.caption else item_to_update.caption
+            item_to_update.addition_date = photo_dst.addition_date if photo_dst.addition_date\
+                else item_to_update.addition_date
+            item_to_update.fk_travel_diary_id = photo_dst.fk_travel_diary_id if photo_dst.fk_travel_diary_id \
+                else item_to_update.fk_travel_diary_id
+            item_to_update.entries.extend(photo_dst.entries)
+            return item_to_update
+        return None
+
+    def delete(self, photo_id: int) -> Photo | None:
+        return self.mock_data.pop(photo_id, None)

src/pilgrim/service/mocks/service_manager_mock.py

@@ -0,0 +1,23 @@
+from pilgrim.service.mocks.entry_service_mock import EntryServiceMock
+from pilgrim.service.mocks.photo_service_mock import PhotoServiceMock
+from pilgrim.service.mocks.travel_diary_service_mock import TravelDiaryServiceMock
+from pilgrim.service.photo_service import PhotoService
+from pilgrim.service.servicemanager import ServiceManager
+
+
+class ServiceManagerMock(ServiceManager):
+    def __init__(self):
+        super().__init__()
+        # Cria instâncias únicas para manter estado consistente
+        self._travel_diary_service = TravelDiaryServiceMock()
+        self._entry_service = EntryServiceMock()
+        self._photo_service = PhotoServiceMock()
+
+    def get_entry_service(self):
+        return self._entry_service
+
+    def get_travel_diary_service(self):
+        return self._travel_diary_service
+
+    def get_photo_service(self):
+        return self._photo_service

src/pilgrim/service/mocks/travel_diary_service_mock.py

@@ -0,0 +1,67 @@
+from pilgrim.service.travel_diary_service import TravelDiaryService
+from pilgrim.models.travel_diary import TravelDiary
+import asyncio
+
+
+class TravelDiaryServiceMock(TravelDiaryService):
+    def __init__(self):
+        super().__init__(None)
+        self.mock_data = {
+            1: TravelDiary(id=1, name="Montreal"),
+            2: TravelDiary(id=2, name="Rio de Janeiro"),
+        }
+        self._next_id = 3
+
+    # Synchronous methods (original)
+    def create(self, name: str):
+        """Synchronous version"""
+        new_travel_diary = TravelDiary(id=self._next_id, name=name)
+        self.mock_data[self._next_id] = new_travel_diary
+        self._next_id += 1
+        return new_travel_diary
+
+    def read_by_id(self, travel_id: int):
+        """Synchronous version"""
+        return self.mock_data.get(travel_id)
+
+    def read_all(self):
+        """Synchronous version"""
+        return list(self.mock_data.values())
+
+    def update(self, travel_diary_id: int, name: str):
+        """Synchronous version"""
+        item_to_update = self.mock_data.get(travel_diary_id)
+        if item_to_update:
+            item_to_update.name = name
+            return item_to_update
+        return None
+
+    def delete(self, travel_diary_id: int):
+        """Synchronous version"""
+        return self.mock_data.pop(travel_diary_id, None)
+
+    # Async methods (new)
+    async def async_create(self, name: str):
+        """Async version"""
+        await asyncio.sleep(0.01)  # Simulates I/O
+        return self.create(name)
+
+    async def async_read_by_id(self, travel_id: int):
+        """Async version"""
+        await asyncio.sleep(0.01)  # Simulates I/O
+        return self.read_by_id(travel_id)
+
+    async def async_read_all(self):
+        """Async version"""
+        await asyncio.sleep(0.01)  # Simulates I/O
+        return self.read_all()
+
+    async def async_update(self, travel_diary_id: int, name: str):
+        """Async version"""
+        await asyncio.sleep(0.01)  # Simulates I/O
+        return self.update(travel_diary_id, name)
+
+    async def async_delete(self, travel_diary_id: int):
+        """Async version"""
+        await asyncio.sleep(0.01)  # Simulates I/O
+        return self.delete(travel_diary_id)

src/pilgrim/service/photo_service.py

@@ -1,8 +1,9 @@
 from pathlib import Path
 from typing import List
 
-from pilgrim import Photo, TravelDiary
 
+from pilgrim.models.photo import Photo
+from pilgrim.models.travel_diary import TravelDiary
 
 class PhotoService:
     def __init__(self, session):

src/pilgrim/service/travel_diary_service.py

@@ -18,18 +18,18 @@ class TravelDiaryService:
     def read_all(self):
         return self.session.query(TravelDiary).all()
 
-    def update(self, travel_diary_src:TravelDiary,travel_diary_dst:TravelDiary):
-        original = self.read_by_id(travel_diary_src.id)
+    def update(self, travel_diary_id: TravelDiary, travel_diary_dst: TravelDiary):
+        original = self.read_by_id(travel_diary_id.id)
         if original is not None:
             original.name = travel_diary_dst.name
             self.session.commit()
             self.session.refresh(original)
         return original
 
-    def delete(self, travel_diary_src:TravelDiary):
-        excluded = self.read_by_id(travel_diary_src.id)
+    def delete(self, travel_diary_id: TravelDiary):
+        excluded = self.read_by_id(travel_diary_id.id)
         if excluded is not None:
-            self.session.delete(travel_diary_src)
+            self.session.delete(travel_diary_id)
             self.session.commit()
             return excluded
         return None

src/pilgrim/ui/screens/about_screen.py

@@ -0,0 +1,73 @@
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.screen import Screen
+from textual.widgets import Header, Footer, Button, Label, TextArea
+from textual.containers import Container
+
+class AboutScreen(Screen[bool]):
+    """Screen to display application information."""
+
+    TITLE = "Pilgrim - About"
+
+    BINDINGS = [
+        Binding("escape", "dismiss", "Close"),
+    ]
+
+    def __init__(self):
+        super().__init__()
+        self.header = Header()
+        self.footer = Footer()
+        self.app_title = Label("Pilgrim", id="AboutScreen_AboutTitle",classes="AboutScreen_AboutTitle")
+        self.content = Label("A TUI Based Travel Diary Application", id="AboutScreen_AboutContent",
+                             classes="AboutScreen_AboutContent")
+        self.version = Label("Version: 0.0.1", id="AboutScreen_AboutVersion",
+                             classes="AboutScreen_AboutVersion")
+        self.developer = Label("Developed By: Gustavo Henrique Miranda ", id="AboutScreen_AboutAuthor")
+        self.contact = Label("git.gustavomiranda.xyz", id="AboutScreen_AboutContact",
+                             classes="AboutScreen_AboutContact")
+        self.license = TextArea(id="AboutScreen_AboutLicense",
+                                classes="AboutScreen_AboutLicense")
+        self.license.text = """Copyright (c) 2025 GHMiranda. 
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."""
+        self.license.read_only = True
+        self.about_container = Container(self.app_title, self.content, self.version, self.developer,
+                                         self.contact, id="AboutScreen_SubContainer",
+                                         classes="AboutScreen_SubContainer")
+        self.container = Container(self.about_container, self.license, id="AboutScreen_AboutContainer",
+                                   classes="AboutScreen_AboutContainer")
+
+    def compose(self) -> ComposeResult:
+        yield self.header
+        yield self.container
+        yield self.footer
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handles button clicks."""
+        if "about-close-button" in event.button.classes:
+            self.dismiss(False)
+        elif "about-info-button" in event.button.classes:
+            self.notify("More information would be displayed here!", title="Info")
+
+    def action_dismiss(self, **kwargs) -> None:
+        """Closes the about box using dismiss.
+        :param **kwargs:
+        """
+        self.dismiss(False)
+
+    def on_key(self, event) -> None:
+        """Intercepts specific keys."""
+        if event.key == "escape":
+            self.dismiss(False)
+            event.prevent_default()
+        elif event.key == "enter":
+            self.dismiss(False)
+            event.prevent_default()

src/pilgrim/ui/screens/diary_list_screen.py

@@ -0,0 +1,299 @@
+from typing import Optional, Tuple
+import asyncio
+
+from textual.app import ComposeResult
+from textual.screen import Screen
+from textual.widgets import Header, Footer, Label, Static, OptionList, Button
+from textual.binding import Binding
+from textual.containers import Vertical, Container, Horizontal
+
+from pilgrim.models.travel_diary import TravelDiary
+from pilgrim.ui.screens.about_screen import AboutScreen
+from pilgrim.ui.screens.edit_diary_modal import EditDiaryModal
+from pilgrim.ui.screens.new_diary_modal import NewDiaryModal
+from pilgrim.ui.screens.edit_entry_screen import EditEntryScreen
+
+
+class DiaryListScreen(Screen):
+    TITLE = "Pilgrim - Main"
+
+    BINDINGS = [
+        Binding("n", "new_diary", "New diary"),
+        Binding("^q", "quit", "Quit Pilgrim"),
+        Binding("enter", "open_selected_diary", "Open diary"),
+        Binding("e", "edit_selected_diary", "Edit diary"),
+        Binding("r", "force_refresh", "Force refresh"),
+    ]
+
+    def __init__(self):
+        super().__init__()
+        self.selected_diary_index = None
+        self.diary_id_map = {}
+        self.is_refreshing = False
+
+        self.header = Header()
+        self.footer = Footer()
+        self.diary_list = OptionList(classes="DiaryListScreen-DiaryListOptions")
+        self.new_diary_button = Button("New diary", id="new_diary", classes="DiaryListScreen-NewDiaryButton")
+        self.edit_diary_button = Button("Edit diary", id="edit_diary", classes="DiaryListScreen-EditDiaryButton")
+        self.open_diary = Button("Open diary", id="open_diary", classes="DiaryListScreen-OpenDiaryButton")
+        self.buttons_grid = Horizontal(
+            self.new_diary_button, self.edit_diary_button, self.open_diary,
+            classes="DiaryListScreen-ButtonsGrid"
+        )
+        self.tips = Static(
+            "Tip: use ↑↓ to navigate • ENTER to Select • "
+            "TAB to alternate the fields • SHIFT + TAB to alternate back • "
+            "Ctrl+P for command palette • R to force refresh",
+            classes="DiaryListScreen-DiaryListTips"
+        )
+        self.container = Container(
+            self.diary_list, self.buttons_grid, self.tips,
+            classes="DiaryListScreen-DiaryListContainer"
+        )
+
+    def compose(self) -> ComposeResult:
+        yield self.header
+        yield self.container
+        yield self.footer
+
+    def on_mount(self) -> None:
+        # Uses synchronous version for initial mount
+        self.refresh_diaries()
+        self.update_buttons_state()
+
+    def refresh_diaries(self):
+        """Synchronous version of refresh"""
+        try:
+            service_manager = self.app.service_manager
+            travel_diary_service = service_manager.get_travel_diary_service()
+
+            # Uses synchronous method
+            diaries = travel_diary_service.read_all()
+
+            # Saves current state
+            current_diary_id = None
+            if (self.selected_diary_index is not None and
+                    self.selected_diary_index in self.diary_id_map):
+                current_diary_id = self.diary_id_map[self.selected_diary_index]
+
+            # Clears and rebuilds
+            self.diary_list.clear_options()
+            self.diary_id_map = {}
+
+            if not diaries:
+                self.diary_list.add_option("[dim]No diaries found. Press 'N' to create a new one![/dim]")
+                self.selected_diary_index = None
+            else:
+                new_selected_index = 0
+
+                for index, diary in enumerate(diaries):
+                    self.diary_id_map[index] = diary.id
+                    self.diary_list.add_option(f"[b]{diary.name}[/b]\n[dim]ID: {diary.id}[/dim]")
+
+                    # Maintains selection if possible
+                    if current_diary_id and diary.id == current_diary_id:
+                        new_selected_index = index
+
+                self.selected_diary_index = new_selected_index
+
+                # Updates highlight
+                self.set_timer(0.05, lambda: self._update_highlight(new_selected_index))
+
+            # Forces visual refresh
+            self.diary_list.refresh()
+            self.update_buttons_state()
+
+        except Exception as e:
+            self.notify(f"Error loading diaries: {str(e)}")
+
+    def _update_highlight(self, index: int):
+        """Updates the OptionList highlight"""
+        try:
+            if index < len(self.diary_list.options):
+                self.diary_list.highlighted = index
+                self.diary_list.refresh()
+        except Exception as e:
+            self.notify(f"Error updating highlight: {str(e)}")
+
+    async def async_refresh_diaries(self):
+        """Async version of refresh"""
+        if self.is_refreshing:
+            return
+
+        self.is_refreshing = True
+
+        try:
+            service_manager = self.app.service_manager
+            travel_diary_service = service_manager.get_travel_diary_service()
+
+            # Uses async method
+            diaries = await travel_diary_service.async_read_all()
+
+            # Saves current state
+            current_diary_id = None
+            if (self.selected_diary_index is not None and
+                    self.selected_diary_index in self.diary_id_map):
+                current_diary_id = self.diary_id_map[self.selected_diary_index]
+
+            # Clears and rebuilds
+            self.diary_list.clear_options()
+            self.diary_id_map = {}
+
+            if not diaries:
+                self.diary_list.add_option("[dim]No diaries found. Press 'N' to create a new one![/dim]")
+                self.selected_diary_index = None
+            else:
+                new_selected_index = 0
+
+                for index, diary in enumerate(diaries):
+                    self.diary_id_map[index] = diary.id
+                    self.diary_list.add_option(f"[b]{diary.name}[/b]\n[dim]ID: {diary.id}[/dim]")
+
+                    if current_diary_id and diary.id == current_diary_id:
+                        new_selected_index = index
+
+                self.selected_diary_index = new_selected_index
+                self.set_timer(0.05, lambda: self._update_highlight(new_selected_index))
+
+            self.diary_list.refresh()
+            self.update_buttons_state()
+
+        except Exception as e:
+            self.notify(f"Error loading diaries: {str(e)}")
+        finally:
+            self.is_refreshing = False
+
+    def on_option_list_option_highlighted(self, event: OptionList.OptionHighlighted) -> None:
+        """Handle when an option is highlighted"""
+        if self.diary_id_map and event.option_index in self.diary_id_map:
+            self.selected_diary_index = event.option_index
+        else:
+            self.selected_diary_index = None
+
+        self.update_buttons_state()
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        """Handle when an option is selected"""
+        if self.diary_id_map and event.option_index in self.diary_id_map:
+            self.selected_diary_index = event.option_index
+            self.action_open_diary()
+        else:
+            self.selected_diary_index = None
+
+        self.update_buttons_state()
+
+    def update_buttons_state(self):
+        """Updates button states"""
+        has_selection = (self.selected_diary_index is not None and
+                         self.selected_diary_index in self.diary_id_map)
+
+        self.edit_diary_button.disabled = not has_selection
+        self.open_diary.disabled = not has_selection
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button clicks"""
+        button_id = event.button.id
+
+        if button_id == "new_diary":
+            self.action_new_diary()
+        elif button_id == "edit_diary":
+            self.action_edit_selected_diary()
+        elif button_id == "open_diary":
+            self.action_open_diary()
+
+    def action_new_diary(self):
+        """Action to create new diary"""
+        self.app.push_screen(NewDiaryModal(),self._on_new_diary_submitted)
+
+    def _on_new_diary_submitted(self,result):
+        self.notify(str(result))
+        if result:
+            self.notify(f"Creating Diary:{result}'...")
+            self.call_later(self._async_create_diary,result)
+        else:
+            self.notify(f"Canceled...")
+
+    async def _async_create_diary(self,name: str):
+
+        try:
+            service = self.app.service_manager.get_travel_diary_service()
+            created_diary = await service.async_create(name)
+            if created_diary:
+                self.diary_id_map[created_diary.id] = created_diary.id
+                await self.async_refresh_diaries()
+                self.notify(f"Diary: '{name}' created!")
+            else:
+                self.notify("Error Creating the diary")
+        except Exception as e:
+            self.notify(f"Exception on creating the diary: {str(e)}")
+
+
+
+    def action_edit_selected_diary(self):
+        """Action to edit selected diary"""
+        if self.selected_diary_index is not None:
+            diary_id = self.diary_id_map.get(self.selected_diary_index)
+            if diary_id:
+                self.app.push_screen(
+                    EditDiaryModal(diary_id=diary_id),
+                    self._on_edited_diary_name_submitted
+                )
+        else:
+            self.notify("Select a diary to edit")
+
+    def action_open_diary(self):
+        """Action to open selected diary"""
+        if self.selected_diary_index is not None:
+            diary_id = self.diary_id_map.get(self.selected_diary_index)
+            if diary_id:
+                self.app.push_screen(EditEntryScreen(diary_id=diary_id))
+                self.notify(f"Opening diary ID: {diary_id}")
+            else:
+                self.notify("Invalid diary ID")
+        else:
+            self.notify("Select a diary to open")
+
+    def _on_edited_diary_name_submitted(self, result: Optional[Tuple[int, str]]) -> None:
+        """Callback after diary editing"""
+        if result:
+            diary_id, name = result
+            self.notify(f"Updating diary ID {diary_id} to '{name}'...")
+            # Schedules async update
+            self.call_later(self._async_update_diary, diary_id, name)
+        else:
+            self.notify("Edit canceled")
+
+    async def _async_update_diary(self, diary_id: int, name: str):
+        """Updates the diary asynchronously"""
+        try:
+            service = self.app.service_manager.get_travel_diary_service()
+            updated_diary = await service.async_update(diary_id, name)
+
+            if updated_diary:
+                self.notify(f"Diary '{name}' updated!")
+                # Forces refresh after update
+                await self.async_refresh_diaries()
+            else:
+                self.notify("Error: Diary not found")
+
+        except Exception as e:
+            self.notify(f"Error updating: {str(e)}")
+
+    def action_force_refresh(self):
+        """Forces manual refresh"""
+        self.notify("Forcing refresh...")
+        # Tries both versions
+        self.refresh_diaries()  # Synchronous
+        self.call_later(self.async_refresh_diaries)  # Asynchronous
+
+    def action_open_selected_diary(self):
+        """Action for ENTER binding"""
+        self.action_open_diary()
+
+    def action_about_cmd(self):
+        self.app.push_screen(AboutScreen())
+
+    def action_quit(self):
+        """Action to quit the application"""
+        self.app.exit()

src/pilgrim/ui/screens/edit_diary_modal.py

@@ -0,0 +1,47 @@
+from textual.app import ComposeResult
+from textual.containers import Vertical, Horizontal
+from textual.screen import ModalScreen
+from textual.widgets import Label, Input, Button
+
+
+class EditDiaryModal(ModalScreen[tuple[int,str]]):
+    BINDINGS = [
+        ("escape", "cancel", "Cancel"),
+    ]
+
+    def __init__(self, diary_id: int):
+        super().__init__()
+        self.diary_id = diary_id
+        self.current_diary_name = self.app.service_manager.get_travel_diary_service().read_by_id(self.diary_id).name
+        self.name_input = Input(value=self.current_diary_name, id="edit_diary_name_input", classes="EditDiaryModal-NameInput")
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="edit_diary_dialog", classes="EditDiaryModal-Dialog"):
+            yield Label("Edit Diary", classes="EditDiaryModal-Title")
+            yield Label("New Diary Name:")
+            yield self.name_input
+            with Horizontal(classes="EditDiaryModal-ButtonsContainer"):
+                yield Button("Save", variant="primary", id="save_diary_button", classes="EditDiaryModal-SaveButton")
+                yield Button("Cancel", variant="default", id="cancel_button", classes="EditDiaryModal-CancelButton")
+
+    def on_mount(self) -> None:
+        """Focuses on the input field and moves cursor to the end of text."""
+        self.name_input.focus()
+        self.name_input.cursor_position = len(self.name_input.value)
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "save_diary_button":
+            new_diary_name = self.name_input.value.strip()
+            if new_diary_name and new_diary_name != self.current_diary_name:
+                self.dismiss((self.diary_id, new_diary_name))
+            elif new_diary_name == self.current_diary_name:
+                self.notify("No changes made.", severity="warning")
+                self.dismiss(None)
+            else:
+                self.notify("Diary name cannot be empty.", severity="warning")
+                self.name_input.focus()
+        elif event.button.id == "cancel_button":
+            self.dismiss(None)
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)

src/pilgrim/ui/screens/edit_entry_screen.py

@@ -0,0 +1,452 @@
+from typing import Optional, List
+import asyncio
+from datetime import datetime
+
+from textual.app import ComposeResult
+from textual.screen import Screen
+from textual.widgets import Header, Footer, Static, TextArea
+from textual.binding import Binding
+from textual.containers import Container, Horizontal
+
+from pilgrim.models.entry import Entry
+from pilgrim.models.travel_diary import TravelDiary
+from pilgrim.ui.screens.rename_entry_modal import RenameEntryModal
+
+
+class EditEntryScreen(Screen):
+    TITLE = "Pilgrim - Edit"
+
+    BINDINGS = [
+        Binding("ctrl+s", "save", "Save"),
+        Binding("ctrl+n", "next_entry", "Next/New Entry"),
+        Binding("ctrl+b", "prev_entry", "Previous Entry"),
+        Binding("ctrl+r", "rename_entry", "Rename Entry"),
+        Binding("escape", "back_to_list", "Back to List")
+    ]
+
+    def __init__(self, diary_id: int = 1):
+        super().__init__()
+        self.diary_id = diary_id
+        self.diary_name = f"Diary {diary_id}"  # Use a better default name
+        self.current_entry_index = 0
+        self.entries: List[Entry] = []
+        self.is_new_entry = False
+        self.has_unsaved_changes = False
+        self.new_entry_content = ""
+        self.new_entry_title = "New Entry"
+        self.next_entry_id = 1
+        self._updating_display = False
+        self._original_content = ""
+        self.is_refreshing = False
+
+        # Main header
+        self.header = Header(name="Pilgrim v6", classes="EditEntryScreen-header")
+
+        # Sub-header widgets
+        self.diary_info = Static(f"Diary: {self.diary_name}", id="diary_info", classes="EditEntryScreen-diary-info")
+        self.entry_info = Static("Loading...", id="entry_info", classes="EditEntryScreen-entry-info")
+        self.status_indicator = Static("Saved", id="status_indicator", classes="EditEntryScreen-status-indicator")
+
+        # Sub-header container
+        self.sub_header = Horizontal(
+            self.diary_info,
+            Static(classes="spacer EditEntryScreen-spacer"),
+            self.entry_info,
+            self.status_indicator,
+            id="sub_header",
+            classes="EditEntryScreen-sub-header"
+        )
+
+        # Text area
+        self.text_entry = TextArea(id="text_entry", classes="EditEntryScreen-text-entry")
+
+        # Main container
+        self.main = Container(
+            self.sub_header,
+            self.text_entry,
+            id="EditEntryScreen_MainContainer",
+            classes="EditEntryScreen-main-container"
+        )
+
+        # Footer
+        self.footer = Footer(classes="EditEntryScreen-footer")
+
+    def compose(self) -> ComposeResult:
+        yield self.header
+        yield self.main
+        yield self.footer
+
+    def on_mount(self) -> None:
+        """Called when the screen is mounted"""
+        # First update diary info, then refresh entries
+        self.update_diary_info()
+        self.refresh_entries()
+
+    def update_diary_info(self):
+        """Updates diary information"""
+        try:
+            service_manager = self.app.service_manager
+            travel_diary_service = service_manager.get_travel_diary_service()
+            
+            diary = travel_diary_service.read_by_id(self.diary_id)
+            if diary:
+                self.diary_name = diary.name
+                self.diary_info.update(f"Diary: {self.diary_name}")
+            else:
+                # If diary not found, try to get a default name
+                self.diary_name = f"Diary {self.diary_id}"
+                self.diary_info.update(f"Diary: {self.diary_name}")
+                self.notify(f"Diary {self.diary_id} not found, using default name")
+        except Exception as e:
+            # If there's an error, use a default name but don't break the app
+            self.diary_name = f"Diary {self.diary_id}"
+            self.diary_info.update(f"Diary: {self.diary_name}")
+            self.notify(f"Error loading diary info: {str(e)}")
+        
+        # Always ensure the diary info is updated
+        self._ensure_diary_info_updated()
+
+    def _ensure_diary_info_updated(self):
+        """Ensures the diary info widget is always updated with current diary name"""
+        try:
+            self.diary_info.update(f"Diary: {self.diary_name}")
+        except Exception as e:
+            # If even this fails, at least try to show something
+            self.diary_info.update(f"Diary: {self.diary_id}")
+
+    def refresh_entries(self):
+        """Synchronous version of refresh"""
+        try:
+            service_manager = self.app.service_manager
+            entry_service = service_manager.get_entry_service()
+
+            # Get all entries for this diary
+            all_entries = entry_service.read_all()
+            self.entries = [entry for entry in all_entries if entry.fk_travel_diary_id == self.diary_id]
+            
+            # Sort by ID
+            self.entries.sort(key=lambda x: x.id)
+
+            # Update next entry ID
+            if self.entries:
+                self.next_entry_id = max(entry.id for entry in self.entries) + 1
+            else:
+                self.next_entry_id = 1
+
+            self._update_entry_display()
+            self._update_sub_header()
+
+        except Exception as e:
+            self.notify(f"Error loading entries: {str(e)}")
+        
+        # Ensure diary info is updated even if entries fail to load
+        self._ensure_diary_info_updated()
+
+    async def async_refresh_entries(self):
+        """Asynchronous version of refresh"""
+        if self.is_refreshing:
+            return
+
+        self.is_refreshing = True
+
+        try:
+            service_manager = self.app.service_manager
+            entry_service = service_manager.get_entry_service()
+
+            # For now, use synchronous method since mock doesn't have async
+            all_entries = entry_service.read_all()
+            self.entries = [entry for entry in all_entries if entry.fk_travel_diary_id == self.diary_id]
+            
+            # Sort by ID
+            self.entries.sort(key=lambda x: x.id)
+
+            # Update next entry ID
+            if self.entries:
+                self.next_entry_id = max(entry.id for entry in self.entries) + 1
+            else:
+                self.next_entry_id = 1
+
+            self._update_entry_display()
+            self._update_sub_header()
+
+        except Exception as e:
+            self.notify(f"Error loading entries: {str(e)}")
+        finally:
+            self.is_refreshing = False
+
+    def _update_status_indicator(self, text: str, css_class: str):
+        """Helper to update status indicator text and class."""
+        self.status_indicator.update(text)
+        self.status_indicator.remove_class("saved", "not-saved", "new", "read-only")
+        self.status_indicator.add_class(css_class)
+
+    def _update_sub_header(self):
+        """Updates the sub-header with current entry information."""
+        if not self.entries and not self.is_new_entry:
+            self.entry_info.update("No entries")
+            self._update_status_indicator("Saved", "saved")
+            return
+
+        if self.is_new_entry:
+            self.entry_info.update(f"New Entry: {self.new_entry_title}")
+            if self.has_unsaved_changes:
+                self._update_status_indicator("Not Saved", "not-saved")
+            else:
+                self._update_status_indicator("New", "new")
+        else:
+            current_entry = self.entries[self.current_entry_index]
+            entry_text = f"Entry: \\[{self.current_entry_index + 1}/{len(self.entries)}] {current_entry.title}"
+            self.entry_info.update(entry_text)
+            self._update_status_indicator("Saved", "saved")
+
+    def _save_current_state(self):
+        """Saves the current state before navigating"""
+        if self.is_new_entry:
+            self.new_entry_content = self.text_entry.text
+        elif self.entries and self.has_unsaved_changes:
+            current_entry = self.entries[self.current_entry_index]
+            current_entry.text = self.text_entry.text
+
+    def _finish_display_update(self):
+        """Finishes the display update by reactivating change detection"""
+        self._updating_display = False
+        self._update_sub_header()
+
+    def _update_entry_display(self):
+        """Updates the display of the current entry"""
+        if not self.entries and not self.is_new_entry:
+            self.text_entry.text = f"No entries found for diary '{self.diary_name}'\n\nPress Ctrl+N to create a new entry."
+            self.text_entry.read_only = True
+            self._original_content = self.text_entry.text
+            self._update_sub_header()
+            return
+
+        self._updating_display = True
+
+        if self.is_new_entry:
+            self.text_entry.text = self.new_entry_content
+            self.text_entry.read_only = False
+            self._original_content = self.new_entry_content
+            self.has_unsaved_changes = False
+        else:
+            current_entry = self.entries[self.current_entry_index]
+            self.text_entry.text = current_entry.text
+            self.text_entry.read_only = False
+            self._original_content = current_entry.text
+            self.has_unsaved_changes = False
+
+        self.call_after_refresh(self._finish_display_update)
+
+    def on_text_area_changed(self, event) -> None:
+        """Detects text changes to mark as unsaved"""
+        if (hasattr(self, 'text_entry') and not self.text_entry.read_only and
+                not getattr(self, '_updating_display', False) and hasattr(self, '_original_content')):
+            current_content = self.text_entry.text
+            if current_content != self._original_content:
+                if not self.has_unsaved_changes:
+                    self.has_unsaved_changes = True
+                    self._update_sub_header()
+            else:
+                if self.has_unsaved_changes:
+                    self.has_unsaved_changes = False
+                    self._update_sub_header()
+
+    def action_back_to_list(self) -> None:
+        """Goes back to the diary list"""
+        if self.is_new_entry and not self.text_entry.text.strip() and not self.has_unsaved_changes:
+            self.app.pop_screen()
+            self.notify("Returned to diary list")
+            return
+
+        if self.has_unsaved_changes or (self.is_new_entry and self.text_entry.text.strip()):
+            self.notify("There are unsaved changes! Use Ctrl+S to save before leaving.")
+            return
+
+        self.app.pop_screen()
+        self.notify("Returned to diary list")
+
+    def action_next_entry(self) -> None:
+        """Goes to the next entry"""
+        self._save_current_state()
+
+        if not self.entries:
+            if not self.is_new_entry:
+                self.is_new_entry = True
+                self._update_entry_display()
+                self.notify("New entry created")
+            else:
+                self.notify("Already in a new entry")
+            return
+
+        if self.is_new_entry:
+            self.notify("Already at the last position (new entry)")
+        elif self.current_entry_index < len(self.entries) - 1:
+            self.current_entry_index += 1
+            self._update_entry_display()
+            current_entry = self.entries[self.current_entry_index]
+            self.notify(f"Navigating to: {current_entry.title}")
+        else:
+            self.is_new_entry = True
+            self._update_entry_display()
+            self.notify("New entry created")
+
+    def action_prev_entry(self) -> None:
+        """Goes to the previous entry"""
+        self._save_current_state()
+
+        if not self.entries:
+            self.notify("No entries to navigate")
+            return
+
+        if self.is_new_entry:
+            if self.entries:
+                self.is_new_entry = False
+                self.current_entry_index = len(self.entries) - 1
+                self._update_entry_display()
+                current_entry = self.entries[self.current_entry_index]
+                self.notify(f"Navigating to: {current_entry.title}")
+            else:
+                self.notify("No previous entries")
+        elif self.current_entry_index > 0:
+            self.current_entry_index -= 1
+            self._update_entry_display()
+            current_entry = self.entries[self.current_entry_index]
+            self.notify(f"Navigating to: {current_entry.title}")
+        else:
+            self.notify("Already at the first entry")
+
+    def action_rename_entry(self) -> None:
+        """Opens a modal to rename the entry."""
+        if not self.entries and not self.is_new_entry:
+            self.notify("No entry to rename", severity="warning")
+            return
+
+        if self.is_new_entry:
+            current_name = self.new_entry_title
+        else:
+            current_entry = self.entries[self.current_entry_index]
+            current_name = current_entry.title
+
+        self.app.push_screen(
+            RenameEntryModal(current_name=current_name),
+            self.handle_rename_result
+        )
+
+    def handle_rename_result(self, new_name: str | None) -> None:
+        """Callback that processes the rename modal result."""
+        if new_name is None:
+            self.notify("Rename cancelled")
+            return
+
+        if not new_name.strip():
+            self.notify("Name cannot be empty", severity="error")
+            return
+
+        if self.is_new_entry:
+            old_name = self.new_entry_title
+            self.new_entry_title = new_name
+            self.notify(f"New entry title changed to '{new_name}'")
+        else:
+            current_entry = self.entries[self.current_entry_index]
+            old_name = current_entry.title
+            current_entry.title = new_name
+            self.notify(f"Title changed from '{old_name}' to '{new_name}'")
+
+        self.has_unsaved_changes = True
+        self._update_sub_header()
+
+    def action_save(self) -> None:
+        """Saves the current entry"""
+        if self.is_new_entry:
+            content = self.text_entry.text.strip()
+            if not content:
+                self.notify("Empty entry cannot be saved")
+                return
+
+            # Schedule async creation
+            self.call_later(self._async_create_entry, content)
+        else:
+            # Schedule async update
+            self.call_later(self._async_update_entry)
+
+    async def _async_create_entry(self, content: str):
+        """Creates a new entry asynchronously"""
+        try:
+            service_manager = self.app.service_manager
+            entry_service = service_manager.get_entry_service()
+
+            # Get current date
+            current_date = datetime.now().strftime("%d/%m/%Y")
+
+            new_entry = entry_service.create(
+                travel_diary_id=self.diary_id,
+                title=self.new_entry_title,
+                text=content,
+                date=current_date
+            )
+
+            if new_entry:
+                self.entries.append(new_entry)
+                self.entries.sort(key=lambda x: x.id)
+
+                # Find the new entry index
+                for i, entry in enumerate(self.entries):
+                    if entry.id == new_entry.id:
+                        self.current_entry_index = i
+                        break
+
+                self.is_new_entry = False
+                self.has_unsaved_changes = False
+                self._original_content = new_entry.text
+                self.new_entry_title = "New Entry"
+                self.next_entry_id = max(entry.id for entry in self.entries) + 1
+
+                self._update_entry_display()
+                self.notify(f"New entry '{new_entry.title}' saved successfully!")
+            else:
+                self.notify("Error creating entry")
+
+        except Exception as e:
+            self.notify(f"Error creating entry: {str(e)}")
+
+    async def _async_update_entry(self):
+        """Updates the current entry asynchronously"""
+        try:
+            if not self.entries:
+                self.notify("No entry to update")
+                return
+
+            current_entry = self.entries[self.current_entry_index]
+            updated_content = self.text_entry.text
+
+            # Create updated entry object
+            updated_entry = Entry(
+                title=current_entry.title,
+                text=updated_content,
+                date=current_entry.date,
+                travel_diary_id=current_entry.fk_travel_diary_id,
+                id=current_entry.id
+            )
+
+            service_manager = self.app.service_manager
+            entry_service = service_manager.get_entry_service()
+
+            result = entry_service.update(current_entry, updated_entry)
+
+            if result:
+                current_entry.text = updated_content
+                self.has_unsaved_changes = False
+                self._original_content = updated_content
+                self._update_sub_header()
+                self.notify(f"Entry '{current_entry.title}' saved successfully!")
+            else:
+                self.notify("Error updating entry")
+
+        except Exception as e:
+            self.notify(f"Error updating entry: {str(e)}")
+
+    def action_force_refresh(self):
+        """Forces manual refresh"""
+        self.notify("Forcing refresh...")
+        self.refresh_entries()
+        self.call_later(self.async_refresh_entries) 

src/pilgrim/ui/screens/new_diary_modal.py

@@ -0,0 +1,43 @@
+from textual.app import ComposeResult
+from textual.containers import Vertical, Horizontal
+from textual.screen import ModalScreen
+from textual.widgets import Label, Input, Button
+
+class NewDiaryModal(ModalScreen[str]):
+    BINDINGS = [
+        ("escape", "cancel", "Cancel"),
+    ]
+    def __init__(self):
+        super().__init__()
+        self.name_input = Input(id="NewDiaryModal-NameInput",classes="NewDiaryModal-NameInput") # This ID is fine, it's specific to the input
+
+    def compose(self) -> ComposeResult:
+
+        with Vertical(id="new_diary_dialog",classes="NewDiaryModal-Dialog"):
+            yield Label("Create a new diary", classes="NewDiaryModal-Title")
+            yield Label("Diary Name:")
+            yield self.name_input
+            with Horizontal(classes="NewDiaryModal-ButtonsContainer"):
+                yield Button("Create", variant="primary", id="create_diary_button",
+                             classes="NewDiaryModal-CreateDiaryButton")
+                yield Button("Cancel", variant="default", id="cancel_button",
+                             classes="NewDiaryModal-CancelButton")
+
+    def on_mount(self):
+          self.name_input.focus()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handles button clicks."""
+        if event.button.id == "create_diary_button":
+            diary_name = self.name_input.value.strip()
+            if diary_name:
+                self.dismiss(diary_name)
+            else:
+                self.notify("Diary name cannot be empty.", severity="warning")
+                self.name_input.focus()
+        elif event.button.id == "cancel_button":
+            self.dismiss("")
+
+    def action_cancel(self) -> None:
+        """Action to cancel the modal."""
+        self.dismiss("")

src/pilgrim/ui/screens/rename_entry_modal.py

@@ -0,0 +1,58 @@
+from textual.app import ComposeResult
+from textual.containers import Vertical, Horizontal
+from textual.screen import ModalScreen
+from textual.widgets import Label, Input, Button
+
+
+class RenameEntryModal(ModalScreen[str]):
+    """A modal screen to rename a diary entry."""
+
+    BINDINGS = [
+        ("escape", "cancel", "Cancel"),
+    ]
+
+    def __init__(self, current_name: str):
+        super().__init__()
+        self._current_name = current_name
+        self.name_input = Input(
+            value=self._current_name,
+            placeholder="Type the new name...",
+            id="rename_input",
+            classes="RenameEntryModal-name-input"
+        )
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="rename_entry_dialog", classes="RenameEntryModal-dialog"):
+            yield Label("Rename Entry", classes="dialog-title RenameEntryModal-title")
+            yield Label("New Entry Title:", classes="RenameEntryModal-label")
+            yield self.name_input
+            with Horizontal(classes="dialog-buttons RenameEntryModal-buttons"):
+                yield Button("Save", variant="primary", id="save", classes="RenameEntryModal-save-button")
+                yield Button("Cancel", variant="default", id="cancel", classes="RenameEntryModal-cancel-button")
+
+    def on_mount(self) -> None:
+        """Focuses on the input when the screen is mounted."""
+        self.name_input.focus()
+        self.name_input.cursor_position = len(self.name_input.value)
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handles button clicks."""
+        if event.button.id == "save":
+            new_name = self.name_input.value.strip()
+            if new_name:
+                self.dismiss(new_name)  # Returns the new name
+            else:
+                self.dismiss(None)  # Considers empty name as cancellation
+        else:
+            self.dismiss(None)  # Returns None for cancellation
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        """Allows saving by pressing Enter."""
+        new_name = event.value.strip()
+        if new_name:
+            self.dismiss(new_name)
+        else:
+            self.dismiss(None)
+    
+    def action_cancel(self) -> None:
+        self.dismiss(None) 

src/pilgrim/ui/styles/pilgrim.css

@@ -0,0 +1,390 @@
+Screen {
+    layout: vertical;
+    background: $surface-darken-1;
+    align: center middle;
+}
+
+.EditEntryScreen-sub-header {
+    layout: horizontal;
+    background: $primary-darken-1;
+    height: 1;
+    padding: 0 1;
+    align: center middle;
+    width: 100%;
+}
+
+.EditEntryScreen-diary-info {
+    width: auto;
+    color: $text-muted;
+    margin-right: 2;
+}
+
+.EditEntryScreen-entry-info {
+    width: auto;
+    color: $text;
+    margin-right: 1;
+}
+
+.EditEntryScreen-spacer {
+    width: 1fr;
+}
+
+.EditEntryScreen-status-indicator {
+    width: auto;
+    padding: 0 1;
+    content-align: center middle;
+}
+
+.EditEntryScreen-status-indicator.saved {
+    background: #2E8B57; /* SeaGreen */
+    color: $text;
+}
+
+.EditEntryScreen-status-indicator.not-saved {
+    background: #B22222; /* FireBrick */
+    color: $text;
+}
+
+.EditEntryScreen-status-indicator.new {
+    background: #4682B4; /* SteelBlue */
+    color: $text;
+}
+
+.EditEntryScreen-status-indicator.read-only {
+    background: #696969; /* DimGray */
+    color: $text-muted;
+}
+
+.EditEntryScreen-main-container {
+    background: bisque;
+    margin: 0;
+}
+
+.EditEntryScreen-text-entry {
+    width: 100%;
+    height: 1fr;
+    border: none;
+}
+
+AboutScreen {
+    align: center middle;
+}
+
+#AboutScreen_AboutContainer {
+    align: center middle;
+    width: 85%;
+    height: 95%;
+    border: thick $primary;
+    background: $surface;
+    margin: 1;
+}
+
+#AboutScreen_AboutContainer TextArea {
+    align: center middle;
+    width: 100%;
+    height: 55%;
+    margin: 2;
+    padding: 1;
+}
+
+#AboutScreen_SubContainer {
+    align: center middle;
+    height: 45%;
+    padding: 1 1;
+    margin: 1 1;
+}
+
+#AboutScreen_AboutTitle {
+    color: $accent;
+    text-style: bold;
+    text-align: center;
+    margin-bottom: 1;
+}
+
+#AboutScreen_AboutVersion {
+    color: $warning;
+    text-style: italic;
+    text-align: center;
+    margin-bottom: 1;
+}
+
+#AboutScreen_AboutContent {
+    text-align: center;
+    margin-bottom: 1;
+}
+
+#AboutScreen_AboutContact,
+#AboutScreen_AboutAuthor {
+    color: $text-muted;
+    text-align: center;
+    margin-bottom: 1;
+}
+
+#AboutScreen_AboutLicense {
+    height: 60%;
+}
+
+/* Main container - distributing vertical space */
+.DiaryListScreen-DiaryListContainer {
+    height: 1fr;
+    width: 100%;
+    layout: vertical;
+    align: center top; /* Aligns at the top to follow the wireframe */
+    padding: 2 4; /* More space on the sides */
+    background: $surface; /* Removing aquamarine to keep it cleaner */
+}
+
+/* Diary list - main area as in the wireframe */
+.DiaryListScreen-DiaryListOptions {
+    border: round $primary-lighten-2;
+    background: $surface;
+    width: 75%; /* Generous width as in the wireframe */
+    height: 60%; /* Occupies available space */
+    margin: 2 0; /* Vertical margin to separate from other elements */
+}
+
+.DiaryListScreen-DiaryListOptions:focus {
+    border: round $primary;
+}
+
+/* Button container - right below the list */
+.DiaryListScreen-ButtonsGrid {
+    layout: horizontal;
+    align: center middle;
+    width: 75%; /* Same width as the diary list */
+    height: 20%; /* Increasing height to fit button text */
+}
+
+/* Individual buttons - ensuring space for text */
+.DiaryListScreen-NewDiaryButton,
+.DiaryListScreen-EditDiaryButton,
+.DiaryListScreen-OpenDiaryButton {
+    margin: 0 1 1 0; /* Space between buttons */
+    height: 1fr;
+    width: 1fr;
+    border: round grey;
+    text-align: center;
+    content-align: center middle;
+}
+
+/* Tips - using the correct class */
+.DiaryListScreen-DiaryListTips {
+    width: 100%; /* Full width when using dock */
+    height: auto;
+    text-style: italic;
+    text-align: center; /* Centers text within the element */
+    color: $text-muted;
+    dock: bottom; /* Sticks to the bottom of the screen */
+    margin: 0 1;
+}
+
+/* Generic styles that haven't changed */
+.option-list--option-highlighted {
+    background: $primary-darken-2;
+}
+
+.option-list--option-selected {
+    text-style: bold;
+    background: $primary;
+}
+
+Header {
+    background: $primary;
+    color: $text;
+}
+
+Footer {
+    background: $primary;
+    color: $text;
+}
+
+Screen.-modal {
+    background: rgba(0, 0, 0, 0.7); /* Darkens the background screen underneath */
+    align: center middle; /* Centers the content (your modal) that is in this modal screen */
+}
+
+/* Style for the new diary modal dialog */
+.NewDiaryModal-dialog {
+    layout: vertical;
+    width: 60%;
+    height: auto;
+    background: $surface;
+    border: thick $accent;
+    padding: 2 4;
+    align: center middle;
+}
+
+.NewDiaryModal-title {
+    text-align: center;
+    text-style: bold;
+    color: $primary;
+    margin-bottom: 1;
+}
+
+.NewDiaryModal-label {
+    margin-bottom: 1;
+}
+
+.NewDiaryModal-name-input {
+    width: 1fr;
+    margin-bottom: 2;
+}
+
+.NewDiaryModal-buttons {
+    width: 1fr;
+    height: auto;
+    align: center middle;
+    padding-top: 1;
+}
+
+.NewDiaryModal-buttons Button {
+    margin: 0 1;
+    width: 1fr;
+}
+
+/* Additional classes for NewDiaryModal */
+.NewDiaryModal-Dialog {
+    layout: vertical;
+    width: 60%;
+    height: auto;
+    background: $surface;
+    border: thick $accent;
+    padding: 2 4;
+    align: center middle;
+}
+
+.NewDiaryModal-Title {
+    text-align: center;
+    text-style: bold;
+    color: $primary;
+    margin-bottom: 1;
+}
+
+.NewDiaryModal-NameInput {
+    width: 1fr;
+    margin-bottom: 2;
+}
+
+.NewDiaryModal-ButtonsContainer {
+    width: 1fr;
+    height: auto;
+    align: center middle;
+    padding-top: 1;
+}
+
+.NewDiaryModal-CreateDiaryButton,
+.NewDiaryModal-CancelButton {
+    margin: 0 1;
+    width: 1fr;
+}
+
+/* Style for the edit diary modal dialog */
+.EditDiaryModal-dialog {
+    layout: vertical;
+    width: 60%;
+    height: auto;
+    background: $surface;
+    border: thick $warning;
+    padding: 2 4;
+    align: center middle;
+}
+
+.EditDiaryModal-title {
+    text-align: center;
+    text-style: bold;
+    color: $warning;
+    margin-bottom: 1;
+}
+
+.EditDiaryModal-label {
+    margin-bottom: 1;
+}
+
+.EditDiaryModal-name-input {
+    width: 1fr;
+    margin-bottom: 2;
+}
+
+.EditDiaryModal-buttons {
+    width: 1fr;
+    height: auto;
+    align: center middle;
+    padding-top: 1;
+}
+
+.EditDiaryModal-buttons Button {
+    margin: 0 1;
+    width: 1fr;
+}
+
+/* Additional classes for EditDiaryModal */
+.EditDiaryModal-Dialog {
+    layout: vertical;
+    width: 60%;
+    height: auto;
+    background: $surface;
+    border: thick $warning;
+    padding: 2 4;
+    align: center middle;
+}
+
+.EditDiaryModal-Title {
+    text-align: center;
+    text-style: bold;
+    color: $warning;
+    margin-bottom: 1;
+}
+
+.EditDiaryModal-NameInput {
+    width: 1fr;
+    margin-bottom: 2;
+}
+
+.EditDiaryModal-ButtonsContainer {
+    width: 1fr;
+    height: auto;
+    align: center middle;
+    padding-top: 1;
+}
+
+.EditDiaryModal-SaveButton,
+.EditDiaryModal-CancelButton {
+    margin: 0 1;
+    width: 1fr;
+}
+
+/* Style for the rename entry modal dialog */
+.RenameEntryModal-dialog {
+    layout: vertical;
+    width: 60%;
+    height: auto;
+    background: $surface;
+    border: thick $accent;
+    padding: 2 4;
+    align: center middle;
+}
+
+.RenameEntryModal-title {
+    text-align: center;
+    text-style: bold;
+    color: $accent;
+    margin-bottom: 1;
+}
+
+.RenameEntryModal-name-input {
+    width: 1fr;
+    margin-bottom: 2;
+}
+
+.RenameEntryModal-buttons {
+    width: 1fr;
+    height: auto;
+    align: center middle;
+    padding-top: 1;
+}
+
+.RenameEntryModal-save-button,
+.RenameEntryModal-cancel-button {
+    margin: 0 1;
+    width: 1fr;
+} 

src/pilgrim/ui/ui.py

@@ -0,0 +1,58 @@
+from pathlib import Path
+from typing import Iterable
+
+from textual.app import App, SystemCommand
+from textual.screen import Screen
+
+
+from pilgrim.service.servicemanager import ServiceManager
+from pilgrim.ui.screens.about_screen import AboutScreen
+from pilgrim.ui.screens.diary_list_screen import DiaryListScreen
+from pilgrim.ui.screens.edit_entry_screen import EditEntryScreen
+
+CSS_FILE_PATH = Path(__file__).parent / "styles" / "pilgrim.css"
+
+
+class UIApp(App):
+    CSS_PATH = CSS_FILE_PATH
+
+    def __init__(self,service_manager: ServiceManager, **kwargs):
+        super().__init__(**kwargs)
+        self.service_manager = service_manager
+
+
+    def on_mount(self) -> None:
+        """Called when the app starts. Loads the main screen."""
+        self.push_screen(DiaryListScreen())
+
+    def get_system_commands(self, screen: Screen) -> Iterable[SystemCommand]:
+        """Return commands based on current screen."""
+
+        # Commands for DiaryListScreen
+        if isinstance(screen, DiaryListScreen):
+            yield SystemCommand(
+                "About Pilgrim",
+                "Open About Pilgrim",
+                screen.action_about_cmd
+            )
+
+        elif isinstance(screen, AboutScreen):
+            yield SystemCommand(
+                "Back to List",
+                "Return to the diary list",
+                screen.dismiss
+            )
+
+        elif isinstance(screen, EditEntryScreen):
+            yield SystemCommand(
+                "Back to Diary List",
+                "Return to the diary list",
+                screen.action_back_to_list
+            )
+
+        # Always include quit command
+        yield SystemCommand(
+            "Quit Application",
+            "Exit Pilgrim",
+            self.action_quit
+        )