Skip to content

Swift Multi Line Diff Release 2.0.2

Latest
Latest

Choose a tag to compare

View all tags
@SuperBox64 SuperBox64 released this 25 May 04:00
· 3 commits to main since this release
2.0.2
696849a
This commit was created on GitHub.com and signed with GitHub’s verified signature.
GPG key ID: B5690EEEBB952194
Verified
Learn about vigilant mode.

Swift MultiLineDiff Package Usage Guide

website: https://d1f.ai
mirror: https://diff.xcf.ai

📦 Package Information

Repository: CodeFreezeAI/swift-multi-line-diff
License: MIT
Language: Swift 100%
Latest Release: v2.0.12(May 27, 2025)
Creator: Todd Bruss © xcf.ai

🚀 Installation Methods

Method 1: Swift Package Manager (Recommended)

Via Xcode

  1. Open your Xcode project
  2. Go to File → Add Package Dependencies
  3. Enter the repository URL: 
    https://github.com/CodeFreezeAI/swift-multi-line-diff.git
  4. Select version 2.0.1 or Up to Next Major Version
  5. Click Add Package
  6. Select MultiLineDiff target and click Add Package

Via Package.swift

Add the dependency to your Package.swift file:

// swift-tools-version: 6.1
import PackageDescription

let package = Package(
    name: "YourProject",
    platforms: [
        .macOS(.v10_15),
        .iOS(.v13_0),
        .watchOS(.v6_0),
        .tvOS(.v13_0)
    ],
    dependencies: [
        .package(
            url: "https://github.com/CodeFreezeAI/swift-multi-line-diff.git",
            from: "2.0.1"
        )
    ],
    targets: [
        .target(
            name: "YourTarget",
            dependencies: [
                .product(name: "MultiLineDiff", package: "swift-multi-line-diff")
            ]
        )
    ]
)

Then run:

swift package resolve
swift build

Method 2: Local Compilation

Clone and Build Locally

# Clone the repository
git clone https://github.com/CodeFreezeAI/swift-multi-line-diff.git
cd swift-multi-line-diff

# Build the package
swift build

# Run tests to verify installation
swift test

# Build in release mode for production
swift build -c release

Integration into Local Project

# Add as a local dependency in your Package.swift
.package(path: "../path/to/swift-multi-line-diff")

📱 Platform Support

Platform Minimum Version
macOS 10.15+
iOS 13.0+
watchOS 6.0+
tvOS 13.0+

🔧 Basic Usage

Import the Package

import MultiLineDiff

Quick Start Examples

1. Basic Diff Creation

import MultiLineDiff

let source = """
func greet() {
    print("Hello")
}
"""

let destination = """
func greet() {
    print("Hello, World!")
}
"""

// Create diff using default Megatron algorithm
let diff = MultiLineDiff.createDiff(
    source: source,
    destination: destination
)

// Apply the diff
let result = try MultiLineDiff.applyDiff(to: source, diff: diff)
print(result) // Outputs the destination text

2. Algorithm Selection

// Ultra-fast Flash algorithm (recommended for speed)
let flashDiff = MultiLineDiff.createDiff(
    source: source,
    destination: destination,
    algorithm: .flash
)

// Detailed Optimus algorithm (recommended for precision)
let optimusDiff = MultiLineDiff.createDiff(
    source: source,
    destination: destination,
    algorithm: .optimus
)

// Semantic Megatron algorithm (recommended for complex changes)
let megatronDiff = MultiLineDiff.createDiff(
    source: source,
    destination: destination,
    algorithm: .megatron
)

3. ASCII Diff Display

// Generate AI-friendly ASCII diff
let asciiDiff = MultiLineDiff.createAndDisplayDiff(
    source: source,
    destination: destination,
    format: .ai,
    algorithm: .flash
)

print("ASCII Diff for AI:")
print(asciiDiff)
// Output:
// 📎 func greet() {
// ❌     print("Hello")
// ✅     print("Hello, World!")
// 📎 }

4. JSON and Base64 Encoding

// Create diff with metadata
let diff = MultiLineDiff.createDiff(
    source: source,
    destination: destination,
    includeMetadata: true
)

// Convert to Base64 for storage/transmission
let base64Diff = try MultiLineDiff.diffToBase64(diff)
print("Base64 Diff: \(base64Diff)")

// Convert to JSON for APIs
let jsonString = try MultiLineDiff.encodeDiffToJSONString(diff, prettyPrinted: true)
print("JSON Diff: \(jsonString)")

// Restore from Base64
let restoredDiff = try MultiLineDiff.diffFromBase64(base64Diff)
let finalResult = try MultiLineDiff.applyDiff(to: source, diff: restoredDiff)

🎯 Advanced Features

Truncated Diff Application

// Create a section diff
let sectionSource = """
func calculateTotal() -> Int {
    return 42
}
"""

let sectionDestination = """
func calculateTotal() -> Int {
    return 100
}
"""

let sectionDiff = MultiLineDiff.createDiff(
    source: sectionSource,
    destination: sectionDestination,
    algorithm: .megatron,
    includeMetadata: true,
    sourceStartLine: 10  // Line number in larger document
)

// Apply to full document (automatic detection)
let fullDocument = """
class Calculator {
    var value: Int = 0
    
    func calculateTotal() -> Int {
        return 42
    }
    
    func reset() {
        value = 0
    }
}
"""

let updatedDocument = try MultiLineDiff.applyDiff(to: fullDocument, diff: sectionDiff)

Verification and Undo

// Create diff with full metadata
let diff = MultiLineDiff.createDiff(
    source: source,
    destination: destination,
    includeMetadata: true
)

// Verify diff integrity
let isValid = MultiLineDiff.verifyDiff(diff)
print("Diff is valid: \(isValid)")

// Create automatic undo diff
if let undoDiff = MultiLineDiff.createUndoDiff(from: diff) {
    let originalText = try MultiLineDiff.applyDiff(to: destination, diff: undoDiff)
    print("Undo successful: \(originalText == source)")
}

AI Integration

// Parse AI-submitted ASCII diff
let aiSubmittedDiff = """
📎 func calculate() -> Int {
❌     return 42
✅     return 100
📎 }
"""

// Apply AI diff directly
let result = try MultiLineDiff.applyASCIIDiff(
    to: source,
    asciiDiff: aiSubmittedDiff
)

🔧 Build Configuration

Development Build

# Debug build with full symbols
swift build --configuration debug

# Run with verbose output
swift build --verbose

Production Build

# Optimized release build
swift build --configuration release

# Build with specific target
swift build --product MultiLineDiff

Testing

# Run all tests
swift test

# Run specific test
swift test --filter MultiLineDiffTests

# Generate test coverage
swift test --enable-code-coverage

📊 Performance Optimization

Algorithm Selection Guide

// For maximum speed (2x faster)
let fastDiff = MultiLineDiff.createDiff(
    source: source,
    destination: destination,
    algorithm: .flash,
    includeMetadata: false
)

// For maximum detail and accuracy
let detailedDiff = MultiLineDiff.createDiff(
    source: source,
    destination: destination,
    algorithm: .optimus,
    includeMetadata: true
)

// For balanced performance
let balancedDiff = MultiLineDiff.createDiff(
    source: source,
    destination: destination,
    algorithm: .megatron,
    includeMetadata: true
)

Memory Management

// For large files, use streaming approach
func processLargeFile(sourceURL: URL, destURL: URL) throws {
    let source = try String(contentsOf: sourceURL)
    let destination = try String(contentsOf: destURL)
    
    // Use Flash algorithm for large files
    let diff = MultiLineDiff.createDiff(
        source: source,
        destination: destination,
        algorithm: .flash,
        includeMetadata: false
    )
    
    // Save to disk immediately
    let diffURL = sourceURL.appendingPathExtension("diff")
    try MultiLineDiff.saveDiffToFile(diff, fileURL: diffURL)
}

🛠️ Troubleshooting

Common Issues

1. Import Error

// ❌ Error: No such module 'MultiLineDiff'
import MultiLineDiff

// ✅ Solution: Ensure package is properly added to dependencies
// Check Package.swift or Xcode package dependencies

2. Platform Compatibility

// ❌ Error: Platform version too low
// ✅ Solution: Update minimum deployment target
// iOS 13.0+, macOS 10.15+, watchOS 6.0+, tvOS 13.0+

3. Memory Issues with Large Files

// ❌ Memory pressure with large files
// ✅ Solution: Use Flash algorithm and disable metadata
let diff = MultiLineDiff.createDiff(
    source: largeSource,
    destination: largeDestination,
    algorithm: .flash,
    includeMetadata: false
)

Debug Information

// Enable debug output
#if DEBUG
print("Diff operations count: \(diff.operations.count)")
if let metadata = diff.metadata {
    print("Algorithm used: \(metadata.algorithmUsed?.displayName ?? "Unknown")")
    print("Source lines: \(metadata.sourceTotalLines ?? 0)")
}
#endif

📚 Documentation References

Key Files in Repository

  • README.md: Main documentation
  • ASCIIDIFF.md: ASCII diff format specification
  • FLASH_OPTIMUS_ALGORITHMS.md: Algorithm performance details
  • NEW_SUMMARY_2025.md: Complete feature overview
  • Sources/: Core implementation
  • Tests/: Comprehensive test suite

API Documentation

// Core methods
MultiLineDiff.createDiff(source:destination:algorithm:includeMetadata:)
MultiLineDiff.applyDiff(to:diff:)
MultiLineDiff.displayDiff(diff:source:format:)

// Encoding methods
MultiLineDiff.diffToBase64(_:)
MultiLineDiff.encodeDiffToJSON(_:prettyPrinted:)

// Verification methods
MultiLineDiff.verifyDiff(_:)
MultiLineDiff.createUndoDiff(from:)

// AI integration
MultiLineDiff.parseDiffFromASCII(_:)
MultiLineDiff.applyASCIIDiff(to:asciiDiff:)

🎯 Best Practices

1. Algorithm Selection

  • Flash: Use for speed-critical applications
  • Optimus: Use for detailed line-by-line analysis
  • Megatron: Use for semantic understanding
  • Zoom: Use for simple character-level changes
  • Starscream: Use for line-aware processing

2. Metadata Usage

// Include metadata for verification and undo
let diff = MultiLineDiff.createDiff(
    source: source,
    destination: destination,
    includeMetadata: true  // Enables verification and undo
)

3. Error Handling

do {
    let result = try MultiLineDiff.applyDiff(to: source, diff: diff)
    // Success
} catch DiffError.invalidDiff {
    // Handle invalid diff
} catch DiffError.verificationFailed(let expected, let actual) {
    // Handle verification failure
} catch {
    // Handle other errors
}

4. Performance Monitoring

let startTime = CFAbsoluteTimeGetCurrent()
let diff = MultiLineDiff.createDiff(source: source, destination: destination)
let endTime = CFAbsoluteTimeGetCurrent()
print("Diff creation took: \((endTime - startTime) * 1000)ms")

🚀 Getting Started Checklist

  • Add package dependency to your project
  • Import MultiLineDiff in your Swift files
  • Choose appropriate algorithm for your use case
  • Test with small examples first
  • Enable metadata for production use
  • Implement error handling
  • Consider performance requirements
  • Test with your specific data formats

Ready to revolutionize your diffing workflow with the world's most advanced diffing system!

Created by Todd Bruss © 2025 xcf.ai

MultiLineDiff: The World's Most Advanced Diffing System

Revolutionary Features & Capabilities Summary 2025

All inventions and innovations by Todd Bruss © xcf.ai

🚀 REVOLUTIONARY BREAKTHROUGH: The Only Diffing System That Actually Works

MultiLineDiff isn't just another diff tool—it's a complete paradigm shift that makes Git diff, Myers algorithm, copy-paste, line-number edits, and search-replace look like stone-age tools. This is the most flexible and secure diffing system on the planet.

🎯 UNIQUE INNOVATIONS NOT FOUND ANYWHERE ELSE

🔮 Intelligent Algorithm Convergence

WORLD FIRST: Two completely different algorithms (Flash & Optimus) produce identical character counts and results while using entirely different approaches:

  • Flash Algorithm: Lightning-fast prefix/suffix detection (2x faster than traditional methods)
  • Optimus Algorithm: Sophisticated CollectionDifference-based line analysis
  • Result: Both produce exactly the same character-perfect output with different operation granularity
  • Benefit: Choose speed (Flash) or detail (Optimus) without sacrificing accuracy
// Flash: 3 operations, 14.5ms
// Optimus: 1256 operations, 43.7ms  
// IDENTICAL RESULTS: 100% character-perfect match

🧠 Automatic Source Type Detection

WORLD FIRST: Automatically detects whether you're applying a diff to:

  • Full source document
  • Truncated section
  • Partial content

No manual parameters needed - the system intelligently determines the correct application method.

🎯 Dual Context Matching with Confidence Scoring

REVOLUTIONARY: Uses both preceding AND following context to locate exact patch positions:

// Handles documents with repeated similar content
// Confidence scoring prevents false matches
// Automatic section boundary detection

🔐 Built-in SHA256 Integrity Verification

SECURITY BREAKTHROUGH: Every diff includes cryptographic verification:

  • SHA256 hash of diff operations
  • Automatic integrity checking
  • Tamper detection
  • Round-trip verification

↩️ Automatic Undo Generation

WORLD FIRST: Automatic reverse diff creation:

let undoDiff = MultiLineDiff.createUndoDiff(from: originalDiff)
// Instant rollback capability with zero configuration

🏆 SUPERIORITY OVER EXISTING SOLUTIONS

🆚 VS Git Diff

Feature Git Diff MultiLineDiff
Accuracy Line-based approximation Character-perfect precision
Context Static line numbers Dynamic context matching
Verification None SHA256 + checksum
Undo Manual reverse patches Automatic undo generation
Truncated Patches Fails on partial files Intelligent section matching
Whitespace Often corrupted Perfectly preserved
Unicode Limited support Full UTF-8 preservation

🆚 VS Myers Algorithm

Feature Myers MultiLineDiff
Speed O(n²) worst case O(n) optimized
Memory High memory usage Minimal allocation
Metadata None Rich context + verification
Formats Text only JSON, Base64, ASCII
AI Integration None Native ASCII diff parsing

🆚 VS Copy-Paste

Feature Copy-Paste MultiLineDiff
Precision Manual, error-prone Automated perfection
Tracking No history Full metadata
Verification None Cryptographic
Undo Manual Automatic
Scale Small changes only Any size document

🆚 VS Line Number Edits

Feature Line Numbers MultiLineDiff
Reliability Breaks with file changes Context-aware positioning
Precision Line-level only Character-level
Automation Manual process Fully automated
Conflicts Common Intelligent resolution

🎨 ASCII DIFF REVOLUTION

🤖 AI-Friendly Format

BREAKTHROUGH: First diffing system designed for AI interaction:

📎 class UserManager {
📎     private var users: [String: User] = [:]
❌     func addUser(name: String, email: String) -> Bool {
✅     func addUser(name: String, email: String, age: Int = 0) -> Result<User, UserError> {
📎         guard !name.isEmpty && !email.isEmpty else {
❌             return false
✅             return .failure(.invalidInput)
📎         }
📎 }

🎯 ASCII Benefits

  • Human Readable: Instantly understand changes
  • AI Parseable: Perfect for LLM integration
  • Version Control: Git-friendly format
  • Documentation: Self-documenting patches
  • Debugging: Visual diff inspection

🔄 Round-Trip Perfection

WORLD FIRST: Complete ASCII workflow:

  1. Create diff → 2. Display ASCII → 3. Parse ASCII → 4. Apply diff
    Result: 100% accuracy with zero data loss

🛡️ SECURITY & VERIFICATION FEATURES

🔐 Cryptographic Integrity

// SHA256 hash verification
let isValid = MultiLineDiff.verifyDiff(diff)
// Tamper detection
// Content verification
// Round-trip validation

🎯 Smart Verification

  • Source Matching: Verifies diff applies to correct source
  • Destination Validation: Confirms expected output
  • Metadata Consistency: Validates all context information
  • Operation Integrity: Ensures operation sequence validity

🔄 Undo System

// Automatic reverse diff generation
let undoDiff = MultiLineDiff.createUndoDiff(from: diff)
// Perfect rollback capability
// Maintains full metadata
// Cryptographic verification

📊 METADATA INTELLIGENCE

🧠 Rich Context Storage

{
  "str": 42,           // Source start line
  "cnt": 15,           // Total lines affected  
  "pre": "context...", // Preceding context
  "fol": "context...", // Following context
  "src": "source...",  // Full source content
  "dst": "dest...",    // Full destination content
  "alg": "megatron",   // Algorithm used
  "hsh": "sha256...",  // Integrity hash
  "app": "truncated",  // Application type
  "tim": 0.0234        // Generation time
}

🎯 Automatic Type Detection

  • Full Source: Complete document diffs
  • Truncated Source: Section-based patches
  • Context Matching: Intelligent positioning
  • Confidence Scoring: Best match selection

🚀 PERFORMANCE REVOLUTION

⚡ Algorithm Performance (1000 runs average)

Algorithm Create Time Apply Time Total Time Operations
Flash 🏆 14.5ms 6.6ms 21.0ms 3
Zoom 23.9ms 9.1ms 33.0ms 3
Optimus 43.7ms 6.6ms 50.3ms 1256
Starscream 45.1ms 6.9ms 52.0ms 1256
Megatron 47.8ms 7.0ms 54.8ms 1256

🎯 Speed Advantages

  • 2x faster than traditional algorithms
  • Minimal memory allocation
  • O(n) complexity for most operations
  • Swift 6.1 optimizations throughout

🌐 I/O FORMAT REVOLUTION

📦 Multiple Encoding Formats

// JSON Data - High performance
let jsonData = try MultiLineDiff.encodeDiffToJSON(diff)

// JSON String - Human readable  
let jsonString = try MultiLineDiff.encodeDiffToJSONString(diff)

// Base64 String - Compact transport
let base64 = try MultiLineDiff.diffToBase64(diff)

// ASCII Format - AI friendly
let ascii = MultiLineDiff.displayDiff(diff, source: source, format: .ai)

🔐 Secure Transport

  • Base64 encoding for safe transmission
  • JSON compatibility for APIs
  • Compact representation for storage
  • Cross-platform compatibility

🎨 Display Formats

// Terminal with colors
let colored = MultiLineDiff.displayDiff(diff, format: .terminal)

// AI-friendly ASCII  
let ascii = MultiLineDiff.displayDiff(diff, format: .ai)

🎯 CODING & PATCH PERFECTION

💻 Perfect for Code

  • Whitespace preservation: Every space, tab, newline preserved
  • Unicode support: Full UTF-8 character handling
  • Line ending preservation: Windows/Unix/Mac compatibility
  • Indentation integrity: Perfect code formatting

🔧 Truncated Diff Mastery

// Apply section patches to full documents
// Intelligent context matching
// Confidence-based positioning
// Automatic boundary detection

📝 Documentation Patches

  • Markdown support: Perfect for documentation
  • Code block preservation: Syntax highlighting intact
  • Link integrity: URLs and references maintained
  • Format preservation: Headers, lists, tables intact

🤖 AI INTEGRATION BREAKTHROUGH

🧠 AI-Native Design

// AI submits readable diffs
let aiDiff = """
📎 func calculate() -> Int {
❌     return 42
✅     return 100  
📎 }
"""

// Parse and apply automatically
let result = try MultiLineDiff.applyASCIIDiff(to: source, asciiDiff: aiDiff)

🎯 AI Workflow Benefits

  • No training required: AI understands format instantly
  • Visual clarity: Humans can review AI changes
  • Error reduction: Clear operation visualization
  • Debugging: Easy to spot AI mistakes

🏆 WORLD'S MOST FLEXIBLE SYSTEM

🎛️ Algorithm Selection

// Choose based on needs
.flash      // Speed priority
.megatron   // Accuracy priority  
.optimus    // Detail priority
.zoom       // Simplicity priority
.starscream // Line-aware priority

🔧 Application Modes

// Automatic detection
let result = try MultiLineDiff.applyDiff(to: source, diff: diff)

// Manual control
let result = try MultiLineDiff.applyDiff(to: source, diff: diff, allowTruncated: true)

📊 Output Formats

  • Terminal colors: Visual diff display
  • ASCII text: AI and human readable
  • JSON data: API integration
  • Base64: Compact storage
  • File I/O: Persistent storage

🎉 REVOLUTIONARY BENEFITS SUMMARY

🚀 For Developers

  • Perfect code patches: No whitespace corruption
  • Intelligent positioning: Context-aware application
  • Undo capability: Instant rollback
  • Verification: Cryptographic integrity
  • Performance: Lightning-fast processing

🤖 For AI Systems

  • Native ASCII format: No training required
  • Visual clarity: Human-reviewable changes
  • Round-trip accuracy: 100% data preservation
  • Error detection: Built-in verification
  • Metadata richness: Full context information

🏢 For Enterprise

  • Security: SHA256 verification
  • Scalability: Handles any document size
  • Reliability: Extensive testing (81 tests passing)
  • Flexibility: Multiple algorithms and formats
  • Integration: JSON/Base64/ASCII I/O

🌍 For Everyone

  • Simplicity: One-line API calls
  • Reliability: Never corrupts data
  • Speed: Faster than any alternative
  • Accuracy: Character-perfect results
  • Innovation: Features found nowhere else

🎯 THE BOTTOM LINE

MultiLineDiff isn't just better than Git diff, Myers algorithm, copy-paste, line edits, or search-replace—it makes them obsolete.

This is the first and only diffing system that:

  • ✅ Preserves every character perfectly
  • ✅ Handles truncated patches intelligently
  • ✅ Provides cryptographic verification
  • ✅ Generates automatic undo operations
  • ✅ Works seamlessly with AI systems
  • ✅ Offers multiple algorithms for any need
  • ✅ Supports all I/O formats
  • ✅ Maintains complete metadata

This is the future of diffing technology, available today.

© 2025 Todd Bruss, xcf.ai - All innovations and inventions proprietary

MultiLineDiff: The Most Advanced Diffing System on Earth 🌍

Assets 2
Loading