opencode-skills-collection 4.1.15 → 4.1.16

package/bundled-skills/azure-communication-callingserver-java/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: azure-communication-callingserver-java
 description: "⚠️ DEPRECATED: This SDK has been renamed to Call Automation. For new projects, use azure-communication-callautomation instead. This skill is for maintaining legacy code only."
-risk: safe
+risk: critical
 source: community
 date_added: "2026-02-27"
 ---
@@ -44,7 +44,7 @@ date_added: "2026-02-27"
 import com.azure.communication.callingserver.CallingServerClient;
 import com.azure.communication.callingserver.CallingServerClientBuilder;
 
-CallingServerClient client = new CallingServerClientBuilder()
+CallingServerClient legacyClient = new CallingServerClientBuilder()
     .connectionString("<connection-string>")
     .buildClient();
 
@@ -52,7 +52,7 @@ CallingServerClient client = new CallingServerClientBuilder()
 import com.azure.communication.callautomation.CallAutomationClient;
 import com.azure.communication.callautomation.CallAutomationClientBuilder;
 
-CallAutomationClient client = new CallAutomationClientBuilder()
+CallAutomationClient automationClient = new CallAutomationClientBuilder()
     .connectionString("<connection-string>")
     .buildClient();
 ```
@@ -64,12 +64,12 @@ CallAutomationClient client = new CallAutomationClientBuilder()
 StartRecordingOptions options = new StartRecordingOptions(serverCallId)
     .setRecordingStateCallbackUri(callbackUri);
 
-StartCallRecordingResult result = client.startRecording(options);
+StartCallRecordingResult result = legacyClient.startRecording(options);
 String recordingId = result.getRecordingId();
 
-client.pauseRecording(recordingId);
-client.resumeRecording(recordingId);
-client.stopRecording(recordingId);
+legacyClient.pauseRecording(recordingId);
+legacyClient.resumeRecording(recordingId);
+legacyClient.stopRecording(recordingId);
 
 // NEW WAY - see azure-communication-callautomation skill
 ```
@@ -93,9 +93,10 @@ See the `azure-communication-callautomation-java` skill for:
 - "migrate callingserver to callautomation"
 
 ## When to Use
-This skill is applicable to execute the workflow or actions described in the overview.
+Use only when maintaining historical CallingServer code or planning migration to azure-communication-callautomation-java; do not start new integrations with the retired package.
 
 ## Limitations
-- Use this skill only when the task clearly matches the scope described above.
+- Legacy and new snippets are alternative fragments, not a drop-in migration. Pin reviewed package versions and verify the exact replacement API; the legacy recording options are not assumed compatible with Call Automation.
+- Call control and recording can affect real participants, costs and sensitive communications. Obtain call/account authorization and required participant consent, keep credentials out of code/logs, and never place or record a call merely to validate these examples.
 - Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
 - Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

package/bundled-skills/azure-cosmos-db-py/SKILL.md

@@ -5,6 +5,13 @@ risk: critical
 source: community
 date_added: "2026-02-27"
 ---
+## Bundled upstream support
+
+Supporting files are included at skill-relative paths. See [UPSTREAM-NOTICE.md](UPSTREAM-NOTICE.md) for their pinned sources, licenses, hashes, and import changes.
+
+## Restored helper safety
+
+The integration fixture in `assets/conftest_template.py` connects to the configured Cosmos endpoint; `cleanup_test_docs` deletes records explicitly added to its tracking list. Use only an isolated disposable test container with test-only records, never production data. Copying the template does not connect to Cosmos.
 
 # Cosmos DB Service Implementation
 

package/bundled-skills/azure-cosmos-db-py/UPSTREAM-LICENSE.txt

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/bundled-skills/azure-cosmos-db-py/UPSTREAM-NOTICE.md

@@ -0,0 +1,20 @@
+# Upstream helpers for azure-cosmos-db-py
+
+The files listed below were recovered from [microsoft/skills](https://github.com/microsoft/skills) at commit `fc164ba1d7a0c10377dbcc1c9ac07253b9329fdb`. The repository ID is `1135891523`.
+
+They retain the upstream **MIT** license reproduced in [UPSTREAM-LICENSE.txt](UPSTREAM-LICENSE.txt). This notice applies to the listed support files; it does not replace the license metadata of other catalog files. Preserve the upstream license and this attribution when redistributing them.
+
+License wording is unchanged; text-only trailing whitespace and EOF blank lines are normalized. Original license: https://github.com/microsoft/skills/blob/fc164ba1d7a0c10377dbcc1c9ac07253b9329fdb/LICENSE
+
+| Local file | Original upstream path | Original Git blob SHA | Import changes |
+| --- | --- | --- | --- |
+| `references/client-setup.md` | `.github/plugins/azure-sdk-python/skills/azure-cosmos-db-py/references/client-setup.md` | `c81c4c803cb119d46baa69a622b14323cca479a2` | text-only trailing whitespace and EOF blank lines normalized |
+| `references/service-layer.md` | `.github/plugins/azure-sdk-python/skills/azure-cosmos-db-py/references/service-layer.md` | `f32dc6773d273279c19702b1e52b4f68150f014c` | text-only trailing whitespace and EOF blank lines normalized |
+| `references/testing.md` | `.github/plugins/azure-sdk-python/skills/azure-cosmos-db-py/references/testing.md` | `b7bd21901bf348525b3992ab64d36fff73818cbf` | text-only trailing whitespace and EOF blank lines normalized |
+| `references/partitioning.md` | `.github/plugins/azure-sdk-python/skills/azure-cosmos-db-py/references/partitioning.md` | `a98e1758815b42fd6f1287ed6edcca735b6ec533` | text-only trailing whitespace and EOF blank lines normalized |
+| `references/error-handling.md` | `.github/plugins/azure-sdk-python/skills/azure-cosmos-db-py/references/error-handling.md` | `d9001341f2584db73eeb33d4d8929aadb6ce5c8a` | text-only trailing whitespace and EOF blank lines normalized |
+| `assets/cosmos_client_template.py` | `.github/plugins/azure-sdk-python/skills/azure-cosmos-db-py/assets/cosmos_client_template.py` | `7af70bae994cbddf64c94a3ade5464559987a124` | content unchanged |
+| `assets/service_template.py` | `.github/plugins/azure-sdk-python/skills/azure-cosmos-db-py/assets/service_template.py` | `2efff3e0a13eac98ed6cbfb834e243d6a7600598` | content unchanged |
+| `assets/conftest_template.py` | `.github/plugins/azure-sdk-python/skills/azure-cosmos-db-py/assets/conftest_template.py` | `996c3025b3c83e756bc7e070777cb4550a4480dd` | content unchanged |
+
+The integration fixture in `assets/conftest_template.py` connects to the configured Cosmos endpoint; `cleanup_test_docs` deletes only IDs explicitly added to its tracking list. Copying the template does not connect to Cosmos. Use an isolated disposable test container and test-only records; never point it at production data. No live account was used during restoration.

package/bundled-skills/azure-cosmos-db-py/assets/conftest_template.py

@@ -0,0 +1,332 @@
+"""
+pytest Fixtures Template for Cosmos DB Testing
+
+Production-ready test fixtures with:
+- Mock Cosmos container
+- Async operation mocking
+- Sample document factories
+- Integration test support
+
+Usage:
+    Place in tests/conftest.py or import into test modules.
+"""
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any, Generator
+from unittest.mock import MagicMock
+
+import pytest
+
+
+# -----------------------------------------------------------------------------
+# Core Cosmos Fixtures
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture
+def mock_cosmos_container() -> MagicMock:
+    """
+    Mock Cosmos container with default behaviors.
+
+    Returns:
+        MagicMock configured for common Cosmos operations
+    """
+    container = MagicMock()
+
+    # Default return values
+    container.read_item.return_value = None
+    container.upsert_item.side_effect = lambda doc: doc  # Return the doc
+    container.delete_item.return_value = None
+    container.query_items.return_value = iter([])
+
+    return container
+
+
+@pytest.fixture
+def mock_cosmos(mock_cosmos_container: MagicMock, mocker) -> MagicMock:
+    """
+    Patch get_container to return mock container.
+
+    Usage:
+        def test_something(mock_cosmos):
+            mock_cosmos.read_item.return_value = {"id": "123", ...}
+            result = await my_service.get_by_id("123", "workspace")
+    """
+    mocker.patch("app.db.cosmos.get_container", return_value=mock_cosmos_container)
+    return mock_cosmos_container
+
+
+@pytest.fixture
+def mock_cosmos_unavailable(mocker) -> None:
+    """
+    Simulate Cosmos being unavailable.
+
+    Usage:
+        def test_graceful_degradation(mock_cosmos_unavailable):
+            result = await my_service.list_items("workspace")
+            assert result == []
+    """
+    mocker.patch("app.db.cosmos.get_container", return_value=None)
+
+
+@pytest.fixture
+def mock_cosmos_async(mock_cosmos_container: MagicMock, mocker) -> MagicMock:
+    """
+    Mock the async wrapper functions (upsert_document, get_document, etc.).
+
+    This is useful when testing service layer directly.
+    """
+    from azure.cosmos.exceptions import CosmosResourceNotFoundError
+
+    async def mock_upsert(doc: dict, partition_key: str) -> dict:
+        return mock_cosmos_container.upsert_item(doc)
+
+    async def mock_get(doc_id: str, partition_key: str) -> dict | None:
+        try:
+            return mock_cosmos_container.read_item(
+                item=doc_id, partition_key=partition_key
+            )
+        except CosmosResourceNotFoundError:
+            return None
+
+    async def mock_delete(doc_id: str, partition_key: str) -> bool:
+        try:
+            mock_cosmos_container.delete_item(
+                item=doc_id, partition_key=partition_key
+            )
+            return True
+        except CosmosResourceNotFoundError:
+            return False
+
+    async def mock_query(
+        doc_type: str,
+        partition_key: str | None = None,
+        extra_filter: str | None = None,
+        parameters: list | None = None,
+    ) -> list[dict]:
+        return list(mock_cosmos_container.query_items())
+
+    mocker.patch("app.db.cosmos.upsert_document", side_effect=mock_upsert)
+    mocker.patch("app.db.cosmos.get_document", side_effect=mock_get)
+    mocker.patch("app.db.cosmos.delete_document", side_effect=mock_delete)
+    mocker.patch("app.db.cosmos.query_documents", side_effect=mock_query)
+    mocker.patch("app.db.cosmos.get_container", return_value=mock_cosmos_container)
+
+    return mock_cosmos_container
+
+
+# -----------------------------------------------------------------------------
+# Test Data Factories
+# -----------------------------------------------------------------------------
+
+
+@dataclass
+class ProjectFactory:
+    """
+    Factory for creating test project data.
+
+    Usage:
+        factory = ProjectFactory(name="Custom Name")
+        mock_cosmos.read_item.return_value = factory.to_doc()
+    """
+
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    name: str = "Test Project"
+    description: str = "Test description"
+    slug: str = "test-project"
+    workspace_id: str = "ws-test"
+    author_id: str = "user-test"
+    visibility: str = "public"
+    tags: list[str] = field(default_factory=list)
+    created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    updated_at: datetime | None = None
+
+    def to_doc(self) -> dict[str, Any]:
+        """Convert to Cosmos document format."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "description": self.description,
+            "slug": self.slug,
+            "workspaceId": self.workspace_id,
+            "authorId": self.author_id,
+            "visibility": self.visibility,
+            "tags": self.tags,
+            "createdAt": self.created_at.isoformat(),
+            "updatedAt": self.updated_at.isoformat() if self.updated_at else None,
+            "docType": "project",
+        }
+
+
+@dataclass
+class WorkspaceFactory:
+    """Factory for creating test workspace data."""
+
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    name: str = "Test Workspace"
+    description: str = "Test workspace description"
+    slug: str = "test-workspace"
+    owner_id: str = "user-test"
+    visibility: str = "private"
+    created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+
+    def to_doc(self) -> dict[str, Any]:
+        """Convert to Cosmos document format."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "description": self.description,
+            "slug": self.slug,
+            "ownerId": self.owner_id,
+            "visibility": self.visibility,
+            "createdAt": self.created_at.isoformat(),
+            "docType": "workspace",
+        }
+
+
+@dataclass
+class UserFactory:
+    """Factory for creating test user data."""
+
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    email: str = "test@example.com"
+    name: str = "Test User"
+    avatar_url: str | None = None
+    role: str = "author"
+    created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+
+    def to_doc(self) -> dict[str, Any]:
+        """Convert to Cosmos document format."""
+        return {
+            "id": self.id,
+            "email": self.email,
+            "name": self.name,
+            "avatarUrl": self.avatar_url,
+            "role": self.role,
+            "createdAt": self.created_at.isoformat(),
+            "docType": "user",
+        }
+
+
+# -----------------------------------------------------------------------------
+# Sample Document Fixtures
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture
+def sample_project_doc() -> dict[str, Any]:
+    """Sample project document as stored in Cosmos."""
+    return ProjectFactory().to_doc()
+
+
+@pytest.fixture
+def sample_workspace_doc() -> dict[str, Any]:
+    """Sample workspace document as stored in Cosmos."""
+    return WorkspaceFactory().to_doc()
+
+
+@pytest.fixture
+def sample_user_doc() -> dict[str, Any]:
+    """Sample user document as stored in Cosmos."""
+    return UserFactory().to_doc()
+
+
+# -----------------------------------------------------------------------------
+# Integration Test Fixtures
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture(scope="module")
+def cosmos_container_integration():
+    """
+    Real Cosmos container for integration tests.
+
+    Requires COSMOS_ENDPOINT environment variable.
+    Skipped if not configured.
+    """
+    import os
+
+    if not os.getenv("COSMOS_ENDPOINT"):
+        pytest.skip("COSMOS_ENDPOINT not configured for integration tests")
+
+    from app.db.cosmos import get_container, reset_connection
+
+    reset_connection()
+    container = get_container()
+
+    if container is None:
+        pytest.skip("Could not connect to Cosmos DB")
+
+    yield container
+
+    reset_connection()
+
+
+@pytest.fixture
+def cleanup_test_docs(
+    cosmos_container_integration,
+) -> Generator[list[tuple[str, str]], None, None]:
+    """
+    Track and clean up test documents after each integration test.
+
+    Usage:
+        def test_create(cleanup_test_docs):
+            project = await service.create(...)
+            cleanup_test_docs.append((project.id, project.workspace_id))
+            # Document will be deleted after test
+    """
+    created: list[tuple[str, str]] = []
+    yield created
+
+    # Cleanup
+    for doc_id, partition_key in created:
+        try:
+            cosmos_container_integration.delete_item(
+                item=doc_id, partition_key=partition_key
+            )
+        except Exception:
+            pass  # Ignore cleanup errors
+
+
+# -----------------------------------------------------------------------------
+# Model Fixtures (customize for your models)
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture
+def project_create_data():
+    """
+    Sample ProjectCreate for testing.
+
+    TODO: Import and use your actual ProjectCreate model.
+    """
+    # from app.models.project import ProjectCreate
+    # return ProjectCreate(
+    #     name="New Project",
+    #     description="Test description",
+    #     workspace_id="ws-test",
+    #     visibility="public",
+    #     tags=["test"],
+    # )
+    return {
+        "name": "New Project",
+        "description": "Test description",
+        "workspace_id": "ws-test",
+        "visibility": "public",
+        "tags": ["test"],
+    }
+
+
+@pytest.fixture
+def project_update_data():
+    """
+    Sample ProjectUpdate for testing.
+
+    TODO: Import and use your actual ProjectUpdate model.
+    """
+    # from app.models.project import ProjectUpdate
+    # return ProjectUpdate(name="Updated Name")
+    return {"name": "Updated Name"}

package/bundled-skills/azure-cosmos-db-py/assets/cosmos_client_template.py

@@ -0,0 +1,225 @@
+"""
+Cosmos DB Client Module Template
+
+Production-ready Azure Cosmos DB NoSQL client with:
+- Dual authentication (DefaultAzureCredential for Azure, key for emulator)
+- Singleton pattern for connection reuse
+- Async wrapping via run_in_threadpool
+- Graceful error handling
+
+Usage:
+    from app.db.cosmos import get_container, upsert_document, get_document
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional
+
+from azure.cosmos import ContainerProxy, CosmosClient
+from azure.cosmos.exceptions import CosmosResourceNotFoundError
+from azure.identity import DefaultAzureCredential
+from starlette.concurrency import run_in_threadpool
+
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+# Module-level singleton state
+_cosmos_container: Optional[ContainerProxy] = None
+_credential: Optional[DefaultAzureCredential] = None
+_init_attempted: bool = False
+
+
+def _is_emulator_endpoint(endpoint: str) -> bool:
+    """Detect if endpoint is Cosmos emulator."""
+    return "localhost" in endpoint.lower() or "127.0.0.1" in endpoint
+
+
+def _create_client() -> CosmosClient:
+    """Create Cosmos client with appropriate authentication."""
+    global _credential
+
+    if _is_emulator_endpoint(settings.cosmos_endpoint):
+        logger.info("Using Cosmos emulator with key authentication")
+        return CosmosClient(
+            url=settings.cosmos_endpoint,
+            credential=settings.cosmos_key,
+            connection_verify=False,  # Emulator uses self-signed cert
+        )
+    else:
+        logger.info("Using Azure Cosmos with DefaultAzureCredential (RBAC)")
+        _credential = DefaultAzureCredential()
+        return CosmosClient(
+            url=settings.cosmos_endpoint,
+            credential=_credential,
+        )
+
+
+def get_container() -> Optional[ContainerProxy]:
+    """
+    Get Cosmos container proxy, initializing on first call.
+
+    Returns:
+        ContainerProxy if connection successful, None otherwise.
+    """
+    global _cosmos_container, _init_attempted
+
+    if _init_attempted:
+        return _cosmos_container
+
+    _init_attempted = True
+
+    try:
+        client = _create_client()
+        database = client.get_database_client(settings.cosmos_database_name)
+        _cosmos_container = database.get_container_client(settings.cosmos_container_id)
+
+        # Verify connection with lightweight operation
+        _cosmos_container.read()
+
+        logger.info(
+            f"✅ Cosmos DB connected: {settings.cosmos_database_name}/{settings.cosmos_container_id}"
+        )
+
+    except Exception as e:
+        logger.error(f"❌ Cosmos DB connection failed: {type(e).__name__}: {e}")
+        import traceback
+
+        logger.error(traceback.format_exc())
+        _cosmos_container = None
+
+    return _cosmos_container
+
+
+def reset_connection() -> None:
+    """Reset connection for testing or environment switching."""
+    global _cosmos_container, _credential, _init_attempted
+    _cosmos_container = None
+    _credential = None
+    _init_attempted = False
+
+
+# -----------------------------------------------------------------------------
+# Async CRUD Operations
+# -----------------------------------------------------------------------------
+
+
+async def upsert_document(doc: dict[str, Any], partition_key: str) -> dict[str, Any]:
+    """
+    Insert or update a document.
+
+    Args:
+        doc: Document to upsert (must include 'id' field)
+        partition_key: Partition key value
+
+    Returns:
+        The upserted document
+
+    Raises:
+        RuntimeError: If Cosmos is not initialized
+    """
+    container = get_container()
+    if container is None:
+        raise RuntimeError("Cosmos DB not initialized")
+
+    result = await run_in_threadpool(container.upsert_item, doc)
+    return result
+
+
+async def get_document(doc_id: str, partition_key: str) -> Optional[dict[str, Any]]:
+    """
+    Read a document by ID.
+
+    Args:
+        doc_id: Document ID
+        partition_key: Partition key value
+
+    Returns:
+        Document dict if found, None otherwise
+    """
+    container = get_container()
+    if container is None:
+        return None
+
+    try:
+        result = await run_in_threadpool(
+            container.read_item,
+            item=doc_id,
+            partition_key=partition_key,
+        )
+        return result
+    except CosmosResourceNotFoundError:
+        return None
+
+
+async def delete_document(doc_id: str, partition_key: str) -> bool:
+    """
+    Delete a document.
+
+    Args:
+        doc_id: Document ID
+        partition_key: Partition key value
+
+    Returns:
+        True if deleted, False if not found
+    """
+    container = get_container()
+    if container is None:
+        return False
+
+    try:
+        await run_in_threadpool(
+            container.delete_item,
+            item=doc_id,
+            partition_key=partition_key,
+        )
+        return True
+    except CosmosResourceNotFoundError:
+        return False
+
+
+async def query_documents(
+    doc_type: str,
+    partition_key: Optional[str] = None,
+    extra_filter: Optional[str] = None,
+    parameters: Optional[list[dict[str, Any]]] = None,
+) -> list[dict[str, Any]]:
+    """
+    Query documents by type with optional filters.
+
+    Args:
+        doc_type: Document type to filter by (docType field)
+        partition_key: Partition key for efficient query (None for cross-partition)
+        extra_filter: Additional SQL WHERE clause (e.g., "AND c.slug = @slug")
+        parameters: Query parameters list (e.g., [{"name": "@slug", "value": "my-slug"}])
+
+    Returns:
+        List of matching documents
+    """
+    container = get_container()
+    if container is None:
+        return []
+
+    # Build parameterized query
+    query = "SELECT * FROM c WHERE c.docType = @docType"
+    query_params: list[dict[str, Any]] = [{"name": "@docType", "value": doc_type}]
+
+    if extra_filter:
+        query += f" {extra_filter}"
+        query_params.extend(parameters or [])
+
+    # Execute query
+    if partition_key:
+        items = container.query_items(
+            query=query,
+            parameters=query_params,
+            partition_key=partition_key,
+        )
+    else:
+        items = container.query_items(
+            query=query,
+            parameters=query_params,
+            enable_cross_partition_query=True,
+        )
+
+    return await run_in_threadpool(list, items)