legal_summariser 0.1.0 → 0.3.0

data/examples/batch_processing.rb

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example: Batch processing multiple legal documents
+require 'legal_summariser'
+
+# Configure for batch processing
+LegalSummariser.configure do |config|
+  config.enable_caching = true
+  config.logger = Logger.new(STDOUT, level: Logger::INFO)
+end
+
+# Example file paths (replace with your actual files)
+file_paths = [
+  'contracts/nda_company_a.pdf',
+  'contracts/service_agreement_b.docx',
+  'contracts/employment_contract_c.txt',
+  'policies/privacy_policy.pdf'
+]
+
+puts "=== Batch Processing Legal Documents ==="
+puts "Processing #{file_paths.length} documents..."
+
+# Batch process all documents
+results = LegalSummariser.batch_summarise(file_paths, {
+  format: 'json',
+  max_sentences: 4
+})
+
+# Analyze results
+successful = results.select { |r| r[:success] }
+failed = results.reject { |r| r[:success] }
+
+puts "\nBatch Processing Results:"
+puts "✓ Successful: #{successful.length}"
+puts "✗ Failed: #{failed.length}"
+
+# Process successful results
+if successful.any?
+  puts "\n=== Successful Analyses ==="
+  
+  successful.each do |result|
+    analysis = JSON.parse(result[:result], symbolize_names: true)
+    
+    puts "\nFile: #{File.basename(result[:file_path])}"
+    puts "Type: #{analysis[:metadata][:document_type]}"
+    puts "Words: #{analysis[:metadata][:word_count]}"
+    puts "Risk Level: #{analysis[:risks][:risk_score][:level].upcase}"
+    
+    # Show key risks
+    high_risks = analysis[:risks][:high_risks]
+    if high_risks.any?
+      puts "High Risks: #{high_risks.map { |r| r[:type] }.join(', ')}"
+    end
+  end
+  
+  # Generate summary report
+  puts "\n=== Summary Report ==="
+  
+  # Document type distribution
+  doc_types = successful.map do |result|
+    JSON.parse(result[:result], symbolize_names: true)[:metadata][:document_type]
+  end
+  
+  type_counts = doc_types.group_by(&:itself).transform_values(&:count)
+  puts "Document Types:"
+  type_counts.each { |type, count| puts "  #{type}: #{count}" }
+  
+  # Risk level distribution
+  risk_levels = successful.map do |result|
+    JSON.parse(result[:result], symbolize_names: true)[:risks][:risk_score][:level]
+  end
+  
+  risk_counts = risk_levels.group_by(&:itself).transform_values(&:count)
+  puts "Risk Levels:"
+  risk_counts.each { |level, count| puts "  #{level}: #{count}" }
+  
+  # Average processing metrics
+  word_counts = successful.map do |result|
+    JSON.parse(result[:result], symbolize_names: true)[:metadata][:word_count]
+  end
+  
+  avg_words = word_counts.sum.to_f / word_counts.length
+  puts "Average Document Size: #{avg_words.round} words"
+end
+
+# Show failed analyses
+if failed.any?
+  puts "\n=== Failed Analyses ==="
+  failed.each do |result|
+    puts "✗ #{File.basename(result[:file_path])}: #{result[:error]}"
+  end
+end
+
+# Export results to files
+puts "\n=== Exporting Results ==="
+require 'fileutils'
+
+output_dir = 'analysis_results'
+FileUtils.mkdir_p(output_dir)
+
+successful.each do |result|
+  filename = File.basename(result[:file_path], '.*')
+  output_file = File.join(output_dir, "#{filename}_analysis.json")
+  
+  File.write(output_file, result[:result])
+  puts "Exported: #{output_file}"
+end
+
+# Generate consolidated report
+consolidated_report = {
+  processed_at: Time.now.iso8601,
+  total_files: file_paths.length,
+  successful: successful.length,
+  failed: failed.length,
+  results: results
+}
+
+report_file = File.join(output_dir, 'batch_report.json')
+File.write(report_file, JSON.pretty_generate(consolidated_report))
+puts "Consolidated report: #{report_file}"
+
+puts "\nBatch processing completed!"

data/exe/legal_summariser

@@ -10,18 +10,28 @@ module LegalSummariser
     option :format, aliases: '-f', default: 'text', desc: 'Output format (json, markdown, text)'
     option :output, aliases: '-o', desc: 'Output file path (optional)'
     option :max_sentences, type: :numeric, default: 5, desc: 'Maximum sentences in summary'
+    option :verbose, aliases: '-v', type: :boolean, default: false, desc: 'Enable verbose logging'
+    option :cache, type: :boolean, default: false, desc: 'Enable result caching'
     def analyze(file_path)
       begin
+        # Configure logging and caching
+        configure_gem(options)
+        
         puts "Analyzing: #{file_path}"
         puts "Format: #{options[:format]}"
+        puts "Caching: #{options[:cache] ? 'enabled' : 'disabled'}"
         puts "-" * 50
         
+        start_time = Time.now
+        
         # Perform analysis
         results = LegalSummariser.summarise(file_path, {
           format: options[:format],
           max_sentences: options[:max_sentences]
         })
         
+        end_time = Time.now
+        
         # Output results
         if options[:output]
           File.write(options[:output], results)
@@ -30,15 +40,24 @@ module LegalSummariser
           puts results
         end
         
+        if options[:verbose]
+          puts "\n" + "-" * 50
+          puts "Analysis completed in #{(end_time - start_time).round(3)}s"
+          puts "Performance stats available via 'legal_summariser stats'"
+        end
+        
       rescue LegalSummariser::DocumentNotFoundError => e
         puts "Error: #{e.message}"
         exit 1
       rescue LegalSummariser::UnsupportedFormatError => e
         puts "Error: #{e.message}"
         exit 1
+      rescue LegalSummariser::Error => e
+        puts "Processing error: #{e.message}"
+        exit 1
       rescue => e
         puts "Unexpected error: #{e.message}"
-        puts e.backtrace if ENV['DEBUG']
+        puts e.backtrace if options[:verbose] || ENV['DEBUG']
         exit 1
       end
     end
@@ -62,6 +81,107 @@ module LegalSummariser
       puts "- Plain text (text, txt)"
     end
 
+    desc "batch FILES", "Analyze multiple legal documents"
+    option :format, aliases: '-f', default: 'text', desc: 'Output format (json, markdown, text)'
+    option :output_dir, aliases: '-d', desc: 'Output directory for results'
+    option :verbose, aliases: '-v', type: :boolean, default: false, desc: 'Enable verbose logging'
+    option :cache, type: :boolean, default: true, desc: 'Enable result caching'
+    def batch(*file_paths)
+      if file_paths.empty?
+        puts "Error: No files specified"
+        puts "Usage: legal_summariser batch file1.pdf file2.docx ..."
+        exit 1
+      end
+      
+      configure_gem(options)
+      
+      puts "Batch processing #{file_paths.length} files..."
+      puts "-" * 50
+      
+      results = LegalSummariser.batch_summarise(file_paths, {
+        format: options[:format]
+      })
+      
+      # Process results
+      successful = results.count { |r| r[:success] }
+      failed = results.count { |r| !r[:success] }
+      
+      puts "\nBatch processing completed:"
+      puts "✓ Successful: #{successful}"
+      puts "✗ Failed: #{failed}" if failed > 0
+      
+      if options[:output_dir]
+        FileUtils.mkdir_p(options[:output_dir])
+        
+        results.each do |result|
+          next unless result[:success]
+          
+          filename = File.basename(result[:file_path], '.*') + '_analysis'
+          extension = case options[:format]
+                     when 'json' then '.json'
+                     when 'markdown', 'md' then '.md'
+                     else '.txt'
+                     end
+          
+          output_file = File.join(options[:output_dir], filename + extension)
+          File.write(output_file, result[:result])
+          puts "Saved: #{output_file}"
+        end
+      end
+    end
+
+    desc "stats", "Show performance and usage statistics"
+    def stats
+      stats = LegalSummariser.stats
+      
+      puts "Legal Summariser Statistics"
+      puts "=" * 50
+      
+      # Performance stats
+      if stats[:performance].any?
+        puts "\nPerformance:"
+        stats[:performance].each do |metric, data|
+          puts "  #{metric.to_s.tr('_', ' ').capitalize}:"
+          puts "    Count: #{data[:count]}"
+          puts "    Average: #{data[:average]}s"
+          puts "    Total: #{data[:total]}s"
+        end
+      end
+      
+      # Cache stats
+      puts "\nCache:"
+      cache_stats = stats[:cache]
+      if cache_stats[:enabled]
+        puts "  Status: Enabled"
+        puts "  Files: #{cache_stats[:file_count]}"
+        puts "  Size: #{cache_stats[:total_size_mb]} MB"
+      else
+        puts "  Status: Disabled"
+      end
+      
+      # Memory stats
+      memory = stats[:memory]
+      if memory[:available] != false
+        puts "\nMemory:"
+        puts "  Objects: #{memory[:object_count]}"
+        puts "  GC Count: #{memory[:gc_count]}"
+        puts "  Estimated Usage: #{memory[:memory_mb]} MB"
+      end
+    end
+
+    desc "config", "Show current configuration"
+    def config
+      config = LegalSummariser.configuration
+      
+      puts "Legal Summariser Configuration"
+      puts "=" * 50
+      puts "Language: #{config.language}"
+      puts "Max File Size: #{config.max_file_size / 1024 / 1024} MB"
+      puts "Timeout: #{config.timeout}s"
+      puts "Caching: #{config.enable_caching ? 'enabled' : 'disabled'}"
+      puts "Cache Directory: #{config.cache_dir}"
+    end
+
     desc "demo", "Run demo analysis on sample documents"
     def demo
       puts "Legal Summariser Demo"
@@ -85,6 +205,16 @@ module LegalSummariser
 
     private
 
+    def configure_gem(options)
+      LegalSummariser.configure do |config|
+        if options[:verbose]
+          require 'logger'
+          config.logger = Logger.new(STDOUT, level: Logger::INFO)
+        end
+        config.enable_caching = options[:cache] if options.key?(:cache)
+      end
+    end
+
     def create_sample_nda
       <<~NDA
         NON-DISCLOSURE AGREEMENT

data/lib/legal_summariser/cache.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'json'
+require 'fileutils'
+
+module LegalSummariser
+  # Caching system for analysis results
+  class Cache
+    def initialize(cache_dir = nil)
+      @cache_dir = cache_dir || LegalSummariser.configuration.cache_dir
+      FileUtils.mkdir_p(@cache_dir) if LegalSummariser.configuration.enable_caching
+    end
+
+    # Generate cache key for a file
+    # @param file_path [String] Path to the file
+    # @param options [Hash] Analysis options
+    # @return [String] Cache key
+    def cache_key(file_path, options = {})
+      file_stat = File.stat(file_path)
+      content = "#{file_path}:#{file_stat.mtime}:#{file_stat.size}:#{options.to_json}"
+      Digest::SHA256.hexdigest(content)
+    end
+
+    # Get cached result
+    # @param key [String] Cache key
+    # @return [Hash, nil] Cached result or nil
+    def get(key)
+      return nil unless LegalSummariser.configuration.enable_caching
+      
+      cache_file = File.join(@cache_dir, "#{key}.json")
+      return nil unless File.exist?(cache_file)
+      
+      # Check if cache is expired (24 hours)
+      return nil if File.mtime(cache_file) < Time.now - (24 * 60 * 60)
+      
+      JSON.parse(File.read(cache_file), symbolize_names: true)
+    rescue JSON::ParserError, Errno::ENOENT
+      nil
+    end
+
+    # Store result in cache
+    # @param key [String] Cache key
+    # @param result [Hash] Result to cache
+    def set(key, result)
+      return unless LegalSummariser.configuration.enable_caching
+      
+      cache_file = File.join(@cache_dir, "#{key}.json")
+      File.write(cache_file, JSON.pretty_generate(result))
+    rescue => e
+      # Silently fail caching - don't break the main functionality
+      LegalSummariser.configuration.logger&.warn("Cache write failed: #{e.message}")
+    end
+
+    # Clear cache
+    def clear!
+      return unless Dir.exist?(@cache_dir)
+      
+      Dir.glob(File.join(@cache_dir, "*.json")).each do |file|
+        File.delete(file)
+      end
+    end
+
+    # Get cache statistics
+    # @return [Hash] Cache statistics
+    def stats
+      return { enabled: false } unless LegalSummariser.configuration.enable_caching
+      
+      cache_files = Dir.glob(File.join(@cache_dir, "*.json"))
+      total_size = cache_files.sum { |file| File.size(file) }
+      
+      {
+        enabled: true,
+        file_count: cache_files.length,
+        total_size_bytes: total_size,
+        total_size_mb: (total_size / 1024.0 / 1024.0).round(2),
+        cache_dir: @cache_dir
+      }
+    end
+  end
+end

data/lib/legal_summariser/configuration.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module LegalSummariser
+  # Configuration class for gem settings
+  class Configuration
+    attr_accessor :logger, :max_file_size, :timeout, :language, :enable_caching, :cache_dir
+
+    def initialize
+      @logger = nil
+      @max_file_size = 50 * 1024 * 1024 # 50MB default
+      @timeout = 30 # 30 seconds default
+      @language = 'en'
+      @enable_caching = false
+      @cache_dir = '/tmp/legal_summariser_cache'
+    end
+
+    # Supported languages for analysis
+    def supported_languages
+      %w[en tr de fr es it]
+    end
+
+    # Validate configuration
+    def validate!
+      raise Error, "Invalid language: #{@language}" unless supported_languages.include?(@language)
+      raise Error, "Max file size must be positive" if @max_file_size <= 0
+      raise Error, "Timeout must be positive" if @timeout <= 0
+    end
+  end
+
+  # Global configuration
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+    configuration.validate!
+  end
+
+  def self.reset_configuration!
+    @configuration = Configuration.new
+  end
+end

data/lib/legal_summariser/performance_monitor.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module LegalSummariser
+  # Performance monitoring and metrics collection
+  class PerformanceMonitor
+    def initialize
+      @metrics = {}
+      @start_times = {}
+    end
+
+    # Start timing an operation
+    # @param operation [String] Operation name
+    def start_timer(operation)
+      @start_times[operation] = Time.now
+    end
+
+    # End timing an operation
+    # @param operation [String] Operation name
+    def end_timer(operation)
+      return unless @start_times[operation]
+      
+      duration = Time.now - @start_times[operation]
+      @metrics[operation] ||= []
+      @metrics[operation] << duration
+      @start_times.delete(operation)
+      duration
+    end
+
+    # Record a metric value
+    # @param metric [String] Metric name
+    # @param value [Numeric] Metric value
+    def record(metric, value)
+      @metrics[metric] ||= []
+      @metrics[metric] << value
+    end
+
+    # Get performance statistics
+    # @return [Hash] Performance statistics
+    def stats
+      stats = {}
+      
+      @metrics.each do |metric, values|
+        next if values.empty?
+        
+        stats[metric] = {
+          count: values.length,
+          total: values.sum.round(4),
+          average: (values.sum / values.length).round(4),
+          min: values.min.round(4),
+          max: values.max.round(4)
+        }
+      end
+      
+      stats
+    end
+
+    # Reset all metrics
+    def reset!
+      @metrics.clear
+      @start_times.clear
+    end
+
+    # Get current memory usage (if available)
+    # @return [Hash] Memory usage information
+    def memory_usage
+      if defined?(GC)
+        {
+          object_count: GC.stat[:heap_live_slots],
+          gc_count: GC.count,
+          memory_mb: (GC.stat[:heap_live_slots] * 40 / 1024.0 / 1024.0).round(2) # Rough estimate
+        }
+      else
+        { available: false }
+      end
+    end
+
+    # Generate performance report
+    # @return [String] Formatted performance report
+    def report
+      report = ["Performance Report", "=" * 50, ""]
+      
+      stats.each do |metric, data|
+        report << "#{metric.to_s.tr('_', ' ').capitalize}:"
+        report << "  Count: #{data[:count]}"
+        report << "  Total: #{data[:total]}s"
+        report << "  Average: #{data[:average]}s"
+        report << "  Min: #{data[:min]}s"
+        report << "  Max: #{data[:max]}s"
+        report << ""
+      end
+      
+      memory = memory_usage
+      if memory[:available] != false
+        report << "Memory Usage:"
+        report << "  Objects: #{memory[:object_count]}"
+        report << "  GC Count: #{memory[:gc_count]}"
+        report << "  Estimated Memory: #{memory[:memory_mb]} MB"
+      end
+      
+      report.join("\n")
+    end
+  end
+
+  # Global performance monitor
+  def self.performance_monitor
+    @performance_monitor ||= PerformanceMonitor.new
+  end
+end