lf-cli 1.0.0

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

@@ -0,0 +1,161 @@
+require 'thor'
+
+module Langfuse
+  module CLI
+    module Commands
+      class Observations < Thor
+        namespace :observations
+
+        def self.exit_on_failure?
+          true
+        end
+
+        desc 'list', 'List observations'
+        long_desc <<-LONGDESC
+          List observations with optional filtering.
+
+          Observations represent LLM calls, spans, or events in your traces.
+
+          FILTERS:
+            --type: Observation type
+              Valid values: generation, span, event
+
+            --trace-id: Filter by parent trace ID
+
+            --name: Filter by observation name
+
+            --user-id: Filter by user ID
+
+            --from, --to: Time range (ISO 8601 or relative like "1 hour ago")
+
+          EXAMPLES:
+
+            # List all generations
+            langfuse observations list --type generation
+
+            # List observations for a specific trace
+            langfuse observations list --trace-id trace_123
+
+            # List recent observations
+            langfuse observations list --from "1 hour ago" --limit 20
+
+          API REFERENCE:
+            Full API documentation: https://api.reference.langfuse.com/
+        LONGDESC
+        option :trace_id, type: :string, desc: 'Filter by trace ID'
+        option :name, type: :string, desc: 'Filter by observation name'
+        option :type, type: :string,
+               enum: %w[generation span event],
+               desc: 'Filter by type'
+        option :user_id, type: :string, desc: 'Filter by user ID'
+        option :from, type: :string, desc: 'Start timestamp (ISO 8601 or relative)'
+        option :to, type: :string, desc: 'End timestamp (ISO 8601 or relative)'
+        option :limit, type: :numeric, desc: 'Limit number of results'
+        option :page, type: :numeric, desc: 'Page number'
+        def list
+          filters = build_filters(options)
+          observations = client.list_observations(filters)
+          output_result(observations)
+        rescue Client::AuthenticationError => e
+          puts "Authentication Error: #{e.message}"
+          exit 1
+        rescue Client::APIError => e
+          puts "Error: #{e.message}"
+          exit 1
+        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::APIError => e
+          puts "Error: #{e.message}"
+          exit 1
+        end
+
+        private
+
+        def client
+          @client ||= begin
+            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"
+              raise Error, error_message
+            end
+            Client.new(config)
+          end
+        end
+
+        def load_config
+          Config.new(
+            profile: parent_options[:profile],
+            public_key: parent_options[:public_key],
+            secret_key: parent_options[:secret_key],
+            host: parent_options[:host],
+            format: parent_options[:format],
+            limit: parent_options[:limit] || options[:limit]
+          )
+        end
+
+        def build_filters(opts)
+          filters = {}
+          filters[:trace_id] = opts[:trace_id] if opts[:trace_id]
+          filters[:name] = opts[:name] if opts[:name]
+          filters[:type] = opts[:type] if opts[:type]
+          filters[:user_id] = opts[:user_id] if opts[:user_id]
+          filters[:from] = opts[:from] if opts[:from]
+          filters[:to] = opts[:to] if opts[:to]
+          filters[:limit] = opts[:limit] if opts[:limit]
+          filters[:page] = opts[:page] if opts[:page]
+          filters
+        end
+
+        def output_result(data)
+          formatted = format_output(data)
+
+          if parent_options[:output]
+            File.write(parent_options[:output], formatted)
+            puts "Output written to #{parent_options[:output]}" if parent_options[:verbose]
+          else
+            puts formatted
+          end
+        end
+
+        def format_output(data)
+          format_type = parent_options[:format] || 'table'
+
+          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 parent_options
+          @parent_options ||= begin
+            if parent.respond_to?(:options)
+              parent.options
+            else
+              {}
+            end
+          rescue
+            {}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+require 'thor'
+
+module Langfuse
+  module CLI
+    module Commands
+      class Scores < Thor
+        namespace :scores
+
+        def self.exit_on_failure?
+          true
+        end
+
+        desc 'list', 'List scores'
+        option :name, type: :string, desc: 'Filter by score name'
+        option :from, type: :string, desc: 'Start timestamp (ISO 8601 or relative)'
+        option :to, type: :string, desc: 'End timestamp (ISO 8601 or relative)'
+        option :limit, type: :numeric, desc: 'Limit number of results'
+        option :page, type: :numeric, desc: 'Page number'
+        def list
+          filters = build_filters(options)
+          scores = client.list_scores(filters)
+          output_result(scores)
+        rescue Client::AuthenticationError => e
+          puts "Authentication Error: #{e.message}"
+          exit 1
+        rescue Client::APIError => e
+          puts "Error: #{e.message}"
+          exit 1
+        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::APIError => e
+          puts "Error: #{e.message}"
+          exit 1
+        end
+
+        private
+
+        def client
+          @client ||= begin
+            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"
+              raise Error, error_message
+            end
+            Client.new(config)
+          end
+        end
+
+        def load_config
+          Config.new(
+            profile: parent_options[:profile],
+            public_key: parent_options[:public_key],
+            secret_key: parent_options[:secret_key],
+            host: parent_options[:host],
+            format: parent_options[:format],
+            limit: parent_options[:limit] || options[:limit]
+          )
+        end
+
+        def build_filters(opts)
+          filters = {}
+          filters[:name] = opts[:name] if opts[:name]
+          filters[:from] = opts[:from] if opts[:from]
+          filters[:to] = opts[:to] if opts[:to]
+          filters[:limit] = opts[:limit] if opts[:limit]
+          filters[:page] = opts[:page] if opts[:page]
+          filters
+        end
+
+        def output_result(data)
+          formatted = format_output(data)
+
+          if parent_options[:output]
+            File.write(parent_options[:output], formatted)
+            puts "Output written to #{parent_options[:output]}" if parent_options[:verbose]
+          else
+            puts formatted
+          end
+        end
+
+        def format_output(data)
+          format_type = parent_options[:format] || 'table'
+
+          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 parent_options
+          @parent_options ||= begin
+            if parent.respond_to?(:options)
+              parent.options
+            else
+              {}
+            end
+          rescue
+            {}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+require 'thor'
+
+module Langfuse
+  module CLI
+    module Commands
+      class Sessions < Thor
+        namespace :sessions
+
+        def self.exit_on_failure?
+          true
+        end
+
+        desc 'list', 'List sessions'
+        option :from, type: :string, desc: 'Start timestamp (ISO 8601 or relative)'
+        option :to, type: :string, desc: 'End timestamp (ISO 8601 or relative)'
+        option :limit, type: :numeric, desc: 'Limit number of results'
+        option :page, type: :numeric, desc: 'Page number'
+        def list
+          filters = build_filters(options)
+          sessions = client.list_sessions(filters)
+          output_result(sessions)
+        rescue Client::AuthenticationError => e
+          puts "Authentication Error: #{e.message}"
+          exit 1
+        rescue Client::APIError => e
+          puts "Error: #{e.message}"
+          exit 1
+        end
+
+        desc 'show SESSION_ID', 'Show a specific session'
+        option :with_traces, type: :boolean, default: false, desc: 'Include all traces'
+        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::APIError => e
+          puts "Error: #{e.message}"
+          exit 1
+        end
+
+        private
+
+        def client
+          @client ||= begin
+            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"
+              raise Error, error_message
+            end
+            Client.new(config)
+          end
+        end
+
+        def load_config
+          Config.new(
+            profile: parent_options[:profile],
+            public_key: parent_options[:public_key],
+            secret_key: parent_options[:secret_key],
+            host: parent_options[:host],
+            format: parent_options[:format],
+            limit: parent_options[:limit] || options[:limit]
+          )
+        end
+
+        def build_filters(opts)
+          filters = {}
+          filters[:from] = opts[:from] if opts[:from]
+          filters[:to] = opts[:to] if opts[:to]
+          filters[:limit] = opts[:limit] if opts[:limit]
+          filters[:page] = opts[:page] if opts[:page]
+          filters
+        end
+
+        def output_result(data)
+          formatted = format_output(data)
+
+          if parent_options[:output]
+            File.write(parent_options[:output], formatted)
+            puts "Output written to #{parent_options[:output]}" if parent_options[:verbose]
+          else
+            puts formatted
+          end
+        end
+
+        def format_output(data)
+          format_type = parent_options[:format] || 'table'
+
+          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 parent_options
+          @parent_options ||= begin
+            if parent.respond_to?(:options)
+              parent.options
+            else
+              {}
+            end
+          rescue
+            {}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+require 'thor'
+
+module Langfuse
+  module CLI
+    module Commands
+      class Traces < Thor
+        namespace :traces
+
+        def self.exit_on_failure?
+          true
+        end
+
+        desc 'list', 'List traces'
+        long_desc <<-LONGDESC
+          List traces with optional filtering.
+
+          Traces represent complete workflows or conversations in Langfuse.
+
+          FILTERS:
+            --name: Filter by trace name
+
+            --user-id: Filter by user ID
+
+            --session-id: Filter by session ID
+
+            --tags: Filter by tags (repeatable)
+
+            --from, --to: Time range (ISO 8601 or relative like "1 hour ago")
+
+          OUTPUT OPTIONS:
+            Global options: --format [table|json|csv|markdown], --output FILE
+
+          EXAMPLES:
+
+            # List recent traces
+            langfuse traces list --from "1 hour ago" --limit 20
+
+            # Find traces by name
+            langfuse traces list --name "chat_completion"
+
+            # Filter by user and session
+            langfuse traces list --user-id user_123 --session-id sess_456
+
+            # Export to CSV
+            langfuse traces list --format csv --output traces.csv
+
+          API REFERENCE:
+            Full API documentation: https://api.reference.langfuse.com/
+        LONGDESC
+        option :from, type: :string, desc: 'Start timestamp (ISO 8601 or relative like "1 hour ago")'
+        option :to, type: :string, desc: 'End timestamp (ISO 8601 or relative)'
+        option :name, type: :string, desc: 'Filter by trace name'
+        option :user_id, type: :string, desc: 'Filter by user ID'
+        option :session_id, type: :string, desc: 'Filter by session ID'
+        option :tags, type: :array, desc: 'Filter by tags'
+        option :limit, type: :numeric, desc: 'Limit number of results'
+        option :page, type: :numeric, desc: 'Page number'
+        def list
+          filters = build_filters(options)
+          traces = client.list_traces(filters)
+          output_result(traces)
+        rescue Client::AuthenticationError => e
+          puts "Authentication Error: #{e.message}"
+          exit 1
+        rescue Client::APIError => e
+          puts "Error: #{e.message}"
+          exit 1
+        end
+
+        desc 'get TRACE_ID', 'Get a specific trace'
+        option :with_observations, type: :boolean, default: false, desc: 'Include all 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
+        rescue Client::APIError => e
+          puts "Error: #{e.message}"
+          exit 1
+        end
+
+        private
+
+        def client
+          @client ||= begin
+            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"
+              raise Error, error_message
+            end
+            Client.new(config)
+          end
+        end
+
+        def load_config
+          Config.new(
+            profile: parent_options[:profile],
+            public_key: parent_options[:public_key],
+            secret_key: parent_options[:secret_key],
+            host: parent_options[:host],
+            format: parent_options[:format],
+            limit: parent_options[:limit] || options[:limit]
+          )
+        end
+
+        def build_filters(opts)
+          filters = {}
+          filters[:from] = opts[:from] if opts[:from]
+          filters[:to] = opts[:to] if opts[:to]
+          filters[:name] = opts[:name] if opts[:name]
+          filters[:user_id] = opts[:user_id] if opts[:user_id]
+          filters[:session_id] = opts[:session_id] if opts[:session_id]
+          filters[:tags] = opts[:tags] if opts[:tags]
+          filters[:limit] = opts[:limit] if opts[:limit]
+          filters[:page] = opts[:page] if opts[:page]
+          filters
+        end
+
+        def output_result(data)
+          formatted = format_output(data)
+
+          if parent_options[:output]
+            File.write(parent_options[:output], formatted)
+            puts "Output written to #{parent_options[:output]}" if parent_options[:verbose]
+          else
+            puts formatted
+          end
+        end
+
+        def format_output(data)
+          format_type = parent_options[:format] || 'table'
+
+          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 parent_options
+          @parent_options ||= begin
+            # Try to get parent options from Thor
+            if parent.respond_to?(:options)
+              parent.options
+            else
+              {}
+            end
+          rescue
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/langfuse/cli/config.rb

@@ -0,0 +1,136 @@
+require 'yaml'
+require 'fileutils'
+
+module Langfuse
+  module CLI
+    class Config
+      attr_accessor :public_key, :secret_key, :host, :profile, :output_format, :page_limit
+
+      DEFAULT_HOST = 'https://cloud.langfuse.com'
+      DEFAULT_OUTPUT_FORMAT = 'table'
+      DEFAULT_PAGE_LIMIT = 50
+      CONFIG_DIR = File.expand_path('~/.langfuse')
+      CONFIG_FILE = File.join(CONFIG_DIR, 'config.yml')
+
+      def initialize(options = {})
+        @profile = options[:profile] || 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
+      def load_config
+        # Start with defaults
+        @host = DEFAULT_HOST
+        @output_format = DEFAULT_OUTPUT_FORMAT
+        @page_limit = DEFAULT_PAGE_LIMIT
+        @public_key = nil
+        @secret_key = nil
+
+        # Load from config file if it exists
+        if File.exist?(CONFIG_FILE)
+          load_from_file
+        end
+
+        # Override with environment variables
+        load_from_env
+      end
+
+      # Load configuration from YAML file
+      def load_from_file
+        config_data = YAML.load_file(CONFIG_FILE)
+
+        # 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']
+      rescue => e
+        warn "Warning: Error loading config file: #{e.message}"
+      end
+
+      # Load configuration from environment variables
+      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']
+      end
+
+      # Merge passed options (highest priority)
+      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]
+      end
+
+      # Validate that required configuration is present
+      def valid?
+        !@public_key.nil? && !@secret_key.nil? && !@host.nil?
+      end
+
+      # Get list of missing required fields
+      def missing_fields
+        fields = []
+        fields << 'public_key' if @public_key.nil?
+        fields << 'secret_key' if @secret_key.nil?
+        fields << 'host' if @host.nil?
+        fields
+      end
+
+      # Save current configuration to file
+      def save(profile_name = nil)
+        profile_name ||= @profile
+
+        # Ensure config directory exists
+        FileUtils.mkdir_p(CONFIG_DIR)
+
+        # Load existing config or create new
+        config_data = File.exist?(CONFIG_FILE) ? YAML.load_file(CONFIG_FILE) : {}
+        config_data['profiles'] ||= {}
+
+        # Update profile
+        config_data['profiles'][profile_name] = {
+          'public_key' => @public_key,
+          'secret_key' => @secret_key,
+          'host' => @host,
+          'output_format' => @output_format,
+          'page_limit' => @page_limit
+        }
+
+        # Write to file
+        File.write(CONFIG_FILE, config_data.to_yaml)
+
+        # Set restrictive permissions
+        File.chmod(0600, CONFIG_FILE)
+
+        true
+      rescue => e
+        warn "Error saving config: #{e.message}"
+        false
+      end
+
+      # Load a specific profile
+      def self.load(profile = nil)
+        new(profile: profile)
+      end
+
+      # Get configuration as a hash
+      def to_h
+        {
+          public_key: @public_key,
+          secret_key: @secret_key,
+          host: @host,
+          profile: @profile,
+          output_format: @output_format,
+          page_limit: @page_limit
+        }
+      end
+    end
+  end
+end