archsight 0.1.2 → 0.1.3

data/lib/archsight/cli.rb

@@ -4,6 +4,10 @@ require "thor"
 
 module Archsight
   class CLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
     class_option :resources,
                  aliases: "-r",
                  type: :string,
@@ -12,11 +16,21 @@ module Archsight
     desc "web", "Start the web server"
     option :port, aliases: "-p", type: :numeric, default: 4567, desc: "Port to listen on"
     option :host, aliases: "-H", type: :string, default: "localhost", desc: "Host to bind to"
+    option :production, type: :boolean, default: false, desc: "Run in production mode"
+    option :disable_reload, type: :boolean, default: false, desc: "Disable the reload button in the UI"
+    option :enable_logging, type: :boolean, default: nil, desc: "Enable request logging (default: false in dev, true in prod)"
     def web
       configure_resources
       require "archsight/web/application"
+
+      env = options[:production] ? :production : :development
+      Archsight::Web::Application.configure_environment!(env, logging: options[:enable_logging])
+      Archsight::Web::Application.set :reload_enabled, !options[:disable_reload]
       Archsight::Web::Application.setup_mcp!
       Archsight::Web::Application.run!(port: options[:port], bind: options[:host])
+    rescue Archsight::ResourceError => e
+      display_error_with_context(e.to_s)
+      exit 1
     end
 
     desc "lint", "Validate architecture resources"
@@ -71,6 +85,80 @@ module Archsight
       binding.irb
     end
 
+    desc "import", "Execute pending imports"
+    option :verbose, aliases: "-v", type: :boolean, default: false, desc: "Verbose output"
+    option :dry_run, aliases: "-n", type: :boolean, default: false, desc: "Show execution plan without running"
+    option :filter, aliases: "-f", type: :string, desc: "Filter imports by name (regex pattern)"
+    option :force, aliases: "-F", type: :boolean, default: false, desc: "Ignore cache and re-run all imports"
+    def import
+      configure_resources
+      require "archsight/database"
+      require "archsight/import/executor"
+
+      resources_dir = Archsight.resources_dir
+
+      # Load all handlers
+      require_import_handlers
+
+      # Create database that loads from resources directory
+      # Only load Import resources to avoid validation errors on incomplete resources
+      db = Archsight::Database.new(resources_dir, verbose: options[:verbose], only_kinds: ["Import"], verify: false)
+
+      if options[:dry_run]
+        puts "Execution Plan:"
+        executor = Archsight::Import::Executor.new(
+          database: db,
+          resources_dir: resources_dir,
+          verbose: true,
+          filter: options[:filter],
+          force: options[:force]
+        )
+        executor.execution_plan
+      else
+        executor = Archsight::Import::Executor.new(
+          database: db,
+          resources_dir: resources_dir,
+          verbose: options[:verbose],
+          filter: options[:filter],
+          force: options[:force]
+        )
+        executor.run!
+        puts "All imports completed successfully."
+      end
+    rescue Archsight::Import::InterruptedError
+      # Graceful shutdown already handled by executor
+      exit 130
+    rescue Archsight::Import::DeadlockError => e
+      puts "Error: #{e.message}"
+      exit 1
+    rescue Archsight::Import::ImportError => e
+      puts "Error: #{e.message}"
+      exit 1
+    rescue Archsight::ResourceError => e
+      display_error_with_context(e.to_s)
+      exit 1
+    end
+
+    desc "analyze", "Execute analysis scripts"
+    option :verbose, aliases: "-v", type: :boolean, default: false, desc: "Verbose output"
+    option :dry_run, aliases: "-n", type: :boolean, default: false, desc: "List analyses without running"
+    option :filter, aliases: "-f", type: :string, desc: "Filter analyses by name (regex pattern)"
+    def analyze
+      configure_resources
+      require "archsight/database"
+      require "archsight/analysis"
+
+      db = load_database_for_analysis
+      analyses = filter_analyses(db)
+
+      return puts("No analyses found#{" matching '#{options[:filter]}'" if options[:filter]}.") if analyses.empty?
+      return print_analysis_dry_run(analyses) if options[:dry_run]
+
+      results = execute_analyses(db, analyses)
+      print_analysis_results(results)
+      exit 1 if results.any?(&:failed?)
+    end
+
     desc "version", "Show version"
     def version
       puts "archsight #{Archsight::VERSION}"
@@ -84,6 +172,81 @@ module Archsight
       Archsight.resources_dir = options[:resources] if options[:resources]
     end
 
+    def require_import_handlers
+      handlers_dir = File.expand_path("import/handlers", __dir__)
+      Dir.glob(File.join(handlers_dir, "*.rb")).each do |handler_file|
+        require handler_file
+      end
+    end
+
+    def load_database_for_analysis
+      db = Archsight::Database.new(Archsight.resources_dir, verbose: options[:verbose])
+      db.reload!
+      db
+    rescue Archsight::ResourceError => e
+      display_error_with_context(e.to_s)
+      exit 1
+    end
+
+    def filter_analyses(db)
+      analyses = db.instances_by_kind("Analysis").values
+      analyses = analyses.select { |a| Regexp.new(options[:filter], Regexp::IGNORECASE).match?(a.name) } if options[:filter]
+      analyses.reject { |a| a.annotations["analysis/enabled"] == "false" }
+    end
+
+    def print_analysis_dry_run(analyses)
+      puts "Analyses to run#{" (filter: #{options[:filter]})" if options[:filter]}:"
+      analyses.sort_by(&:name).each_with_index do |analysis, idx|
+        timeout = analysis.annotations["analysis/timeout"] || "30s"
+        desc = analysis.annotations["analysis/description"] || "(no description)"
+        puts "  #{idx + 1}. #{analysis.name} [#{timeout}]"
+        puts "     #{desc}"
+      end
+    end
+
+    def execute_analyses(db, analyses)
+      executor = Archsight::Analysis::Executor.new(db)
+      analyses.map { |analysis| executor.execute(analysis) }
+    end
+
+    def print_analysis_results(results)
+      require "tty-markdown"
+
+      results.each do |result|
+        print_single_result(result)
+        puts ""
+      end
+
+      summary_md = build_analysis_summary_markdown(results)
+      puts TTY::Markdown.parse(summary_md)
+    end
+
+    def print_single_result(result)
+      # Print status header
+      header = "# #{result.status_emoji} #{result.name}"
+      header += " (#{result.duration_str})" unless result.duration_str.empty?
+      puts TTY::Markdown.parse(header)
+
+      # Print error if failed
+      puts TTY::Markdown.parse(result.error_markdown(verbose: options[:verbose])) if result.failed?
+
+      # Print script output
+      output = result.to_s(verbose: options[:verbose])
+      puts output unless output.empty?
+    end
+
+    def build_analysis_summary_markdown(results)
+      passed = results.count(&:success?)
+      failed = results.count(&:failed?)
+      with_findings = results.count(&:has_findings?)
+
+      lines = ["---", "", "# Summary", ""]
+      lines << "- ✅ **#{passed}** passed"
+      lines << "- ❌ **#{failed}** failed" if failed.positive?
+      lines << "- ⚠️ **#{with_findings}** with findings" if with_findings.positive?
+      lines.join("\n")
+    end
+
     def list_kinds
       puts "Available resource kinds:\n\n"
       Archsight::Resources.resource_classes.each_key { |kind| puts "  - #{kind}" }

data/lib/archsight/database.rb

@@ -43,13 +43,14 @@ module Archsight
   # of the structure. The loading and parsing of files will raise errors
   # if invalid data is passed.
   class Database
-    attr_accessor :instances, :verbose, :verify, :compute_annotations
+    attr_accessor :instances, :verbose, :verify, :compute_annotations, :only_kinds
 
-    def initialize(path, verbose: false, verify: true, compute_annotations: true)
+    def initialize(path, verbose: false, verify: true, compute_annotations: true, only_kinds: nil)
       @path = path
       @verbose = verbose
       @verify = verify
       @compute_annotations = compute_annotations
+      @only_kinds = only_kinds
       @instances = {}
     end
 
@@ -127,6 +128,9 @@ module Archsight
           obj = node.to_ruby
           next unless obj # skip empty / unknown documents
 
+          # Skip resources that don't match only_kinds filter
+          next if @only_kinds && !@only_kinds.include?(obj["kind"])
+
           self << create_valid_instance(obj)
         end
       end

data/lib/archsight/helpers/analysis_renderer.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "rack/utils"
+
+module Archsight
+  module Helpers
+    # AnalysisRenderer provides HTML rendering for analysis result sections
+    module AnalysisRenderer
+      module_function
+
+      # HTML escape helper
+      def escape_html(text)
+        Rack::Utils.escape_html(text.to_s)
+      end
+
+      # Render a single analysis section to HTML
+      # @param section [Hash] Section data with :type and content
+      # @param markdown_renderer [Proc, nil] Optional proc to render markdown
+      def render_analysis_section(section, markdown_renderer: nil)
+        case section[:type]
+        when :heading
+          render_heading(section)
+        when :text
+          render_text(section, markdown_renderer)
+        when :message
+          render_message(section)
+        when :table
+          render_table(section)
+        when :list
+          render_list(section)
+        when :code
+          render_code(section)
+        else
+          ""
+        end
+      end
+
+      # Render analysis table section to HTML
+      def render_analysis_table(section)
+        render_table(section)
+      end
+
+      # Private rendering methods
+
+      def render_heading(section)
+        %(<div class="analysis-heading level-#{section[:level]}">#{escape_html(section[:text])}</div>)
+      end
+
+      def render_text(section, markdown_renderer)
+        content = markdown_renderer ? markdown_renderer.call(section[:content]) : escape_html(section[:content])
+        %(<div class="analysis-text">#{content}</div>)
+      end
+
+      def render_message(section)
+        icon = case section[:level]
+               when :error then "xmark-circle"
+               when :warning then "warning-triangle"
+               else "info-circle"
+               end
+        %(<div class="analysis-message message-#{section[:level]}"><i class="iconoir-#{icon}"></i> #{escape_html(section[:message])}</div>)
+      end
+
+      def render_table(section)
+        headers = section[:headers].map { |h| "<th>#{escape_html(h)}</th>" }.join
+        rows = section[:rows].map do |row|
+          cells = row.map { |cell| "<td>#{escape_html(cell.to_s)}</td>" }.join
+          "<tr>#{cells}</tr>"
+        end.join
+        %(<div class="analysis-table-wrapper"><table><thead><tr>#{headers}</tr></thead><tbody>#{rows}</tbody></table></div>)
+      end
+
+      def render_list(section)
+        items = section[:items].map { |item| "<li>#{escape_html(item)}</li>" }.join
+        %(<ul class="analysis-list">#{items}</ul>)
+      end
+
+      def render_code(section)
+        lang_class = section[:lang] ? " class=\"language-#{section[:lang]}\"" : ""
+        %(<pre class="code"><code#{lang_class}>#{escape_html(section[:content])}</code></pre>)
+      end
+    end
+  end
+end

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