archsight 0.1.1 → 0.1.3

data/lib/archsight/helpers/formatting.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Archsight
+  module Helpers
+    # Formatting provides string and number formatting utilities
+    module Formatting
+      module_function
+
+      # Convert string to class name format
+      def classify(val)
+        val.to_s.split("-").map(&:capitalize).join
+      end
+
+      # Format number as euro currency
+      def to_euro(num)
+        rounded = (num * 100).round / 100.0
+        parts = format("%.2f", rounded).split(".")
+        parts[0] = parts[0].reverse.scan(/\d{1,3}/).join(",").reverse
+        "€#{parts.join(".")}"
+      end
+
+      # AI-adjusted project estimate configuration
+      # Source values stored separately for easy adjustment
+      AI_ESTIMATE_CONFIG = {
+        cocomo_salary: 150_000,      # COCOMO assumes US salary in USD
+        target_salary: 80_000,       # Target salary in EUR
+        ai_cost_multiplier: 3.0,     # AI productivity boost for cost
+        ai_schedule_multiplier: 2.5, # AI productivity boost for schedule
+        ai_team_multiplier: 3.0      # AI productivity boost for team size
+      }.freeze
+
+      # Apply AI adjustment factors to project estimates
+      # @param type [Symbol] :cost, :schedule, or :team
+      # @param value [Numeric, nil] Raw estimate value
+      # @return [Numeric, nil] Adjusted value
+      def ai_adjusted_estimate(type, value)
+        return nil if value.nil?
+
+        cfg = AI_ESTIMATE_CONFIG
+        salary_ratio = cfg[:target_salary].to_f / cfg[:cocomo_salary]
+
+        adjusted = case type
+                   when :cost
+                     value.to_f * salary_ratio / cfg[:ai_cost_multiplier]
+                   when :schedule
+                     value.to_f / cfg[:ai_schedule_multiplier]
+                   when :team
+                     (value.to_f / cfg[:ai_team_multiplier]).ceil
+                   else
+                     raise ArgumentError, "Unknown estimate type: #{type}"
+                   end
+
+        type == :team ? adjusted.to_i : adjusted
+      end
+
+      # Convert git URL to HTTPS URL
+      def http_git(repo_url)
+        repo_url.gsub(/.git$/, "")
+                .gsub(":", "/")
+                .gsub("git@", "https://")
+      end
+
+      # Format number with thousands delimiter
+      def number_with_delimiter(num)
+        num.to_s.reverse.scan(/\d{1,3}/).join(",").reverse
+      end
+
+      # Convert timestamp to human-readable relative time
+      def time_ago(timestamp)
+        return nil unless timestamp
+
+        time = timestamp.is_a?(Time) ? timestamp : Time.parse(timestamp.to_s)
+        seconds = (Time.now - time).to_i
+
+        units = [
+          [60, "second"],
+          [60, "minute"],
+          [24, "hour"],
+          [7, "day"],
+          [4, "week"],
+          [12, "month"],
+          [Float::INFINITY, "year"]
+        ]
+
+        value = seconds
+        units.each do |divisor, unit|
+          return "just now" if unit == "second" && value < 10
+          return "#{value} #{unit}#{"s" if value != 1} ago" if value < divisor
+
+          value /= divisor
+        end
+      end
+    end
+  end
+end

data/lib/archsight/helpers.rb

@@ -1,8 +1,15 @@
 # frozen_string_literal: true
 
+require_relative "helpers/formatting"
+require_relative "helpers/analysis_renderer"
+
 module Archsight
   # Helpers provides utility functions for the architecture tool
   module Helpers
+    # Include sub-modules for direct access
+    extend Formatting
+    extend AnalysisRenderer
+
     module_function
 
     # Make path relative to resources directory
@@ -45,10 +52,6 @@ module Archsight
       end
     end
 
-    def classify(val)
-      val.to_s.split("-").map(&:capitalize).join
-    end
-
     def deep_merge(hash1, hash2)
       hash1.dup.merge(hash2) do |_, old_value, new_value|
         if old_value.is_a?(Hash) && new_value.is_a?(Hash)
@@ -206,5 +209,18 @@ module Archsight
         (val_a || "").to_s.downcase <=> (val_b || "").to_s.downcase
       end
     end
+
+    # Delegate formatting methods
+    def classify(val) = Formatting.classify(val)
+    def to_euro(num) = Formatting.to_euro(num)
+    def ai_adjusted_estimate(type, value) = Formatting.ai_adjusted_estimate(type, value)
+    def http_git(repo_url) = Formatting.http_git(repo_url)
+    def number_with_delimiter(num) = Formatting.number_with_delimiter(num)
+    def time_ago(timestamp) = Formatting.time_ago(timestamp)
+
+    # Delegate analysis renderer methods
+    def escape_html(text) = AnalysisRenderer.escape_html(text)
+    def render_analysis_section(section, **) = AnalysisRenderer.render_analysis_section(section, **)
+    def render_analysis_table(section) = AnalysisRenderer.render_analysis_table(section)
   end
 end

data/lib/archsight/import/concurrent_progress.rb

@@ -0,0 +1,341 @@
+# frozen_string_literal: true
+
+# Manages concurrent progress output with slot-based display
+#
+# In TTY mode: Each slot gets its own line, updated in place using ANSI codes with colors
+# In non-TTY mode: Each update prints on its own line with context prefix (no colors)
+class Archsight::Import::ConcurrentProgress
+  # ANSI color codes
+  COLORS = {
+    reset: "\e[0m",
+    bold: "\e[1m",
+    dim: "\e[2m",
+    green: "\e[32m",
+    yellow: "\e[33m",
+    blue: "\e[34m",
+    magenta: "\e[35m",
+    cyan: "\e[36m",
+    red: "\e[31m"
+  }.freeze
+
+  # ANSI cursor control
+  CURSOR_HIDE = "\e[?25l"
+  CURSOR_SHOW = "\e[?25h"
+  CURSOR_SAVE = "\e[s"
+  CURSOR_RESTORE = "\e[u"
+
+  def initialize(max_slots:, output: $stdout)
+    @output = output
+    @tty = output.respond_to?(:tty?) && output.tty?
+    @max_slots = max_slots
+    @mutex = Mutex.new
+    @slots = {}
+    @slot_queue = Queue.new
+    @lines_printed = 0
+
+    # Overall progress tracking
+    @total_imports = 0
+    @completed_imports = 0
+    @has_overall_line = false
+    @start_time = nil
+
+    # Initialize slot queue
+    max_slots.times { |i| @slot_queue << i }
+  end
+
+  def tty?
+    @tty
+  end
+
+  # Initialize total number of imports for overall progress
+  def total=(total)
+    @mutex.synchronize do
+      @total_imports = total
+      @completed_imports = 0
+      @start_time = Time.now
+      if @tty && !@has_overall_line
+        # Save cursor position and hide cursor for clean display
+        @output.print CURSOR_SAVE
+        @output.print CURSOR_HIDE
+        @output.puts build_overall_line
+        @has_overall_line = true
+        @lines_printed += 1
+      end
+    end
+  end
+
+  # Update total without resetting completed count (for multi-stage imports)
+  def update_total(total)
+    @mutex.synchronize do
+      @total_imports = total
+      update_overall_line if @tty && @has_overall_line
+    end
+  end
+
+  # Increment completed count and update overall progress
+  def increment_completed
+    @mutex.synchronize do
+      @completed_imports += 1
+      update_overall_line if @tty && @has_overall_line
+    end
+  end
+
+  # Acquire a slot for a new task
+  # @return [SlotProgress] A progress reporter for this slot
+  def acquire_slot(context)
+    slot_id = @slot_queue.pop
+    slot = SlotProgress.new(self, slot_id, context)
+
+    @mutex.synchronize do
+      @slots[slot_id] = slot
+      # Slot lines start after the overall progress line (if present)
+      effective_line = @has_overall_line ? slot_id + 1 : slot_id
+      if @tty && effective_line >= @lines_printed
+        # Print empty lines to reserve space
+        (@lines_printed..effective_line).each { @output.puts }
+        @lines_printed = effective_line + 1
+      end
+    end
+
+    slot
+  end
+
+  # Release a slot back to the pool
+  def release_slot(slot_id)
+    @mutex.synchronize do
+      @slots.delete(slot_id)
+    end
+    @slot_queue << slot_id
+  end
+
+  # Update a specific slot's display
+  def update_slot(slot_id, context, message, current: nil, total: nil, color: nil)
+    line = build_line(context, message, current, total, color: color)
+
+    @mutex.synchronize do
+      if @tty
+        # Move cursor to slot line and update (account for overall progress line)
+        effective_line = @has_overall_line ? slot_id + 1 : slot_id
+        lines_up = @lines_printed - effective_line
+        @output.print "\e[#{lines_up}A" # Move up
+        @output.print "\e[2K"           # Clear line
+        @output.print line
+        @output.print "\e[#{lines_up}B" # Move back down
+        @output.print "\r"              # Return to start of line
+        @output.flush
+      else
+        @output.puts line
+      end
+    end
+  end
+
+  # Mark a slot as complete
+  def complete_slot(slot_id, context, message = nil)
+    @mutex.synchronize do
+      if @tty
+        effective_line = @has_overall_line ? slot_id + 1 : slot_id
+        lines_up = @lines_printed - effective_line
+        @output.print "\e[#{lines_up}A"
+        @output.print "\e[2K"
+        msg = message || "Done"
+        @output.print "#{COLORS[:bold]}#{context}#{COLORS[:reset]} - #{COLORS[:green]}#{msg}#{COLORS[:reset]}"
+        @output.print "\e[#{lines_up}B"
+        @output.print "\r"
+        @output.flush
+      elsif message
+        @output.puts "#{context} - #{message}"
+      end
+    end
+  end
+
+  # Report an error for a slot
+  def error_slot(slot_id, context, message)
+    safe_message = sanitize_message(message)
+    @mutex.synchronize do
+      if @tty
+        effective_line = @has_overall_line ? slot_id + 1 : slot_id
+        lines_up = @lines_printed - effective_line
+        @output.print "\e[#{lines_up}A"
+        @output.print "\e[2K"
+        @output.print "#{COLORS[:bold]}#{context}#{COLORS[:reset]} - #{COLORS[:red]}Error: #{safe_message}#{COLORS[:reset]}"
+        @output.print "\e[#{lines_up}B"
+        @output.print "\r"
+        @output.flush
+      else
+        @output.puts "#{context} - Error: #{safe_message}"
+      end
+    end
+  end
+
+  # Sanitize message to prevent breaking TTY display (remove newlines, truncate)
+  def sanitize_message(message)
+    return "" if message.nil?
+
+    # Replace newlines with spaces and collapse multiple spaces
+    clean = message.to_s.gsub(/[\r\n]+/, " ").gsub(/\s+/, " ").strip
+    # Truncate if too long
+    clean.length > 80 ? "#{clean[0, 77]}..." : clean
+  end
+
+  # Print a final summary (restores cursor and shows it)
+  # Note: Use finish_from_trap when called from a signal handler
+  def finish(message)
+    @mutex.synchronize do
+      finish_unsafe(message)
+    end
+  end
+
+  # Trap-safe version of finish (no mutex, safe to call from signal handlers)
+  def finish_from_trap(message)
+    finish_unsafe(message)
+  end
+
+  # Show interrupt message without clearing progress (called on first Ctrl-C)
+  # Note: Use interrupt_from_trap when called from a signal handler
+  def interrupt(message)
+    @mutex.synchronize do
+      interrupt_unsafe(message)
+    end
+  end
+
+  # Trap-safe version of interrupt (no mutex, safe to call from signal handlers)
+  def interrupt_from_trap(message)
+    interrupt_unsafe(message)
+  end
+
+  private
+
+  def finish_unsafe(message)
+    if @tty
+      # Restore cursor position and show cursor
+      @output.print CURSOR_RESTORE
+      # Clear from cursor to end of screen to remove progress lines
+      @output.print "\e[J"
+      @output.print CURSOR_SHOW
+    end
+    @output.puts message if message
+  end
+
+  def interrupt_unsafe(message)
+    if @tty
+      # Move to the line below progress and print message
+      @output.print "\n"
+      @output.print "\e[2K"
+      @output.print "#{COLORS[:yellow]}#{message}#{COLORS[:reset]}"
+      @output.print "\n"
+      @output.flush
+      # Increase lines printed to account for the interrupt message
+      @lines_printed += 2
+    else
+      @output.puts message
+    end
+  end
+
+  def build_overall_line
+    percentage = @total_imports.positive? ? ((@completed_imports.to_f / @total_imports) * 100).round : 0
+    progress_bar = build_progress_bar(percentage)
+    eta_str = calculate_eta_string
+    if @tty
+      "#{COLORS[:bold]}#{COLORS[:magenta]}Overall#{COLORS[:reset]} #{progress_bar} " \
+        "#{COLORS[:cyan]}#{percentage}%#{COLORS[:reset]} " \
+        "[#{@completed_imports}/#{@total_imports}] " \
+        "#{COLORS[:dim]}#{eta_str}#{COLORS[:reset]}"
+    else
+      "Overall: [#{@completed_imports}/#{@total_imports}] #{percentage}% #{eta_str}"
+    end
+  end
+
+  def calculate_eta_string
+    return "ETA: --:--" if @start_time.nil? || @completed_imports.zero?
+
+    elapsed = Time.now - @start_time
+    remaining = @total_imports - @completed_imports
+    rate = @completed_imports.to_f / elapsed
+    eta_seconds = (remaining / rate).round
+
+    if eta_seconds < 60
+      "ETA: #{eta_seconds}s"
+    elsif eta_seconds < 3600
+      minutes = eta_seconds / 60
+      seconds = eta_seconds % 60
+      format("ETA: %d:%02d", minutes, seconds)
+    else
+      hours = eta_seconds / 3600
+      minutes = (eta_seconds % 3600) / 60
+      format("ETA: %d:%02d:%02d", hours, minutes, eta_seconds % 60)
+    end
+  end
+
+  def build_progress_bar(percentage)
+    width = 20
+    filled = [(percentage / 5.0).round, width].min
+    filled = [filled, 0].max
+    empty = width - filled
+    bar = "#{"█" * filled}#{"░" * empty}"
+    "#{COLORS[:green]}#{bar}#{COLORS[:reset]}"
+  end
+
+  def update_overall_line
+    # Move to first line (overall progress line), update, move back
+    lines_up = @lines_printed
+    @output.print "\e[#{lines_up}A"
+    @output.print "\e[2K"
+    @output.print build_overall_line
+    @output.print "\e[#{lines_up}B"
+    @output.print "\r"
+    @output.flush
+  end
+
+  def build_line(context, message, current, total, color: nil)
+    parts = []
+    if @tty
+      parts << "#{COLORS[:bold]}#{context}#{COLORS[:reset]}"
+      parts << "#{COLORS[:cyan]}#{progress_indicator(current, total)}#{COLORS[:reset]}" if current && total
+      msg_color = color || COLORS[:reset]
+      parts << "#{msg_color}#{message}#{COLORS[:reset]}"
+    else
+      parts << context
+      parts << progress_indicator(current, total) if current && total
+      parts << message
+    end
+    parts.join(" - ")
+  end
+
+  def progress_indicator(current, total)
+    percentage = ((current.to_f / total) * 100).round
+    "[#{current}/#{total} #{percentage}%]"
+  end
+
+  # Individual slot progress reporter
+  class SlotProgress
+    attr_reader :slot_id
+    attr_accessor :context
+
+    def initialize(parent, slot_id, context)
+      @parent = parent
+      @slot_id = slot_id
+      @context = context
+    end
+
+    def update(message, current: nil, total: nil)
+      @parent.update_slot(@slot_id, @context, message, current: current, total: total)
+    end
+
+    def complete(message = nil)
+      @parent.complete_slot(@slot_id, @context, message)
+    end
+
+    def error(message)
+      @parent.error_slot(@slot_id, @context, message)
+    end
+
+    def warn(message)
+      # Warnings are shown inline with the current context (yellow in TTY mode)
+      @parent.update_slot(@slot_id, @context, "Warning: #{message}", color: COLORS[:yellow])
+    end
+
+    def release
+      @parent.release_slot(@slot_id)
+    end
+  end
+end