feat: Add Official Microsoft & Gemini Skills (845+ Total)

🚀 Impact Significantly expands the capabilities of **Antigravity Awesome Skills** by integrating official skill collections from **Microsoft** and **Google Gemini**. This update increases the total skill count to **845+**, making the library even more comprehensive for AI coding assistants. ✨ Key Changes 1. New Official Skills - **Microsoft Skills**: Added a massive collection of official skills from [microsoft/skills](https://github.com/microsoft/skills). - Includes Azure, .NET, Python, TypeScript, and Semantic Kernel skills. - Preserves the original directory structure under `skills/official/microsoft/`. - Includes plugin skills from the `.github/plugins` directory. - **Gemini Skills**: Added official Gemini API development skills under `skills/gemini-api-dev/`. 2. New Scripts & Tooling - **`scripts/sync_microsoft_skills.py`**: A robust synchronization script that: - Clones the official Microsoft repository. - Preserves the original directory heirarchy. - Handles symlinks and plugin locations. - Generates attribution metadata. - **`scripts/tests/inspect_microsoft_repo.py`**: Debug tool to inspect the remote repository structure. - **`scripts/tests/test_comprehensive_coverage.py`**: Verification script to ensure 100% of skills are captured during sync. 3. Core Improvements - **`scripts/generate_index.py`**: Enhanced frontmatter parsing to safely handle unquoted values containing `@` symbols and commas (fixing issues with some Microsoft skill descriptions). - **`package.json`**: Added `sync:microsoft` and `sync:all-official` scripts for easy maintenance. 4. Documentation - Updated `README.md` to reflect the new skill counts (845+) and added Microsoft/Gemini to the provider list. - Updated `CATALOG.md` and `skills_index.json` with the new skills. 🧪 Verification - Ran `scripts/tests/test_comprehensive_coverage.py` to verify all Microsoft skills are detected. - Validated `generate_index.py` fixes by successfully indexing the new skills.
2026-02-11 20:16:23 +05:00
parent 167d7c97c7
commit 17bce709de
145 changed files with 44081 additions and 72 deletions
--- a/skills/official/microsoft/dotnet/data/fabric/SKILL.md
+++ b/skills/official/microsoft/dotnet/data/fabric/SKILL.md
@@ -0,0 +1,338 @@
+---
+name: azure-mgmt-fabric-dotnet
+description: |
+  Azure Resource Manager SDK for Fabric in .NET. Use for MANAGEMENT PLANE operations: provisioning, scaling, suspending/resuming Microsoft Fabric capacities, checking name availability, and listing SKUs via Azure Resource Manager. Triggers: "Fabric capacity", "create capacity", "suspend capacity", "resume capacity", "Fabric SKU", "provision Fabric", "ARM Fabric", "FabricCapacityResource".
+package: Azure.ResourceManager.Fabric
+---
+
+# Azure.ResourceManager.Fabric (.NET)
+
+Management plane SDK for provisioning and managing Microsoft Fabric capacity resources via Azure Resource Manager.
+
+> **Management Plane Only**
+> This SDK manages Fabric *capacities* (compute resources). For working with Fabric workspaces, lakehouses, warehouses, and data items, use the Microsoft Fabric REST API or data plane SDKs.
+
+## Installation
+
+```bash
+dotnet add package Azure.ResourceManager.Fabric
+dotnet add package Azure.Identity
+```
+
+**Current Version**: 1.0.0 (GA - September 2025)  
+**API Version**: 2023-11-01  
+**Target Frameworks**: .NET 8.0, .NET Standard 2.0
+
+## Environment Variables
+
+```bash
+AZURE_SUBSCRIPTION_ID=<your-subscription-id>
+# For service principal auth (optional)
+AZURE_TENANT_ID=<tenant-id>
+AZURE_CLIENT_ID=<client-id>
+AZURE_CLIENT_SECRET=<client-secret>
+```
+
+## Authentication
+
+```csharp
+using Azure.Identity;
+using Azure.ResourceManager;
+using Azure.ResourceManager.Fabric;
+
+// Always use DefaultAzureCredential
+var credential = new DefaultAzureCredential();
+var armClient = new ArmClient(credential);
+
+// Get subscription
+var subscription = await armClient.GetDefaultSubscriptionAsync();
+```
+
+## Resource Hierarchy
+
+```
+ArmClient
+└── SubscriptionResource
+    └── ResourceGroupResource
+        └── FabricCapacityResource
+```
+
+## Core Workflows
+
+### 1. Create Fabric Capacity
+
+```csharp
+using Azure.ResourceManager.Fabric;
+using Azure.ResourceManager.Fabric.Models;
+using Azure.Core;
+
+// Get resource group
+var resourceGroup = await subscription.GetResourceGroupAsync("my-resource-group");
+
+// Define capacity configuration
+var administration = new FabricCapacityAdministration(
+    new[] { "admin@contoso.com" }  // Capacity administrators (UPNs or object IDs)
+);
+
+var properties = new FabricCapacityProperties(administration);
+
+var sku = new FabricSku("F64", FabricSkuTier.Fabric);
+
+var capacityData = new FabricCapacityData(
+    AzureLocation.WestUS2,
+    properties,
+    sku)
+{
+    Tags = { ["Environment"] = "Production" }
+};
+
+// Create capacity (long-running operation)
+var capacityCollection = resourceGroup.Value.GetFabricCapacities();
+var operation = await capacityCollection.CreateOrUpdateAsync(
+    WaitUntil.Completed,
+    "my-fabric-capacity",
+    capacityData);
+
+FabricCapacityResource capacity = operation.Value;
+Console.WriteLine($"Created capacity: {capacity.Data.Name}");
+Console.WriteLine($"State: {capacity.Data.Properties.State}");
+```
+
+### 2. Get Fabric Capacity
+
+```csharp
+// Get existing capacity
+var capacity = await resourceGroup.Value
+    .GetFabricCapacityAsync("my-fabric-capacity");
+
+Console.WriteLine($"Name: {capacity.Value.Data.Name}");
+Console.WriteLine($"Location: {capacity.Value.Data.Location}");
+Console.WriteLine($"SKU: {capacity.Value.Data.Sku.Name}");
+Console.WriteLine($"State: {capacity.Value.Data.Properties.State}");
+Console.WriteLine($"Provisioning State: {capacity.Value.Data.Properties.ProvisioningState}");
+```
+
+### 3. Update Capacity (Scale SKU or Change Admins)
+
+```csharp
+var capacity = await resourceGroup.Value
+    .GetFabricCapacityAsync("my-fabric-capacity");
+
+var patch = new FabricCapacityPatch
+{
+    Sku = new FabricSku("F128", FabricSkuTier.Fabric),  // Scale up
+    Properties = new FabricCapacityUpdateProperties
+    {
+        Administration = new FabricCapacityAdministration(
+            new[] { "admin@contoso.com", "newadmin@contoso.com" }
+        )
+    }
+};
+
+var updateOperation = await capacity.Value.UpdateAsync(
+    WaitUntil.Completed,
+    patch);
+
+Console.WriteLine($"Updated SKU: {updateOperation.Value.Data.Sku.Name}");
+```
+
+### 4. Suspend and Resume Capacity
+
+```csharp
+// Suspend capacity (stop billing for compute)
+await capacity.Value.SuspendAsync(WaitUntil.Completed);
+Console.WriteLine("Capacity suspended");
+
+// Resume capacity
+var resumeOperation = await capacity.Value.ResumeAsync(WaitUntil.Completed);
+Console.WriteLine($"Capacity resumed. State: {resumeOperation.Value.Data.Properties.State}");
+```
+
+### 5. Delete Capacity
+
+```csharp
+await capacity.Value.DeleteAsync(WaitUntil.Completed);
+Console.WriteLine("Capacity deleted");
+```
+
+### 6. List All Capacities
+
+```csharp
+// In a resource group
+await foreach (var cap in resourceGroup.Value.GetFabricCapacities())
+{
+    Console.WriteLine($"- {cap.Data.Name} ({cap.Data.Sku.Name})");
+}
+
+// In a subscription
+await foreach (var cap in subscription.GetFabricCapacitiesAsync())
+{
+    Console.WriteLine($"- {cap.Data.Name} in {cap.Data.Location}");
+}
+```
+
+### 7. Check Name Availability
+
+```csharp
+var checkContent = new FabricNameAvailabilityContent
+{
+    Name = "my-new-capacity",
+    ResourceType = "Microsoft.Fabric/capacities"
+};
+
+var result = await subscription.CheckFabricCapacityNameAvailabilityAsync(
+    AzureLocation.WestUS2,
+    checkContent);
+
+if (result.Value.IsNameAvailable == true)
+{
+    Console.WriteLine("Name is available!");
+}
+else
+{
+    Console.WriteLine($"Name unavailable: {result.Value.Reason} - {result.Value.Message}");
+}
+```
+
+### 8. List Available SKUs
+
+```csharp
+// List all SKUs available in subscription
+await foreach (var skuDetails in subscription.GetSkusFabricCapacitiesAsync())
+{
+    Console.WriteLine($"SKU: {skuDetails.Name}");
+    Console.WriteLine($"  Resource Type: {skuDetails.ResourceType}");
+    foreach (var location in skuDetails.Locations)
+    {
+        Console.WriteLine($"  Location: {location}");
+    }
+}
+
+// List SKUs available for an existing capacity (for scaling)
+await foreach (var skuDetails in capacity.Value.GetSkusForCapacityAsync())
+{
+    Console.WriteLine($"Can scale to: {skuDetails.Sku.Name}");
+}
+```
+
+## SKU Reference
+
+| SKU Name | Capacity Units (CU) | Power BI Equivalent |
+|----------|---------------------|---------------------|
+| F2 | 2 | - |
+| F4 | 4 | - |
+| F8 | 8 | EM1/A1 |
+| F16 | 16 | EM2/A2 |
+| F32 | 32 | EM3/A3 |
+| F64 | 64 | P1/A4 |
+| F128 | 128 | P2/A5 |
+| F256 | 256 | P3/A6 |
+| F512 | 512 | P4/A7 |
+| F1024 | 1024 | P5/A8 |
+| F2048 | 2048 | - |
+
+## Key Types Reference
+
+| Type | Purpose |
+|------|---------|
+| `ArmClient` | Entry point for all ARM operations |
+| `FabricCapacityResource` | Represents a Fabric capacity instance |
+| `FabricCapacityCollection` | Collection for capacity CRUD operations |
+| `FabricCapacityData` | Capacity creation/read data model |
+| `FabricCapacityPatch` | Capacity update payload |
+| `FabricCapacityProperties` | Capacity properties (administration, state) |
+| `FabricCapacityAdministration` | Admin members configuration |
+| `FabricSku` | SKU configuration (name and tier) |
+| `FabricSkuTier` | Pricing tier (currently only "Fabric") |
+| `FabricProvisioningState` | Provisioning states (Succeeded, Failed, etc.) |
+| `FabricResourceState` | Resource states (Active, Suspended, etc.) |
+| `FabricNameAvailabilityContent` | Name availability check request |
+| `FabricNameAvailabilityResult` | Name availability check response |
+
+## Provisioning and Resource States
+
+### Provisioning States (`FabricProvisioningState`)
+- `Succeeded` - Operation completed successfully
+- `Failed` - Operation failed
+- `Canceled` - Operation was canceled
+- `Deleting` - Capacity is being deleted
+- `Provisioning` - Initial provisioning in progress
+- `Updating` - Update operation in progress
+
+### Resource States (`FabricResourceState`)
+- `Active` - Capacity is running and available
+- `Provisioning` - Being provisioned
+- `Failed` - In failed state
+- `Updating` - Being updated
+- `Deleting` - Being deleted
+- `Suspending` - Transitioning to suspended
+- `Suspended` - Suspended (not billing for compute)
+- `Pausing` - Transitioning to paused
+- `Paused` - Paused
+- `Resuming` - Resuming from suspended/paused
+- `Scaling` - Scaling to different SKU
+- `Preparing` - Preparing resources
+
+## Best Practices
+
+1. **Use `WaitUntil.Completed`** for operations that must finish before proceeding
+2. **Use `WaitUntil.Started`** when you want to poll manually or run operations in parallel
+3. **Always use `DefaultAzureCredential`** — never hardcode credentials
+4. **Handle `RequestFailedException`** for ARM API errors
+5. **Use `CreateOrUpdateAsync`** for idempotent operations
+6. **Suspend when not in use** — Fabric capacities bill for compute even when idle
+7. **Check provisioning state** before performing operations on a capacity
+8. **Use appropriate SKU** — Start small (F2/F4) for dev/test, scale up for production
+
+## Error Handling
+
+```csharp
+using Azure;
+
+try
+{
+    var operation = await capacityCollection.CreateOrUpdateAsync(
+        WaitUntil.Completed, capacityName, capacityData);
+}
+catch (RequestFailedException ex) when (ex.Status == 409)
+{
+    Console.WriteLine("Capacity already exists or conflict");
+}
+catch (RequestFailedException ex) when (ex.Status == 400)
+{
+    Console.WriteLine($"Invalid configuration: {ex.Message}");
+}
+catch (RequestFailedException ex) when (ex.Status == 403)
+{
+    Console.WriteLine("Insufficient permissions or quota exceeded");
+}
+catch (RequestFailedException ex)
+{
+    Console.WriteLine($"ARM Error: {ex.Status} - {ex.ErrorCode}: {ex.Message}");
+}
+```
+
+## Common Pitfalls
+
+1. **Capacity names must be globally unique** — Fabric capacity names must be unique across all Azure subscriptions
+2. **Suspend doesn't delete** — Suspended capacities still exist but don't bill for compute
+3. **SKU changes may require downtime** — Scaling operations can take several minutes
+4. **Admin UPNs must be valid** — Capacity administrators must be valid Azure AD users
+5. **Location constraints** — Not all SKUs are available in all regions; use `GetSkusFabricCapacitiesAsync` to check
+6. **Long provisioning times** — Capacity creation can take 5-15 minutes
+
+## Related SDKs
+
+| SDK | Purpose | Install |
+|-----|---------|---------|
+| `Azure.ResourceManager.Fabric` | Management plane (this SDK) | `dotnet add package Azure.ResourceManager.Fabric` |
+| `Microsoft.Fabric.Api` | Data plane operations (beta) | `dotnet add package Microsoft.Fabric.Api --prerelease` |
+| `Azure.ResourceManager` | Core ARM SDK | `dotnet add package Azure.ResourceManager` |
+| `Azure.Identity` | Authentication | `dotnet add package Azure.Identity` |
+
+## References
+
+- [Azure.ResourceManager.Fabric NuGet](https://www.nuget.org/packages/Azure.ResourceManager.Fabric)
+- [GitHub Source](https://github.com/Azure/azure-sdk-for-net/tree/main/sdk/fabric/Azure.ResourceManager.Fabric)
+- [Microsoft Fabric Documentation](https://learn.microsoft.com/fabric/)
+- [Fabric Capacity Management](https://learn.microsoft.com/fabric/admin/service-admin-portal-capacity-settings)