legal_summariser 0.1.0

data/lib/legal_summariser/formatter.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module LegalSummariser
+  class Formatter
+    # Format analysis results in specified format
+    # @param results [Hash] Analysis results
+    # @param format [String] Output format (json, markdown, text)
+    # @return [String] Formatted output
+    def self.format(results, format)
+      case format.to_s.downcase
+      when 'json'
+        format_json(results)
+      when 'markdown', 'md'
+        format_markdown(results)
+      when 'text', 'txt'
+        format_text(results)
+      else
+        raise Error, "Unsupported format: #{format}"
+      end
+    end
+
+    private
+
+    # Format results as JSON
+    # @param results [Hash] Analysis results
+    # @return [String] JSON formatted string
+    def self.format_json(results)
+      JSON.pretty_generate(results)
+    end
+
+    # Format results as Markdown
+    # @param results [Hash] Analysis results
+    # @return [String] Markdown formatted string
+    def self.format_markdown(results)
+      md = []
+      
+      md << "# Legal Document Analysis"
+      md << ""
+      md << "**Document Type:** #{results[:metadata][:document_type].capitalize}"
+      md << "**Word Count:** #{results[:metadata][:word_count]}"
+      md << "**Processed:** #{results[:metadata][:processed_at]}"
+      md << ""
+
+      # Summary section
+      md << "## Summary"
+      md << ""
+      md << results[:plain_text]
+      md << ""
+
+      # Key points
+      if results[:key_points] && !results[:key_points].empty?
+        md << "## Key Points"
+        md << ""
+        results[:key_points].each do |point|
+          md << "- #{point}"
+        end
+        md << ""
+      end
+
+      # Clauses section
+      if results[:clauses] && results[:clauses].any? { |_, clauses| !clauses.empty? }
+        md << "## Detected Clauses"
+        md << ""
+        
+        results[:clauses].each do |clause_type, clauses|
+          next if clauses.empty?
+          
+          md << "### #{clause_type.to_s.split('_').map(&:capitalize).join(' ')}"
+          md << ""
+          
+          clauses.each do |clause|
+            md << "- **#{clause[:type]}**: #{clause[:content][0..200]}#{'...' if clause[:content].length > 200}"
+          end
+          md << ""
+        end
+      end
+
+      # Risks section
+      if results[:risks]
+        md << "## Risk Analysis"
+        md << ""
+        
+        risk_score = results[:risks][:risk_score]
+        md << "**Overall Risk Level:** #{risk_score[:level].upcase} (Score: #{risk_score[:score]})"
+        md << ""
+
+        # High risks
+        if results[:risks][:high_risks] && !results[:risks][:high_risks].empty?
+          md << "### ⚠️ High Risks"
+          md << ""
+          results[:risks][:high_risks].each do |risk|
+            md << "- **#{risk[:type]}**: #{risk[:description]}"
+            md << "  - *Recommendation*: #{risk[:recommendation]}"
+          end
+          md << ""
+        end
+
+        # Medium risks
+        if results[:risks][:medium_risks] && !results[:risks][:medium_risks].empty?
+          md << "### ⚡ Medium Risks"
+          md << ""
+          results[:risks][:medium_risks].each do |risk|
+            md << "- **#{risk[:type]}**: #{risk[:description]}"
+            md << "  - *Recommendation*: #{risk[:recommendation]}"
+          end
+          md << ""
+        end
+
+        # Compliance gaps
+        if results[:risks][:compliance_gaps] && !results[:risks][:compliance_gaps].empty?
+          md << "### 📋 Compliance Gaps"
+          md << ""
+          results[:risks][:compliance_gaps].each do |gap|
+            md << "- **#{gap[:type]}** (#{gap[:regulation]}): #{gap[:description]}"
+            md << "  - *Recommendation*: #{gap[:recommendation]}"
+          end
+          md << ""
+        end
+
+        # Unfair terms
+        if results[:risks][:unfair_terms] && !results[:risks][:unfair_terms].empty?
+          md << "### ⚖️ Potentially Unfair Terms"
+          md << ""
+          results[:risks][:unfair_terms].each do |term|
+            md << "- **#{term[:type]}**: #{term[:description]}"
+            md << "  - *Impact*: #{term[:impact]}"
+            md << "  - *Recommendation*: #{term[:recommendation]}"
+          end
+          md << ""
+        end
+      end
+
+      md.join("\n")
+    end
+
+    # Format results as plain text
+    # @param results [Hash] Analysis results
+    # @return [String] Plain text formatted string
+    def self.format_text(results)
+      text = []
+      
+      text << "LEGAL DOCUMENT ANALYSIS"
+      text << "=" * 50
+      text << ""
+      text << "Document Type: #{results[:metadata][:document_type].capitalize}"
+      text << "Word Count: #{results[:metadata][:word_count]}"
+      text << "Processed: #{results[:metadata][:processed_at]}"
+      text << ""
+
+      # Summary
+      text << "SUMMARY"
+      text << "-" * 20
+      text << results[:plain_text]
+      text << ""
+
+      # Key points
+      if results[:key_points] && !results[:key_points].empty?
+        text << "KEY POINTS"
+        text << "-" * 20
+        results[:key_points].each_with_index do |point, index|
+          text << "#{index + 1}. #{point}"
+        end
+        text << ""
+      end
+
+      # Risk analysis
+      if results[:risks]
+        text << "RISK ANALYSIS"
+        text << "-" * 20
+        
+        risk_score = results[:risks][:risk_score]
+        text << "Overall Risk Level: #{risk_score[:level].upcase} (Score: #{risk_score[:score]})"
+        text << "Total Issues Found: #{risk_score[:total_issues]}"
+        text << ""
+
+        # List all risks
+        all_risks = []
+        all_risks.concat(results[:risks][:high_risks] || [])
+        all_risks.concat(results[:risks][:medium_risks] || [])
+        all_risks.concat(results[:risks][:compliance_gaps] || [])
+        all_risks.concat(results[:risks][:unfair_terms] || [])
+
+        if !all_risks.empty?
+          text << "Issues Found:"
+          all_risks.each_with_index do |risk, index|
+            severity = risk[:severity] || risk[:regulation] || "concern"
+            text << "#{index + 1}. [#{severity.upcase}] #{risk[:type]}: #{risk[:description]}"
+          end
+        end
+        text << ""
+      end
+
+      # Clause summary
+      if results[:clauses]
+        clause_count = results[:clauses].values.flatten.length
+        if clause_count > 0
+          text << "CLAUSES DETECTED"
+          text << "-" * 20
+          text << "Total clauses found: #{clause_count}"
+          
+          results[:clauses].each do |clause_type, clauses|
+            next if clauses.empty?
+            text << "#{clause_type.to_s.split('_').map(&:capitalize).join(' ')}: #{clauses.length}"
+          end
+        end
+      end
+
+      text.join("\n")
+    end
+  end
+end

data/lib/legal_summariser/risk_analyzer.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module LegalSummariser
+  class RiskAnalyzer
+    attr_reader :text
+
+    def initialize(text)
+      @text = text.downcase
+    end
+
+    # Analyze document for potential legal risks
+    # @return [Hash] Risk analysis results
+    def analyze
+      {
+        high_risks: detect_high_risks,
+        medium_risks: detect_medium_risks,
+        compliance_gaps: detect_compliance_gaps,
+        unfair_terms: detect_unfair_terms,
+        risk_score: calculate_overall_risk_score
+      }
+    end
+
+    private
+
+    # Detect high-risk clauses and terms
+    # @return [Array<Hash>] High-risk items
+    def detect_high_risks
+      risks = []
+
+      # Unlimited liability
+      if text.match?(/unlimited\s+liability|no\s+limit.*liability/i)
+        risks << {
+          type: "Unlimited Liability",
+          description: "Agreement may expose party to unlimited financial liability",
+          severity: "high",
+          recommendation: "Consider adding liability caps or limitations"
+        }
+      end
+
+      # Broad indemnification
+      if text.match?(/indemnify.*against.*claims|hold\s+harmless.*all.*claims/i)
+        risks << {
+          type: "Broad Indemnification",
+          description: "Very broad indemnification obligations that could be costly",
+          severity: "high",
+          recommendation: "Narrow the scope of indemnification obligations"
+        }
+      end
+
+      # Automatic renewal without notice
+      if text.match?(/automatic.*renew|automatically.*extend/i) && !text.match?(/notice.*terminat|notice.*cancel/i)
+        risks << {
+          type: "Automatic Renewal",
+          description: "Agreement may auto-renew without adequate termination notice",
+          severity: "high",
+          recommendation: "Ensure adequate notice periods for termination"
+        }
+      end
+
+      # Exclusive dealing
+      if text.match?(/exclusive|solely|only.*party/i) && text.match?(/deal|contract|agreement/i)
+        risks << {
+          type: "Exclusive Dealing",
+          description: "Agreement may contain exclusive dealing obligations",
+          severity: "high",
+          recommendation: "Review exclusivity terms carefully"
+        }
+      end
+
+      risks
+    end
+
+    # Detect medium-risk issues
+    # @return [Array<Hash>] Medium-risk items
+    def detect_medium_risks
+      risks = []
+
+      # Vague termination clauses
+      if text.match?(/terminat.*convenience|terminat.*reason/i) && !text.match?(/\d+\s+days?\s+notice/i)
+        risks << {
+          type: "Vague Termination",
+          description: "Termination clauses lack specific notice periods",
+          severity: "medium",
+          recommendation: "Specify clear termination notice requirements"
+        }
+      end
+
+      # Broad confidentiality
+      if text.match?(/all\s+information.*confidential|any\s+information.*confidential/i)
+        risks << {
+          type: "Overly Broad Confidentiality",
+          description: "Confidentiality obligations may be too broad",
+          severity: "medium",
+          recommendation: "Define confidential information more specifically"
+        }
+      end
+
+      # Assignment restrictions
+      if text.match?(/not.*assign|cannot.*assign|may\s+not.*assign/i)
+        risks << {
+          type: "Assignment Restrictions",
+          description: "Agreement restricts assignment rights",
+          severity: "medium",
+          recommendation: "Consider if assignment restrictions are necessary"
+        }
+      end
+
+      # Governing law concerns
+      if text.match?(/laws?\s+of.*(?:foreign|international)/i)
+        risks << {
+          type: "Foreign Governing Law",
+          description: "Agreement governed by foreign law",
+          severity: "medium",
+          recommendation: "Consider implications of foreign law governance"
+        }
+      end
+
+      risks
+    end
+
+    # Detect compliance gaps (GDPR, KVKK, etc.)
+    # @return [Array<Hash>] Compliance issues
+    def detect_compliance_gaps
+      gaps = []
+
+      # GDPR compliance checks
+      if text.match?(/personal\s+data|data\s+processing/i)
+        unless text.match?(/gdpr|general\s+data\s+protection/i)
+          gaps << {
+            type: "Missing GDPR Reference",
+            description: "Document processes personal data but lacks GDPR compliance language",
+            regulation: "GDPR",
+            recommendation: "Add GDPR compliance clauses"
+          }
+        end
+
+        unless text.match?(/data\s+subject\s+rights|right\s+to\s+erasure|right\s+of\s+access/i)
+          gaps << {
+            type: "Missing Data Subject Rights",
+            description: "No mention of data subject rights under GDPR",
+            regulation: "GDPR",
+            recommendation: "Include data subject rights provisions"
+          }
+        end
+      end
+
+      # KVKK compliance (Turkish data protection)
+      if text.match?(/turkey|turkish|kvkk/i) && text.match?(/personal\s+data/i)
+        unless text.match?(/kvkk|kişisel\s+verilerin\s+korunması/i)
+          gaps << {
+            type: "Missing KVKK Compliance",
+            description: "Turkish context requires KVKK compliance",
+            regulation: "KVKK",
+            recommendation: "Add KVKK compliance provisions"
+          }
+        end
+      end
+
+      # Employment law compliance
+      if text.match?(/employment|employee|job/i)
+        unless text.match?(/equal\s+opportunity|discrimination|harassment/i)
+          gaps << {
+            type: "Missing Employment Protections",
+            description: "Employment agreement lacks standard protection clauses",
+            regulation: "Employment Law",
+            recommendation: "Add anti-discrimination and harassment policies"
+          }
+        end
+      end
+
+      gaps
+    end
+
+    # Detect potentially unfair terms
+    # @return [Array<Hash>] Unfair terms
+    def detect_unfair_terms
+      unfair_terms = []
+
+      # One-sided termination rights
+      if text.match?(/company.*may.*terminat/i) && !text.match?(/employee.*may.*terminat|party.*may.*terminat/i)
+        unfair_terms << {
+          type: "One-sided Termination",
+          description: "Only one party has termination rights",
+          impact: "Creates imbalanced relationship",
+          recommendation: "Consider mutual termination rights"
+        }
+      end
+
+      # Penalty clauses without reciprocity
+      if text.match?(/penalty|fine|liquidated\s+damages/i)
+        unfair_terms << {
+          type: "Penalty Clauses",
+          description: "Agreement contains penalty or liquidated damages clauses",
+          impact: "May be unenforceable or unfair",
+          recommendation: "Review enforceability of penalty clauses"
+        }
+      end
+
+      # Broad non-compete
+      if text.match?(/non.?compete|not.*compete/i) && !text.match?(/reasonable.*period|limited.*scope/i)
+        unfair_terms << {
+          type: "Broad Non-Compete",
+          description: "Non-compete clause may be overly broad",
+          impact: "Could restrict future employment opportunities",
+          recommendation: "Ensure non-compete is reasonable in scope and duration"
+        }
+      end
+
+      # Unilateral modification rights
+      if text.match?(/may.*modify.*agreement|reserve.*right.*change/i) && !text.match?(/mutual.*consent|both.*parties/i)
+        unfair_terms << {
+          type: "Unilateral Modification",
+          description: "One party can modify agreement without consent",
+          impact: "Creates uncertainty and imbalance",
+          recommendation: "Require mutual consent for modifications"
+        }
+      end
+
+      unfair_terms
+    end
+
+    # Calculate overall risk score
+    # @return [Hash] Risk score and level
+    def calculate_overall_risk_score
+      high_risks = detect_high_risks.length
+      medium_risks = detect_medium_risks.length
+      compliance_gaps = detect_compliance_gaps.length
+      unfair_terms = detect_unfair_terms.length
+
+      # Weighted scoring
+      score = (high_risks * 10) + (medium_risks * 5) + (compliance_gaps * 7) + (unfair_terms * 6)
+
+      level = case score
+              when 0..10
+                "low"
+              when 11..25
+                "medium"
+              when 26..50
+                "high"
+              else
+                "critical"
+              end
+
+      {
+        score: score,
+        level: level,
+        total_issues: high_risks + medium_risks + compliance_gaps + unfair_terms,
+        breakdown: {
+          high_risks: high_risks,
+          medium_risks: medium_risks,
+          compliance_gaps: compliance_gaps,
+          unfair_terms: unfair_terms
+        }
+      }
+    end
+  end
+end

data/lib/legal_summariser/summariser.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module LegalSummariser
+  class Summariser
+    attr_reader :text, :options
+
+    def initialize(text, options = {})
+      @text = text
+      @options = default_options.merge(options)
+    end
+
+    # Generate a summary of the legal document
+    # @return [Hash] Summary with plain text and key points
+    def generate
+      sentences = extract_sentences
+      key_sentences = identify_key_sentences(sentences)
+      
+      {
+        plain_text: generate_plain_text_summary(key_sentences),
+        key_points: extract_key_points(sentences),
+        summary_ratio: calculate_summary_ratio(sentences, key_sentences)
+      }
+    end
+
+    private
+
+    def default_options
+      {
+        max_sentences: 5,
+        min_sentence_length: 20,
+        focus_keywords: %w[
+          agreement contract party parties obligation liability
+          termination confidentiality data protection privacy
+          payment fee term condition warranty indemnity
+        ]
+      }
+    end
+
+    # Extract sentences from text
+    # @return [Array<String>] Array of sentences
+    def extract_sentences
+      # Split on sentence boundaries while preserving legal formatting
+      sentences = text.split(/(?<=[.!?])\s+(?=[A-Z])/)
+      
+      # Filter out very short sentences and clean up
+      sentences.select { |s| s.length >= options[:min_sentence_length] }
+               .map { |s| s.strip.gsub(/\s+/, ' ') }
+    end
+
+    # Identify the most important sentences for summary
+    # @param sentences [Array<String>] All sentences
+    # @return [Array<String>] Key sentences for summary
+    def identify_key_sentences(sentences)
+      scored_sentences = sentences.map do |sentence|
+        {
+          sentence: sentence,
+          score: calculate_sentence_score(sentence)
+        }
+      end
+
+      # Sort by score and take top sentences
+      scored_sentences.sort_by { |s| -s[:score] }
+                     .first(options[:max_sentences])
+                     .map { |s| s[:sentence] }
+    end
+
+    # Calculate importance score for a sentence
+    # @param sentence [String] The sentence to score
+    # @return [Float] Importance score
+    def calculate_sentence_score(sentence)
+      score = 0.0
+      sentence_lower = sentence.downcase
+
+      # Keyword matching
+      options[:focus_keywords].each do |keyword|
+        score += 2.0 if sentence_lower.include?(keyword)
+      end
+
+      # Legal action words
+      legal_actions = %w[shall must will may agree consent terminate breach]
+      legal_actions.each do |action|
+        score += 1.5 if sentence_lower.include?(action)
+      end
+
+      # Important legal phrases
+      important_phrases = [
+        'in the event', 'subject to', 'provided that', 'notwithstanding',
+        'pursuant to', 'in accordance with', 'for the purpose of'
+      ]
+      important_phrases.each do |phrase|
+        score += 1.0 if sentence_lower.include?(phrase)
+      end
+
+      # Penalty for very long sentences (likely boilerplate)
+      score -= 0.5 if sentence.length > 200
+
+      # Bonus for sentences with specific terms or dates
+      score += 1.0 if sentence.match?(/\d+\s+(days?|months?|years?)/i)
+      score += 0.5 if sentence.match?(/\$\d+|\d+%/i)
+
+      score
+    end
+
+    # Generate plain English summary
+    # @param key_sentences [Array<String>] Important sentences
+    # @return [String] Plain text summary
+    def generate_plain_text_summary(key_sentences)
+      summary_parts = []
+
+      # Identify document type and add context
+      doc_type = identify_document_context(key_sentences)
+      summary_parts << doc_type if doc_type
+
+      # Process key sentences into plain English
+      key_sentences.each do |sentence|
+        plain_sentence = simplify_legal_language(sentence)
+        summary_parts << plain_sentence if plain_sentence
+      end
+
+      summary_parts.join(' ')
+    end
+
+    # Identify document context for better summary introduction
+    # @param sentences [Array<String>] Key sentences
+    # @return [String, nil] Context introduction
+    def identify_document_context(sentences)
+      combined_text = sentences.join(' ').downcase
+
+      case combined_text
+      when /non.?disclosure|confidentiality/
+        "This Non-Disclosure Agreement establishes confidentiality obligations between parties."
+      when /employment|job|position/
+        "This Employment Agreement outlines the terms of employment."
+      when /service|provide|deliver/
+        "This Service Agreement defines the terms for service delivery."
+      when /privacy|data protection|gdpr|kvkv/
+        "This Privacy Policy explains how personal data is handled."
+      when /license|licensing|intellectual property/
+        "This License Agreement grants specific usage rights."
+      else
+        "This legal agreement establishes terms and conditions between parties."
+      end
+    end
+
+    # Simplify legal language into plain English
+    # @param sentence [String] Legal sentence
+    # @return [String] Simplified sentence
+    def simplify_legal_language(sentence)
+      simplified = sentence.dup
+
+      # Common legal phrase replacements
+      replacements = {
+        /shall\s+/i => 'will ',
+        /pursuant to/i => 'according to',
+        /in the event that/i => 'if',
+        /provided that/i => 'as long as',
+        /notwithstanding/i => 'despite',
+        /heretofore/i => 'before this',
+        /hereafter/i => 'after this',
+        /whereas/i => 'since',
+        /whereby/i => 'by which',
+        /aforementioned/i => 'mentioned above',
+        /party of the first part/i => 'first party',
+        /party of the second part/i => 'second party'
+      }
+
+      replacements.each do |pattern, replacement|
+        simplified.gsub!(pattern, replacement)
+      end
+
+      # Remove excessive legal formality
+      simplified.gsub!(/\b(said|such|aforesaid)\s+/i, '')
+      
+      simplified.strip
+    end
+
+    # Extract key points as bullet points
+    # @param sentences [Array<String>] All sentences
+    # @return [Array<String>] Key points
+    def extract_key_points(sentences)
+      points = []
+
+      # Look for specific types of important information
+      sentences.each do |sentence|
+        sentence_lower = sentence.downcase
+
+        # Duration/term information
+        if sentence.match?(/\d+\s+(days?|months?|years?|weeks?)/i)
+          duration = sentence.match(/\d+\s+(?:days?|months?|years?|weeks?)/i)[0]
+          points << "Duration: #{duration}"
+        end
+
+        # Payment information
+        if sentence.match?(/\$[\d,]+|\d+\s*(?:dollars?|pounds?|euros?)/i)
+          points << "Contains payment terms"
+        end
+
+        # Termination clauses
+        if sentence_lower.include?('terminat')
+          points << "Includes termination provisions"
+        end
+
+        # Liability clauses
+        if sentence_lower.include?('liabilit') || sentence_lower.include?('liable')
+          points << "Contains liability provisions"
+        end
+
+        # Confidentiality
+        if sentence_lower.include?('confidential') || sentence_lower.include?('non-disclosure')
+          points << "Includes confidentiality requirements"
+        end
+      end
+
+      points.uniq.first(5) # Limit to 5 key points
+    end
+
+    # Calculate summary compression ratio
+    # @param original_sentences [Array<String>] Original sentences
+    # @param summary_sentences [Array<String>] Summary sentences
+    # @return [Float] Compression ratio
+    def calculate_summary_ratio(original_sentences, summary_sentences)
+      original_length = original_sentences.join(' ').length
+      summary_length = summary_sentences.join(' ').length
+      
+      return 0.0 if original_length == 0
+      
+      (summary_length.to_f / original_length * 100).round(2)
+    end
+  end
+end