vybekiit 0.4.0 → 0.6.0

package/dist/global-skills/firebase-ai-logic-basics/references/ios_setup.md

@@ -0,0 +1,156 @@
+# Firebase AI Logic iOS Setup Guide
+
+## 1. Import and Initialize
+
+Ensure you have installed the `FirebaseAILogic` SDK via Swift Package Manager.
+
+```swift
+import FirebaseAILogic
+
+// Initialize the Firebase AI service and the generative model.
+let ai = FirebaseAI.firebaseAI()
+
+// [AGENT] Replace "<latest_supported_model>" with the latest model from https://firebase.google.com/docs/ai-logic/models.md.txt
+let model = ai.generativeModel(modelName: "<latest_supported_model>")
+```
+
+## 2. SwiftUI Integration (Best Practices)
+
+Use the `@Observable` pattern to manage AI state and provide a smooth UX with
+loading indicators and error handling.
+
+> **⛔️ CRITICAL WARNING:** Do NOT initialize the model inline as a class
+> property if there's any chance the view model is instantiated before
+> `FirebaseApp.configure()` executes in the app root. To be safe, initialize the
+> model lazily or pass it in from a point in the hierarchy where Firebase is
+> guaranteed to be configured.
+
+```swift
+import SwiftUI
+import FirebaseAILogic
+
+@MainActor
+@Observable
+final class AIViewModel {
+    // [AGENT] Replace with the latest model from https://firebase.google.com/docs/ai-logic/models.md.txt
+    private lazy var model = FirebaseAI.firebaseAI().generativeModel(modelName: "<latest_supported_model>")
+    
+    var responseText: String = ""
+    var isFetching: Bool = false
+    var errorMessage: String?
+    
+    func generate(prompt: String) async {
+        isFetching = true
+        errorMessage = nil
+        defer { isFetching = false }
+        
+        do {
+            let response = try await model.generateContent(prompt)
+            self.responseText = response.text ?? "No response"
+        } catch {
+            self.errorMessage = error.localizedDescription
+        }
+    }
+}
+
+struct AIView: View {
+    @State private var viewModel = AIViewModel()
+    @State private var prompt = "Write a story about a magic backpack."
+    
+    var body: some View {
+        VStack {
+            TextField("Enter prompt", text: $prompt)
+            
+            Button("Generate") {
+                Task { await viewModel.generate(prompt: prompt) }
+            }
+            .disabled(viewModel.isFetching)
+            
+            if viewModel.isFetching {
+                ProgressView()
+            } else if let error = viewModel.errorMessage {
+                Text(error).foregroundStyle(.red)
+            } else {
+                ScrollView {
+                    Text(viewModel.responseText)
+                }
+            }
+        }
+        .padding()
+    }
+}
+```
+
+## 3. Safety Settings
+
+You can configure safety thresholds to prevent the model from generating harmful
+content.
+
+```swift
+let safetySettings = [
+  SafetySetting(category: .harassment, threshold: .blockLowAndAbove),
+  SafetySetting(category: .hateSpeech, threshold: .blockMediumAndAbove)
+]
+
+let model = FirebaseAI.firebaseAI().generativeModel(
+  modelName: "<latest_supported_model>", // [AGENT] Replace with the latest model from https://firebase.google.com/docs/ai-logic/models.md.txt
+  safetySettings: safetySettings
+)
+```
+
+# Advanced Features
+
+### Chat Session (Multi-turn)
+
+Chat sessions persist state across multiple interactions, which is essential for
+ongoing conversations or when using tools like function calling.
+
+```swift
+let chat = model.startChat()
+
+Task {
+    do {
+        let response1 = try await chat.sendMessage("Hello! I have two dogs in my house.")
+        print(response1.text ?? "")
+
+        let response2 = try await chat.sendMessage("How many paws are in my house?")
+        print(response2.text ?? "")
+    } catch {
+        print("Error in chat: \(error)")
+    }
+}
+```
+
+### Function Calling (Tools)
+
+Define functions that the model can request to execute to interact with external
+systems. *Note: Advanced workflows like function calling generally require a
+multi-turn Chat Session to handle the back-and-forth execution.*
+
+```swift
+let getStockPriceTool = Tool(functionDeclarations: [
+  FunctionDeclaration(
+    name: "getStockPrice",
+    description: "Get the current stock price for a given symbol.",
+    parameters: [
+      "symbol": Schema(
+        type: .string,
+        description: "The stock symbol, e.g. AAPL"
+      )
+    ]
+  )
+])
+
+let model = FirebaseAI.firebaseAI().generativeModel(
+  modelName: "<latest_supported_model>", // [AGENT] Replace with the latest model from https://firebase.google.com/docs/ai-logic/models.md.txt
+  tools: [getStockPriceTool]
+)
+
+// In your task (using a chat session):
+let chat = model.startChat()
+let response = try await chat.sendMessage("What is the stock price of Apple?")
+if let functionCall = response.functionCalls.first {
+    // Handle the function call (e.g. call a local API and send the result back)
+    print("Model requested function: \(functionCall.name) with args: \(functionCall.args)")
+}
+```

package/dist/global-skills/firebase-ai-logic-basics/references/usage_patterns_android.md

@@ -0,0 +1,157 @@
+# Firebase AI Logic on Android (Kotlin)
+
+First, ensure you have initialized the Firebase App (see `firebase-basics`
+skill). Then, initialize the AI Logic service as below
+
+### 0. Enable Firebase AI Logic via CLI
+
+Before adding dependencies in your app, make sure you enable the AI Logic
+service in your Firebase Project using the Firebase CLI:
+
+```bash
+npx -y firebase-tools@latest init
+# When prompted, select 'AI logic' to enable the Gemini API in your project.
+```
+
+______________________________________________________________________
+
+### 1. Add Dependencies
+
+In your module-level `build.gradle.kts` (usually `app/build.gradle.kts`), add
+the dependency for Firebase AI:
+
+```kotlin
+dependencies {
+    // [AGENT] Fetch the latest available BoM version from https://firebase.google.com/support/release-notes/android before adding this
+    implementation(platform("com.google.firebase:firebase-bom:<latest_bom_version>"))
+
+    // Add the dependency for the Firebase AI library
+    implementation("com.google.firebase:firebase-ai")
+}
+```
+
+______________________________________________________________________
+
+### 2. Initialize and Generate Content
+
+In your Activity or Fragment, initialize the `FirebaseAI` service and generate
+content using a Gemini model:
+
+```kotlin
+import com.google.firebase.ai.FirebaseAI
+import com.google.firebase.ai.ktx.ai
+import com.google.firebase.ktx.Firebase
+
+class MainActivity : AppCompatActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_main)
+
+        // Initialize Firebase AI
+        val ai = Firebase.ai
+
+        // [AGENT] Replace "<latest_supported_model>" with the latest model from https://firebase.google.com/docs/ai-logic/models.md.txt
+        val model = ai.generativeModel("<latest_supported_model>")
+
+        // Generate content
+        lifecycleScope.launch {
+            try {
+                val response = model.generateContent("Write a story about a magic backpack.")
+                Log.d(TAG, "Response: ${response.text}")
+            } catch (e: Exception) {
+                Log.e(TAG, "Error generating content", e)
+            }
+        }
+    }
+}
+```
+
+#### Jetpack Compose (Modern)
+
+Initialize inside a `ComponentActivity` and use `setContent`:
+
+```kotlin
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.lifecycle.lifecycleScope
+import com.google.firebase.Firebase
+import com.google.firebase.ai.ai
+import kotlinx.coroutines.launch
+
+class MainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        val ai = Firebase.ai
+        // [AGENT] Replace with the latest model from https://firebase.google.com/docs/ai-logic/models.md.txt
+        val model = ai.generativeModel("<latest_supported_model>")
+        
+        lifecycleScope.launch {
+            val response = model.generateContent("Hello Gemini!")
+            setContent {
+                MaterialTheme {
+                    Text("AI Response: ${response.text}")
+                }
+            }
+        }
+    }
+}
+```
+
+______________________________________________________________________
+
+### 3. Multimodal Input (Text and Images)
+
+Pass bitmap data along with text prompts:
+
+```kotlin
+val image1: Bitmap = ... // Load your bitmap
+val image2: Bitmap = ...
+
+val response = model.generateContent(
+    content("Analyze these images for me") {
+        image(image1)
+        image(image2)
+        text("Compare these two items.")
+    }
+)
+Log.d(TAG, response.text)
+```
+
+______________________________________________________________________
+
+### 4. Chat Session (Multi-turn)
+
+Maintain chat history automatically:
+
+```kotlin
+val chat = model.startChat(
+    history = listOf(
+        content("user") { text("Hello, I am a software engineer.") },
+        content("model") { text("Hello! How can I help you today?") }
+    )
+)
+
+lifecycleScope.launch {
+    val response = chat.sendMessage("What should I learn next?")
+    Log.d(TAG, response.text)
+}
+```
+
+______________________________________________________________________
+
+### 5. Streaming Responses
+
+For faster display, stream the response:
+
+```kotlin
+lifecycleScope.launch {
+    model.generateContentStream("Tell me a long story.")
+        .collect { chunk ->
+            print(chunk.text) // Update UI incrementally
+        }
+}
+```

package/dist/global-skills/firebase-ai-logic-basics/references/usage_patterns_web.md

@@ -0,0 +1,186 @@
+# Firebase AI Logic Basics
+
+## Initialization Pattern
+
+You must initialize the ai-logic service after the main Firebase App.
+
+```JavaScript
+import { initializeApp } from "firebase/app";
+import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";
+
+
+// If running in Firebase App Hosting, you can skip Firebase Config and instead use:
+// const app = initializeApp();
+
+const firebaseConfig = {
+  // ... your firebase config
+};
+
+const app = initializeApp(firebaseConfig);
+
+// Initialize the AI Logic service (defaults to Gemini Developer API)
+// To set the AI provider, set the backend as the second parameter
+const ai = getAI(app, { backend: new GoogleAIBackend() });
+
+const generationConfig = {
+  candidate_count: 1,
+  maxOutputTokens: 2048,
+  stopSequences: [],
+  temperature: 0.7,      // Balanced: creative but focused
+  topP: 0.95,            // Standard: allows a wide range of probable tokens
+  topK: 40,              // Standard: considers the top 40 tokens
+};
+
+// Specify the config as part of creating the `GenerativeModel` instance
+// [AGENT] Replace "<latest_supported_model>" with the latest model from https://firebase.google.com/docs/ai-logic/models.md.txt
+const model = getGenerativeModel(ai, { model: "<latest_supported_model>",  generationConfig });
+```
+
+## Core Capabilities
+
+Text-Only Generation
+
+```JavaScript
+async function generateText(prompt) {
+  const result = await model.generateContent(prompt);
+  const response = await result.response;
+  return response.text();
+}
+```
+
+## Multimodal (Text + Images/Audio/Video/PDF input)
+
+Firebase AI Logic accepts Base64 encoded data or specific file references.
+
+```JavaScript
+// Helper to convert file to base64 generic object
+async function fileToGenerativePart(file) {
+  const base64EncodedDataPromise = new Promise((resolve) => {
+    const reader = new FileReader();
+    reader.onloadend = () => resolve(reader.result.split(',')[1]);
+    reader.readAsDataURL(file);
+  });
+  
+  return {
+    inlineData: {
+      data: await base64EncodedDataPromise,
+      mimeType: file.type,
+    },
+  };
+}
+
+async function analyzeImage(prompt, imageFile) {
+  const imagePart = await fileToGenerativePart(imageFile);
+  const result = await model.generateContent([prompt, imagePart]);
+  return result.response.text();
+}
+```
+
+## Chat Session (Multi-turn)
+
+Maintain history automatically using startChat.
+
+```JavaScript
+const chat = model.startChat({
+  history: [
+    {
+      role: "user",
+      parts: [{ text: "Hello, I am a developer." }],
+    },
+    {
+      role: "model",
+      parts: [{ text: "Great to meet you. How can I help with code?" }],
+    },
+  ],
+});
+
+async function sendMessage(msg) {
+  const result = await chat.sendMessage(msg);
+  return result.response.text();
+}
+```
+
+## Streaming Responses
+
+For real-time UI updates (like a typing effect).
+
+```JavaScript
+async function streamResponse(prompt) {
+  const result = await model.generateContentStream(prompt);
+  for await (const chunk of result.stream) {
+    const chunkText = chunk.text();
+    console.log("Stream chunk:", chunkText);
+    // Update UI here
+  }
+}
+```
+
+Generate Images with Nano Banana
+
+```Javascript
+import { initializeApp } from "firebase/app";
+import { getAI, getGenerativeModel, GoogleAIBackend, ResponseModality } from "firebase/ai";
+
+
+// Initialize FirebaseApp
+const firebaseApp = initializeApp(firebaseConfig);
+
+// Initialize the Gemini Developer API backend service
+const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });
+
+// Create a `GenerativeModel` instance with a model that supports your use case
+const model = getGenerativeModel(ai, {
+  model: "<latest_supported_image_model>", // [AGENT] Replace with the latest image model from https://firebase.google.com/docs/ai-logic/models.md.txt
+  // Configure the model to respond with text and images (required)
+  generationConfig: {
+    responseModalities: [ResponseModality.TEXT, ResponseModality.IMAGE],
+  },
+});
+
+// Provide a text prompt instructing the model to generate an image
+const prompt = 'Generate an image of the Eiffel Tower with fireworks in the background.';
+
+// To generate an image, call `generateContent` with the text input
+const result = model.generateContent(prompt);
+
+// Handle the generated image
+try {
+  const inlineDataParts = result.response.inlineDataParts();
+  if (inlineDataParts?.[0]) {
+    const image = inlineDataParts[0].inlineData;
+    console.log(image.mimeType, image.data);
+  }
+} catch (err) {
+  console.error('Prompt or candidate was blocked:', err);
+}
+```
+
+## Advanced Features
+
+Structured Output (JSON) Enforce a specific JSON schema for the response.
+
+```JavaScript
+import { getGenerativeModel, Schema } from "firebase/ai";
+const jsonModel = getGenerativeModel(ai, {
+    model: "<latest_supported_model>", // [AGENT] Replace with the latest model from https://firebase.google.com/docs/ai-logic/models.md.txt
+    generationConfig: {
+        responseMimeType: "application/json",
+        // Optional: Define a schema
+        schema = Schema.object({ ... });
+    }
+});
+
+async function getJsonData(prompt) {
+    const result = await jsonModel.generateContent(prompt);
+    return JSON.parse(result.response.text());
+}
+```
+
+On-Device AI (Hybrid) Automatically switch between local Gemini Nano and cloud
+models based on device capability.
+
+```JavaScript
+import {getGenerativeModel, InferenceMode } from "firebase/ai";
+
+const hybridModel = getGenerativeModel(ai, { mode: InferenceMode.PREFER_ON_DEVICE });
+```

package/dist/global-skills/firebase-app-hosting-basics/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: firebase-app-hosting-basics
+description: Deploy and manage web apps with Firebase App Hosting. Use this skill when deploying Next.js/Angular apps with backends.
+---
+
+# App Hosting Basics
+
+## Description
+
+This skill enables the agent to deploy and manage modern, full-stack web
+applications (Next.js, Angular, etc.) using Firebase App Hosting.
+
+**Important**: In order to use App Hosting, your Firebase project must be on the
+Blaze pricing plan. Direct the user to
+https://console.firebase.google.com/project/_/overview?purchaseBillingPlan=metered
+to upgrade their plan.
+
+## Hosting vs App Hosting
+
+**Choose Firebase Hosting if:**
+
+- You are deploying a static site (HTML/CSS/JS).
+- You are deploying a simple SPA (React, Vue, etc. without SSR).
+- You want full control over the build and deploy process via CLI.
+
+**Choose Firebase App Hosting if:**
+
+- You are using a supported full-stack framework like Next.js or Angular.
+- You need Server-Side Rendering (SSR) or ISR.
+- You want an automated "git push to deploy" workflow with zero configuration.
+
+## Deploying to App Hosting
+
+### Deploy from Source
+
+This is the recommended flow for most users.
+
+1. Configure `firebase.json` with an `apphosting` block.
+   ```json
+   {
+     "apphosting": {
+       "backendId": "my-app-id",
+       "rootDir": "/",
+       "ignore": [
+         "node_modules",
+         ".git",
+         "firebase-debug.log",
+         "firebase-debug.*.log",
+         "functions"
+       ]
+     }
+   }
+   ```
+1. Create or edit `apphosting.yaml`- see
+   [Configuration](references/configuration.md) for more information on how to
+   do so.
+1. If the app needs safe access to sensitive keys, use
+   `npx -y firebase-tools@latest apphosting:secrets` commands to set and grant
+   access to secrets.
+1. Run `npx -y firebase-tools@latest deploy` when you are ready to deploy.
+
+### Automated deployment via GitHub (CI/CD)
+
+Alternatively, set up a backend connected to a GitHub repository for automated
+deployments "git push" deployments. This is only recommended for more advanced
+users, and is not required to use App Hosting. See
+[CLI Commands](references/cli_commands.md) for more information on how to set
+this up using CLI commands.
+
+## Emulation
+
+See [Emulation](references/emulation.md) for more information on how to test
+your app locally using the Firebase Local Emulator Suite.

package/dist/global-skills/firebase-app-hosting-basics/references/cli_commands.md

@@ -0,0 +1,85 @@
+# App Hosting CLI Commands
+
+The Firebase CLI provides a comprehensive suite of commands to manage App
+Hosting resources. These commands are often faster and more scriptable than
+using the Firebase Console.
+
+## Initialization
+
+### `npx -y firebase-tools@latest init apphosting`
+
+- **Purpose**: Interactive command that sets up App Hosting in your local
+  project. Use this command only if you are able to handle interactive CLI
+  inputs well. Alternatively, you can manually edit `firebase.json` and
+  `apphosting.yml`.
+
+- **Effect**:
+
+  - Detects your web framework.
+  - Creates/updates `apphosting.yaml`.
+  - Can optionally create a backend if one doesn't exist.
+
+## Backend Management
+
+### `npx -y firebase-tools@latest apphosting:backends:list`
+
+- **Purpose**: Lists all backends in the current project.
+
+### `npx -y firebase-tools@latest apphosting:backends:get <backend-id>`
+
+- **Purpose**: Shows details for a specific backend.
+
+### `npx -y firebase-tools@latest apphosting:backends:delete <backend-id>`
+
+- **Purpose**: Deletes a backend and its associated resources.
+
+### `npx -y firebase-tools@latest apphosting:rollouts:list <backend-id>`
+
+- **Purpose**: Lists the history of rollouts for a backend.
+
+## Secrets Management
+
+App Hosting uses Cloud Secret Manager to securely handle sensitive environment
+variables (like API keys).
+
+### `npx -y firebase-tools@latest apphosting:secrets:set <secret-name>`
+
+- **Purpose**: Creates or updates a secret in Cloud Secret Manager and makes it
+  available to App Hosting.
+- **Behavior**: Prompts for the secret value (hidden input).
+
+### `npx -y firebase-tools@latest apphosting:secrets:grantaccess <secret-name>`
+
+- **Purpose**: Grants the App Hosting service account permission to access the
+  secret.
+- **Note**: Often handled automatically by `secrets:set`, but useful for
+  debugging permission issues or granting access to existing secrets.
+
+## Automated deployment via GitHub (CI/CD)
+
+**IMPORTANT** Only use these commands if you are setting up automated
+deployments via GitHub. If you are managing deployments using
+`npx -y firebase-tools@latest deploy`, DO NOT use these commands.
+
+### `npx -y firebase-tools@latest apphosting:rollouts:create <backend-id>`
+
+- **Purpose**: Manually triggers a new rollout (deployment).
+- **Options**:
+  - `--git-branch <branch>`: Deploy the latest commit from a specific branch.
+  - `--git-commit <commit-hash>`: Deploy a specific commit.
+- **Use Case**: Useful for redeploying without code changes, or rolling back to
+  a specific commit.
+
+### `npx -y firebase-tools@latest apphosting:backends:create`
+
+- **Purpose**: Creates a new App Hosting backend. Use this when setting up
+  automated deployments via GitHub.
+- **Options**:
+  - `--app <webAppId>`: The ID of an existing Firebase web app to associate with
+    the backend.
+  - `--backend <backendId>`: The ID of the new backend.
+  - `--primary-region <location>`: The primary region for the backend.
+  - `--root-dir <rootDir>`: The root directory for the backend. If omitted,
+    defaults to the root directory of the project.
+  - `--service-account <service-account>`: The service account used to run the
+    server. If omitted, defaults to the default service account.