universal_document_processor 1.0.1 → 1.0.3

data/AI_USAGE_GUIDE.md

@@ -1,404 +0,0 @@
-# 🤖 Universal Document Processor - AI Agent Usage Guide
-
-## Overview
-
-The Universal Document Processor gem includes powerful AI-powered document analysis capabilities through its built-in **Agentic AI** features. Once you've installed the gem, you can leverage AI to analyze, summarize, extract information, and interact with your documents intelligently.
-
-## 🚀 Quick Setup
-
-### 1. Install the Gem
-
-```bash
-gem install universal_document_processor
-```
-
-### 2. Set Up Your OpenAI API Key
-
-```bash
-# Set environment variable
-export OPENAI_API_KEY="your-openai-api-key-here"
-```
-
-Or pass it directly in your code:
-
-```ruby
-options = { api_key: 'your-openai-api-key-here' }
-```
-
-### 3. Basic AI Usage
-
-```ruby
-require 'universal_document_processor'
-
-# Basic AI analysis
-result = UniversalDocumentProcessor.ai_analyze('document.pdf')
-puts result
-```
-
-## 🧠 AI Features Overview
-
-### Available AI Methods
-
-1. **`ai_analyze`** - Comprehensive document analysis
-2. **`ai_summarize`** - Generate summaries of different lengths
-3. **`ai_extract_info`** - Extract specific information categories
-4. **`ai_translate`** - Translate document content
-5. **`ai_classify`** - Classify document type and purpose
-6. **`ai_insights`** - Generate insights and recommendations
-7. **`ai_action_items`** - Extract actionable items
-8. **`ai_compare`** - Compare multiple documents
-9. **`ai_chat`** - Interactive chat about documents
-
-## 📝 Detailed Usage Examples
-
-### 1. Document Analysis
-
-#### General Analysis
-```ruby
-# Analyze any document comprehensively
-analysis = UniversalDocumentProcessor.ai_analyze('report.pdf')
-puts analysis
-```
-
-#### Specific Query Analysis
-```ruby
-# Ask specific questions about the document
-analysis = UniversalDocumentProcessor.ai_analyze('contract.pdf', {
-  query: "What are the key terms and conditions?"
-})
-puts analysis
-```
-
-### 2. Document Summarization
-
-```ruby
-# Short summary (2-3 sentences)
-summary = UniversalDocumentProcessor.ai_summarize('document.pdf', length: :short)
-
-# Medium summary (1-2 paragraphs) - default
-summary = UniversalDocumentProcessor.ai_summarize('document.pdf', length: :medium)
-
-# Detailed summary
-summary = UniversalDocumentProcessor.ai_summarize('document.pdf', length: :long)
-
-puts summary
-```
-
-### 3. Information Extraction
-
-```ruby
-# Extract default categories
-info = UniversalDocumentProcessor.ai_extract_info('meeting_notes.pdf')
-
-# Extract specific categories
-info = UniversalDocumentProcessor.ai_extract_info('contract.pdf', [
-  'parties', 'dates', 'financial_terms', 'obligations', 'deadlines'
-])
-
-puts info
-```
-
-### 4. Document Translation
-
-```ruby
-# Translate to different languages
-spanish_content = UniversalDocumentProcessor.ai_translate('document.pdf', 'Spanish')
-japanese_content = UniversalDocumentProcessor.ai_translate('document.pdf', 'Japanese')
-french_content = UniversalDocumentProcessor.ai_translate('document.pdf', 'French')
-
-puts spanish_content
-```
-
-### 5. Document Classification
-
-```ruby
-# Classify document type and purpose
-classification = UniversalDocumentProcessor.ai_classify('unknown_document.pdf')
-
-# Returns structured information about document type
-puts classification
-```
-
-### 6. Generate Insights
-
-```ruby
-# Get AI-powered insights and recommendations
-insights = UniversalDocumentProcessor.ai_insights('business_plan.pdf')
-
-# Returns analysis of key themes, recommendations, etc.
-puts insights
-```
-
-### 7. Extract Action Items
-
-```ruby
-# Extract actionable items from documents
-action_items = UniversalDocumentProcessor.ai_action_items('meeting_minutes.pdf')
-
-# Returns structured list of tasks, deadlines, assignments
-puts action_items
-```
-
-### 8. Compare Documents
-
-```ruby
-# Compare multiple documents
-comparison = UniversalDocumentProcessor.ai_compare([
-  'version1.pdf',
-  'version2.pdf',
-  'version3.pdf'
-], :content)
-
-puts comparison
-```
-
-## 🎯 Advanced Usage with Document Objects
-
-### Using Document Objects for More Control
-
-```ruby
-# Create document object for advanced operations
-doc = UniversalDocumentProcessor::Document.new('complex_document.pdf')
-
-# Use AI methods on the document object
-summary = doc.ai_summarize(length: :medium)
-insights = doc.ai_insights
-action_items = doc.ai_action_items
-
-# Interactive chat about the document
-response = doc.ai_chat("What are the main risks mentioned in this document?")
-puts response
-```
-
-### Creating and Reusing AI Agent
-
-```ruby
-# Create an AI agent with custom configuration
-ai_agent = UniversalDocumentProcessor.create_ai_agent({
-  model: 'gpt-4',
-  temperature: 0.7,
-  api_key: 'your-api-key'
-})
-
-# Process document
-doc_result = UniversalDocumentProcessor.process('document.pdf')
-
-# Use AI agent for multiple operations
-summary = ai_agent.summarize_document(doc_result, length: :short)
-insights = ai_agent.generate_insights(doc_result)
-classification = ai_agent.classify_document(doc_result)
-
-# Interactive chat
-response = ai_agent.chat("Tell me about the financial projections", doc_result)
-```
-
-## 🛠️ Configuration Options
-
-### AI Agent Configuration
-
-```ruby
-options = {
-  api_key: 'your-openai-api-key',      # OpenAI API key
-  model: 'gpt-4',                       # AI model to use
-  temperature: 0.7,                     # Response creativity (0.0-1.0)
-  max_history: 10,                      # Conversation history limit
-  base_url: 'https://api.openai.com/v1' # API endpoint
-}
-
-# Use with any AI method
-result = UniversalDocumentProcessor.ai_analyze('document.pdf', options)
-```
-
-## 💡 Use Case Examples
-
-### 1. Legal Document Analysis
-
-```ruby
-# Analyze legal contracts
-contract_analysis = UniversalDocumentProcessor.ai_analyze('contract.pdf', {
-  query: "Extract all key terms, obligations, and potential risks"
-})
-
-# Extract specific legal information
-legal_info = UniversalDocumentProcessor.ai_extract_info('contract.pdf', [
-  'parties', 'effective_date', 'termination_clauses', 'payment_terms', 'liabilities'
-])
-```
-
-### 2. Business Report Processing
-
-```ruby
-# Summarize quarterly reports
-summary = UniversalDocumentProcessor.ai_summarize('q4_report.pdf', length: :medium)
-
-# Extract key business metrics
-metrics = UniversalDocumentProcessor.ai_extract_info('q4_report.pdf', [
-  'revenue', 'expenses', 'profit_margins', 'growth_metrics', 'forecasts'
-])
-
-# Get strategic insights
-insights = UniversalDocumentProcessor.ai_insights('q4_report.pdf')
-```
-
-### 3. Meeting Minutes Processing
-
-```ruby
-# Extract action items from meeting notes
-action_items = UniversalDocumentProcessor.ai_action_items('meeting_notes.pdf')
-
-# Summarize meeting outcomes
-summary = UniversalDocumentProcessor.ai_summarize('meeting_notes.pdf', length: :short)
-
-# Extract key decisions and follow-ups
-decisions = UniversalDocumentProcessor.ai_extract_info('meeting_notes.pdf', [
-  'decisions_made', 'action_items', 'deadlines', 'assigned_people'
-])
-```
-
-### 4. Research Paper Analysis
-
-```ruby
-# Analyze research papers
-analysis = UniversalDocumentProcessor.ai_analyze('research_paper.pdf', {
-  query: "What are the main findings and methodology used?"
-})
-
-# Extract research data
-research_info = UniversalDocumentProcessor.ai_extract_info('research_paper.pdf', [
-  'hypothesis', 'methodology', 'results', 'conclusions', 'future_work'
-])
-```
-
-## 🔄 Interactive Document Chat
-
-```ruby
-# Create document object
-doc = UniversalDocumentProcessor::Document.new('document.pdf')
-
-# Start interactive chat session
-puts "Chat with your document (type 'exit' to quit):"
-
-loop do
-  print "> "
-  user_input = gets.chomp
-  break if user_input.downcase == 'exit'
-  
-  response = doc.ai_chat(user_input)
-  puts "AI: #{response}\n\n"
-end
-```
-
-## 📊 Batch AI Processing
-
-```ruby
-# Process multiple documents with AI
-documents = ['doc1.pdf', 'doc2.docx', 'doc3.xlsx']
-
-# Batch summarization
-summaries = documents.map do |file|
-  {
-    file: file,
-    summary: UniversalDocumentProcessor.ai_summarize(file, length: :short)
-  }
-end
-
-# Batch classification
-classifications = documents.map do |file|
-  {
-    file: file,
-    classification: UniversalDocumentProcessor.ai_classify(file)
-  }
-end
-```
-
-## 🚨 Error Handling
-
-```ruby
-begin
-  result = UniversalDocumentProcessor.ai_analyze('document.pdf')
-  puts result
-rescue ArgumentError => e
-  puts "Configuration error: #{e.message}"
-  puts "Please check your OpenAI API key"
-rescue UniversalDocumentProcessor::ProcessingError => e
-  puts "Processing error: #{e.message}"
-rescue StandardError => e
-  puts "Unexpected error: #{e.message}"
-end
-```
-
-## 🎛️ Environment Variables
-
-Set these environment variables for seamless operation:
-
-```bash
-# Required
-export OPENAI_API_KEY="your-openai-api-key"
-
-# Optional
-export OPENAI_MODEL="gpt-4"
-export OPENAI_TEMPERATURE="0.7"
-export OPENAI_BASE_URL="https://api.openai.com/v1"
-```
-
-## 🔧 Troubleshooting
-
-### Common Issues and Solutions
-
-1. **Missing API Key**
-   ```ruby
-   # Error: ArgumentError: OpenAI API key is required
-   # Solution: Set OPENAI_API_KEY environment variable or pass api_key in options
-   ```
-
-2. **API Rate Limits**
-   ```ruby
-   # Add delays between requests for large batch operations
-   documents.each_with_index do |doc, index|
-     result = UniversalDocumentProcessor.ai_analyze(doc)
-     sleep(1) if index % 10 == 0  # Pause every 10 requests
-   end
-   ```
-
-3. **Large Documents**
-   ```ruby
-   # For very large documents, consider processing in chunks
-   options = { max_content_length: 10000 }
-   result = UniversalDocumentProcessor.ai_analyze('large_doc.pdf', options)
-   ```
-
-## 📚 Best Practices
-
-1. **Optimize API Usage**
-   - Cache results for repeated analysis
-   - Use appropriate summary lengths
-   - Batch similar operations
-
-2. **Security**
-   - Store API keys securely
-   - Don't log sensitive document content
-   - Use environment variables for configuration
-
-3. **Performance**
-   - Process documents in parallel when possible
-   - Use specific queries rather than general analysis
-   - Consider document size when choosing AI operations
-
-## 🎯 Next Steps
-
-1. **Explore Advanced Features**: Try different AI models and temperature settings
-2. **Integrate with Your Application**: Build AI-powered document workflows
-3. **Customize for Your Domain**: Create domain-specific extraction categories
-4. **Scale Your Usage**: Implement batch processing for large document sets
-
-## 📞 Support
-
-For issues with AI functionality:
-1. Check your OpenAI API key and credits
-2. Verify document format compatibility
-3. Review error messages for specific guidance
-4. Consult the main gem documentation for additional features
-
----
-
-*This guide covers the AI capabilities of the Universal Document Processor gem. The AI features require an OpenAI API key and internet connection to function.* 

data/GEM_RELEASE_GUIDE.md

@@ -1,288 +0,0 @@
-# 🚀 Universal Document Processor - Gem Release Guide
-
-## Overview
-
-This guide will walk you through the complete process of releasing your Universal Document Processor gem through GitHub and publishing it to RubyGems.
-
-## 📋 Prerequisites
-
-1. **GitHub Account**: Make sure you have a GitHub account
-2. **RubyGems Account**: Create an account at [rubygems.org](https://rubygems.org)
-3. **Git**: Ensure Git is installed and configured
-4. **Ruby**: Ruby 2.7+ installed
-5. **Bundler**: Latest version of Bundler
-
-## 🛠️ Step-by-Step Release Process
-
-### Step 1: Prepare Your Local Repository
-
-```bash
-# Navigate to your gem directory
-cd universal_document_processor
-
-# Check current status
-git status
-
-# Add all files to git
-git add .
-
-# Commit your changes
-git commit -m "Initial gem setup with AI features"
-
-# Check your remote origin (should point to GitHub)
-git remote -v
-```
-
-### Step 2: Create GitHub Repository
-
-1. **Go to GitHub**: Visit [github.com](https://github.com)
-2. **Create New Repository**:
-   - Repository name: `universal_document_processor`
-   - Description: "Universal document processor with AI capabilities for all file formats"
-   - Make it **Public** (required for gem publishing)
-   - Don't initialize with README (you already have one)
-
-3. **Add GitHub as remote origin**:
-```bash
-# Replace YOUR_USERNAME with your actual GitHub username
-git remote add origin https://github.com/YOUR_USERNAME/universal_document_processor.git
-
-# Or if you already have origin set, update it:
-git remote set-url origin https://github.com/YOUR_USERNAME/universal_document_processor.git
-```
-
-### Step 3: Push to GitHub
-
-```bash
-# Push to GitHub
-git branch -M main
-git push -u origin main
-```
-
-### Step 4: Set Up RubyGems Account
-
-1. **Create RubyGems Account**: Visit [rubygems.org](https://rubygems.org) and sign up
-2. **Get API Key**: 
-   - Go to your profile → "Edit Profile" → "API Keys"
-   - Create a new API key with appropriate permissions
-3. **Configure local gem credentials**:
-```bash
-# This will prompt for your RubyGems.org credentials
-gem push --help
-```
-
-### Step 5: Build and Test Your Gem Locally
-
-```bash
-# Install dependencies
-bundle install
-
-# Build the gem
-gem build universal_document_processor.gemspec
-
-# Test installation locally
-gem install ./universal_document_processor-1.0.0.gem
-
-# Test that it works
-ruby -e "require 'universal_document_processor'; puts 'Gem loaded successfully!'"
-```
-
-### Step 6: Publish to RubyGems
-
-```bash
-# Push the gem to RubyGems
-gem push universal_document_processor-1.0.0.gem
-```
-
-If successful, you'll see:
-```
-Pushing gem to https://rubygems.org...
-Successfully registered gem: universal_document_processor (1.0.0)
-```
-
-### Step 7: Create GitHub Release
-
-1. **Go to your GitHub repository**
-2. **Click "Releases"** → **"Create a new release"**
-3. **Fill in the details**:
-   - **Tag version**: `v1.0.0`
-   - **Release title**: `Universal Document Processor v1.0.0`
-   - **Description**: Copy from your CHANGELOG.md
-4. **Publish release**
-
-### Step 8: Update Repository Links
-
-Update your gemspec file with the correct GitHub URLs:
-
-```ruby
-# In universal_document_processor.gemspec
-spec.homepage = "https://github.com/YOUR_USERNAME/universal_document_processor"
-spec.metadata = {
-  "homepage_uri"      => "https://github.com/YOUR_USERNAME/universal_document_processor",
-  "source_code_uri"   => "https://github.com/YOUR_USERNAME/universal_document_processor",
-  "bug_tracker_uri"   => "https://github.com/YOUR_USERNAME/universal_document_processor/issues",
-  # ... other metadata
-}
-```
-
-## 🔄 Future Updates and Versioning
-
-### Semantic Versioning
-
-Follow [Semantic Versioning](https://semver.org/):
-- **MAJOR** (1.0.0 → 2.0.0): Breaking changes
-- **MINOR** (1.0.0 → 1.1.0): New features, backward compatible
-- **PATCH** (1.0.0 → 1.0.1): Bug fixes, backward compatible
-
-### Release Process for Updates
-
-1. **Update version** in `lib/universal_document_processor/version.rb`:
-```ruby
-module UniversalDocumentProcessor
-  VERSION = "1.1.0"
-end
-```
-
-2. **Update CHANGELOG.md** with new changes
-
-3. **Commit and tag**:
-```bash
-git add .
-git commit -m "Release v1.1.0"
-git tag v1.1.0
-git push origin main --tags
-```
-
-4. **Build and publish**:
-```bash
-gem build universal_document_processor.gemspec
-gem push universal_document_processor-1.1.0.gem
-```
-
-5. **Create GitHub Release** for the new version
-
-## 🛡️ Security Best Practices
-
-### 1. Enable MFA on RubyGems
-```bash
-# Enable two-factor authentication
-gem owner --add your@email.com --otp 123456
-```
-
-### 2. Secure API Keys
-- Never commit API keys to the repository
-- Use environment variables for sensitive data
-- Add `.env` files to `.gitignore`
-
-### 3. Gem Signing (Optional but Recommended)
-```bash
-# Create a self-signed certificate
-gem cert --build your@email.com
-
-# Sign your gem
-gem build universal_document_processor.gemspec --sign
-```
-
-## 📊 GitHub Actions for Automated Testing (Optional)
-
-Create `.github/workflows/ci.yml`:
-
-```yaml
-name: CI
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        ruby-version: ['2.7', '3.0', '3.1', '3.2']
-
-    steps:
-    - uses: actions/checkout@v3
-    
-    - name: Set up Ruby
-      uses: ruby/setup-ruby@v1
-      with:
-        ruby-version: ${{ matrix.ruby-version }}
-        bundler-cache: true
-    
-    - name: Run tests
-      run: bundle exec rspec
-    
-    - name: Run rubocop
-      run: bundle exec rubocop
-```
-
-## 🎯 Post-Release Checklist
-
-- [ ] Gem is available on [rubygems.org](https://rubygems.org)
-- [ ] GitHub repository is public and accessible
-- [ ] README.md is comprehensive and up-to-date
-- [ ] CHANGELOG.md reflects all changes
-- [ ] License file is present
-- [ ] GitHub release is created with proper tags
-- [ ] Links in gemspec point to correct repositories
-- [ ] Documentation is clear for users
-
-## 📈 Promotion and Marketing
-
-### 1. Announce Your Gem
-- Write a blog post about your gem
-- Share on social media (Twitter, LinkedIn)
-- Post in Ruby communities and forums
-- Submit to Ruby newsletter curators
-
-### 2. Documentation
-- Create detailed documentation using YARD
-- Add code examples and tutorials
-- Create video demonstrations
-
-### 3. Community Engagement
-- Respond to issues and pull requests promptly
-- Maintain active development
-- Gather user feedback and iterate
-
-## 🆘 Troubleshooting
-
-### Common Issues
-
-1. **"Permission denied" when pushing to RubyGems**
-   - Check your API credentials
-   - Ensure you have push permissions
-   - Verify gem name isn't already taken
-
-2. **Git push rejected**
-   - Pull latest changes: `git pull origin main`
-   - Resolve any conflicts
-   - Try push again
-
-3. **Gem build fails**
-   - Check gemspec syntax
-   - Ensure all required files are present
-   - Verify Ruby version compatibility
-
-4. **GitHub repository access issues**
-   - Check repository visibility (should be public)
-   - Verify SSH keys or access tokens
-   - Ensure correct remote URL
-
-## 📞 Support
-
-If you encounter issues during the release process:
-
-1. **Check the logs**: Most tools provide detailed error messages
-2. **GitHub Documentation**: [GitHub Docs](https://docs.github.com)
-3. **RubyGems Guides**: [RubyGems.org Guides](https://guides.rubygems.org)
-4. **Ruby Community**: Stack Overflow, Reddit r/ruby
-
----
-
-**Congratulations! Your gem is now live and available to the Ruby community! 🎉**
-
-Remember to maintain your gem regularly, respond to user feedback, and keep it updated with new features and bug fixes.