geminize 0.1.1 → 1.1.0

data/.cursor/rules/isolation_rules/visual-maps/van_mode_split/van-qa-validation.md.old

@@ -0,0 +1,363 @@
+# VAN MODE: QA TECHNICAL VALIDATION (Pre-BUILD)
+
+> **TL;DR:** This map details the technical validation process executed *after* CREATIVE mode and *before* BUILD mode, triggered by the `VAN QA` command. It ensures dependencies, configuration, environment, and basic build functionality are sound.
+
+## 🚀 VAN QA MODE ACTIVATION
+
+After completing CREATIVE mode, when the user types "VAN QA", respond:
+
+```
+User: VAN QA
+
+Response: OK VAN QA - Beginning Technical Validation
+Loading QA Validation map...
+```
+
+## 🔄 QA COMMAND PRECEDENCE (QA Override)
+
+QA validation can be called at any point (`QA` command) and takes immediate precedence:
+
+```mermaid
+graph TD
+    UserQA["User Types: QA"] --> HighPriority["⚠️ HIGH PRIORITY COMMAND"]
+    HighPriority --> CurrentTask["Pause Current Task/Process"]
+    CurrentTask --> LoadQA["Load QA Validation Map (This File)"]
+    LoadQA --> RunQA["Execute QA Validation Process"]
+    RunQA --> QAResults{"QA Results"}
+    
+    QAResults -->|"PASS"| ResumeFlow["Resume Prior Process Flow"]
+    QAResults -->|"FAIL"| FixIssues["Fix Identified Issues"]
+    FixIssues --> ReRunQA["Re-run QA Validation"]
+    ReRunQA --> QAResults
+    
+    style UserQA fill:#f8d486,stroke:#e8b84d,color:black
+    style HighPriority fill:#ff0000,stroke:#cc0000,color:white,stroke-width:3px
+    style LoadQA fill:#4da6ff,stroke:#0066cc,color:white
+    style RunQA fill:#4da6ff,stroke:#0066cc,color:white
+    style QAResults fill:#f6546a,stroke:#c30052,color:white
+```
+
+### QA Interruption Rules
+
+1. **Immediate Precedence:** `QA` command interrupts everything.
+2. **Load & Execute:** Load this map (`van-qa-validation.mdc`) and run the full process.
+3. **Remediation Priority:** Fixes take priority over pending mode switches.
+4. **Resume:** On PASS, resume the previous flow.
+
+```
+⚠️ QA OVERRIDE ACTIVATED
+All other processes paused
+QA validation checks now running...
+Any issues found MUST be remediated before continuing with normal process flow
+```
+
+## 🔍 TECHNICAL VALIDATION OVERVIEW
+
+Four-point validation process:
+
+```mermaid
+graph TD
+    VANQA["VAN QA MODE"] --> FourChecks["FOUR-POINT VALIDATION"]
+    
+    FourChecks --> DepCheck["1️⃣ DEPENDENCY VERIFICATION"]
+    DepCheck --> ConfigCheck["2️⃣ CONFIGURATION VALIDATION"]
+    ConfigCheck --> EnvCheck["3️⃣ ENVIRONMENT VALIDATION"]
+    EnvCheck --> MinBuildCheck["4️⃣ MINIMAL BUILD TEST"]
+    
+    MinBuildCheck --> ValidationResults{"All Checks<br>Passed?"}
+    ValidationResults -->|"Yes"| SuccessReport["GENERATE SUCCESS REPORT"]
+    ValidationResults -->|"No"| FailureReport["GENERATE FAILURE REPORT"]
+    
+    SuccessReport --> BUILD_Transition["Trigger BUILD Mode"]
+    FailureReport --> FixIssues["Fix Technical Issues"]
+    FixIssues --> ReValidate["Re-validate (Re-run VAN QA)"]
+    ReValidate --> FourChecks
+    
+    style VANQA fill:#4da6ff,stroke:#0066cc,color:white
+    style FourChecks fill:#f6546a,stroke:#c30052,color:white
+    style ValidationResults fill:#f6546a,stroke:#c30052,color:white
+    style BUILD_Transition fill:#10b981,stroke:#059669,color:white
+    style FixIssues fill:#ff5555,stroke:#dd3333,color:white
+```
+
+## 🔄 INTEGRATION WITH DESIGN DECISIONS
+
+Reads Creative Phase outputs (e.g., `memory-bank/systemPatterns.md`) to inform validation:
+
+```mermaid
+graph TD
+    Start["Read Design Decisions"] --> ReadCreative["Parse Creative Phase<br>Documentation"]
+    ReadCreative --> ExtractTech["Extract Technology<br>Choices"]
+    ExtractTech --> ExtractDeps["Extract Required<br>Dependencies"]
+    ExtractDeps --> BuildValidationPlan["Build Validation<br>Plan"]
+    BuildValidationPlan --> StartValidation["Start Four-Point<br>Validation Process"]
+    
+    style Start fill:#4da6ff,stroke:#0066cc,color:white
+    style ExtractTech fill:#f6546a,stroke:#c30052,color:white
+    style BuildValidationPlan fill:#10b981,stroke:#059669,color:white
+    style StartValidation fill:#f6546a,stroke:#c30052,color:white
+```
+
+### Example Technology Extraction (PowerShell):
+```powershell
+# Example: Extract technology choices from creative phase documentation
+function Extract-TechnologyChoices {
+    $techChoices = @{}
+    # Read from systemPatterns.md
+    if (Test-Path "memory-bank\systemPatterns.md") {
+        $content = Get-Content "memory-bank\systemPatterns.md" -Raw
+        if ($content -match "Framework:\s*(\w+)") { $techChoices["framework"] = $Matches[1] }
+        if ($content -match "UI Library:\s*(\w+)") { $techChoices["ui_library"] = $Matches[1] }
+        if ($content -match "State Management:\s*([^\n]+)") { $techChoices["state_management"] = $Matches[1].Trim() }
+    }
+    return $techChoices
+}
+```
+
+## 🔍 DETAILED QA VALIDATION STEPS & SCRIPTS
+
+### 1️⃣ DEPENDENCY VERIFICATION
+
+```mermaid
+# Mermaid graph for Dependency Verification (as in original file)
+graph TD
+    Start["Dependency Verification"] --> ReadDeps["Read Required Dependencies<br>from Creative Phase"]
+    ReadDeps --> CheckInstalled["Check if Dependencies<br>are Installed"]
+    CheckInstalled --> DepStatus{"All Dependencies<br>Installed?"}
+    DepStatus -->|"Yes"| VerifyVersions["Verify Versions<br>and Compatibility"]
+    DepStatus -->|"No"| InstallMissing["Install Missing<br>Dependencies"]
+    InstallMissing --> VerifyVersions
+    VerifyVersions --> VersionStatus{"Versions<br>Compatible?"}
+    VersionStatus -->|"Yes"| DepSuccess["Dependencies Verified<br>✅ PASS"]
+    VersionStatus -->|"No"| UpgradeVersions["Upgrade/Downgrade<br>as Needed"]
+    UpgradeVersions --> RetryVerify["Retry Verification"]
+    RetryVerify --> VersionStatus
+    style Start fill:#4da6ff; style DepSuccess fill:#10b981; style DepStatus fill:#f6546a; style VersionStatus fill:#f6546a;
+```
+
+#### Example Implementation (PowerShell):
+```powershell
+# Verify-Dependencies function (as in original file)
+function Verify-Dependencies {
+    $requiredDeps = @{ "node" = ">=14.0.0"; "npm" = ">=6.0.0" }
+    $missingDeps = @(); $incompatibleDeps = @()
+    try { $nodeVersion = node -v; if ($nodeVersion -match "v(\d+).*") { if ([int]$Matches[1] -lt 14) { $incompatibleDeps += "node" } } } catch { $missingDeps += "node" }
+    try { $npmVersion = npm -v; if ($npmVersion -match "(\d+).*") { if ([int]$Matches[1] -lt 6) { $incompatibleDeps += "npm" } } } catch { $missingDeps += "npm" }
+    if ($missingDeps.Count -eq 0 -and $incompatibleDeps.Count -eq 0) { Write-Output "✅ Deps OK"; return $true } else { Write-Output "❌ Deps FAIL"; return $false }
+}
+```
+
+#### Example Implementation (Bash):
+```bash
+# verify_dependencies function (as in original file)
+verify_dependencies() {
+    local missing_deps=(); local incompatible_deps=()
+    if command -v node &> /dev/null; then node_version=$(node -v); if [[ $node_version =~ v([0-9]+) ]]; then if (( ${BASH_REMATCH[1]} < 14 )); then incompatible_deps+=("node"); fi; fi; else missing_deps+=("node"); fi
+    if command -v npm &> /dev/null; then npm_version=$(npm -v); if [[ $npm_version =~ ([0-9]+) ]]; then if (( ${BASH_REMATCH[1]} < 6 )); then incompatible_deps+=("npm"); fi; fi; else missing_deps+=("npm"); fi
+    if [ ${#missing_deps[@]} -eq 0 ] && [ ${#incompatible_deps[@]} -eq 0 ]; then echo "✅ Deps OK"; return 0; else echo "❌ Deps FAIL"; return 1; fi
+}
+```
+
+### 2️⃣ CONFIGURATION VALIDATION
+
+```mermaid
+# Mermaid graph for Configuration Validation (as in original file)
+graph TD
+    Start["Configuration Validation"] --> IdentifyConfigs["Identify Files"]
+    IdentifyConfigs --> ReadConfigs["Read Files"]
+    ReadConfigs --> ValidateSyntax["Validate Syntax"]
+    ValidateSyntax --> SyntaxStatus{"Valid?"}
+    SyntaxStatus -->|"Yes"| CheckCompatibility["Check Compatibility"]
+    SyntaxStatus -->|"No"| FixSyntax["Fix Syntax"]
+    FixSyntax --> RetryValidate["Retry"]
+    RetryValidate --> SyntaxStatus
+    CheckCompatibility --> CompatStatus{"Compatible?"}
+    CompatStatus -->|"Yes"| ConfigSuccess["Configs Validated ✅ PASS"]
+    CompatStatus -->|"No"| AdaptConfigs["Adapt Configs"]
+    AdaptConfigs --> RetryCompat["Retry Check"]
+    RetryCompat --> CompatStatus
+    style Start fill:#4da6ff; style ConfigSuccess fill:#10b981; style SyntaxStatus fill:#f6546a; style CompatStatus fill:#f6546a;
+```
+
+#### Example Implementation (PowerShell):
+```powershell
+# Validate-Configurations function (as in original file)
+function Validate-Configurations {
+    $configFiles = @("package.json", "tsconfig.json", "vite.config.js")
+    $invalidConfigs = @(); $incompatibleConfigs = @()
+    foreach ($configFile in $configFiles) {
+        if (Test-Path $configFile) {
+            if ($configFile -match "\.json$") { try { Get-Content $configFile -Raw | ConvertFrom-Json | Out-Null } catch { $invalidConfigs += "$configFile (JSON)"; continue } }
+            if ($configFile -eq "vite.config.js") { $content = Get-Content $configFile -Raw; if ($content -notmatch "react\(\)") { $incompatibleConfigs += "$configFile (React)" } }
+        } else { $invalidConfigs += "$configFile (missing)" }
+    }
+    if ($invalidConfigs.Count -eq 0 -and $incompatibleConfigs.Count -eq 0) { Write-Output "✅ Configs OK"; return $true } else { Write-Output "❌ Configs FAIL"; return $false }
+}
+```
+
+### 3️⃣ ENVIRONMENT VALIDATION
+
+```mermaid
+# Mermaid graph for Environment Validation (as in original file)
+graph TD
+    Start["Environment Validation"] --> CheckEnv["Check Env"]
+    CheckEnv --> VerifyBuildTools["Verify Tools"]
+    VerifyBuildTools --> ToolsStatus{"Available?"}
+    ToolsStatus -->|"Yes"| CheckPerms["Check Permissions"]
+    ToolsStatus -->|"No"| InstallTools["Install Tools"]
+    InstallTools --> RetryTools["Retry"]
+    RetryTools --> ToolsStatus
+    CheckPerms --> PermsStatus{"Sufficient?"}
+    PermsStatus -->|"Yes"| EnvSuccess["Environment Validated ✅ PASS"]
+    PermsStatus -->|"No"| FixPerms["Fix Permissions"]
+    FixPerms --> RetryPerms["Retry Check"]
+    RetryPerms --> PermsStatus
+    style Start fill:#4da6ff; style EnvSuccess fill:#10b981; style ToolsStatus fill:#f6546a; style PermsStatus fill:#f6546a;
+```
+
+#### Example Implementation (PowerShell):
+```powershell
+# Validate-Environment function (as in original file)
+function Validate-Environment {
+    $requiredTools = @(@{Name='git';Cmd='git --version'},@{Name='node';Cmd='node --version'},@{Name='npm';Cmd='npm --version'})
+    $missingTools = @(); $permissionIssues = @()
+    foreach ($tool in $requiredTools) { try { Invoke-Expression $tool.Cmd | Out-Null } catch { $missingTools += $tool.Name } }
+    try { $testFile = ".__perm_test"; New-Item $testFile -ItemType File -Force | Out-Null; Remove-Item $testFile -Force } catch { $permissionIssues += "CWD Write" }
+    try { $L = New-Object Net.Sockets.TcpListener([Net.IPAddress]::Loopback, 3000); $L.Start(); $L.Stop() } catch { $permissionIssues += "Port 3000" }
+    if ($missingTools.Count -eq 0 -and $permissionIssues.Count -eq 0) { Write-Output "✅ Env OK"; return $true } else { Write-Output "❌ Env FAIL"; return $false }
+}
+```
+
+### 4️⃣ MINIMAL BUILD TEST
+
+```mermaid
+# Mermaid graph for Minimal Build Test (as in original file)
+graph TD
+    Start["Minimal Build Test"] --> CreateTest["Create Test Proj"]
+    CreateTest --> BuildTest["Attempt Build"]
+    BuildTest --> BuildStatus{"Success?"}
+    BuildStatus -->|"Yes"| RunTest["Run Basic Test"]
+    BuildStatus -->|"No"| FixBuild["Fix Build Issues"]
+    FixBuild --> RetryBuild["Retry Build"]
+    RetryBuild --> BuildStatus
+    RunTest --> TestStatus{"Passed?"}
+    TestStatus -->|"Yes"| TestSuccess["Build Test ✅ PASS"]
+    TestStatus -->|"No"| FixTest["Fix Test Issues"]
+    FixTest --> RetryTest["Retry Test"]
+    RetryTest --> TestStatus
+    style Start fill:#4da6ff; style TestSuccess fill:#10b981; style BuildStatus fill:#f6546a; style TestStatus fill:#f6546a;
+```
+
+#### Example Implementation (PowerShell):
+```powershell
+# Perform-MinimalBuildTest function (as in original file)
+function Perform-MinimalBuildTest {
+    $buildSuccess = $false; $testSuccess = $false; $testDir = ".__build_test"
+    if (Test-Path $testDir) { Remove-Item $testDir -Recurse -Force }
+    try {
+        New-Item $testDir -ItemType Directory | Out-Null; Push-Location $testDir
+        '{"name": "build-test","scripts": {"build": "echo Build test successful"}}' | Set-Content package.json
+        npm run build | Out-Null; $buildSuccess = $true
+        'console.log("Test successful");' | Set-Content index.js
+        node index.js | Out-Null; $testSuccess = $true
+    } catch { Write-Output "❌ Build test exception" } finally { Pop-Location; if (Test-Path $testDir) { Remove-Item $testDir -Recurse -Force } }
+    if ($buildSuccess -and $testSuccess) { Write-Output "✅ Build Test OK"; return $true } else { Write-Output "❌ Build Test FAIL"; return $false }
+}
+```
+
+## 📝 VALIDATION REPORT FORMATS
+
+### Comprehensive Success Report:
+```
+╔═════════════════════ 🔍 QA VALIDATION REPORT ══════════════════════╗
+│ PROJECT: [Project Name] | TIMESTAMP: [Current Date/Time]            │
+├─────────────────────────────────────────────────────────────────────┤
+│ 1️⃣ DEPENDENCIES: ✓ Compatible                                       │
+│ 2️⃣ CONFIGURATION: ✓ Valid & Compatible                             │
+│ 3️⃣ ENVIRONMENT: ✓ Ready                                             │
+│ 4️⃣ MINIMAL BUILD: ✓ Successful & Passed                            │
+├─────────────────────────────────────────────────────────────────────┤
+│ 🚨 FINAL VERDICT: PASS                                              │
+│ ➡️ Clear to proceed to BUILD mode                                   │
+╚═════════════════════════════════════════════════════════════════════╝
+```
+
+### Detailed Failure Report:
+```
+⚠️⚠️⚠️ QA VALIDATION FAILED ⚠️⚠️⚠️
+Issues must be resolved before BUILD mode:
+
+1️⃣ DEPENDENCY ISSUES: [Details/Fix]
+2️⃣ CONFIGURATION ISSUES: [Details/Fix]
+3️⃣ ENVIRONMENT ISSUES: [Details/Fix]
+4️⃣ BUILD TEST ISSUES: [Details/Fix]
+
+⚠️ BUILD MODE BLOCKED. Type 'VAN QA' after fixing to re-validate.
+```
+
+## 🧪 COMMON QA VALIDATION FIXES
+
+- **Dependencies:** Install Node/npm, run `npm install`, check versions.
+- **Configuration:** Validate JSON, check required plugins (e.g., React for Vite), ensure TSConfig compatibility.
+- **Environment:** Check permissions (Admin/sudo), ensure ports are free, install missing CLI tools (git, etc.).
+- **Build Test:** Check logs for errors, verify minimal config, check path separators.
+
+## 🔒 BUILD MODE PREVENTION MECHANISM
+
+Logic to check QA status before allowing BUILD mode transition.
+
+```mermaid
+graph TD
+    Start["User Types: BUILD"] --> CheckQA{"QA Validation<br>Passed?"}
+    CheckQA -->|"Yes"| AllowBuild["Allow BUILD Mode"]
+    CheckQA -->|"No"| BlockBuild["BLOCK BUILD MODE"]
+    BlockBuild --> Message["Display:<br>⚠️ QA VALIDATION REQUIRED"]
+    Message --> ReturnToVANQA["Prompt: Type VAN QA"]
+    
+    style CheckQA fill:#f6546a; style BlockBuild fill:#ff0000,stroke:#990000; style Message fill:#ff5555; style ReturnToVANQA fill:#4da6ff;
+```
+
+### Example Implementation (PowerShell):
+```powershell
+# Example: Check QA status before allowing BUILD
+function Check-QAValidationStatus {
+    $qaStatusFile = "memory-bank\.qa_validation_status" # Assumes status is written here
+    if (Test-Path $qaStatusFile) {
+        if ((Get-Content $qaStatusFile -Raw) -match "PASS") { return $true }
+    }
+    Write-Output "🚫 BUILD MODE BLOCKED: QA VALIDATION REQUIRED. Type 'VAN QA'. 🚫"
+    return $false
+}
+```
+
+## 🚨 MODE TRANSITION TRIGGERS (Relevant to QA)
+
+### CREATIVE to VAN QA Transition:
+```
+⏭️ NEXT MODE: VAN QA
+To validate technical requirements before implementation, please type 'VAN QA'
+```
+
+### VAN QA to BUILD Transition (On Success):
+```
+✅ TECHNICAL VALIDATION COMPLETE
+All prerequisites verified successfully
+You may now proceed to BUILD mode
+Type 'BUILD' to begin implementation
+```
+
+## 📋 FINAL QA VALIDATION CHECKPOINT
+
+```
+✓ SECTION CHECKPOINT: QA VALIDATION
+- Dependency Verification Passed? [YES/NO]
+- Configuration Validation Passed? [YES/NO]
+- Environment Validation Passed? [YES/NO]
+- Minimal Build Test Passed? [YES/NO]
+
+→ If all YES: Ready for BUILD mode transition.
+→ If any NO: Fix identified issues and re-run VAN QA.
+```
+
+**Next Step (on PASS):** Trigger BUILD mode.
+**Next Step (on FAIL):** Address issues and re-run `VAN QA`. 

data/.env.example

@@ -0,0 +1,7 @@
+# Gemini API Key
+GOOGLE_AI_API_KEY=your_api_key_here
+
+# API Configuration
+GOOGLE_AI_API_VERSION=v1beta
+GEMINI_MODEL=gemini-2.0-flash
+GEMINI_EMBEDDING_MODEL=gemini-embedding-exp-03-07

data/.memory_bank/activeContext.md

@@ -0,0 +1,78 @@
+# Active Context
+
+## Current Focus Areas
+
+### Core Functionality
+
+- Text generation with Gemini models
+- Chat conversation support
+- Multimodal content handling (text + images)
+- Embeddings generation
+- Streaming responses
+
+### Key Implementation Details
+
+#### Text Generation
+
+- Support for all Gemini models
+- System instructions for guiding model behavior
+- Generation parameters (temperature, top_k, top_p)
+- Support for stop sequences
+
+#### Multimodal Support
+
+- Image handling from multiple sources (files, URLs, bytes)
+- MIME type detection and validation
+- Size limits enforcement
+- Support for JPEG, PNG, GIF, WEBP formats
+
+#### Chat & Conversations
+
+- Conversation state management
+- Message history tracking
+- Context preservation
+- System instructions for chat
+
+#### Embeddings
+
+- Vector generation for semantic text analysis
+- Vector similarity operations
+- Task type optimization
+- Normalization utilities
+
+#### Streaming
+
+- Multiple streaming modes (raw, incremental, delta)
+- Cancellation support
+- Efficient buffer management
+- Error handling for interrupted streams
+
+### API and HTTP Communication
+
+- Robust HTTP client implementation
+- Retry mechanisms for transient errors
+- Timeout handling
+- Response parsing and validation
+
+### Error Handling Strategy
+
+- Comprehensive error class hierarchy
+- Detailed error messages
+- API error translation
+- Validation prior to API calls
+
+## Active Development Areas
+
+### Current Improvements
+
+- Enhanced multimodal support
+- Streaming response optimizations
+- Comprehensive documentation
+- Error handling refinements
+
+### Upcoming Features
+
+- Support for newer Gemini models
+- Advanced parameter tuning
+- Additional vector operations
+- Improved conversation persistence

data/.memory_bank/progress.md

@@ -0,0 +1,80 @@
+# Progress
+
+## Current Status
+
+Geminize is a functional Ruby gem providing a complete interface to the Google Gemini API. The current implementation includes all core features with a focus on stability, documentation, and ease of use.
+
+## Development Progress
+
+### Core Functionality
+
+- **Text Generation**: ✅ Complete
+- **Chat Conversations**: ✅ Complete
+- **Embeddings**: ✅ Complete
+- **Multimodal Support**: ✅ Complete
+- **Streaming Responses**: ✅ Complete
+- **Error Handling**: ✅ Complete
+- **Configuration System**: ✅ Complete
+
+### Documentation
+
+- **README**: ✅ Complete
+- **YARD Documentation**: 🟡 Partially Complete (80%)
+- **Examples**: ✅ Complete
+- **Diagrams**: ❌ Not Started
+
+### Testing
+
+- **Unit Tests**: ✅ Complete
+- **Integration Tests**: 🟡 Partially Complete (70%)
+- **Performance Tests**: ❌ Not Started
+
+### Deployment
+
+- **RubyGems Publishing**: ✅ Complete
+- **CI/CD Pipeline**: 🟡 Partially Complete (50%)
+- **Version Management**: ✅ Complete
+
+## Version History
+
+### v0.1.0 (2025-04-21)
+
+- Initial release
+- Core functionality implemented
+- Basic documentation
+
+### v0.1.1 (2025-05-01)
+
+- Added Rails integration
+- Enhanced multimodal support
+- Additional embedding task types
+- Improved documentation
+
+### v1.0.0 (Planned for 2025-05-02)
+
+- Removed Rails-specific integration
+- Simplified usage
+- API stabilization
+
+## Upcoming Milestones
+
+### v1.1.0 (Planned)
+
+- Support for latest Gemini models
+- Advanced vector operations
+- Improved streaming performance
+- Enhanced documentation
+
+### v1.2.0 (Planned)
+
+- Batch processing capabilities
+- Improved conversation persistence
+- Additional configuration options
+- Memory optimizations
+
+### v2.0.0 (Planned)
+
+- Major API refinements
+- Advanced function calling support
+- Performance improvements
+- Additional middleware options

data/.memory_bank/projectbrief.md

@@ -0,0 +1,29 @@
+# Geminize Project Brief
+
+## Project Overview
+
+Geminize is a Ruby gem providing a convenient and robust interface to Google's Gemini AI API. It enables Ruby developers to easily integrate Google's powerful generative AI models into their applications with a clean, idiomatic API.
+
+## Core Features
+
+- **Text Generation**: Generate text using various Gemini models
+- **Multimodal Support**: Send mixed content including text and images
+- **Conversation Management**: Maintain conversation context for chat applications
+- **Embeddings Generation**: Generate and manipulate vector representations for text
+- **Streaming Responses**: Support for efficient streaming output
+- **Error Handling**: Comprehensive error handling and validation
+
+## Technical Foundation
+
+- Pure Ruby implementation with minimal dependencies
+- Faraday for HTTP client functionality
+- Support for environment-based or programmatic configuration
+- Comprehensive API for both simple and advanced use cases
+
+## Project Goals
+
+- Provide a complete Ruby interface to all Gemini API capabilities
+- Ensure robust error handling and validation
+- Maintain clean, well-documented, and idiomatic Ruby code
+- Support both simple use cases and advanced configurations
+- Enable seamless integration with various Ruby applications

data/.memory_bank/systemPatterns.md

@@ -0,0 +1,90 @@
+# System Patterns
+
+## Design Patterns
+
+### Singleton Pattern
+
+- Used for the `Configuration` class to ensure a single global configuration instance.
+- Implemented using Ruby's `Singleton` module.
+
+### Builder Pattern
+
+- Employed in `RequestBuilder` to construct API requests.
+- Separates request construction from execution.
+
+### Factory Methods
+
+- Used throughout the codebase to instantiate model objects from API responses.
+- Example: `Models::ContentResponse.from_hash(response_data)`
+
+### Repository Pattern
+
+- Implemented in `ConversationRepository` for conversation persistence.
+- Abstracts storage details from the conversation service.
+
+### Adapter Pattern
+
+- Used to adapt various image sources (files, URLs, raw bytes) to a common format.
+
+### Strategy Pattern
+
+- Applied in streaming responses with different processing modes (raw, incremental, delta).
+- Allows clients to choose how streaming data is processed.
+
+## Core Architectural Principles
+
+### Separation of Concerns
+
+- Each class has a single, well-defined responsibility.
+- Examples: `Client` handles HTTP, `TextGeneration` handles generation logic.
+
+### Immutable Objects
+
+- Response objects are designed to be immutable.
+- Request objects are built incrementally but not modified after submission.
+
+### Comprehensive Validation
+
+- Input validation happens before API calls.
+- Extensive parameter checking and error handling.
+
+### Error Handling
+
+- Structured hierarchy of error classes.
+- Detailed error messages with relevant context.
+- Translation of API errors to gem-specific errors.
+
+### Configuration Flexibility
+
+- Multiple configuration approaches (env vars, block config).
+- Sensible defaults with override capabilities.
+
+### Developer Experience
+
+- Method signatures follow Ruby idioms.
+- Clear documentation with usage examples.
+- Consistent return values and error handling.
+
+## Code Organization
+
+### Module Structure
+
+- Everything contained within the `Geminize` namespace.
+- Logical grouping of related functionality.
+
+### Dependency Management
+
+- Minimal external dependencies.
+- Clear version requirements.
+
+### Testing Approach
+
+- RSpec for unit and integration tests.
+- VCR for recording and replaying HTTP interactions.
+- Comprehensive test coverage.
+
+### Documentation
+
+- YARD documentation for all public methods.
+- Usage examples throughout codebase.
+- Clear README with quickstart and detailed examples.