# MOGU DOCUMENTATION FOR LLM

## SYSTEM OVERVIEW
Mogu is a modern decentralized backup system that combines end-to-end encryption with IPFS storage. The system is designed to provide secure, versioned, and efficient data backups.

## CORE COMPONENTS

1. STORAGE SERVICES
- PINATA: Primary IPFS storage service
  - Requires: pinataJwt, pinataGateway (optional)
  - Handles: file upload, download, pinning
- IPFS-CLIENT: Direct IPFS node connection
  - Requires: url
  - Provides: direct IPFS network access

2. ENCRYPTION
- Algorithm: aes-256-gcm
- Features:
  - End-to-end encryption
  - Optional per-backup encryption
  - Key management

3. BACKUP SYSTEM
- Features:
  - File versioning
  - Incremental backups
  - Smart caching
  - Detailed version comparison

## CONFIGURATION STRUCTURE
```typescript
interface MoguConfig {
  storage: {
    service: 'PINATA' | 'IPFS-CLIENT';
    config: {
      pinataJwt?: string;
      pinataGateway?: string;
      url?: string;
    }
  };
  features: {
    encryption: {
      enabled: boolean;
      algorithm: string;
    };
    useIPFS?: boolean;
  };
  paths?: {
    backup?: string;
    restore?: string;
    storage?: string;
    logs?: string;
  };
  performance?: {
    chunkSize?: number;
    maxConcurrent?: number;
    cacheEnabled?: boolean;
    cacheSize?: number;
  };
}
```

## MAIN OPERATIONS

1. BACKUP
```typescript
mogu.backup(sourcePath: string, options?: BackupOptions): Promise<BackupResult>
// Creates a backup of the specified directory
// Options include encryption settings and metadata
```

2. RESTORE
```typescript
mogu.restore(hash: string, targetPath: string, options?: BackupOptions): Promise<boolean>
// Restores a backup to the specified directory
// Uses the same encryption settings as backup
```

3. COMPARE
```typescript
mogu.compare(hash: string, sourcePath: string): Promise<VersionComparison>
// Compares a backup with local files
// Returns basic comparison info

mogu.compareDetailed(hash: string, sourcePath: string): Promise<DetailedComparison>
// Returns detailed file-by-file comparison
```

4. DELETE
```typescript
mogu.delete(hash: string): Promise<boolean>
// Deletes a backup from storage
// Returns success status
```

## ERROR HANDLING
The system implements comprehensive error handling:
- Storage service errors (connection, authentication)
- Encryption/decryption errors
- File system errors
- Version comparison errors

## USAGE EXAMPLES

1. Basic Backup with Pinata
```typescript
const mogu = new Mogu({
  storage: {
    service: 'PINATA',
    config: {
      pinataJwt: 'your-jwt-token'
    }
  }
});
const backup = await mogu.backup('./data');
```

2. Encrypted Backup
```typescript
const backup = await mogu.backup('./data', {
  encryption: {
    enabled: true,
    key: 'your-encryption-key'
  }
});
```

3. Version Comparison
```typescript
const comparison = await mogu.compareDetailed(backup.hash, './data');
console.log(`Modified files: ${comparison.totalChanges.modified}`);
```

## BEST PRACTICES

1. ENCRYPTION
- Always use strong encryption keys
- Store encryption keys securely
- Enable encryption for sensitive data

2. BACKUP STRATEGY
- Regular backup schedule
- Version comparison before backup
- Proper error handling
- Cache management for large datasets

3. STORAGE
- Monitor IPFS pinning status
- Regular cleanup of unused backups
- Validate restored files

## LIMITATIONS AND CONSIDERATIONS

1. PERFORMANCE
- Large file handling requires adequate memory
- IPFS operations depend on network conditions
- Cache size affects memory usage

2. SECURITY
- Encryption key management is user responsibility
- IPFS content is public (though encrypted)
- Pinata JWT token security

3. COMPATIBILITY
- Node.js environment required
- IPFS network access needed
- File system permissions required 

## LLM INTEGRATION

1. FETCHING DOCUMENTATION
```bash
# Fetch the LLM documentation
curl -L https://raw.githubusercontent.com/scobru/mogu/main/DOCS_LLM.txt

# Using with jq to parse specific sections
curl -L https://raw.githubusercontent.com/scobru/mogu/main/DOCS_LLM.txt | grep -A 10 "## MAIN OPERATIONS"
```

2. LLM PROMPT EXAMPLES
```text
# For configuration help
"Using the Mogu backup system, show me the configuration for encrypted backup with Pinata storage"

# For operation guidance
"How do I compare two versions of a backup in Mogu?"

# For error handling
"What are the best practices for handling encryption errors in Mogu?"
```

3. STRUCTURED QUERIES
The documentation is organized in sections that can be queried independently:
- SYSTEM OVERVIEW: General understanding
- CORE COMPONENTS: Technical details
- CONFIGURATION: Setup instructions
- MAIN OPERATIONS: API usage
- ERROR HANDLING: Troubleshooting
- BEST PRACTICES: Optimization tips

4. API PATTERNS
When working with Mogu through an LLM, follow these patterns:
```typescript
// Pattern 1: Basic initialization
const mogu = new Mogu({
  storage: {
    service: 'PINATA',
    config: {
      pinataJwt: process.env.PINATA_JWT
    }
  }
});

// Pattern 2: Error handling wrapper
try {
  const result = await mogu.operation();
  if (!result) handleError();
} catch (error) {
  handleError(error);
}

// Pattern 3: Version comparison
const comparison = await mogu.compareDetailed(hash, path);
if (comparison.totalChanges.modified > 0) {
  // Handle changes
}
```

5. COMMON LLM TASKS
- Configuration validation
- Error message interpretation
- Best practices application
- Security assessment
- Performance optimization
- Integration patterns