vybekiit 0.4.0 → 0.6.0

package/dist/global-skills/firebase-firestore/references/standard/web_sdk_usage.md

@@ -0,0 +1,192 @@
+# Firestore Web SDK Usage Guide
+
+This guide focuses on the **Modular Web SDK** (v9+), which is tree-shakeable and
+efficient.
+
+## Initialization
+
+```javascript
+import { initializeApp } from "firebase/app";
+import { getFirestore } from "firebase/firestore";
+
+// If running in Firebase App Hosting, you can skip Firebase Config and instead use:
+// const app = initializeApp();
+
+const firebaseConfig = {
+  // Your config options. Get the values by running 'npx -y firebase-tools@latest apps:sdkconfig <platform> <app-id>'
+};
+
+const app = initializeApp(firebaseConfig);
+const db = getFirestore(app);
+
+```
+
+## Writing Data
+
+### Set a Document (`setDoc`)
+
+Creates a document if it doesn't exist, or overwrites it if it does.
+
+```javascript
+import { doc, setDoc } from "firebase/firestore";
+
+// Create/Overwrite document with ID "LA"
+await setDoc(doc(db, "cities", "LA"), {
+  name: "Los Angeles",
+  state: "CA",
+  country: "USA"
+});
+
+// To merge with existing data instead of overwriting:
+await setDoc(doc(db, "cities", "LA"), { population: 3900000 }, { merge: true });
+```
+
+### Add a Document with Auto-ID (`addDoc`)
+
+Use when you don't care about the document ID.
+
+```javascript
+import { collection, addDoc } from "firebase/firestore";
+
+const docRef = await addDoc(collection(db, "cities"), {
+  name: "Tokyo",
+  country: "Japan"
+});
+console.log("Document written with ID: ", docRef.id);
+```
+
+### Update a Document (`updateDoc`)
+
+Update some fields of an existing document without overwriting the entire
+document. Fails if the document doesn't exist.
+
+```javascript
+import { doc, updateDoc } from "firebase/firestore";
+
+const laRef = doc(db, "cities", "LA");
+
+await updateDoc(laRef, {
+  capital: true
+});
+```
+
+### Transactions
+
+Perform an atomic read-modify-write operation.
+
+```javascript
+import { runTransaction, doc } from "firebase/firestore";
+
+const sfDocRef = doc(db, "cities", "SF");
+
+try {
+  await runTransaction(db, async (transaction) => {
+    const sfDoc = await transaction.get(sfDocRef);
+    if (!sfDoc.exists()) {
+      throw "Document does not exist!";
+    }
+
+    const newPopulation = sfDoc.data().population + 1;
+    transaction.update(sfDocRef, { population: newPopulation });
+  });
+  console.log("Transaction successfully committed!");
+} catch (e) {
+  console.log("Transaction failed: ", e);
+}
+```
+
+## Reading Data
+
+### Get a Single Document (`getDoc`)
+
+```javascript
+import { doc, getDoc } from "firebase/firestore";
+
+const docRef = doc(db, "cities", "SF");
+const docSnap = await getDoc(docRef);
+
+if (docSnap.exists()) {
+  console.log("Document data:", docSnap.data());
+} else {
+  console.log("No such document!");
+}
+```
+
+### Get Multiple Documents (`getDocs`)
+
+Fetches all documents in a query or collection once.
+
+```javascript
+import { collection, getDocs } from "firebase/firestore";
+
+const querySnapshot = await getDocs(collection(db, "cities"));
+querySnapshot.forEach((doc) => {
+  // doc.data() is never undefined for query doc snapshots
+  console.log(doc.id, " => ", doc.data());
+});
+```
+
+## Realtime Updates
+
+### Listen to a Document/Query (`onSnapshot`)
+
+```javascript
+import { doc, onSnapshot } from "firebase/firestore";
+
+const unsub = onSnapshot(doc(db, "cities", "SF"), (doc) => {
+    console.log("Current data: ", doc.data());
+});
+
+// Stop listening
+// unsub();
+```
+
+### Handle Changes (Added/Modified/Removed)
+
+```javascript
+import { collection, query, where, onSnapshot } from "firebase/firestore";
+
+const q = query(collection(db, "cities"), where("state", "==", "CA"));
+const unsubscribe = onSnapshot(q, (snapshot) => {
+  snapshot.docChanges().forEach((change) => {
+    if (change.type === "added") {
+        console.log("New city: ", change.doc.data());
+    }
+    if (change.type === "modified") {
+        console.log("Modified city: ", change.doc.data());
+    }
+    if (change.type === "removed") {
+        console.log("Removed city: ", change.doc.data());
+    }
+  });
+});
+```
+
+## Queries
+
+### Simple and Compound Queries
+
+Use `query()` to combine filters.
+
+```javascript
+import { collection, query, where, getDocs } from "firebase/firestore";
+
+const citiesRef = collection(db, "cities");
+
+// Simple equality
+const q1 = query(citiesRef, where("state", "==", "CA"));
+
+// Compound (AND)
+// Note: Requires an index if filtering on different fields
+const q2 = query(citiesRef, where("state", "==", "CA"), where("population", ">", 1000000));
+```
+
+### Order and Limit
+
+Sort and limit results.
+
+```javascript
+import { orderBy, limit } from "firebase/firestore";
+
+const q = query(citiesRef, orderBy("name"), limit(3));
+```

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

@@ -0,0 +1,64 @@
+---
+name: firebase-hosting-basics
+description: Skill for working with Firebase Hosting (Classic). Use this when you want to deploy static web apps, Single Page Apps (SPAs), or simple microservices. Do NOT use for Firebase App Hosting.
+---
+
+# hosting-basics
+
+This skill provides instructions and references for working with Firebase
+Hosting, a fast and secure hosting service for your web app, static and dynamic
+content, and microservices.
+
+## Overview
+
+Firebase Hosting provides production-grade web content hosting for developers.
+With a single command, you can deploy web apps and serve both static and dynamic
+content to a global CDN (content delivery network).
+
+**Key Features:**
+
+- **Fast Content Delivery:** Files are cached on SSDs at CDN edges around the
+  world.
+- **Secure by Default:** Zero-configuration SSL is built-in.
+- **Preview Channels:** View and test changes on temporary preview URLs before
+  deploying live.
+- **GitHub Integration:** Automate previews and deploys with GitHub Actions.
+- **Dynamic Content:** Serve dynamic content and microservices using Cloud
+  Functions or Cloud Run.
+
+## 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.
+
+## Instructions
+
+### 1. Configuration (`firebase.json`)
+
+For details on configuring Hosting behavior, including public directories,
+redirects, rewrites, and headers, see
+[configuration.md](references/configuration.md).
+
+### 2. Deploying
+
+For instructions on deploying your site, using preview channels, and managing
+releases, see [deploying.md](references/deploying.md).
+
+### 3. Emulation
+
+To test your app locally:
+
+```bash
+npx -y firebase-tools@latest emulators:start --only hosting
+```
+
+This serves your app at `http://localhost:5000` by default.

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

@@ -0,0 +1,115 @@
+# Hosting Configuration (`firebase.json`)
+
+The `hosting` section of `firebase.json` configures how your site is deployed
+and served.
+
+## Key Attributes
+
+### `public` (Required)
+
+Specifies the directory to deploy to Firebase Hosting.
+
+```json
+"hosting": {
+  "public": "public"
+}
+```
+
+### `ignore` (Optional)
+
+Files to ignore on deploy. Uses glob patterns (like `.gitignore`). **Default
+ignores:** `firebase.json`, `**/.*`, `**/node_modules/**`
+
+### `redirects` (Optional)
+
+URL redirects to prevent broken links or shorten URLs.
+
+```json
+"redirects": [
+  {
+    "source": "/foo",
+    "destination": "/bar",
+    "type": 301
+  }
+]
+```
+
+### `rewrites` (Optional)
+
+Serve the same content for multiple URLs, useful for SPAs or Dynamic Content.
+
+```json
+"rewrites": [
+  {
+    "source": "**",
+    "destination": "/index.html"
+  },
+  {
+    "source": "/api/**",
+    "function": "apiFunction"
+  },
+  {
+    "source": "/container/**",
+    "run": {
+      "serviceId": "helloworld",
+      "region": "us-central1"
+    }
+  }
+]
+```
+
+### `headers` (Optional)
+
+Custom response headers.
+
+```json
+"headers": [
+  {
+    "source": "**/*.@(eot|otf|ttf|ttc|woff|font.css)",
+    "headers": [
+      {
+        "key": "Access-Control-Allow-Origin",
+        "value": "*"
+      }
+    ]
+  }
+]
+```
+
+### `cleanUrls` (Optional)
+
+If `true`, drops `.html` extension from URLs.
+
+```json
+"cleanUrls": true
+```
+
+### `trailingSlash` (Optional)
+
+Controls trailing slashes in static content URLs.
+
+- `true`: Adds trailing slash.
+- `false`: Removes trailing slash.
+
+## Full Example
+
+```json
+{
+  "hosting": {
+    "public": "dist",
+    "ignore": [
+      "firebase.json",
+      "**/.*",
+      "**/node_modules/**"
+    ],
+    "rewrites": [
+      {
+        "source": "**",
+        "destination": "/index.html"
+      }
+    ],
+    "cleanUrls": true,
+    "trailingSlash": false
+  }
+}
+```

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

@@ -0,0 +1,48 @@
+# Deploying to Firebase Hosting
+
+## Standard Deployment
+
+To deploy your Hosting content and configuration to your live site:
+
+```bash
+npx -y firebase-tools@latest deploy --only hosting
+```
+
+This deploys to your default sites (`PROJECT_ID.web.app` and
+`PROJECT_ID.firebaseapp.com`).
+
+## Preview Channels
+
+Preview channels allow you to test changes on a temporary URL before going live.
+
+### Deploy to a Preview Channel
+
+```bash
+npx -y firebase-tools@latest hosting:channel:deploy CHANNEL_ID
+```
+
+Replace `CHANNEL_ID` with a name (e.g., `feature-beta`). This returns a preview
+URL like `PROJECT_ID--CHANNEL_ID-RANDOM_HASH.web.app`.
+
+### Expiration
+
+Channels expire after 7 days by default. To set a different expiration:
+
+```bash
+npx -y firebase-tools@latest hosting:channel:deploy CHANNEL_ID --expires 1d
+```
+
+## Cloning to Live
+
+You can promote a version from a preview channel to your live channel without
+rebuilding.
+
+```bash
+npx -y firebase-tools@latest hosting:clone SOURCE_SITE_ID:SOURCE_CHANNEL_ID TARGET_SITE_ID:live
+```
+
+**Example:** Clone the `feature-beta` channel on your default site to live:
+
+```bash
+npx -y firebase-tools@latest hosting:clone my-project:feature-beta my-project:live
+```

package/dist/global-skills/firebase-remote-config-basics/SKILL.md

@@ -0,0 +1,124 @@
+---
+name: firebase-remote-config-basics
+description: Comprehensive guide for Firebase Remote Config, including template management and SDK usage. Use this skill when the user needs help setting up Remote Config, managing feature flags, or updating app behavior dynamically.
+compatibility: This skill is best used with the Firebase CLI, but does not require it. Firebase CLI can be accessed through `npx -y firebase-tools@latest`.
+---
+
+# Remote Config
+
+This skill provides a complete guide for getting started with Remote Config on
+Android or iOS. Remote Config allows you to change the behavior and appearance
+of your app without publishing an app update by maintaining a cloud-based
+configuration template.
+
+## Prerequisites
+
+Provisioning Remote Config requires both a Firebase project and a Firebase app,
+either Android or iOS. To manage the Remote Config template and conditions via
+the command line, use the Firebase CLI. See the `firebase-basics` skill for
+references on project initialization.
+
+## Troubleshooting Execution
+
+### Handling npx 403 Forbidden Errors
+
+If `npx -y firebase-tools@latest` fails due to registry permissions (403 error):
+
+1. **Inform the user**: "I am unable to fetch the latest Firebase tools via npx
+   due to a registry error."
+1. **Fallback**: Attempt to use the local `firebase` command directly if the
+   user confirms it is installed globally (`npm install -g firebase-tools`).
+
+### Handling Project Context Issues
+
+If a command fails because "no active project is selected":
+
+1. **Check login**: Run `npx -y firebase-tools@latest login:list`.
+1. **Prompt for ID**: If logged in but no project is active, ask the user:
+   "Please provide your Firebase Project ID to proceed."
+1. **Use Flag**: Append `--project <PROJECT_ID>` to every subsequent command.
+
+## SDK Setup
+
+To learn how to set up Remote Config in your application code, choose your
+platform:
+
+- **Android**: [android_setup.md](references/android_setup.md)
+- **iOS**: [ios_setup.md](references/ios_setup.md)
+
+## Best Practices and Template Management
+
+Follow these guidelines and use the associated CLI tools to ensure efficient and
+safe use of Remote Config.
+
+### Fetching Strategies
+
+To optimize app performance and user experience, follow these recommended
+patterns (see
+[Loading Strategies](https://firebase.google.com/docs/remote-config/loading)):
+
+- **Load new values for next startup**: The most effective pattern is to
+  activate previously fetched values immediately on startup and fetch new values
+  in the background to be used next time. This minimizes user wait time.
+- **Real-time Updates**: Use the SDK's real-time listener to update the app
+  instantly without a refresh when server-side configuration changes.
+
+### Template Management via CLI
+
+Use the following commands to manage your Remote Config template and version
+history through the terminal:
+
+### Template Management via CLI
+
+Use the following commands to manage your Remote Config template and version
+history through the terminal:
+
+- **Get current template**: Save the remote template to a local JSON file for
+  auditing or modification.
+
+  ```bash
+  npx -y firebase-tools@latest remoteconfig:get -o remote_config.json
+  ```
+
+- **Autonomous Editing & Discovery** : Modify the local `remote_config.json`
+  directly. Determine the correct signal (e.g., device.country or percent) and
+  update the "conditions" array and "parameters" map accordingly.
+
+- **MANDATORY: User Review and Verification** : STOP and ask the user to verify
+  your changes before proceeding to deployment.
+
+  - Action: Inform the user: "I have prepared the changes in remote_config.json.
+    Please review the file for accuracy. Once you are satisfied, tell me to
+    'deploy' to make the changes live."
+
+- **Deployment Orchestration** : To push changes, you must ensure the
+  environment is configured for deployment.
+
+  - Config Mapping: If a firebase.json file is missing, create one to map the
+    local JSON to the Remote Config service:
+
+  ```json
+    { "remoteconfig": { "template": "remote_config.json" } }
+  ```
+
+  - Deploy: Execute the partial deployment command
+    ```bash
+    npx -y firebase-tools@latest deploy --only remoteconfig
+    ```
+
+- **Verification**: After deployment, verify the update by listing the version
+  history.
+
+  ```bash
+  npx -y firebase-tools@latest remoteconfig:versions:list
+  ```
+
+The SDK provides a number of features to make your application dynamic and
+responsive to user segments.
+
+- **Set In-App Defaults**: Define baseline values to ensure the app functions
+  offline or before the first fetch.
+- **Fetch and Activate**: Retrieve values from the Firebase backend and apply
+  them to the local UI/Logic.
+- **Template Management**: Use the Firebase CLI to version-control, get, and
+  deploy your config JSON files.

package/dist/global-skills/firebase-remote-config-basics/references/android_setup.md

@@ -0,0 +1,91 @@
+# Firebase Remote Config Android Setup Guide
+
+Important references:
+
+- Refer to the `firebase-basics` skills, particularly those for project and app
+  setup, before proceeding.
+
+## Project and App Setup
+
+Before you begin, ensure you have the following. If a `google-services.json`
+file is present, then use that Firebase project and app. Otherwise you may need
+to create them.
+
+- **Firebase CLI**: Installed and logged in (see `firebase-basics`).
+- **Firebase Project**: Created via
+  `npx -y firebase-tools@latest projects:create` (see `firebase-basics`).
+- **Firebase App**: Created via
+  `npx -y firebase-tools@latest apps:create <IOS|ANDROID|WEB> <package-name-or-bundle-id>`
+
+The `google-services.json` file must be present in the Android app's module
+directory. If missing, get the config using the Firebase CLI:
+`npx -y firebase-tools@latest apps:sdkconfig ANDROID <App-ID>`.
+
+## Add Dependencies to Gradle Build
+
+These changes are made to your Android project's Gradle files. Google Analytics
+is highly recommended as it enables conditional targeting based on user
+properties and audiences.
+
+### Project-level `build.gradle.kts` (`<project>/build.gradle.kts`)
+
+Ensure the Google Services plugin is in the `plugins` block:
+
+```kotlin
+plugins {
+    // ... other plugins
+    id("com.google.gms.google-services") version "4.4.0" apply false
+}
+```
+
+### App-level `build.gradle.kts` (`<project>/<app-module>/build.gradle.kts`)
+
+1. Add the Google Services plugin to the `plugins` block:
+
+   ```kotlin
+   plugins {
+       // ... other plugins
+       id("com.google.gms.google-services")
+   }
+   ```
+
+1. Add the Firebase Remote Config and Analytics dependencies. Using the Firebase
+   Bill of Materials (BoM) is the best practice for version management.
+
+   ```kotlin
+   dependencies {
+       // ... other dependencies
+
+       // Import the Firebase BoM
+       implementation(platform("com.google.firebase:firebase-bom:32.7.0"))
+
+       // Add the dependencies for Remote Config and Analytics
+       implementation("com.google.firebase:firebase-config-ktx")
+       implementation("com.google.firebase:firebase-analytics-ktx")
+   }
+   ```
+
+## Follow up Steps
+
+The following steps cover the essential patterns for using Remote Config
+effectively.
+
+### Set In-App Defaults
+
+Define default values so your app has functional logic before it ever fetches a
+template from the server. Create an XML file (e.g.,
+`res/xml/remote_config_defaults.xml`):
+`xml     <!-- Example Remote Config Defaults File -->     <?xml version="1.0" encoding="utf-8"?>     <defaultsMap>         <entry>             <key>welcome_message</key>             <value>Welcome to the app!</value>         </entry>         <entry>             <key>is_feature_enabled</key>             <value>false</value>         </entry>     </defaultsMap>     `
+Then, initialize the SDK in your Activity or Application class:
+
+````
+```kotlin
+val remoteConfig = Firebase.remoteConfig
+remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)
+```
+````
+
+### Fetch and Activate Values
+
+To apply values from the cloud, you must fetch them and then activate them.
+`kotlin     remoteConfig.fetchAndActivate()     .addOnCompleteListener(this) { task ->         if (task.isSuccessful) {             val updated = task.result             println("Config params updated: $updated")         } else {             println("Fetch failed")         }         // Access a value         val message = remoteConfig.getString("welcome_message")     }     `