fuso 0.1.2

data/lib/fuso/app.rb

@@ -0,0 +1,470 @@
+# frozen_string_literal: true
+
+require "bubbletea"
+require "lipgloss"
+require "date"
+require "time"
+
+require_relative "config"
+require_relative "session"
+require_relative "styles"
+require_relative "views/main_view"
+require_relative "views/settings_view"
+require_relative "views/report_view"
+require_relative "heartbeat"
+
+module Fuso
+  class TickMessage; end
+
+  class App
+    include Bubbletea::Model
+
+    attr_reader :config, :session
+    attr_reader :current_project, :current_category
+    attr_reader :active_project, :active_category
+    attr_accessor :settings_focus, :settings_index, :settings_input_mode
+    attr_accessor :settings_input_buffer, :settings_message
+    attr_accessor :report_mode, :report_date
+    attr_reader :toast
+
+    def initialize
+      @config = Config.load
+      @session = Session.load
+
+      @current_project = @config.default_project
+      @current_category = @config.default_category
+
+      # Timer state
+      @tracking = false
+      @active_project = nil
+      @active_category = nil
+      @timer_start = nil
+      @timer_accumulated = 0  # seconds accumulated before pause
+
+      # Screen state
+      @screen = :main
+
+      # Settings state
+      @settings_focus = :projects
+      @settings_index = 0
+      @settings_input_mode = false
+      @settings_input_buffer = ""
+      @settings_message = nil
+
+      # Report state
+      @report_mode = :weekly
+      @report_date = Date.today
+
+      # Toast notification
+      @toast = nil
+      @toast_expires_at = nil
+
+      # Views
+      @main_view = Views::MainView.new
+      @settings_view = Views::SettingsView.new
+      @report_view = Views::ReportView.new
+
+      # Heartbeat for suspend detection
+      @heartbeat = Heartbeat.new
+    end
+
+    def init
+      [self, schedule_tick]
+    end
+
+    def update(message)
+      case message
+      when TickMessage
+        # Check for suspend via heartbeat staleness
+        if @tracking
+          if (stale_time = @heartbeat.pulse)
+            save_and_stop(at: stale_time)
+            show_toast("Timer stopped — system was suspended")
+          end
+        end
+        # Clear expired toast
+        if @toast && @toast_expires_at && Time.now > @toast_expires_at
+          @toast = nil
+          @toast_expires_at = nil
+        end
+        # Timer ticks — just re-render
+        [self, schedule_tick]
+      when Bubbletea::WindowSizeMessage
+        @width = message.width
+        @height = message.height
+        [self, nil]
+      when Bubbletea::KeyMessage
+        handle_key(message)
+      else
+        [self, nil]
+      end
+    end
+
+    def view
+      content = case @screen
+                when :main
+                  @main_view.render(self)
+                when :settings
+                  @settings_view.render(self)
+                when :report
+                  @report_view.render(self)
+                end
+
+      # Append toast notification if present
+      if @toast
+        content += "\n\n" + Styles.toast.render(@toast)
+      end
+
+      if @width && @height
+        Lipgloss.place(@width, @height, :center, :center, content)
+      else
+        content
+      end
+    end
+
+    # Public state accessors
+
+    def tracking?
+      @tracking
+    end
+
+    def active_elapsed_seconds
+      return 0 unless @tracking && @timer_start
+
+      @timer_accumulated + (Time.now - @timer_start).to_i
+    end
+
+    def current_timer_seconds
+      return 0 unless @tracking && @timer_start
+
+      (Time.now - @timer_start).to_i
+    end
+
+    private
+
+    def schedule_tick
+      Bubbletea.tick(0.5) { TickMessage.new }
+    end
+
+    def handle_key(message)
+      key = message.to_s
+
+      # Global quit
+      if key == "ctrl+c"
+        save_and_stop if @tracking
+        return [self, Bubbletea.quit]
+      end
+
+      case @screen
+      when :main
+        handle_main_key(key)
+      when :settings
+        handle_settings_key(key)
+      when :report
+        handle_report_key(key)
+      end
+    end
+
+    # ── Main Screen ──
+
+    def handle_main_key(key)
+      case key
+      when "q"
+        save_and_stop if @tracking
+        [self, Bubbletea.quit]
+      when "s", " "
+        toggle_tracking
+        [self, nil]
+      when "1", "2", "3", "4", "5", "6", "7", "8", "9"
+        idx = key.to_i - 1
+        switch_category(idx) if idx < @config.categories.size
+        [self, nil]
+      when "p"
+        cycle_project
+        [self, nil]
+      when "m"
+        @screen = :settings
+        @settings_index = 0
+        @settings_focus = :projects
+        @settings_message = nil
+        [self, nil]
+      when "r"
+        @screen = :report
+        @report_date = Date.today
+        [self, nil]
+      else
+        [self, nil]
+      end
+    end
+
+    def toggle_tracking
+      if @tracking
+        save_and_stop
+      else
+        start_tracking(@current_project, @current_category)
+      end
+    end
+
+    def start_tracking(project, category)
+      @heartbeat.clear
+      @tracking = true
+      @active_project = project
+      @active_category = category
+      @current_project = project
+      @current_category = category
+      @timer_start = Time.now
+      @timer_accumulated = 0
+    end
+
+    def save_and_stop(at: nil)
+      return unless @tracking && @timer_start
+
+      end_time = at || Time.now
+      elapsed = (end_time - @timer_start).to_i
+      total = @timer_accumulated + elapsed
+
+      if total > 0
+        started_at = end_time - total
+        @session.record(
+          project: @active_project,
+          category: @active_category,
+          started_at: started_at,
+          ended_at: end_time,
+          elapsed_seconds: total
+        )
+      end
+
+      @tracking = false
+      @timer_start = nil
+      @timer_accumulated = 0
+      @active_project = nil
+      @active_category = nil
+      @heartbeat.clear
+    end
+
+    def switch_category(idx)
+      new_category = @config.categories[idx]
+      return if new_category.nil?
+      return if @tracking && new_category == @active_category && @current_project == @active_project
+
+      if @tracking
+        # Save current session
+        elapsed = (Time.now - @timer_start).to_i
+        total = @timer_accumulated + elapsed
+
+        if total > 0
+          started_at = Time.now - total
+          @session.record(
+            project: @active_project,
+            category: @active_category,
+            started_at: started_at,
+            ended_at: Time.now,
+            elapsed_seconds: total
+          )
+        end
+
+        # Start new session
+        start_tracking(@current_project, new_category)
+      else
+        @current_category = new_category
+      end
+    end
+
+    def cycle_project
+      return if @config.projects.size <= 1
+
+      current_idx = @config.projects.index(@current_project) || 0
+      next_idx = (current_idx + 1) % @config.projects.size
+      new_project = @config.projects[next_idx]
+
+      if @tracking
+        # Save current session
+        elapsed = (Time.now - @timer_start).to_i
+        total = @timer_accumulated + elapsed
+
+        if total > 0
+          started_at = Time.now - total
+          @session.record(
+            project: @active_project,
+            category: @active_category,
+            started_at: started_at,
+            ended_at: Time.now,
+            elapsed_seconds: total
+          )
+        end
+
+        # Start on new project with current category
+        start_tracking(new_project, @current_category)
+      else
+        @current_project = new_project
+      end
+    end
+
+    # ── Settings Screen ──
+
+    def handle_settings_key(key)
+      if @settings_input_mode
+        handle_settings_input_key(key)
+      else
+        handle_settings_nav_key(key)
+      end
+    end
+
+    def handle_settings_nav_key(key)
+      case key
+      when "esc"
+        @screen = :main
+        @current_project = @config.default_project
+        @current_category = @config.default_category
+        [self, nil]
+      when "tab"
+        @settings_focus = @settings_focus == :projects ? :categories : :projects
+        @settings_index = 0
+        @settings_message = nil
+        [self, nil]
+      when "up", "k"
+        @settings_index = [0, @settings_index - 1].max
+        @settings_message = nil
+        [self, nil]
+      when "down", "j"
+        max = current_settings_list.size - 1
+        @settings_index = [@settings_index + 1, max].min
+        @settings_message = nil
+        [self, nil]
+      when "a"
+        @settings_input_mode = true
+        @settings_input_buffer = ""
+        @settings_message = nil
+        [self, nil]
+      when "d"
+        set_default_selected
+        [self, nil]
+      when "x"
+        delete_selected
+        [self, nil]
+      else
+        [self, nil]
+      end
+    end
+
+    def handle_settings_input_key(key)
+      case key
+      when "esc"
+        @settings_input_mode = false
+        @settings_input_buffer = ""
+        [self, nil]
+      when "enter"
+        add_item(@settings_input_buffer)
+        @settings_input_mode = false
+        @settings_input_buffer = ""
+        [self, nil]
+      when "backspace"
+        @settings_input_buffer = @settings_input_buffer[0..-2]
+        [self, nil]
+      else
+        if key.length == 1
+          @settings_input_buffer += key
+        end
+        [self, nil]
+      end
+    end
+
+    def current_settings_list
+      @settings_focus == :projects ? @config.projects : @config.categories
+    end
+
+    def add_item(name)
+      if @settings_focus == :projects
+        if @config.add_project(name)
+          @settings_message = "Added project: #{name}"
+        else
+          @settings_message = "Could not add project (empty or duplicate)"
+        end
+      else
+        if @config.add_category(name)
+          @settings_message = "Added category: #{name}"
+        else
+          @settings_message = "Could not add category (empty or duplicate)"
+        end
+      end
+    end
+
+    def set_default_selected
+      list = current_settings_list
+      return if @settings_index >= list.size
+
+      item = list[@settings_index]
+      if @settings_focus == :projects
+        @config.set_default_project(item)
+        @settings_message = "Default project: #{item}"
+      else
+        @config.set_default_category(item)
+        @settings_message = "Default category: #{item}"
+      end
+    end
+
+    def delete_selected
+      list = current_settings_list
+      return if @settings_index >= list.size
+
+      item = list[@settings_index]
+      if @settings_focus == :projects
+        if @config.remove_project(item)
+          @settings_message = "Removed project: #{item}"
+          @settings_index = [@settings_index, @config.projects.size - 1].min
+        else
+          @settings_message = "Cannot remove (last project)"
+        end
+      else
+        if @config.remove_category(item)
+          @settings_message = "Removed category: #{item}"
+          @settings_index = [@settings_index, @config.categories.size - 1].min
+        else
+          @settings_message = "Cannot remove (last category)"
+        end
+      end
+    end
+
+    # ── Report Screen ──
+
+    def handle_report_key(key)
+      case key
+      when "esc"
+        @screen = :main
+        [self, nil]
+      when "tab"
+        @report_mode = @report_mode == :weekly ? :monthly : :weekly
+        [self, nil]
+      when "left", "h"
+        navigate_report(-1)
+        [self, nil]
+      when "right", "l"
+        navigate_report(1)
+        [self, nil]
+      when "e"
+        filename = @report_view.export_csv(self)
+        show_toast("File saved to #{filename}")
+        [self, nil]
+      else
+        [self, nil]
+      end
+    end
+
+    def navigate_report(direction)
+      if @report_mode == :weekly
+        @report_date += (direction * 7)
+      else
+        if direction > 0
+          @report_date = Date.new(@report_date.year, @report_date.month, 1).next_month
+        else
+          @report_date = Date.new(@report_date.year, @report_date.month, 1).prev_month
+        end
+      end
+    end
+
+    def show_toast(message)
+      @toast = message
+      @toast_expires_at = Time.now + 4
+    end
+  end
+end

data/lib/fuso/config.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Fuso
+  class Config
+    CONFIG_DIR = File.join(Dir.home, ".fuso")
+    CONFIG_FILE = File.join(CONFIG_DIR, "config.json")
+
+    DEFAULT = {
+      "projects" => ["Project 1"],
+      "categories" => ["Development", "Planning", "Meeting", "Support"],
+      "default_project" => "Project 1",
+      "default_category" => "Development"
+    }.freeze
+
+    attr_accessor :projects, :categories, :default_project, :default_category
+
+    def initialize
+      @projects = []
+      @categories = []
+      @default_project = nil
+      @default_category = nil
+    end
+
+    def self.load
+      config = new
+      FileUtils.mkdir_p(CONFIG_DIR)
+
+      if File.exist?(CONFIG_FILE)
+        data = JSON.parse(File.read(CONFIG_FILE))
+      else
+        data = {
+          "projects" => DEFAULT["projects"].dup,
+          "categories" => DEFAULT["categories"].dup,
+          "default_project" => DEFAULT["default_project"],
+          "default_category" => DEFAULT["default_category"]
+        }
+        File.write(CONFIG_FILE, JSON.pretty_generate(data))
+      end
+
+      config.projects = (data["projects"] || []).dup
+      config.categories = (data["categories"] || []).dup
+      config.default_project = data["default_project"]
+      config.default_category = data["default_category"]
+      config
+    end
+
+    def save
+      FileUtils.mkdir_p(CONFIG_DIR)
+      data = {
+        "projects" => @projects,
+        "categories" => @categories,
+        "default_project" => @default_project,
+        "default_category" => @default_category
+      }
+      File.write(CONFIG_FILE, JSON.pretty_generate(data))
+    end
+
+    def add_project(name)
+      name = name.strip
+      return false if name.empty? || @projects.include?(name)
+
+      @projects << name
+      @default_project ||= name
+      save
+      true
+    end
+
+    def add_category(name)
+      name = name.strip
+      return false if name.empty? || @categories.include?(name)
+
+      @categories << name
+      @default_category ||= name
+      save
+      true
+    end
+
+    def remove_project(name)
+      return false unless @projects.include?(name)
+      return false if @projects.size <= 1
+
+      @projects.delete(name)
+      @default_project = @projects.first if @default_project == name
+      save
+      true
+    end
+
+    def remove_category(name)
+      return false unless @categories.include?(name)
+      return false if @categories.size <= 1
+
+      @categories.delete(name)
+      @default_category = @categories.first if @default_category == name
+      save
+      true
+    end
+
+    def set_default_project(name)
+      return false unless @projects.include?(name)
+
+      @default_project = name
+      save
+      true
+    end
+
+    def set_default_category(name)
+      return false unless @categories.include?(name)
+
+      @default_category = name
+      save
+      true
+    end
+  end
+end

data/lib/fuso/heartbeat.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Fuso
+  # Writes a timestamp to ~/.fuso/heartbeat every INTERVAL seconds while
+  # the timer is running. On each tick, checks whether the last heartbeat
+  # is stale (gap > STALE_THRESHOLD), which indicates the system was
+  # suspended. Returns the stale timestamp so the app can use it as the
+  # real session end time.
+  class Heartbeat
+    HEARTBEAT_FILE = File.join(Config::CONFIG_DIR, "heartbeat")
+    INTERVAL = 10       # seconds between file writes
+    STALE_THRESHOLD = 60 # seconds — gap larger than this means suspend
+
+    def initialize
+      @last_write_at = nil
+    end
+
+    # Call on each tick while tracking. Returns the last-known timestamp
+    # if a suspend gap was detected, nil otherwise.
+    def pulse
+      now = Time.now
+      stale_time = detect_staleness(now)
+      return stale_time if stale_time
+
+      if @last_write_at.nil? || (now - @last_write_at) >= INTERVAL
+        write(now)
+        @last_write_at = now
+      end
+
+      nil
+    end
+
+    # Call when tracking stops or app quits.
+    def clear
+      File.delete(HEARTBEAT_FILE) if File.exist?(HEARTBEAT_FILE)
+      @last_write_at = nil
+    end
+
+    private
+
+    def detect_staleness(now)
+      return nil unless File.exist?(HEARTBEAT_FILE)
+
+      last = Time.at(File.read(HEARTBEAT_FILE).strip.to_f)
+      gap = now - last
+
+      gap > STALE_THRESHOLD ? last : nil
+    rescue
+      nil
+    end
+
+    def write(time)
+      FileUtils.mkdir_p(Config::CONFIG_DIR)
+      File.write(HEARTBEAT_FILE, time.to_f.to_s)
+    end
+  end
+end