LLM URL-forkorting

import base64
import urllib.parse
import requests

def shorten_url_llm(url):
    """
    Create a predictable shortened URL using Base64 encoding
    Compatible with ZAGL LLM functionality
    """
    # Validate URL
    if len(url) > 4096:
        raise ValueError("URL exceeds 4KB limit")
    
    # Encode to Base64
    encoded_bytes = base64.b64encode(url.encode('utf-8'))
    encoded_str = encoded_bytes.decode('utf-8')
    
    # Remove padding for cleaner URLs
    clean_encoded = encoded_str.rstrip('=')
    
    # Generate short URL
    short_url = f"https://yourdomain.com/e/{clean_encoded}"
    
    return {
        "short_url": short_url,
        "encoded": clean_encoded,
        "original_url": url
    }

def decode_llm_url(encoded_url):
    """
    Decode a Base64 encoded URL
    """
    # Add padding back if needed
    padding_needed = 4 - (len(encoded_url) % 4)
    if padding_needed != 4:
        encoded_url += '=' * padding_needed
    
    # Decode
    decoded_bytes = base64.b64decode(encoded_url)
    return decoded_bytes.decode('utf-8')

# Example usage
original_url = "https://example.com/very/long/url/path"
result = shorten_url_llm(original_url)
print(f"Short URL: {result['short_url']}")
print(f"Encoded: {result['encoded']}")

// JavaScript/Node.js implementation
function shortenUrlLLM(url) {
    // Validate URL
    if (url.length > 4096) {
        throw new Error("URL exceeds 4KB limit");
    }
    
    // Validate URL format
    try {
        new URL(url);
    } catch {
        throw new Error("Invalid URL format");
    }
    
    // Encode to Base64
    const base64 = Buffer.from(url, 'utf-8').toString('base64');
    
    // Remove padding for cleaner URLs
    const cleanBase64 = base64.replace(/=/g, '');
    
    // Generate short URL
    const shortUrl = `https://yourdomain.com/e/${cleanBase64}`;
    
    return {
        shortUrl,
        encoded: cleanBase64,
        originalUrl: url
    };
}

function decodeLLMUrl(encodedUrl) {
    // Add padding back if needed
    let paddedBase64 = encodedUrl;
    while (paddedBase64.length % 4) {
        paddedBase64 += '=';
    }
    
    // Decode from Base64
    return Buffer.from(paddedBase64, 'base64').toString('utf-8');
}

// Example usage
const originalUrl = "https://example.com/very/long/url/path";
const result = shortenUrlLLM(originalUrl);
console.log(`Short URL: ${result.shortUrl}`);
console.log(`Encoded: ${result.encoded}`);