Gemini CLI en Xcode

import Foundation
import ArgumentParser
import GoogleGenerativeAI

@main
struct GeminiTool: AsyncParsableCommand {
    
    // Configuración de la herramienta
    static var configuration = CommandConfiguration(
        commandName: "gemini",
        abstract: "Una herramienta CLI para interactuar con Google Gemini en Swift."
    )
    
    // Argumento de entrada: El prompt
    @Argument(help: "El texto que quieres enviar a la IA.")
    var prompt: String
    
    // Flag opcional para ser creativo
    @Flag(name: .shortAndLong, help: "Activa el modo creativo.")
    var creative: Bool = false
    
    func run() async throws {
        // 1. Configuración de seguridad (NUNCA hardcodear API Keys en producción real)
        // Lo ideal es leerla de una variable de entorno
        guard let apiKey = ProcessInfo.processInfo.environment["GEMINI_API_KEY"] else {
            print("Error: Por favor configura la variable de entorno GEMINI_API_KEY.")
            return
        }
        
        // 2. Inicialización del modelo
        let model = GenerativeModel(name: "gemini-pro", apiKey: apiKey)
        
        print("🤖 Consultando a Gemini...")
        
        do {
            // 3. Generación de contenido
            let response = try await model.generateContent(prompt)
            
            if let text = response.text {
                print("\n--- RESPUESTA ---\n")
                print(text)
                print("\n-----------------\n")
            } else {
                print("Gemini no devolvió texto.")
            }
        } catch {
            print("Error: \(error.localizedDescription)")
        }
    }
}

export GEMINI_API_KEY="tu_api_key_aqui"
./GeminiCLI "Escribe un poema sobre la programación Swift"

import Foundation
import GoogleGenerativeAI

enum GeminiError: Error {
    case noAPIKey
    case networkError(String)
}

actor GeminiService {
    private var model: GenerativeModel?
    
    init() {
        // En una app real, usa un archivo .plist seguro o Keychain
        if let path = Bundle.main.path(forResource: "GenerativeAI-Info", ofType: "plist"),
           let plist = NSDictionary(contentsOfFile: path),
           let key = plist["API_KEY"] as? String {
            self.model = GenerativeModel(name: "gemini-pro", apiKey: key)
        }
    }
    
    func sendMessage(_ text: String) async throws -> String {
        guard let model = model else { throw GeminiError.noAPIKey }
        
        do {
            let response = try await model.generateContent(text)
            return response.text ?? "Sin respuesta"
        } catch {
            throw GeminiError.networkError(error.localizedDescription)
        }
    }
    
    // Función para Streaming (Efecto máquina de escribir)
    func sendMessageStream(_ text: String) -> AsyncThrowingStream<String, Error> {
        return AsyncThrowingStream { continuation in
            guard let model = model else {
                continuation.finish(throwing: GeminiError.noAPIKey)
                return
            }
            
            Task {
                do {
                    for try await chunk in model.generateContentStream(text) {
                        if let text = chunk.text {
                            continuation.yield(text)
                        }
                    }
                    continuation.finish()
                } catch {
                    continuation.finish(throwing: error)
                }
            }
        }
    }
}

import SwiftUI

@MainActor
class ChatViewModel: ObservableObject {
    @Published var responseText: String = ""
    @Published var isLoading: Bool = false
    @Published var userInput: String = ""
    
    private let service = GeminiService()
    
    func sendQuery() {
        guard !userInput.isEmpty else { return }
        
        isLoading = true
        responseText = "" // Limpiar respuesta anterior
        let query = userInput
        userInput = "" // Limpiar input
        
        Task {
            do {
                // Usamos streaming para mejor UX
                let stream = await service.sendMessageStream(query)
                for try await chunk in stream {
                    responseText += chunk
                }
            } catch {
                responseText = "Error: \(error.localizedDescription)"
            }
            isLoading = false
        }
    }
}

import SwiftUI

struct ContentView: View {
    @StateObject private var viewModel = ChatViewModel()
    @FocusState private var isInputFocused: Bool
    
    var body: some View {
        NavigationStack {
            VStack(spacing: 20) {
                // Área de Resultados
                ScrollView {
                    VStack(alignment: .leading) {
                        if viewModel.responseText.isEmpty && !viewModel.isLoading {
                            ContentUnavailableView(
                                "Pregunta a Gemini",
                                systemImage: "sparkles",
                                description: Text("Escribe algo para comenzar la magia.")
                            )
                            .opacity(0.7)
                        } else {
                            Text(viewModel.responseText)
                                .font(.body)
                                .padding()
                                .textSelection(.enabled) // Importante para macOS
                        }
                    }
                    .frame(maxWidth: .infinity, alignment: .leading)
                }
                .background(Color.gray.opacity(0.1))
                .cornerRadius(12)
                
                // Área de Input
                HStack {
                    TextField("Escribe tu prompt...", text: $viewModel.userInput)
                        .textFieldStyle(.roundedBorder)
                        .focused($isInputFocused)
                        .disabled(viewModel.isLoading)
                        .onSubmit {
                            viewModel.sendQuery()
                        }
                    
                    if viewModel.isLoading {
                        ProgressView()
                            .scaleEffect(0.8)
                    } else {
                        Button(action: {
                            viewModel.sendQuery()
                        }) {
                            Image(systemName: "arrow.up.circle.fill")
                                .font(.title2)
                        }
                        .disabled(viewModel.userInput.isEmpty)
                    }
                }
                .padding()
            }
            .padding()
            .navigationTitle("Gemini Swift")
            #if os(macOS)
            .frame(minWidth: 400, minHeight: 500)
            #endif
        }
    }
}

// WatchContentView.swift
import SwiftUI

struct WatchContentView: View {
    @StateObject private var viewModel = ChatViewModel()
    
    var body: some View {
        VStack {
            ScrollView {
                Text(viewModel.responseText)
            }
            
            // Usar TextField en watchOS activa dictado o teclado QWERTY automáticamente
            TextField("Preguntar...", text: $viewModel.userInput)
                .onSubmit {
                    viewModel.sendQuery()
                }
        }
    }
}

// Actualización en GeminiService.swift

func analyzeImage(_ image: UIImage, prompt: String) async throws -> String {
    // Configurar modelo de visión
    let visionModel = GenerativeModel(name: "gemini-1.5-flash", apiKey: "API_KEY")
    
    // Convertir UIImage a formato compatible
    // Nota: En macOS sería NSImage
    let response = try await visionModel.generateContent(prompt, image)
    return response.text ?? ""
}