shoko 0.1.0

data/lib/shoko/adapters/storage/repositories/progress_repository.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'time'
+
+require_relative 'base_repository'
+require_relative 'storage/progress_file_store'
+
+module Shoko
+  module Adapters::Storage::Repositories
+      # Repository for reading progress persistence, abstracting the underlying storage mechanism.
+      #
+      # This repository provides a clean domain interface for progress operations,
+      # hiding the file-based persistence details from domain services.
+      #
+      # @example Saving progress
+      #   repo = ProgressRepository.new(dependencies)
+      #   repo.save_for_book('/path/to/book.epub', chapter_index: 3, line_offset: 150)
+      #
+      # @example Loading progress
+      #   progress = repo.find_by_book_path('/path/to/book.epub')
+      class ProgressRepository < BaseRepository
+        # Progress data structure
+        ProgressData = Struct.new(:chapter_index, :line_offset, :timestamp, keyword_init: true) do
+          def to_h
+            {
+              chapter: chapter_index,
+              line_offset: line_offset,
+              timestamp: timestamp,
+            }
+          end
+
+          def self.from_h(hash)
+            return nil unless hash
+
+            new(
+              chapter_index: hash['chapter'] || hash[:chapter],
+              line_offset: hash['line_offset'] || hash[:line_offset],
+              timestamp: hash['timestamp'] || hash[:timestamp]
+            )
+          end
+        end
+
+        def initialize(dependencies)
+          super
+          file_writer = dependencies.resolve(:file_writer)
+          @storage = Storage::ProgressFileStore.new(file_writer:)
+        end
+
+        # Save reading progress for a specific book
+        #
+        # @param book_path [String] Path to the EPUB file
+        # @param chapter_index [Integer] Chapter index (0-based)
+        # @param line_offset [Integer] Line offset within the chapter
+        # @return [ProgressData] The saved progress data
+        def save_for_book(book_path, chapter_index:, line_offset:)
+          validate_required_params(
+            { book_path: book_path, chapter_index: chapter_index, line_offset: line_offset },
+            %i[book_path chapter_index line_offset]
+          )
+
+          begin
+            @storage.save(book_path, chapter_index, line_offset)
+
+            # Return the progress data that was saved
+            ProgressData.new(
+              chapter_index: chapter_index,
+              line_offset: line_offset,
+              timestamp: Time.now.iso8601
+            )
+          rescue StandardError => e
+            handle_storage_error(e, "saving progress for #{book_path}")
+          end
+        end
+
+        # Find reading progress for a specific book
+        #
+        # @param book_path [String] Path to the EPUB file
+        # @return [ProgressData, nil] Progress data for the book, or nil if none exists
+        def find_by_book_path(book_path)
+          validate_required_params({ book_path: book_path }, [:book_path])
+
+          begin
+            progress_hash = @storage.load(book_path)
+            ProgressData.from_h(progress_hash)
+          rescue StandardError => e
+            handle_storage_error(e, "loading progress for #{book_path}")
+          end
+        end
+
+        # Find all reading progress across all books
+        #
+        # @return [Hash<String, ProgressData>] Hash mapping book paths to progress data
+        def find_all
+          all_progress = @storage.load_all
+          all_progress.transform_values { |progress_hash| ProgressData.from_h(progress_hash) }
+        rescue StandardError => e
+          handle_storage_error(e, 'loading all progress data')
+        end
+
+        # Check if progress exists for a book
+        #
+        # @param book_path [String] Path to the EPUB file
+        # @return [Boolean] True if progress data exists for the book
+        def exists_for_book?(book_path)
+          !find_by_book_path(book_path).nil?
+        rescue StandardError => e
+          handle_storage_error(e, "checking progress existence for #{book_path}")
+        end
+
+        # Get the timestamp of the last progress update for a book
+        #
+        # @param book_path [String] Path to the EPUB file
+        # @return [Time, nil] Last update timestamp, or nil if no progress exists
+        def last_updated_at(book_path)
+          progress = find_by_book_path(book_path)
+          ts = progress&.timestamp
+          return nil unless ts
+
+          Time.parse(ts)
+        rescue StandardError => e
+          handle_storage_error(e, "getting last update time for #{book_path}")
+        end
+
+        # Get books ordered by most recently read
+        #
+        # @param limit [Integer, nil] Maximum number of books to return
+        # @return [Array<String>] Array of book paths ordered by recency
+        def recent_books(limit: nil)
+          all_progress = find_all
+          sorted_paths = all_progress.sort_by do |_path, progress|
+            ts = progress.timestamp
+            ts ? Time.parse(ts) : Time.at(0)
+          end.reverse.map(&:first)
+
+          limit ? sorted_paths.take(limit) : sorted_paths
+        rescue StandardError => e
+          handle_storage_error(e, 'getting recent books')
+        end
+
+        # Update progress only if the new position is further than current
+        #
+        # @param book_path [String] Path to the EPUB file
+        # @param chapter_index [Integer] Chapter index (0-based)
+        # @param line_offset [Integer] Line offset within the chapter
+        # @return [ProgressData] The saved progress data
+        def save_if_further(book_path, chapter_index:, line_offset:)
+          current_progress = find_by_book_path(book_path)
+
+          should_save = if current_progress.nil?
+                          true
+                        else
+                          cur_ch = current_progress.chapter_index
+                          cur_off = current_progress.line_offset
+                          chapter_index > cur_ch ||
+                            (chapter_index == cur_ch && line_offset > cur_off)
+                        end
+
+          return save_for_book(book_path, chapter_index: chapter_index, line_offset: line_offset) if should_save
+
+          current_progress
+        rescue StandardError => e
+          handle_storage_error(e, "conditionally saving progress for #{book_path}")
+        end
+      end
+  end
+end

data/lib/shoko/adapters/storage/repositories/storage/annotation_file_store.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+require 'time'
+
+require_relative '../../../output/terminal/terminal_sanitizer.rb'
+require_relative 'file_store_utils'
+require_relative '../../config_paths'
+# Domain storage helpers should operate via injected services to avoid reaching into infrastructure.
+
+module Shoko
+  module Adapters::Storage::Repositories::Storage
+    # File-backed annotation storage under Domain.
+    # Persists annotations to ${XDG_CONFIG_HOME:-~/.config}/shoko/annotations.json
+    class AnnotationFileStore
+      FILE_NAME = 'annotations.json'
+
+      def initialize(file_writer:)
+        @file_writer = file_writer
+      end
+
+      def all
+        sanitize_all(load_all)
+      rescue StandardError
+        {}
+      end
+
+      def get(path)
+        sanitize_list(load_all[path.to_s] || []).dup
+      rescue StandardError
+        []
+      end
+
+      def add(path, text, note, range, chapter_index, page_meta = nil)
+        data = load_all
+        key = path.to_s
+        list = data[key] || []
+        now = Time.now
+        ann = {
+          'id' => now.to_f.to_s,
+          'text' => sanitize_body(text),
+          'note' => sanitize_body(note),
+          'range' => range,
+          'chapter_index' => chapter_index,
+          'created_at' => now.iso8601,
+        }
+        if page_meta.is_a?(Hash)
+          ann['page_current'] = page_meta[:current] || page_meta['current']
+          ann['page_total'] = page_meta[:total] || page_meta['total']
+          ann['page_mode'] = page_meta[:type] || page_meta['type']
+        end
+        list << ann
+        data[key] = list
+        save_all(data)
+        true
+      rescue StandardError
+        false
+      end
+
+      def update(path, id, note)
+        data = load_all
+        key = path.to_s
+        list = data[key] || []
+        ann = list.find { |a| a['id'] == id }
+        return false unless ann
+
+        ann['note'] = sanitize_body(note)
+        ann['updated_at'] = Time.now.iso8601
+        data[key] = list
+        save_all(data)
+        true
+      rescue StandardError
+        false
+      end
+
+      def delete(path, id)
+        data = load_all
+        key = path.to_s
+        list = data[key] || []
+        list.reject! { |a| a['id'] == id }
+        list.empty? ? data.delete(key) : data[key] = list
+        save_all(data)
+        true
+      rescue StandardError
+        false
+      end
+
+      private
+
+      attr_reader :file_writer
+
+      def load_all
+        FileStoreUtils.load_json_or_empty(file_path)
+      end
+
+      def sanitize_all(data)
+        return {} unless data.is_a?(Hash)
+
+        data.transform_values { |list| sanitize_list(list) }
+      end
+
+      def sanitize_list(list)
+        Array(list).map do |ann|
+          next ann unless ann.is_a?(Hash)
+
+          safe = ann.dup
+          safe['text'] = sanitize_body(safe['text'])
+          safe['note'] = sanitize_body(safe['note'])
+          safe
+        end
+      end
+
+      def sanitize_body(text)
+        Shoko::Adapters::Output::Terminal::TerminalSanitizer.sanitize(text.to_s, preserve_newlines: true, preserve_tabs: true)
+      end
+
+      def save_all(data)
+        payload = JSON.pretty_generate(data)
+        file_writer.write(file_path, payload)
+      end
+
+      def file_path
+        Adapters::Storage::ConfigPaths.config_path(FILE_NAME)
+      end
+    end
+  end
+end

data/lib/shoko/adapters/storage/repositories/storage/bookmark_file_store.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+require 'time'
+
+require_relative '../../../output/terminal/terminal_sanitizer.rb'
+require_relative '../../../../core/models/bookmark.rb'
+require_relative '../../../../core/models/bookmark_data.rb'
+require_relative 'file_store_utils'
+require_relative '../../config_paths'
+# Domain storage helpers should operate via injected services to avoid reaching into infrastructure.
+
+module Shoko
+  module Adapters::Storage::Repositories::Storage
+    # File-backed bookmark storage isolated under Domain.
+    # Persists bookmarks to ${XDG_CONFIG_HOME:-~/.config}/shoko/bookmarks.json
+    class BookmarkFileStore
+      FILE_NAME = 'bookmarks.json'
+
+      def initialize(file_writer:)
+        @file_writer = file_writer
+      end
+
+      def add(bookmark_data)
+        unless bookmark_data.is_a?(Shoko::Core::Models::BookmarkData)
+          raise ArgumentError, 'bookmark_data must be BookmarkData'
+        end
+
+        all = load_all
+        path = bookmark_data.path.to_s
+        list = all[path] || []
+        entry = {
+          'chapter' => bookmark_data.chapter,
+          'line_offset' => bookmark_data.line_offset,
+          'text' => sanitize_text(bookmark_data.text),
+          'timestamp' => Time.now.iso8601,
+        }
+        list << entry
+        all[path] = list
+        save_all(all)
+        entry
+      end
+
+      def get(path)
+        all = load_all
+        list = all[path.to_s] || []
+        list.map do |h|
+          safe = h.is_a?(Hash) ? h.dup : {}
+          safe['text'] = sanitize_text(safe['text'])
+          Shoko::Core::Models::Bookmark.from_h(safe)
+        end
+      rescue StandardError
+        []
+      end
+
+      def delete(path, bookmark)
+        all = load_all
+        key = path.to_s
+        list = all[key] || []
+        # Delete by matching serialized representation
+        predicate = if bookmark.respond_to?(:to_h)
+                      target = bookmark.to_h
+                      ->(stored_entry) { equivalent?(stored_entry, target) }
+                    else
+                      # Best-effort: match by position
+                      chapter = bookmark.respond_to?(:chapter_index) ? bookmark.chapter_index : bookmark[:chapter_index]
+                      offset = bookmark.respond_to?(:line_offset) ? bookmark.line_offset : bookmark[:line_offset]
+                      lambda { |stored_entry|
+                        stored_entry['chapter'] == chapter && stored_entry['line_offset'] == offset
+                      }
+                    end
+        list.reject!(&predicate)
+        list.empty? ? all.delete(key) : all[key] = list
+        save_all(all)
+        true
+      rescue StandardError
+        false
+      end
+
+      private
+
+      attr_reader :file_writer
+
+      def equivalent?(stored_entry, target)
+        stored_entry['chapter'] == target['chapter'] &&
+          stored_entry['line_offset'] == target['line_offset'] &&
+          (stored_entry['text'].to_s == target['text'].to_s)
+      end
+
+      def sanitize_text(text)
+        Shoko::Adapters::Output::Terminal::TerminalSanitizer.sanitize(text.to_s, preserve_newlines: false, preserve_tabs: false)
+      end
+
+      def load_all
+        FileStoreUtils.load_json_or_empty(file_path)
+      end
+
+      def save_all(data)
+        payload = JSON.pretty_generate(data)
+        file_writer.write(file_path, payload)
+      end
+
+      def file_path
+        Adapters::Storage::ConfigPaths.config_path(FILE_NAME)
+      end
+    end
+  end
+end

data/lib/shoko/adapters/storage/repositories/storage/file_store_utils.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Shoko
+  module Adapters::Storage::Repositories::Storage
+    # Small, shared helpers for file-backed JSON stores.
+    module FileStoreUtils
+      module_function
+
+      def load_json_or_empty(file_path)
+        return {} unless File.exist?(file_path)
+
+        JSON.parse(File.read(file_path))
+      rescue StandardError
+        {}
+      end
+    end
+  end
+end

data/lib/shoko/adapters/storage/repositories/storage/progress_file_store.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+require 'time'
+require_relative 'file_store_utils'
+require_relative '../../config_paths'
+# Domain storage helpers should operate via injected services to avoid reaching into infrastructure.
+
+module Shoko
+  module Adapters::Storage::Repositories::Storage
+    # File-backed progress storage under Domain.
+    # Persists progress to ${XDG_CONFIG_HOME:-~/.config}/shoko/progress.json
+    class ProgressFileStore
+      FILE_NAME = 'progress.json'
+
+      def initialize(file_writer:)
+        @file_writer = file_writer
+      end
+
+      def save(path, chapter_index, line_offset)
+        all = load_all
+        all[path.to_s] = {
+          'chapter' => chapter_index,
+          'line_offset' => line_offset,
+          'timestamp' => Time.now.iso8601,
+        }
+        save_all(all)
+        true
+      rescue StandardError
+        false
+      end
+
+      def load(path)
+        all = load_all
+        all[path.to_s]
+      rescue StandardError
+        nil
+      end
+
+      def load_all
+        FileStoreUtils.load_json_or_empty(file_path)
+      end
+
+      private
+
+      attr_reader :file_writer
+
+      def save_all(data)
+        payload = JSON.pretty_generate(data)
+        file_writer.write(file_path, payload)
+      end
+
+      def file_path
+        Adapters::Storage::ConfigPaths.config_path(FILE_NAME)
+      end
+    end
+  end
+end

data/lib/shoko/application/annotation_editor_overlay_session.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative 'state/actions/update_selection_action.rb'
+require_relative '../application/selectors/reader_selectors'
+
+module Shoko
+  module Application
+    # Adapter exposing the annotation editor overlay through the same interface as
+    # the legacy screen component so Application commands can drive it via the input
+    # dispatcher.
+    class AnnotationEditorOverlaySession
+      def initialize(state, dependencies, ui_controller)
+        @state = state
+        @dependencies = dependencies
+        @ui_controller = ui_controller
+      end
+
+      def active?
+        overlay = current_overlay
+        overlay.respond_to?(:visible?) && overlay.visible?
+      end
+
+      def save_annotation
+        overlay = current_overlay
+        return :pass unless overlay
+
+        service, book_path = resolve_save_context
+        return cancel_and_pass unless service && book_path
+
+        persist_annotation(overlay, service, book_path)
+        :handled
+      end
+
+      def cancel_annotation
+        close_overlay
+        clear_selection
+        @ui_controller.set_message('Annotation cancelled', 2)
+        :handled
+      end
+
+      def cancel_and_pass
+        cancel_annotation
+        :pass
+      end
+
+      def handle_backspace
+        overlay = current_overlay
+        overlay&.handle_backspace
+        :handled
+      end
+
+      def handle_enter
+        overlay = current_overlay
+        overlay&.handle_enter if overlay.respond_to?(:handle_enter)
+        :handled
+      end
+
+      def handle_character(char)
+        overlay = current_overlay
+        overlay&.handle_character(char) if overlay.respond_to?(:handle_character)
+        :handled
+      end
+
+      private
+
+      def current_overlay
+        Shoko::Application::Selectors::ReaderSelectors.annotation_editor_overlay(@state)
+      end
+
+      def resolve_save_context
+        service = resolve_annotation_service
+        book_path = current_book_path
+        [service, book_path]
+      end
+
+      def current_book_path
+        return unless @ui_controller.respond_to?(:current_book_path)
+
+        @ui_controller.current_book_path
+      end
+
+      def persist_annotation(overlay, service, book_path)
+        save_overlay(overlay, service, book_path)
+        refresh_annotations
+      rescue StandardError => e
+        @ui_controller.set_message("Save failed: #{e.message}", 3)
+      ensure
+        close_overlay
+        clear_selection
+      end
+
+      def save_overlay(overlay, service, book_path)
+        if overlay.annotation_id
+          service.update(book_path, overlay.annotation_id, overlay.note)
+          @ui_controller.set_message('Annotation updated', 2)
+        else
+          service.add(book_path,
+                      overlay.selected_text,
+                      overlay.note,
+                      overlay.selection_range,
+                      overlay.chapter_index,
+                      nil)
+          @ui_controller.set_message('Annotation saved!', 2)
+        end
+      end
+
+      def refresh_annotations
+        return unless @ui_controller.respond_to?(:refresh_annotations)
+
+        @ui_controller.refresh_annotations
+      end
+
+      def resolve_annotation_service
+        return unless @dependencies.respond_to?(:resolve)
+
+        @dependencies.resolve(:annotation_service)
+      rescue StandardError
+        nil
+      end
+
+      def close_overlay
+        return unless @ui_controller
+
+        begin
+          @ui_controller.send(:close_annotation_editor_overlay)
+        rescue StandardError
+          nil
+        end
+      end
+
+      def clear_selection
+        @state.dispatch(Shoko::Application::Actions::ClearSelectionAction.new)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end