ruby_llm-text 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb717f8d64403316c14b7da6ae2354f5f72d60a2caae6c892ca3f9fe109343d8
-  data.tar.gz: 286d134ed832cee3a0289052b5b81693a6b70822080dc9f4fa3535c492f73198
+  metadata.gz: df272052ddd3c5340c8c1c1045561c53ecbc712f591b0a4374b67ede8db47847
+  data.tar.gz: 7dd889e901cbd9a9bf9c84369c7b1e74b1f3f446e4bff99398f263d12dc5cb1d
 SHA512:
-  metadata.gz: 7227c8ae62491a00d308d3d59751435f404d5ee1e405b71db323a3b4edab832dac23bbc7162ef530562bae28d58ef5a765ba89f790d0f4e07469b99964519873
-  data.tar.gz: bb9eea87d7aafb8251a49ea5137f073fc5eea5a0ffcf29a699c2251bde7cfd31131afb81d51f293befa5faba8e1f397ca0080cd0626f6c394db4fcd2729a5f25
+  metadata.gz: 864290308b5e0c4352a1393db5639f43bbeda934ed800e17e8c57c84b78704a05bc149762c9ffb127fbc91f40ae85a6598a3fddb7d6d18b606b80ffd38b09cb3
+  data.tar.gz: b8ddb46a92a0ec6ece6acf35670e1f665a8dc769fb617b97f349a595bcfb4a44c0aac2081c805a4abf2d415b4f2a6e643c93f99f0104a9189a0be1c031db3f34

data/CHANGELOG.md

@@ -7,6 +7,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0] - 2025-02-17
+
+### Added
+- **Phase 2 Text Operations** - Five powerful new methods for advanced text processing:
+  - `fix_grammar` - Grammar and spelling correction with optional change explanations
+  - `sentiment` - Sentiment analysis with confidence scores and custom categories
+  - `key_points` - Extract main points from long text with format options (bullets, numbers, sentences)
+  - `rewrite` - Transform text tone and style (professional, casual, academic, creative, etc.)
+  - `answer` - Question answering against provided text with boolean question detection
+- **Enhanced Configuration** - Per-method model configuration for all Phase 2 methods
+- **Resilient JSON Parsing** - Robust parsing with fallback mechanisms for varied LLM response formats
+- **Extended String Extensions** - All Phase 2 methods available as String monkey-patches
+- **Comprehensive Manual Testing** - Updated test script covering all 9 methods with real API calls
+- **Complete Documentation** - Comprehensive README with API reference for all methods
+
+### Improved
+- **Error Handling** - Graceful fallbacks for JSON parsing failures
+- **Test Coverage** - 93 tests with 240 assertions covering all functionality
+- **Code Quality** - RuboCop compliant codebase with consistent formatting
+
+### Dependencies
+- ruby_llm ~> 1.0 (unchanged)
+- Ruby >= 3.2.0 (unchanged)
+
 ## [0.1.0] - 2025-02-16
 
 ### Added
@@ -27,5 +51,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - ruby_llm ~> 1.0 (core dependency)
 - Ruby >= 3.2.0
 
-[Unreleased]: https://github.com/patrols/ruby_llm-text/compare/v0.1.0...HEAD
+[Unreleased]: https://github.com/patrols/ruby_llm-text/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/patrols/ruby_llm-text/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/patrols/ruby_llm-text/releases/tag/v0.1.0

data/README.md

@@ -7,7 +7,7 @@ ActiveSupport-style LLM utilities for Ruby that make AI operations feel like nat
 
 ## Overview
 
-`ruby_llm-text` provides intuitive one-liner utility methods for common LLM tasks like summarizing text, translation, data extraction, and classification. It integrates seamlessly with the [ruby_llm](https://github.com/crmne/ruby_llm) ecosystem, providing a simple interface without requiring chat objects, message arrays, or configuration boilerplate.
+`ruby_llm-text` provides intuitive one-liner utility methods for common LLM tasks including text summarization, translation, data extraction, classification, grammar correction, sentiment analysis, key point extraction, text rewriting, and question answering. It integrates seamlessly with the [ruby_llm](https://github.com/crmne/ruby_llm) ecosystem, providing a simple interface without requiring chat objects, message arrays, or configuration boilerplate.
 
 ## Installation
 
@@ -53,6 +53,16 @@ data = RubyLLM::Text.extract(text, schema: { name: :string, age: :integer })
 # Classify text
 review = "This product is amazing!"
 sentiment = RubyLLM::Text.classify(review, categories: ["positive", "negative", "neutral"])
+
+# Fix grammar and spelling
+corrected = RubyLLM::Text.fix_grammar("Their going to the stor tommorow")
+
+# Get sentiment with confidence
+sentiment_analysis = RubyLLM::Text.sentiment("I love this product!")
+# => {"label" => "positive", "confidence" => 0.95}
+
+# Extract key points from long text
+points = RubyLLM::Text.key_points("Long meeting notes...", max_points: 3)
 ```
 
 ## API Reference
@@ -66,12 +76,14 @@ RubyLLM::Text.summarize(text, length: :medium, max_words: nil, model: nil)
 ```
 
 **Parameters:**
+
 - `text` (String): The text to summarize
 - `length` (Symbol|String): Predefined length (`:short`, `:medium`, `:detailed`) or custom description
 - `max_words` (Integer, optional): Maximum word count for summary
 - `model` (String, optional): Specific model to use
 
 **Examples:**
+
 ```ruby
 # Basic usage
 RubyLLM::Text.summarize("Long article text...")
@@ -95,12 +107,14 @@ RubyLLM::Text.translate(text, to:, from: nil, model: nil)
 ```
 
 **Parameters:**
+
 - `text` (String): The text to translate
 - `to` (String): Target language (e.g., "en", "spanish", "français")
 - `from` (String, optional): Source language for better accuracy
 - `model` (String, optional): Specific model to use
 
 **Examples:**
+
 ```ruby
 # Basic translation
 RubyLLM::Text.translate("Bonjour", to: "en")
@@ -121,17 +135,20 @@ RubyLLM::Text.extract(text, schema:, model: nil)
 ```
 
 **Parameters:**
+
 - `text` (String): The text to extract data from
 - `schema` (Hash): Data structure specification
 - `model` (String, optional): Specific model to use
 
 **Schema Types:**
+
 - `:string` - Text fields
 - `:integer`, `:number` - Numeric fields
 - `:boolean` - True/false fields
 - `:array` - List fields
 
 **Examples:**
+
 ```ruby
 # Extract person details
 text = "John Smith is 30 years old and works as a software engineer in San Francisco."
@@ -163,11 +180,13 @@ RubyLLM::Text.classify(text, categories:, model: nil)
 ```
 
 **Parameters:**
+
 - `text` (String): The text to classify
 - `categories` (Array): List of possible categories
 - `model` (String, optional): Specific model to use
 
 **Examples:**
+
 ```ruby
 # Sentiment analysis
 review = "This product exceeded my expectations!"
@@ -188,6 +207,173 @@ priority = RubyLLM::Text.classify(email,
 )
 ```
 
+### Fix Grammar
+
+Correct grammar, spelling, and punctuation errors.
+
+```ruby
+RubyLLM::Text.fix_grammar(text, explain: false, preserve_style: false, model: nil)
+```
+
+**Parameters:**
+
+- `text` (String): The text to correct
+- `explain` (Boolean, optional): Return explanations of changes made (default: false)
+- `preserve_style` (Boolean, optional): Keep original tone and style (default: false)
+- `model` (String, optional): Specific model to use
+
+**Examples:**
+
+```ruby
+# Basic grammar correction
+RubyLLM::Text.fix_grammar("Their going to the stor tommorow")
+# => "They're going to the store tomorrow"
+
+# With explanations
+result = RubyLLM::Text.fix_grammar("bad grammer here", explain: true)
+# => {"corrected" => "bad grammar here", "changes" => ["grammer → grammar"]}
+
+# Preserve casual style
+RubyLLM::Text.fix_grammar("hey whats up", preserve_style: true)
+# => "Hey, what's up?" (keeps casual tone)
+```
+
+### Sentiment
+
+Analyze sentiment with confidence scores.
+
+```ruby
+RubyLLM::Text.sentiment(text, categories: ["positive", "negative", "neutral"], simple: false, model: nil)
+```
+
+**Parameters:**
+
+- `text` (String): The text to analyze
+- `categories` (Array, optional): Custom sentiment categories (default: positive/negative/neutral)
+- `simple` (Boolean, optional): Return just the label without confidence (default: false)
+- `model` (String, optional): Specific model to use
+
+**Examples:**
+
+```ruby
+# Basic sentiment analysis with confidence
+RubyLLM::Text.sentiment("I love this product!")
+# => {"label" => "positive", "confidence" => 0.95}
+
+# Simple mode (just the label)
+RubyLLM::Text.sentiment("Great service!", simple: true)
+# => "positive"
+
+# Custom categories
+RubyLLM::Text.sentiment("I'm excited about tomorrow!",
+  categories: ["excited", "calm", "worried", "neutral"])
+# => {"label" => "excited", "confidence" => 0.92}
+```
+
+### Key Points
+
+Extract main points from longer text.
+
+```ruby
+RubyLLM::Text.key_points(text, max_points: nil, format: :sentences, model: nil)
+```
+
+**Parameters:**
+
+- `text` (String): The text to extract points from
+- `max_points` (Integer, optional): Maximum number of points to extract
+- `format` (Symbol, optional): Output format (`:sentences`, `:bullets`, `:numbers`)
+- `model` (String, optional): Specific model to use
+
+**Examples:**
+
+```ruby
+# Basic key points extraction
+meeting_notes = "We discussed budget, hiring, and marketing plans..."
+points = RubyLLM::Text.key_points(meeting_notes)
+# => ["Budget allocation reviewed", "New hiring plans discussed", ...]
+
+# Limit number of points
+RubyLLM::Text.key_points(text, max_points: 3)
+
+# Different formats
+RubyLLM::Text.key_points(text, format: :bullets)   # Returns clean text
+RubyLLM::Text.key_points(text, format: :numbers)   # Returns clean text
+RubyLLM::Text.key_points(text, format: :sentences) # Returns clean sentences
+```
+
+### Rewrite
+
+Transform text tone and style.
+
+```ruby
+RubyLLM::Text.rewrite(text, tone: nil, style: nil, instruction: nil, model: nil)
+```
+
+**Parameters:**
+
+- `text` (String): The text to rewrite
+- `tone` (Symbol|String, optional): Target tone (`:professional`, `:casual`, `:academic`, `:creative`, `:brief`)
+- `style` (Symbol|String, optional): Target style (`:concise`, `:detailed`, `:formal`, `:informal`)
+- `instruction` (String, optional): Custom rewriting instruction
+- `model` (String, optional): Specific model to use
+
+**Examples:**
+
+```ruby
+# Change tone
+RubyLLM::Text.rewrite("hey whats up", tone: :professional)
+# => "Good morning. How are you doing?"
+
+# Change style
+RubyLLM::Text.rewrite("This is a long explanation...", style: :concise)
+# => "Brief explanation."
+
+# Custom instructions
+RubyLLM::Text.rewrite("Hello there", instruction: "make it sound like a pirate")
+# => "Ahoy there, matey!"
+
+# Combine multiple transformations
+RubyLLM::Text.rewrite(text, tone: :professional, style: :concise)
+```
+
+### Answer
+
+Answer questions based on provided text.
+
+```ruby
+RubyLLM::Text.answer(text, question, include_confidence: false, model: nil)
+```
+
+**Parameters:**
+
+- `text` (String): The text to search for answers
+- `question` (String): The question to answer
+- `include_confidence` (Boolean, optional): Include confidence score (default: false)
+- `model` (String, optional): Specific model to use
+
+**Examples:**
+
+```ruby
+article = "Ruby was created by Yukihiro Matsumoto in 1995..."
+
+# Basic question answering
+RubyLLM::Text.answer(article, "Who created Ruby?")
+# => "Yukihiro Matsumoto"
+
+# Boolean questions
+RubyLLM::Text.answer(article, "Is Ruby a programming language?")
+# => true
+
+# With confidence scores
+result = RubyLLM::Text.answer(article, "When was Ruby created?", include_confidence: true)
+# => {"answer" => "1995", "confidence" => 0.98}
+
+# When answer not found
+RubyLLM::Text.answer(article, "What is Python?")
+# => "information not available"
+```
+
 ## Configuration
 
 This gem uses `ruby_llm`'s configuration for API keys and default models:
@@ -213,10 +399,16 @@ RubyLLM::Text.configure do |config|
   config.translate_model = "claude-sonnet-4-5"  # Use Claude for translation
   config.extract_model = "gpt-4.1"              # Use GPT-4 for extraction
   config.classify_model = "gpt-4.1-mini"
+  config.grammar_model = "gpt-4.1-mini"         # Good for grammar correction
+  config.sentiment_model = "claude-haiku-4-5"   # Fast for sentiment analysis
+  config.key_points_model = "gpt-4.1-mini"      # Good for summarization tasks
+  config.rewrite_model = "gpt-4.1"              # Creative rewriting tasks
+  config.answer_model = "claude-sonnet-4-5"     # Strong reasoning for Q&A
 end
 ```
 
 **Per-call overrides:**
+
 ```ruby
 # Override model for specific calls
 RubyLLM::Text.summarize(text, model: "claude-sonnet-4-5")
@@ -237,6 +429,11 @@ require 'ruby_llm/text/string_ext'
 "Bonjour".translate(to: "en")
 "John is 30".extract(schema: { name: :string, age: :integer })
 "Great product!".classify(categories: ["positive", "negative"])
+"Their going to the stor".fix_grammar
+"I love this!".sentiment
+"Long meeting notes...".key_points(max_points: 3)
+"hey whats up".rewrite(tone: :professional)
+"Ruby was created in 1995".answer("When was Ruby created?")
 ```
 
 ## Integration with ruby_llm
@@ -253,12 +450,16 @@ The gem provides clear error messages for common issues:
 
 ```ruby
 # Missing required parameters
-RubyLLM::Text.extract("text")  # ArgumentError: schema is required
-
+RubyLLM::Text.extract("text")  # ArgumentError: schema is required for extraction
 RubyLLM::Text.classify("text", categories: [])  # ArgumentError: categories are required
+RubyLLM::Text.answer("text", "")  # ArgumentError: question is required
+RubyLLM::Text.rewrite("text")  # ArgumentError: Must specify at least one of: tone, style, or instruction
 
 # API errors are wrapped with context
 RubyLLM::Text.summarize("text")  # RubyLLM::Text::Error: LLM call failed: [original error]
+
+# Graceful fallbacks for parsing issues
+RubyLLM::Text.sentiment("text")  # Falls back to simple mode if JSON parsing fails
 ```
 
 ## Development
@@ -301,7 +502,7 @@ export ANTHROPIC_API_KEY="your-key"
 bin/manual-test
 ```
 
-This script tests all four methods with real LLM APIs and provides helpful output for verification.
+This script tests all nine methods with real LLM APIs and provides helpful output for verification.
 
 ## Contributing
 

data/lib/ruby_llm/text/answer.rb

@@ -0,0 +1,136 @@
+module RubyLLM
+  module Text
+    module Answer
+      def self.call(text, question, include_confidence: false, model: nil, **options)
+        raise ArgumentError, "question is required" if question.nil? || question.strip.empty?
+
+        model ||= RubyLLM::Text.config.model_for(:answer)
+
+        prompt = build_prompt(text, question, include_confidence: include_confidence)
+
+        if include_confidence
+          # For structured output with confidence score
+          schema = build_confidence_schema(question)
+          response = Base.call_llm(prompt, model: model, schema: schema, **options)
+
+          begin
+            result = JSON.parse(Base.clean_json_response(response))
+          rescue JSON::ParserError
+            # Fallback: if JSON parsing fails, return best-effort structured response
+            cleaned_response = Base.clean_json_response(response)
+            result = {
+              "answer" => cleaned_response,
+              "confidence" => nil
+            }
+          end
+
+          # Convert confidence to float when present (preserve nil as "unknown")
+          if result.key?("confidence") && !result["confidence"].nil?
+            result["confidence"] = result["confidence"].to_f
+          end
+
+          # Handle boolean answers
+          if is_boolean_answer?(result["answer"])
+            result["answer"] = parse_boolean(result["answer"])
+          end
+
+          result
+        else
+          response = Base.call_llm(prompt, model: model, **options)
+
+          # Handle boolean answers for simple responses
+          if is_boolean_question?(question)
+            parse_boolean(response)
+          else
+            response
+          end
+        end
+      end
+
+      private
+
+      def self.build_prompt(text, question, include_confidence:)
+        if include_confidence
+          output_instruction = <<~OUTPUT
+            Return a JSON object with:
+            - "answer": the answer to the question (use true/false for yes/no questions)
+            - "confidence": a confidence score between 0 and 1
+
+            If the answer cannot be found in the text, return "information not available" as the answer with low confidence.
+          OUTPUT
+        else
+          output_instruction = <<~OUTPUT
+            Answer the question based only on the information provided in the text.
+            For yes/no questions, respond with true or false.
+            If the answer cannot be found in the text, respond with "information not available".
+            Return only the answer, no explanation.
+          OUTPUT
+        end
+
+        <<~PROMPT
+          Based on the following text, answer this question: "#{question}"
+
+          #{output_instruction}
+
+          Text:
+          #{text}
+        PROMPT
+      end
+
+      def self.build_confidence_schema(question)
+        # For boolean questions, allow both boolean and string types
+        # to handle "information not available" fallback
+        answer_type = if is_boolean_question?(question)
+          {
+            oneOf: [
+              { type: "boolean" },
+              { type: "string" }
+            ]
+          }
+        else
+          { type: "string" }
+        end
+
+        {
+          type: "object",
+          properties: {
+            answer: answer_type,
+            confidence: { type: "number", minimum: 0, maximum: 1 }
+          },
+          required: [ "answer", "confidence" ]
+        }
+      end
+
+      def self.is_boolean_question?(question)
+        question_lower = question.downcase.strip
+        question_lower.start_with?("is ", "are ", "was ", "were ", "do ", "does ", "did ", "can ", "could ", "will ", "would ", "should ") ||
+        question_lower.start_with?("has ", "have ", "had ") ||
+        question_lower.include?(" or not") ||
+        (question_lower.end_with?("?") && question_lower.include?("yes or no"))
+      end
+
+      def self.is_boolean_answer?(answer)
+        return true if answer.is_a?(TrueClass) || answer.is_a?(FalseClass)
+        return false unless answer.is_a?(String)
+
+        answer_lower = answer.downcase.strip
+        [ "true", "false", "yes", "no" ].include?(answer_lower)
+      end
+
+      def self.parse_boolean(answer)
+        return answer if answer.is_a?(TrueClass) || answer.is_a?(FalseClass)
+        return answer unless answer.is_a?(String)
+
+        answer_lower = answer.downcase.strip
+        case answer_lower
+        when "true", "yes"
+          true
+        when "false", "no"
+          false
+        else
+          answer # Return as-is if not clearly boolean
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/text/base.rb

@@ -7,7 +7,11 @@ module RubyLLM
 
         chat = RubyLLM.chat(model: model)
         chat = chat.with_temperature(temperature)
-        chat = chat.with_schema(schema) if schema
+        if schema
+          # Convert plain Hash schemas to RubyLLM::Schema objects if needed
+          schema_obj = build_schema(schema)
+          chat = chat.with_schema(schema_obj)
+        end
 
         # Apply any additional options
         options.each do |key, value|
@@ -20,6 +24,123 @@ module RubyLLM
       rescue => e
         raise RubyLLM::Text::Error, "LLM call failed: #{e.message}"
       end
+
+      def self.clean_json_response(response)
+        # Remove markdown code block formatting if present
+        cleaned = response.gsub(/^```json\n/, "").gsub(/\n```$/, "").strip
+
+        # If still no JSON, try to extract JSON from mixed content
+        if !cleaned.start_with?("{") && cleaned.include?("{")
+          # Find JSON object in the response with proper brace matching
+          brace_count = 0
+          start_pos = cleaned.index("{")
+          if start_pos
+            end_pos = start_pos
+            cleaned[start_pos..-1].each_char.with_index(start_pos) do |char, i|
+              if char == "{"
+                brace_count += 1
+              elsif char == "}"
+                brace_count -= 1
+                if brace_count == 0
+                  end_pos = i
+                  break
+                end
+              end
+            end
+
+            if brace_count == 0
+              cleaned = cleaned[start_pos..end_pos]
+            end
+          end
+        end
+
+        cleaned
+      end
+
+      def self.build_schema(schema)
+        # If already a schema object, return as-is
+        return schema if schema.respond_to?(:schema)
+
+        return nil unless schema.is_a?(Hash)
+
+        schema_class = Class.new(RubyLLM::Schema)
+
+        # Handle JSON Schema-style hashes (e.g., {type: "object", properties: {...}})
+        # Check both symbol and string keys to handle parsed JSON
+        schema_type = schema[:type] || schema["type"]
+        schema_properties = schema[:properties] || schema["properties"]
+
+        if schema_type == "object" && schema_properties
+          required_fields = schema[:required] || schema["required"] || []
+
+          schema_properties.each do |field, spec|
+            # Build constraint options
+            constraints = {}
+
+            # Handle required fields
+            constraints[:required] = required_fields.include?(field.to_s) || required_fields.include?(field)
+
+            # Extract constraints from spec
+            [ :enum, :minimum, :maximum ].each do |constraint|
+              value = spec[constraint] || spec[constraint.to_s]
+              constraints[constraint] = value if value
+            end
+
+            # Handle oneOf union types - default to string for compatibility
+            # Check both symbol and string keys
+            if spec[:oneOf] || spec["oneOf"]
+              schema_class.string field, **constraints # Use string as most flexible type
+            else
+              case spec[:type] || spec["type"]
+              when "string"
+                schema_class.string field, **constraints
+              when "number", "integer"
+                schema_class.number field, **constraints
+              when "boolean"
+                schema_class.boolean field, **constraints
+              when "array"
+                # Handle array with items specification
+                items_spec = spec[:items] || spec["items"]
+                if items_spec
+                  items_type = items_spec[:type] || items_spec["type"]
+                  case items_type
+                  when "string"
+                    schema_class.array field, :string, **constraints
+                  when "number", "integer"
+                    schema_class.array field, :number, **constraints
+                  when "boolean"
+                    schema_class.array field, :boolean, **constraints
+                  else
+                    schema_class.array field, :string, **constraints
+                  end
+                else
+                  schema_class.array field, :string, **constraints
+                end
+              else
+                schema_class.string field, **constraints # fallback to string
+              end
+            end
+          end
+        else
+          # Handle simple symbol-based schemas (e.g., {name: :string, age: :integer})
+          schema.each do |field, type|
+            case type
+            when :string
+              schema_class.string field
+            when :integer, :number
+              schema_class.number field
+            when :boolean
+              schema_class.boolean field
+            when :array
+              schema_class.array field
+            else
+              schema_class.string field # fallback to string
+            end
+          end
+        end
+
+        schema_class
+      end
     end
 
     class Error < StandardError; end

data/lib/ruby_llm/text/configuration.rb

@@ -4,7 +4,7 @@ module RubyLLM
       # Method-specific model overrides (optional)
       # If not set, falls back to RubyLLM.config.default_model
       attr_accessor :summarize_model, :translate_model,
-                    :extract_model, :classify_model
+                    :extract_model, :classify_model, :grammar_model, :sentiment_model, :key_points_model, :rewrite_model, :answer_model
 
       # Default temperature for text operations
       attr_accessor :temperature
@@ -15,6 +15,11 @@ module RubyLLM
         @translate_model = nil
         @extract_model = nil
         @classify_model = nil
+        @grammar_model = nil
+        @sentiment_model = nil
+        @key_points_model = nil
+        @rewrite_model = nil
+        @answer_model = nil
       end
 
       def model_for(method_name)

data/lib/ruby_llm/text/extract.rb

@@ -1,5 +1,3 @@
-require "ruby_llm/schema"
-
 module RubyLLM
   module Text
     module Extract
@@ -7,40 +5,22 @@ module RubyLLM
         model ||= RubyLLM::Text.config.model_for(:extract)
         raise ArgumentError, "schema is required for extraction" unless schema
 
-        # Convert simple hash schema to RubyLLM::Schema
-        schema_obj = build_schema(schema)
         prompt = build_prompt(text, schema)
 
-        Base.call_llm(prompt, model: model, schema: schema_obj, **options)
+        Base.call_llm(prompt, model: model, schema: schema, **options)
       end
 
       private
 
-      def self.build_schema(schema)
-        # If already a schema object, return as-is
-        return schema if schema.respond_to?(:schema)
-
-        # Build dynamic schema class from hash
-        schema_class = Class.new(RubyLLM::Schema)
-        schema.each do |field, type|
-          case type
-          when :string
-            schema_class.string field
-          when :integer, :number
-            schema_class.number field
-          when :boolean
-            schema_class.boolean field
-          when :array
-            schema_class.array field
-          else
-            schema_class.string field # fallback to string
-          end
-        end
-        schema_class
-      end
-
       def self.build_prompt(text, schema)
-        fields = schema.keys.join(", ")
+        # Support both simple field-hash schemas and JSON Schema-style hashes
+        properties = schema[:properties] || schema["properties"] if schema.respond_to?(:[])
+        field_keys = if properties.is_a?(Hash)
+                       properties.keys
+        else
+                       schema.keys
+        end
+        fields = field_keys.join(", ")
 
         <<~PROMPT
           Extract the following information from the text: #{fields}

data/lib/ruby_llm/text/grammar.rb

@@ -0,0 +1,68 @@
+module RubyLLM
+  module Text
+    module Grammar
+      def self.call(text, explain: false, preserve_style: false, model: nil, **options)
+        model ||= RubyLLM::Text.config.model_for(:grammar)
+
+        prompt = build_prompt(text, explain: explain, preserve_style: preserve_style)
+
+        if explain
+          # For structured output with explanations
+          schema = {
+            type: "object",
+            properties: {
+              corrected: { type: "string" },
+              changes: {
+                type: "array",
+                items: { type: "string" }
+              }
+            },
+            required: [ "corrected", "changes" ]
+          }
+          response = Base.call_llm(prompt, model: model, schema: schema, **options)
+
+          begin
+            JSON.parse(Base.clean_json_response(response))
+          rescue JSON::ParserError
+            # Fallback: if JSON parsing fails, return best-effort structured response
+            cleaned_response = Base.clean_json_response(response)
+            {
+              "corrected" => cleaned_response,
+              "changes" => []
+            }
+          end
+        else
+          Base.call_llm(prompt, model: model, **options)
+        end
+      end
+
+      private
+
+      def self.build_prompt(text, explain:, preserve_style:)
+        style_instruction = preserve_style ?
+          "Preserve the original tone, style, and level of formality." :
+          ""
+
+        if explain
+          output_instruction = <<~OUTPUT
+            Return a JSON object with:
+            - "corrected": the corrected text
+            - "changes": an array of changes made (e.g., "their → they're", "tommorow → tomorrow")
+          OUTPUT
+        else
+          output_instruction = "Return only the corrected text with no explanation or additional commentary."
+        end
+
+        <<~PROMPT
+          Fix grammar, spelling, punctuation, and word choice errors in the following text.
+          #{style_instruction}
+
+          #{output_instruction}
+
+          Text:
+          #{text}
+        PROMPT
+      end
+    end
+  end
+end

data/lib/ruby_llm/text/key_points.rb

@@ -0,0 +1,54 @@
+module RubyLLM
+  module Text
+    module KeyPoints
+      def self.call(text, max_points: nil, format: :sentences, model: nil, **options)
+        model ||= RubyLLM::Text.config.model_for(:key_points)
+
+        prompt = build_prompt(text, max_points: max_points, format: format)
+        response = Base.call_llm(prompt, model: model, **options)
+
+        # Parse response into array of strings
+        parse_response(response, format)
+      end
+
+      private
+
+      def self.build_prompt(text, max_points:, format:)
+        count_instruction = max_points ? " (maximum #{max_points} points)" : ""
+
+        format_instruction = case format
+        when :bullets
+          "Format each point with a bullet (•) at the start."
+        when :numbers
+          "Format as a numbered list (1. 2. 3. etc.)."
+        when :sentences
+          "Format as complete sentences, one per line."
+        else
+          "Format as complete sentences, one per line."
+        end
+
+        <<~PROMPT
+          Extract the key points from the following text#{count_instruction}.
+          #{format_instruction}
+          Return only the key points, no preamble or explanation.
+          Each point should be on a separate line.
+
+          Text:
+          #{text}
+        PROMPT
+      end
+
+      def self.parse_response(response, format)
+        lines = response.strip.split("\n").map(&:strip).reject(&:empty?)
+
+        # Clean up formatting markers regardless of format for robust output
+        lines.map do |line|
+          # Always clean common formatting markers to handle LLM inconsistencies
+          cleaned = line.gsub(/^[•\*\-]\s*/, "")  # Remove bullets
+          cleaned = cleaned.gsub(/^\d+\.\s*/, "")  # Remove numbers
+          cleaned
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/text/rewrite.rb

@@ -0,0 +1,65 @@
+module RubyLLM
+  module Text
+    module Rewrite
+      TONES = {
+        casual: "friendly, informal, and conversational",
+        professional: "business-appropriate, formal, and polished",
+        academic: "scholarly, formal, and precise",
+        creative: "engaging, descriptive, and imaginative",
+        brief: "brief, direct, and to-the-point"
+      }.freeze
+
+      STYLES = {
+        concise: "Make it shorter and more direct while preserving meaning",
+        detailed: "Expand with more context, examples, and explanation",
+        formal: "Use formal language and professional terminology",
+        informal: "Use informal, friendly language"
+      }.freeze
+
+      def self.call(text, tone: nil, style: nil, instruction: nil, model: nil, **options)
+        model ||= RubyLLM::Text.config.model_for(:rewrite)
+
+        # Validate that at least one transformation is specified
+        if tone.nil? && style.nil? && instruction.nil?
+          raise ArgumentError, "Must specify at least one of: tone, style, or instruction"
+        end
+
+        prompt = build_prompt(text, tone: tone, style: style, instruction: instruction)
+        Base.call_llm(prompt, model: model, **options)
+      end
+
+      private
+
+      def self.build_prompt(text, tone:, style:, instruction:)
+        transformations = []
+
+        if tone
+          tone_description = TONES[tone] || tone.to_s
+          transformations << "Tone: #{tone_description}"
+        end
+
+        if style
+          style_description = STYLES[style] || style.to_s
+          transformations << "Style: #{style_description}"
+        end
+
+        if instruction
+          transformations << "Additional instruction: #{instruction}"
+        end
+
+        transformation_text = transformations.join("\n")
+
+        <<~PROMPT
+          Rewrite the following text according to these requirements:
+
+          #{transformation_text}
+
+          Return only the rewritten text, no explanation or commentary.
+
+          Text:
+          #{text}
+        PROMPT
+      end
+    end
+  end
+end

data/lib/ruby_llm/text/sentiment.rb

@@ -0,0 +1,66 @@
+module RubyLLM
+  module Text
+    module Sentiment
+      DEFAULT_CATEGORIES = [ "positive", "negative", "neutral" ].freeze
+
+      def self.call(text, categories: DEFAULT_CATEGORIES, simple: false, model: nil, **options)
+        model ||= RubyLLM::Text.config.model_for(:sentiment)
+
+        prompt = build_prompt(text, categories: categories, simple: simple)
+
+        if simple
+          Base.call_llm(prompt, model: model, **options)
+        else
+          # For structured output with confidence score
+          schema = {
+            type: "object",
+            properties: {
+              label: { type: "string", enum: categories },
+              confidence: { type: "number", minimum: 0, maximum: 1 }
+            },
+            required: [ "label", "confidence" ]
+          }
+          response = Base.call_llm(prompt, model: model, schema: schema, **options)
+
+          begin
+            result = JSON.parse(Base.clean_json_response(response))
+            # Ensure confidence is a float
+            result["confidence"] = result["confidence"].to_f
+            result
+          rescue JSON::ParserError
+            # If JSON parsing fails, fall back to simple mode (no schema), as documented.
+            simple_prompt = build_prompt(text, categories: categories, simple: true)
+            Base.call_llm(simple_prompt, model: model, **options)
+          end
+        end
+      end
+
+      private
+
+      def self.build_prompt(text, categories:, simple:)
+        categories_list = categories.join(", ")
+
+        if simple
+          output_instruction = "Return only the sentiment category name, nothing else."
+        else
+          output_instruction = <<~OUTPUT
+            Return a JSON object with:
+            - "label": the sentiment category
+            - "confidence": a confidence score between 0 and 1 (where 1 is completely confident)
+          OUTPUT
+        end
+
+        <<~PROMPT
+          Analyze the sentiment of the following text.
+
+          Categories: #{categories_list}
+
+          #{output_instruction}
+
+          Text:
+          #{text}
+        PROMPT
+      end
+    end
+  end
+end

data/lib/ruby_llm/text/string_ext.rb

@@ -15,4 +15,24 @@ class String
   def classify(**options)
     RubyLLM::Text.classify(self, **options)
   end
+
+  def fix_grammar(**options)
+    RubyLLM::Text.fix_grammar(self, **options)
+  end
+
+  def sentiment(**options)
+    RubyLLM::Text.sentiment(self, **options)
+  end
+
+  def key_points(**options)
+    RubyLLM::Text.key_points(self, **options)
+  end
+
+  def rewrite(**options)
+    RubyLLM::Text.rewrite(self, **options)
+  end
+
+  def answer(question, **options)
+    RubyLLM::Text.answer(self, question, **options)
+  end
 end

data/lib/ruby_llm/text/version.rb

@@ -1,5 +1,5 @@
 module RubyLLM
   module Text
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/ruby_llm/text.rb

@@ -1,4 +1,6 @@
 require "ruby_llm"
+require "ruby_llm/schema"
+require "json"
 require_relative "text/version"
 require_relative "text/configuration"
 require_relative "text/base"
@@ -6,6 +8,11 @@ require_relative "text/summarize"
 require_relative "text/translate"
 require_relative "text/extract"
 require_relative "text/classify"
+require_relative "text/grammar"
+require_relative "text/sentiment"
+require_relative "text/key_points"
+require_relative "text/rewrite"
+require_relative "text/answer"
 
 module RubyLLM
   module Text
@@ -35,6 +42,26 @@ module RubyLLM
       def classify(text, **options)
         Classify.call(text, **options)
       end
+
+      def fix_grammar(text, **options)
+        Grammar.call(text, **options)
+      end
+
+      def sentiment(text, **options)
+        Sentiment.call(text, **options)
+      end
+
+      def key_points(text, **options)
+        KeyPoints.call(text, **options)
+      end
+
+      def rewrite(text, **options)
+        Rewrite.call(text, **options)
+      end
+
+      def answer(text, question, **options)
+        Answer.call(text, question, **options)
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-text
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Patrick Rendal Olsen
@@ -79,8 +79,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
-description: Intuitive one-liner utility methods for common LLM tasks like summarize,
-  translate, extract, and classify.
+description: Intuitive one-liner utility methods for common LLM tasks like text summarization,
+  translation, data extraction, classification, grammar correction, sentiment analysis,
+  key point extraction, text rewriting, and question answering.
 email:
 - patrick@rendal.me
 executables: []
@@ -91,10 +92,15 @@ files:
 - LICENSE
 - README.md
 - lib/ruby_llm/text.rb
+- lib/ruby_llm/text/answer.rb
 - lib/ruby_llm/text/base.rb
 - lib/ruby_llm/text/classify.rb
 - lib/ruby_llm/text/configuration.rb
 - lib/ruby_llm/text/extract.rb
+- lib/ruby_llm/text/grammar.rb
+- lib/ruby_llm/text/key_points.rb
+- lib/ruby_llm/text/rewrite.rb
+- lib/ruby_llm/text/sentiment.rb
 - lib/ruby_llm/text/string_ext.rb
 - lib/ruby_llm/text/summarize.rb
 - lib/ruby_llm/text/translate.rb