lf-cli 1.0.0 → 1.0.2

data/lib/langfuse/cli/commands/observations.rb

@@ -1,4 +1,5 @@
 require 'thor'
+require 'json'
 
 module Langfuse
   module CLI
@@ -31,13 +32,13 @@ module Langfuse
           EXAMPLES:
 
             # List all generations
-            langfuse observations list --type generation
+            lf observations list --type generation
 
             # List observations for a specific trace
-            langfuse observations list --trace-id trace_123
+            lf observations list --trace-id trace_123
 
             # List recent observations
-            langfuse observations list --from "1 hour ago" --limit 20
+            lf observations list --from "1 hour ago" --limit 20
 
           API REFERENCE:
             Full API documentation: https://api.reference.langfuse.com/
@@ -57,23 +58,19 @@ module Langfuse
           observations = client.list_observations(filters)
           output_result(observations)
         rescue Client::AuthenticationError => e
-          puts "Authentication Error: #{e.message}"
-          exit 1
+          raise_cli_error("Authentication Error: #{e.message}")
         rescue Client::APIError => e
-          puts "Error: #{e.message}"
-          exit 1
+          raise_cli_error("Error: #{e.message}")
         end
 
         desc 'get OBSERVATION_ID', 'Get a specific observation'
         def get(observation_id)
           observation = client.get_observation(observation_id)
           output_result(observation)
-        rescue Client::NotFoundError => e
-          puts "Error: Observation not found - #{observation_id}"
-          exit 1
+        rescue Client::NotFoundError
+          raise_cli_error("Observation not found - #{observation_id}")
         rescue Client::APIError => e
-          puts "Error: #{e.message}"
-          exit 1
+          raise_cli_error("Error: #{e.message}")
         end
 
         private
@@ -83,7 +80,7 @@ module Langfuse
             config = load_config
             unless config.valid?
               error_message = "Missing required configuration: #{config.missing_fields.join(', ')}"
-              error_message += "\n\nPlease set environment variables or run: langfuse config setup"
+              error_message += "\n\nPlease set environment variables or run: lf config setup"
               raise Error, error_message
             end
             Client.new(config)
@@ -115,35 +112,37 @@ module Langfuse
         end
 
         def output_result(data)
-          formatted = format_output(data)
+          format_type = parent_options[:format] || 'json'
 
           if parent_options[:output]
-            File.write(parent_options[:output], formatted)
+            write_output(parent_options[:output], data, format_type)
             puts "Output written to #{parent_options[:output]}" if parent_options[:verbose]
           else
-            puts formatted
+            puts format_output(data, format_type: format_type)
           end
         end
 
-        def format_output(data)
-          format_type = parent_options[:format] || 'table'
-
+        def format_output(data, format_type: 'json')
           case format_type
           when 'json'
-            require 'json'
             JSON.pretty_generate(data)
           when 'csv'
             require_relative '../formatters/csv_formatter'
             Formatters::CSVFormatter.format(data)
-          when 'markdown'
-            require_relative '../formatters/markdown_formatter'
-            Formatters::MarkdownFormatter.format(data)
           else # table
             require_relative '../formatters/table_formatter'
             Formatters::TableFormatter.format(data)
           end
         end
 
+        def write_output(path, data, format_type)
+          if format_type == 'json'
+            File.open(path, 'w') { |file| JSON.dump(data, file) }
+          else
+            File.write(path, format_output(data, format_type: format_type))
+          end
+        end
+
         def parent_options
           @parent_options ||= begin
             if parent.respond_to?(:options)
@@ -155,6 +154,10 @@ module Langfuse
             {}
           end
         end
+
+        def raise_cli_error(message)
+          raise Langfuse::CLI::Error, message
+        end
       end
     end
   end

data/lib/langfuse/cli/commands/scores.rb

@@ -1,4 +1,5 @@
 require 'thor'
+require 'json'
 
 module Langfuse
   module CLI
@@ -21,23 +22,19 @@ module Langfuse
           scores = client.list_scores(filters)
           output_result(scores)
         rescue Client::AuthenticationError => e
-          puts "Authentication Error: #{e.message}"
-          exit 1
+          raise_cli_error("Authentication Error: #{e.message}")
         rescue Client::APIError => e
-          puts "Error: #{e.message}"
-          exit 1
+          raise_cli_error("Error: #{e.message}")
         end
 
         desc 'get SCORE_ID', 'Get a specific score'
         def get(score_id)
           score = client.get_score(score_id)
           output_result(score)
-        rescue Client::NotFoundError => e
-          puts "Error: Score not found - #{score_id}"
-          exit 1
+        rescue Client::NotFoundError
+          raise_cli_error("Score not found - #{score_id}")
         rescue Client::APIError => e
-          puts "Error: #{e.message}"
-          exit 1
+          raise_cli_error("Error: #{e.message}")
         end
 
         private
@@ -47,7 +44,7 @@ module Langfuse
             config = load_config
             unless config.valid?
               error_message = "Missing required configuration: #{config.missing_fields.join(', ')}"
-              error_message += "\n\nPlease set environment variables or run: langfuse config setup"
+              error_message += "\n\nPlease set environment variables or run: lf config setup"
               raise Error, error_message
             end
             Client.new(config)
@@ -76,35 +73,37 @@ module Langfuse
         end
 
         def output_result(data)
-          formatted = format_output(data)
+          format_type = parent_options[:format] || 'json'
 
           if parent_options[:output]
-            File.write(parent_options[:output], formatted)
+            write_output(parent_options[:output], data, format_type)
             puts "Output written to #{parent_options[:output]}" if parent_options[:verbose]
           else
-            puts formatted
+            puts format_output(data, format_type: format_type)
           end
         end
 
-        def format_output(data)
-          format_type = parent_options[:format] || 'table'
-
+        def format_output(data, format_type: 'json')
           case format_type
           when 'json'
-            require 'json'
             JSON.pretty_generate(data)
           when 'csv'
             require_relative '../formatters/csv_formatter'
             Formatters::CSVFormatter.format(data)
-          when 'markdown'
-            require_relative '../formatters/markdown_formatter'
-            Formatters::MarkdownFormatter.format(data)
           else # table
             require_relative '../formatters/table_formatter'
             Formatters::TableFormatter.format(data)
           end
         end
 
+        def write_output(path, data, format_type)
+          if format_type == 'json'
+            File.open(path, 'w') { |file| JSON.dump(data, file) }
+          else
+            File.write(path, format_output(data, format_type: format_type))
+          end
+        end
+
         def parent_options
           @parent_options ||= begin
             if parent.respond_to?(:options)
@@ -116,6 +115,10 @@ module Langfuse
             {}
           end
         end
+
+        def raise_cli_error(message)
+          raise Langfuse::CLI::Error, message
+        end
       end
     end
   end

data/lib/langfuse/cli/commands/sessions.rb

@@ -1,4 +1,5 @@
 require 'thor'
+require 'json'
 
 module Langfuse
   module CLI
@@ -20,11 +21,9 @@ module Langfuse
           sessions = client.list_sessions(filters)
           output_result(sessions)
         rescue Client::AuthenticationError => e
-          puts "Authentication Error: #{e.message}"
-          exit 1
+          raise_cli_error("Authentication Error: #{e.message}")
         rescue Client::APIError => e
-          puts "Error: #{e.message}"
-          exit 1
+          raise_cli_error("Error: #{e.message}")
         end
 
         desc 'show SESSION_ID', 'Show a specific session'
@@ -32,12 +31,10 @@ module Langfuse
         def show(session_id)
           session = client.get_session(session_id)
           output_result(session)
-        rescue Client::NotFoundError => e
-          puts "Error: Session not found - #{session_id}"
-          exit 1
+        rescue Client::NotFoundError
+          raise_cli_error("Session not found - #{session_id}")
         rescue Client::APIError => e
-          puts "Error: #{e.message}"
-          exit 1
+          raise_cli_error("Error: #{e.message}")
         end
 
         private
@@ -47,7 +44,7 @@ module Langfuse
             config = load_config
             unless config.valid?
               error_message = "Missing required configuration: #{config.missing_fields.join(', ')}"
-              error_message += "\n\nPlease set environment variables or run: langfuse config setup"
+              error_message += "\n\nPlease set environment variables or run: lf config setup"
               raise Error, error_message
             end
             Client.new(config)
@@ -75,35 +72,37 @@ module Langfuse
         end
 
         def output_result(data)
-          formatted = format_output(data)
+          format_type = parent_options[:format] || 'json'
 
           if parent_options[:output]
-            File.write(parent_options[:output], formatted)
+            write_output(parent_options[:output], data, format_type)
             puts "Output written to #{parent_options[:output]}" if parent_options[:verbose]
           else
-            puts formatted
+            puts format_output(data, format_type: format_type)
           end
         end
 
-        def format_output(data)
-          format_type = parent_options[:format] || 'table'
-
+        def format_output(data, format_type: 'json')
           case format_type
           when 'json'
-            require 'json'
             JSON.pretty_generate(data)
           when 'csv'
             require_relative '../formatters/csv_formatter'
             Formatters::CSVFormatter.format(data)
-          when 'markdown'
-            require_relative '../formatters/markdown_formatter'
-            Formatters::MarkdownFormatter.format(data)
           else # table
             require_relative '../formatters/table_formatter'
             Formatters::TableFormatter.format(data)
           end
         end
 
+        def write_output(path, data, format_type)
+          if format_type == 'json'
+            File.open(path, 'w') { |file| JSON.dump(data, file) }
+          else
+            File.write(path, format_output(data, format_type: format_type))
+          end
+        end
+
         def parent_options
           @parent_options ||= begin
             if parent.respond_to?(:options)
@@ -115,6 +114,10 @@ module Langfuse
             {}
           end
         end
+
+        def raise_cli_error(message)
+          raise Langfuse::CLI::Error, message
+        end
       end
     end
   end

data/lib/langfuse/cli/commands/traces.rb

@@ -1,4 +1,5 @@
 require 'thor'
+require 'json'
 
 module Langfuse
   module CLI
@@ -28,21 +29,21 @@ module Langfuse
             --from, --to: Time range (ISO 8601 or relative like "1 hour ago")
 
           OUTPUT OPTIONS:
-            Global options: --format [table|json|csv|markdown], --output FILE
+            Global options: --format [json|table|csv], --output FILE
 
           EXAMPLES:
 
             # List recent traces
-            langfuse traces list --from "1 hour ago" --limit 20
+            lf traces list --from "1 hour ago" --limit 20
 
             # Find traces by name
-            langfuse traces list --name "chat_completion"
+            lf traces list --name "chat_completion"
 
             # Filter by user and session
-            langfuse traces list --user-id user_123 --session-id sess_456
+            lf traces list --user-id user_123 --session-id sess_456
 
             # Export to CSV
-            langfuse traces list --format csv --output traces.csv
+            lf traces list --format csv --output traces.csv
 
           API REFERENCE:
             Full API documentation: https://api.reference.langfuse.com/
@@ -60,24 +61,19 @@ module Langfuse
           traces = client.list_traces(filters)
           output_result(traces)
         rescue Client::AuthenticationError => e
-          puts "Authentication Error: #{e.message}"
-          exit 1
+          raise_cli_error("Authentication Error: #{e.message}")
         rescue Client::APIError => e
-          puts "Error: #{e.message}"
-          exit 1
+          raise_cli_error("Error: #{e.message}")
         end
 
-        desc 'get TRACE_ID', 'Get a specific trace'
-        option :with_observations, type: :boolean, default: false, desc: 'Include all observations'
+        desc 'get TRACE_ID', 'Get a specific trace with observations'
         def get(trace_id)
           trace = client.get_trace(trace_id)
-          output_result(trace)
-        rescue Client::NotFoundError => e
-          puts "Error: Trace not found - #{trace_id}"
-          exit 1
+          output_result(ensure_observations(trace))
+        rescue Client::NotFoundError => _e
+          raise_cli_error("Trace not found - #{trace_id}")
         rescue Client::APIError => e
-          puts "Error: #{e.message}"
-          exit 1
+          raise_cli_error("Error: #{e.message}")
         end
 
         private
@@ -87,7 +83,7 @@ module Langfuse
             config = load_config
             unless config.valid?
               error_message = "Missing required configuration: #{config.missing_fields.join(', ')}"
-              error_message += "\n\nPlease set environment variables or run: langfuse config setup"
+              error_message += "\n\nPlease set environment variables or run: lf config setup"
               raise Error, error_message
             end
             Client.new(config)
@@ -119,35 +115,43 @@ module Langfuse
         end
 
         def output_result(data)
-          formatted = format_output(data)
+          format_type = parent_options[:format] || 'json'
 
           if parent_options[:output]
-            File.write(parent_options[:output], formatted)
+            write_output(parent_options[:output], data, format_type)
             puts "Output written to #{parent_options[:output]}" if parent_options[:verbose]
           else
-            puts formatted
+            puts format_output(data, format_type: format_type)
           end
         end
 
-        def format_output(data)
-          format_type = parent_options[:format] || 'table'
-
+        def format_output(data, format_type: 'json')
           case format_type
           when 'json'
-            require 'json'
             JSON.pretty_generate(data)
           when 'csv'
             require_relative '../formatters/csv_formatter'
             Formatters::CSVFormatter.format(data)
-          when 'markdown'
-            require_relative '../formatters/markdown_formatter'
-            Formatters::MarkdownFormatter.format(data)
           else # table
             require_relative '../formatters/table_formatter'
             Formatters::TableFormatter.format(data)
           end
         end
 
+        def write_output(path, data, format_type)
+          if format_type == 'json'
+            File.open(path, 'w') { |file| JSON.dump(data, file) }
+          else
+            File.write(path, format_output(data, format_type: format_type))
+          end
+        end
+
+        def ensure_observations(trace)
+          return trace unless trace.is_a?(Hash)
+
+          trace.merge('observations' => trace['observations'] || [])
+        end
+
         def parent_options
           @parent_options ||= begin
             # Try to get parent options from Thor
@@ -160,6 +164,10 @@ module Langfuse
             {}
           end
         end
+
+        def raise_cli_error(message)
+          raise Langfuse::CLI::Error, message
+        end
       end
     end
   end

data/lib/langfuse/cli/config.rb

@@ -1,25 +1,30 @@
 require 'yaml'
 require 'fileutils'
+require 'sorbet-runtime'
 
 module Langfuse
   module CLI
     class Config
+      extend T::Sig
+
       attr_accessor :public_key, :secret_key, :host, :profile, :output_format, :page_limit
 
       DEFAULT_HOST = 'https://cloud.langfuse.com'
-      DEFAULT_OUTPUT_FORMAT = 'table'
+      DEFAULT_OUTPUT_FORMAT = 'json'
       DEFAULT_PAGE_LIMIT = 50
       CONFIG_DIR = File.expand_path('~/.langfuse')
       CONFIG_FILE = File.join(CONFIG_DIR, 'config.yml')
 
+      sig { params(options: T::Hash[Symbol, T.untyped]).void }
       def initialize(options = {})
-        @profile = options[:profile] || ENV['LANGFUSE_PROFILE'] || 'default'
+        @profile = normalize_string(options[:profile]) || normalize_string(ENV['LANGFUSE_PROFILE']) || 'default'
         load_config
         merge_options(options)
       end
 
       # Load configuration from file and environment variables
       # Priority: passed options > ENV vars > config file > defaults
+      sig { void }
       def load_config
         # Start with defaults
         @host = DEFAULT_HOST
@@ -38,52 +43,60 @@ module Langfuse
       end
 
       # Load configuration from YAML file
+      sig { void }
       def load_from_file
-        config_data = YAML.load_file(CONFIG_FILE)
+        config_data = read_config_data
 
         # Load profile-specific config
-        profile_config = config_data.dig('profiles', @profile) || config_data['default'] || {}
-
-        @public_key = profile_config['public_key'] if profile_config['public_key']
-        @secret_key = profile_config['secret_key'] if profile_config['secret_key']
-        @host = profile_config['host'] if profile_config['host']
-        @output_format = profile_config['output_format'] if profile_config['output_format']
-        @page_limit = profile_config['page_limit'] if profile_config['page_limit']
+        profiles = config_data['profiles'].is_a?(Hash) ? config_data['profiles'] : {}
+        legacy_default = config_data['default'].is_a?(Hash) ? config_data['default'] : {}
+        profile_config = profiles[@profile] || profiles['default'] || legacy_default
+
+        @public_key = normalize_string(profile_config['public_key']) || @public_key
+        @secret_key = normalize_string(profile_config['secret_key']) || @secret_key
+        @host = normalize_string(profile_config['host']) || @host
+        @output_format = normalize_string(profile_config['output_format']) || @output_format
+        @page_limit = normalize_integer(profile_config['page_limit']) || @page_limit
       rescue => e
         warn "Warning: Error loading config file: #{e.message}"
       end
 
       # Load configuration from environment variables
+      sig { void }
       def load_from_env
-        @public_key = ENV['LANGFUSE_PUBLIC_KEY'] if ENV['LANGFUSE_PUBLIC_KEY']
-        @secret_key = ENV['LANGFUSE_SECRET_KEY'] if ENV['LANGFUSE_SECRET_KEY']
-        @host = ENV['LANGFUSE_HOST'] if ENV['LANGFUSE_HOST']
+        @public_key = normalize_string(ENV['LANGFUSE_PUBLIC_KEY']) || @public_key
+        @secret_key = normalize_string(ENV['LANGFUSE_SECRET_KEY']) || @secret_key
+        @host = normalize_string(ENV['LANGFUSE_HOST']) || @host
       end
 
       # Merge passed options (highest priority)
+      sig { params(options: T::Hash[Symbol, T.untyped]).void }
       def merge_options(options)
-        @public_key = options[:public_key] if options[:public_key]
-        @secret_key = options[:secret_key] if options[:secret_key]
-        @host = options[:host] if options[:host]
-        @output_format = options[:format] if options[:format]
-        @page_limit = options[:limit] if options[:limit]
+        @public_key = normalize_string(options[:public_key]) || @public_key
+        @secret_key = normalize_string(options[:secret_key]) || @secret_key
+        @host = normalize_string(options[:host]) || @host
+        @output_format = normalize_string(options[:format]) || @output_format
+        @page_limit = normalize_integer(options[:limit]) || @page_limit
       end
 
       # Validate that required configuration is present
+      sig { returns(T::Boolean) }
       def valid?
-        !@public_key.nil? && !@secret_key.nil? && !@host.nil?
+        present?(@public_key) && present?(@secret_key) && present?(@host)
       end
 
       # Get list of missing required fields
+      sig { returns(T::Array[String]) }
       def missing_fields
         fields = []
-        fields << 'public_key' if @public_key.nil?
-        fields << 'secret_key' if @secret_key.nil?
-        fields << 'host' if @host.nil?
+        fields << 'public_key' unless present?(@public_key)
+        fields << 'secret_key' unless present?(@secret_key)
+        fields << 'host' unless present?(@host)
         fields
       end
 
       # Save current configuration to file
+      sig { params(profile_name: T.nilable(String)).returns(T::Boolean) }
       def save(profile_name = nil)
         profile_name ||= @profile
 
@@ -91,7 +104,7 @@ module Langfuse
         FileUtils.mkdir_p(CONFIG_DIR)
 
         # Load existing config or create new
-        config_data = File.exist?(CONFIG_FILE) ? YAML.load_file(CONFIG_FILE) : {}
+        config_data = File.exist?(CONFIG_FILE) ? read_config_data : {}
         config_data['profiles'] ||= {}
 
         # Update profile
@@ -116,11 +129,13 @@ module Langfuse
       end
 
       # Load a specific profile
+      sig { params(profile: T.nilable(String)).returns(Config) }
       def self.load(profile = nil)
         new(profile: profile)
       end
 
       # Get configuration as a hash
+      sig { returns(T::Hash[Symbol, T.untyped]) }
       def to_h
         {
           public_key: @public_key,
@@ -131,6 +146,43 @@ module Langfuse
           page_limit: @page_limit
         }
       end
+
+      private
+
+      sig { params(value: T.untyped).returns(T.nilable(String)) }
+      def normalize_string(value)
+        return nil if value.nil?
+
+        normalized = value.to_s.strip
+        normalized.empty? ? nil : normalized
+      end
+
+      sig { params(value: T.untyped).returns(T.nilable(Integer)) }
+      def normalize_integer(value)
+        return nil if value.nil?
+
+        Integer(value)
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      sig { params(value: T.nilable(String)).returns(T::Boolean) }
+      def present?(value)
+        !value.nil? && !value.strip.empty?
+      end
+
+      sig { returns(T::Hash[String, T.untyped]) }
+      def read_config_data
+        data = YAML.safe_load(
+          File.read(CONFIG_FILE),
+          permitted_classes: [],
+          permitted_symbols: [],
+          aliases: false
+        )
+        data.is_a?(Hash) ? data : {}
+      rescue Errno::ENOENT
+        {}
+      end
     end
   end
 end

data/lib/langfuse/cli/formatters/csv_formatter.rb

@@ -1,5 +1,6 @@
 require 'csv'
 require 'json'
+require 'date'
 
 module Langfuse
   module CLI