undefined

undefined

android {
    namespace = "com.yourcompany.yourapp"
    compileSdk = 34
    ndkVersion = "25.1.8937393"

    defaultConfig {
        minSdk = 28  // Required for llama_flutter_android
        targetSdk = 34
        ndk {
            abiFilters.add("arm64-v8a")  // 64-bit ARM only
        }
    }

    buildTypes {
        release {
            isMinifyEnabled = true
            isShrinkResources = true
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }
}

platform :ios, '12.0'

target 'Runner' do
  use_frameworks!
  use_modular_headers!
  
  # Ensure Metal framework for GPU acceleration
  pod 'MetalKit'
end

// lib/main.dart
import 'package:flutter/material.dart';
import 'package:get/get.dart';
import 'package:hive_flutter/hive_flutter.dart';
import 'package:firebase_core/firebase_core.dart';
import 'services/hive_service.dart';
import 'services/device_info_service.dart';
import 'controllers/settings_controller.dart';
import 'controllers/model_controller.dart';
import 'controllers/chat_controller.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  
  // Initialize Firebase
  await Firebase.initializeApp();
  
  // Initialize Hive
  await Hive.initFlutter();
  await HiveService.init();
  
  // Initialize GetX controllers
  Get.put(DeviceInfoService());
  Get.put(SettingsController());
  Get.put(ModelController());
  Get.put(ChatController());
  
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return GetMaterialApp(
      title: 'PrivateLM Chat',
      theme: ThemeData.dark(),
      home: HomeView(),
    );
  }
}

// lib/services/inference_service.dart
import 'package:get/get.dart';
import 'dart:io' show Platform;

class InferenceService extends GetxService {
  static bool get supportsLocalInference {
    if (Platform.isAndroid) return true;
    if (Platform.isIOS) return true;
    return false;  // Web not yet supported
  }

  Future<void> loadModel(String modelPath, {
    required int contextSize,
    required int numThreads,
    required int gpuLayers,
  }) async {
    if (!supportsLocalInference) {
      throw UnsupportedError('Local inference not available on this platform');
    }
    
    // Platform-specific implementation
    if (Platform.isAndroid || Platform.isIOS) {
      await _loadModelNative(modelPath, contextSize, numThreads, gpuLayers);
    }
  }

  Stream<String> generateChat({
    required List<Map<String, String>> messages,
    required String template,
    int maxTokens = 512,
    double temperature = 0.7,
  }) async* {
    // Streaming token generation
    // Implementation calls native llama.cpp bridge
  }
}

// lib/services/cloud_service.dart
import 'package:dio/dio.dart';
import 'package:get/get.dart';

class CloudService extends GetxService {
  final Dio _dio = Dio();

  // OpenAI-compatible endpoint
  Stream<String> generateOpenAI({
    required String apiKey,
    required List<Map<String, dynamic>> messages,
    String model = 'gpt-4',
    int maxTokens = 1024,
    double temperature = 0.7,
  }) async* {
    final response = await _dio.post(
      'https://api.openai.com/v1/chat/completions',
      options: Options(
        headers: {
          'Authorization': 'Bearer $apiKey',
          'Content-Type': 'application/json',
        },
      ),
      data: {
        'model': model,
        'messages': messages,
        'max_tokens': maxTokens,
        'temperature': temperature,
        'stream': true,
      },
    );
    
    // Parse SSE stream
    await for (final chunk in response.data.stream) {
      yield _parseOpenAIChunk(chunk);
    }
  }

  // Anthropic Claude endpoint
  Stream<String> generateClaude({
    required String apiKey,
    required List<Map<String, dynamic>> messages,
    String model = 'claude-3-opus-20240229',
    int maxTokens = 1024,
  }) async* {
    // Extract system message
    String? systemMessage;
    final userMessages = messages.where((m) {
      if (m['role'] == 'system') {
        systemMessage = m['content'];
        return false;
      }
      return true;
    }).toList();

    final response = await _dio.post(
      'https://api.anthropic.com/v1/messages',
      options: Options(
        headers: {
          'x-api-key': apiKey,
          'anthropic-version': '2023-06-01',
          'Content-Type': 'application/json',
        },
      ),
      data: {
        'model': model,
        'max_tokens': maxTokens,
        'messages': userMessages,
        if (systemMessage != null) 'system': systemMessage,
        'stream': true,
      },
    );
    
    await for (final chunk in response.data.stream) {
      yield _parseClaudeChunk(chunk);
    }
  }

  // Google Gemini endpoint
  Stream<String> generateGemini({
    required String apiKey,
    required List<Map<String, dynamic>> messages,
    String model = 'gemini-1.5-pro',
  }) async* {
    final contents = messages.map((m) => {
      'role': m['role'] == 'assistant' ? 'model' : 'user',
      'parts': [{'text': m['content']}],
    }).toList();

    final response = await _dio.post(
      'https://generativelanguage.googleapis.com/v1beta/models/$model:streamGenerateContent?key=$apiKey',
      options: Options(
        headers: {'Content-Type': 'application/json'},
      ),
      data: {'contents': contents},
    );
    
    await for (final chunk in response.data.stream) {
      yield _parseGeminiChunk(chunk);
    }
  }
}

// lib/services/device_info_service.dart
import 'package:device_info_plus/device_info_plus.dart';
import 'package:get/get.dart';
import 'dart:io';

enum DeviceTier { ultra, high, mid, low }

class DeviceInfoService extends GetxService {
  final DeviceInfoPlugin _deviceInfo = DeviceInfoPlugin();
  
  DeviceTier? _tier;
  int? _totalRamMB;
  
  DeviceTier get tier => _tier ?? DeviceTier.mid;
  int get totalRamMB => _totalRamMB ?? 4096;
  
  Future<void> detectDevice() async {
    if (Platform.isAndroid) {
      final androidInfo = await _deviceInfo.androidInfo;
      _totalRamMB = _estimateAndroidRAM(androidInfo);
    } else if (Platform.isIOS) {
      final iosInfo = await _deviceInfo.iosInfo;
      _totalRamMB = _estimateIOSRAM(iosInfo);
    }
    
    _tier = _calculateTier(_totalRamMB!);
  }
  
  DeviceTier _calculateTier(int ramMB) {
    if (ramMB >= 12000) return DeviceTier.ultra;  // 12GB+
    if (ramMB >= 8000) return DeviceTier.high;    // 8-12GB
    if (ramMB >= 6000) return DeviceTier.mid;     // 6-8GB
    return DeviceTier.low;                         // <6GB
  }
  
  Map<String, int> getOptimalSettings() {
    switch (tier) {
      case DeviceTier.ultra:
        return {
          'contextSize': 8192,
          'threads': 8,
          'gpuLayers': 33,
          'batchSize': 512,
        };
      case DeviceTier.high:
        return {
          'contextSize': 4096,
          'threads': 6,
          'gpuLayers': 25,
          'batchSize': 256,
        };
      case DeviceTier.mid:
        return {
          'contextSize': 2048,
          'threads': 4,
          'gpuLayers': 15,
          'batchSize': 128,
        };
      case DeviceTier.low:
        return {
          'contextSize': 1024,
          'threads': 2,
          'gpuLayers': 8,
          'batchSize': 64,
        };
    }
  }
}

// lib/controllers/model_controller.dart
import 'package:get/get.dart';
import 'package:dio/dio.dart';
import 'package:path_provider/path_provider.dart';
import 'dart:io';

class ModelController extends GetxController {
  final RxList<LocalModel> models = <LocalModel>[].obs;
  final RxMap<String, double> downloadProgress = <String, double>{}.obs;
  
  Future<void> downloadModel({
    required String url,
    required String modelName,
    required String fileName,
  }) async {
    final appDir = await getApplicationDocumentsDirectory();
    final modelDir = Directory('${appDir.path}/models');
    if (!await modelDir.exists()) {
      await modelDir.create(recursive: true);
    }
    
    final filePath = '${modelDir.path}/$fileName';
    
    try {
      await Dio().download(
        url,
        filePath,
        onReceiveProgress: (received, total) {
          if (total != -1) {
            final progress = received / total;
            downloadProgress[modelName] = progress;
          }
        },
      );
      
      // Save model metadata
      final model = LocalModel(
        name: modelName,
        path: filePath,
        sizeBytes: File(filePath).lengthSync(),
        downloadDate: DateTime.now(),
      );
      
      models.add(model);
      await _saveModelsToHive();
      
      Get.snackbar('Success', '$modelName downloaded successfully');
    } catch (e) {
      Get.snackbar('Error', 'Failed to download $modelName: $e');
      downloadProgress.remove(modelName);
    }
  }
  
  Future<void> deleteModel(String modelName) async {
    final model = models.firstWhere((m) => m.name == modelName);
    final file = File(model.path);
    
    if (await file.exists()) {
      await file.delete();
    }
    
    models.removeWhere((m) => m.name == modelName);
    await _saveModelsToHive();
  }
}

class LocalModel {
  final String name;
  final String path;
  final int sizeBytes;
  final DateTime downloadDate;
  
  LocalModel({
    required this.name,
    required this.path,
    required this.sizeBytes,
    required this.downloadDate,
  });
}

// lib/controllers/chat_controller.dart
import 'package:get/get.dart';
import '../services/inference_service.dart';
import '../services/cloud_service.dart';
import '../services/hive_service.dart';

class ChatController extends GetxController {
  final InferenceService _inference = Get.find();
  final CloudService _cloud = Get.find();
  final HiveService _hive = Get.find();
  
  final RxList<ChatMessage> messages = <ChatMessage>[].obs;
  final RxBool isGenerating = false.obs;
  final RxString currentProvider = 'local'.obs;  // 'local', 'openai', 'claude', etc.
  
  Future<void> sendMessage(String text, {String? imagePath}) async {
    // Add user message
    final userMsg = ChatMessage(
      role: 'user',
      content: text,
      timestamp: DateTime.now(),
      imagePath: imagePath,
    );
    messages.add(userMsg);
    
    // Create assistant message placeholder
    final assistantMsg = ChatMessage(
      role: 'assistant',
      content: '',
      timestamp: DateTime.now(),
    );
    messages.add(assistantMsg);
    
    isGenerating.value = true;
    
    try {
      if (currentProvider.value == 'local') {
        await _generateLocal(assistantMsg);
      } else {
        await _generateCloud(assistantMsg);
      }
    } catch (e) {
      assistantMsg.content = 'Error: $e';
    } finally {
      isGenerating.value = false;
      await _saveConversation();
    }
  }
  
  Future<void> _generateLocal(ChatMessage assistantMsg) async {
    final chatHistory = messages
        .where((m) => m.role != 'system')
        .map((m) => {
          'role': m.role,
          'content': m.content,
        })
        .toList();
    
    await for (final token in _inference.generateChat(
      messages: chatHistory,
      template: 'chatml',  // or 'llama3', 'gemma', 'phi'
      maxTokens: 512,
      temperature: 0.7,
    )) {
      assistantMsg.content += token;
      messages.refresh();  // Trigger UI update
    }
  }
  
  Future<void> _generateCloud(ChatMessage assistantMsg) async {
    final apiKey = _hive.getApiKey(currentProvider.value);
    if (apiKey == null) {
      throw Exception('API key not configured for ${currentProvider.value}');
    }
    
    final chatHistory = messages
        .where((m) => m != assistantMsg)
        .map((m) => {
          'role': m.role,
          'content': m.content,
        })
        .toList();
    
    Stream<String> stream;
    
    switch (currentProvider.value) {
      case 'openai':
        stream = _cloud.generateOpenAI(
          apiKey: apiKey,
          messages: chatHistory,
          model: 'gpt-4',
        );
        break;
      case 'claude':
        stream = _cloud.generateClaude(
          apiKey: apiKey,
          messages: chatHistory,
          model: 'claude-3-opus-20240229',
        );
        break;
      case 'gemini':
        stream = _cloud.generateGemini(
          apiKey: apiKey,
          messages: chatHistory,
        );
        break;
      default:
        throw Exception('Unknown provider: ${currentProvider.value}');
    }
    
    await for (final token in stream) {
      assistantMsg.content += token;
      messages.refresh();
    }
  }
  
  Future<void> switchProvider(String provider) async {
    currentProvider.value = provider;
    
    // If switching to local, ensure model is loaded
    if (provider == 'local') {
      final modelController = Get.find<ModelController>();
      if (modelController.models.isEmpty) {
        Get.snackbar('Warning', 'No local models available. Download a model first.');
      }
    }
  }
}

class ChatMessage {
  final String role;
  String content;
  final DateTime timestamp;
  final String? imagePath;
  
  ChatMessage({
    required this.role,
    required this.content,
    required this.timestamp,
    this.imagePath,
  });
}

// lib/services/vision_service.dart
import 'dart:convert';
import 'dart:io';
import 'package:get/get.dart';

class VisionService extends GetxService {
  // For local models (Qwen2-VL)
  Future<String> processImageLocal(String imagePath, String prompt) async {
    final bytes = await File(imagePath).readAsBytes();
    final base64Image = base64Encode(bytes);
    
    final inference = Get.find<InferenceService>();
    
    final messages = [
      {
        'role': 'user',
        'content': [
          {'type': 'image', 'data': base64Image},
          {'type': 'text', 'text': prompt},
        ],
      },
    ];
    
    String response = '';
    await for (final token in inference.generateChat(
      messages: messages,
      template: 'qwen2vl',
    )) {
      response += token;
    }
    
    return response;
  }
  
  // For cloud providers (OpenAI GPT-4V, Gemini)
  Future<String> processImageCloud({
    required String provider,
    required String apiKey,
    required String imagePath,
    required String prompt,
  }) async {
    final bytes = await File(imagePath).readAsBytes();
    final base64Image = base64Encode(bytes);
    
    final cloud = Get.find<CloudService>();
    
    if (provider == 'openai') {
      final messages = [
        {
          'role': 'user',
          'content': [
            {'type': 'text', 'text': prompt},
            {
              'type': 'image_url',
              'image_url': {
                'url': 'data:image/jpeg;base64,$base64Image',
              },
            },
          ],
        },
      ];
      
      String response = '';
      await for (final token in cloud.generateOpenAI(
        apiKey: apiKey,
        messages: messages,
        model: 'gpt-4-vision-preview',
      )) {
        response += token;
      }
      return response;
    } else if (provider == 'gemini') {
      // Gemini handles images inline
      final messages = [
        {
          'role': 'user',
          'content': prompt,
          'image': base64Image,
        },
      ];
      
      String response = '';
      await for (final token in cloud.generateGemini(
        apiKey: apiKey,
        messages: messages,
      )) {
        response += token;
      }
      return response;
    }
    
    throw Exception('Vision not supported for provider: $provider');
  }
}