[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6CWJWFRNFB75W6702BF352H":3,"skill-same:01M6CWJWFRNFB75W6702BF352H":50},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":17,"publishedAt":23,"linkOnly":24,"markdownContent":25,"markdownBody":26,"frontMatter":27,"refName":30,"commitSha":31,"skillDirectory":5,"forksCount":32,"repositoryHtmlUrl":33,"repositoryHomepageUrl":6,"ownerHtmlUrl":34,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":35,"install":36,"resources":49},"01M6CWJWFRNFB75W6702BF352H","caching",null,"Caching strategies and best practices","ffsshhttiikk\u002Fopencode-agents-skills","ffsshhttiikk","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F226346827?v=4","01M6CWD9RR3Y7VRQX3MXYC8FYH","01M6CWD9WVPYAZW0J82G1VKGHY",3,"MIT","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fcaching\u002FSKILL.md",[],[5,18,19,20,21,22],"performance","best practices","opencode","strategies","caching strategies","2026-11-10 10:12:30",false,"---\nname: caching\ndescription: Caching strategies and best practices\nlicense: MIT\ncompatibility: opencode\nmetadata:\n  audience: developers\n  category: performance\n---\n## What I do\n- Implement caching at multiple levels\n- Choose appropriate cache strategies\n- Handle cache invalidation\n- Prevent cache stampede\n- Use distributed caching effectively\n- Monitor cache performance\n- Implement cache warming\n\n## When to use me\nWhen implementing caching solutions or optimizing cache performance.\n\n## Multi-Level Caching\n```\n┌─────────────────────────────────────────────────────────────┐\n│                     Request                                │\n└────────────────────────┬────────────────────────────────────┘\n                         │\n┌────────────────────────▼────────────────────────────────────┐\n│                Browser Cache (HTTP)                         │\n│  - Cache-Control headers                                    │\n│  - ETag\u002FLast-Modified                                      │\n│  - LocalStorage\u002FSessionStorage                              │\n└────────────────────────┬────────────────────────────────────┘\n                         │\n┌────────────────────────▼────────────────────────────────────┐\n│                CDN \u002F Edge Cache                              │\n│  - CloudFront, Cloudflare                                   │\n│  - Static assets, API responses                             │\n└────────────────────────┬────────────────────────────────────┘\n                         │\n┌────────────────────────▼────────────────────────────────────┐\n│                Application Cache (Memory)                     │\n│  - In-memory caches (LRU, LFU)                              │\n│  - Per-process or shared memory                             │\n└────────────────────────┬────────────────────────────────────┘\n                         │\n┌────────────────────────▼────────────────────────────────────┐\n│                Distributed Cache (Redis\u002FMemcached)            │\n│  - Shared across instances                                  │\n│  - High availability                                        │\n└────────────────────────┬────────────────────────────────────┘\n                         │\n┌────────────────────────▼────────────────────────────────────┐\n│                Database Cache                                │\n│  - Query cache                                             │\n│  - Buffer pool                                             │\n└─────────────────────────────────────────────────────────────┘\n```\n\n## Cache Strategies\n```python\nimport redis\nimport json\nfrom typing import Optional, Callable, Any\nfrom functools import wraps\nfrom datetime import timedelta\n\n\nclass CacheService:\n    \"\"\"Multi-level cache service with TTL support.\"\"\"\n    \n    def __init__(self, redis_url: str) -> None:\n        self.redis = redis.from_url(redis_url)\n        self.local_cache = {}\n    \n    def get(self, key: str) -> Optional[Any]:\n        \"\"\"Get from cache hierarchy.\"\"\"\n        # Check local cache first\n        if key in self.local_cache:\n            value, expires = self.local_cache[key]\n            if expires > datetime.utcnow():\n                return value\n            del self.local_cache[key]\n        \n        # Check distributed cache\n        cached = self.redis.get(key)\n        if cached:\n            value = json.loads(cached)\n            # Populate local cache\n            self.local_cache[key] = (\n                value,\n                datetime.utcnow() + timedelta(seconds=60)\n            )\n            return value\n        \n        return None\n    \n    def set(\n        self,\n        key: str,\n        value: Any,\n        ttl_seconds: int = 3600,\n        local_ttl_seconds: int = 60\n    ) -> None:\n        \"\"\"Set in both cache layers.\"\"\"\n        # Set distributed cache\n        self.redis.setex(key, ttl_seconds, json.dumps(value))\n        \n        # Set local cache with shorter TTL\n        self.local_cache[key] = (\n            value,\n            datetime.utcnow() + timedelta(seconds=local_ttl_seconds)\n        )\n    \n    def delete(self, key: str) -> None:\n        \"\"\"Delete from both cache layers.\"\"\"\n        self.redis.delete(key)\n        self.local_cache.pop(key, None)\n    \n    def invalidate_pattern(self, pattern: str) -> None:\n        \"\"\"Delete keys matching pattern.\"\"\"\n        keys = self.redis.keys(pattern)\n        if keys:\n            self.redis.delete(*keys)\n        # Clear local cache\n        for key in list(self.local_cache.keys()):\n            if pattern.replace('*', '') in key:\n                del self.local_cache[key]\n\n\ndef cached(\n    ttl: int = 3600,\n    key_prefix: str = ''\n):\n    \"\"\"Decorator for caching function results.\"\"\"\n    def decorator(func: Callable) -> Callable:\n        @wraps(func)\n        def wrapper(*args, **kwargs) -> Any:\n            cache = get_cache_service()\n            key = f\"{key_prefix}:{func.__name__}:{args}:{kwargs}\"\n            \n            cached_value = cache.get(key)\n            if cached_value is not None:\n                return cached_value\n            \n            result = func(*args, **kwargs)\n            cache.set(key, result, ttl)\n            return result\n        return wrapper\n    return decorator\n```\n\n## Cache Stampede Prevention\n```python\nimport asyncio\nimport async_timeout\n\n\nclass CacheStampedePreventer:\n    \"\"\"Prevent cache stampede with distributed locking.\"\"\"\n    \n    def __init__(\n        self,\n        cache: CacheService,\n        lock_ttl: int = 30\n    ) -> None:\n        self.cache = cache\n        self.lock_ttl = lock_ttl\n    \n    async def get_or_compute(\n        self,\n        key: str,\n        compute_fn: Callable,\n        ttl: int = 3600\n    ) -> Any:\n        \"\"\"Get from cache or compute with stampede prevention.\"\"\"\n        # Try cache first\n        cached = self.cache.get(key)\n        if cached is not None:\n            return cached\n        \n        # Acquire distributed lock\n        lock_key = f\"lock:{key}\"\n        lock_acquired = self.cache.redis.set(\n            lock_key,\n            \"locked\",\n            nx=True,\n            ex=self.lock_ttl\n        )\n        \n        if not lock_acquired:\n            # Wait for other process to compute\n            return await self._wait_for_computation(key, compute_fn)\n        \n        try:\n            # Compute and cache\n            result = await compute_fn()\n            self.cache.set(key, result, ttl)\n            return result\n        finally:\n            # Release lock\n            self.cache.redis.delete(lock_key)\n    \n    async def _wait_for_computation(\n        self,\n        key: str,\n        compute_fn: Callable\n    ) -> Any:\n        \"\"\"Wait for computation to complete.\"\"\"\n        max_wait = 10  # seconds\n        \n        for _ in range(max_wait * 10):  # Poll every 100ms\n            cached = self.cache.get(key)\n            if cached is not None:\n                return cached\n            await asyncio.sleep(0.1)\n        \n        # If still not cached, compute ourselves\n        return await compute_fn()\n\n\nclass ProbabilisticEarlyRecomputation:\n    \"\"\"Prevent expired cache with early recomputation.\"\"\"\n    \n    def __init__(\n        self,\n        cache: CacheService,\n        delta_percent: int = 10\n    ) -> None:\n        self.cache = cache\n        self.delta_percent = delta_percent\n    \n    def get(self, key: str, compute_fn: Callable) -> Any:\n        \"\"\"Get with early recomputation.\"\"\"\n        cached = self.cache.get(key)\n        if cached is not None:\n            return cached\n        \n        ttl = self.cache.redis.ttl(key)\n        if ttl == -1:  # Key doesn't exist\n            return compute_fn()\n        \n        # If within delta period, recompute in background\n        threshold = ttl * (100 - self.delta_percent) \u002F 100\n        if ttl \u003C threshold:\n            # Could trigger background task here\n            pass\n        \n        return compute_fn()\n```\n\n## HTTP Caching\n```python\nfrom fastapi import Request, Response\nfrom typing import Optional\n\n\nclass CacheControlMiddleware:\n    \"\"\"Add appropriate cache control headers.\"\"\"\n    \n    def __init__(self, app):\n        self.app = app\n    \n    async def __call__(self, scope, receive, send):\n        if scope['type'] != 'http':\n            await self.app(scope, receive, send)\n            return\n        \n        async def send_wrapper(message):\n            if message['type'] == 'http.response.start':\n                request = Request(scope)\n                response = Response(\n                    content=b'',\n                    status_code=message['status'],\n                    headers=dict(message.get('headers', []))\n                )\n                \n                # Set cache headers based on route\n                if '\u002Fapi\u002F' in request.url.path:\n                    # API endpoints - no cache or short cache\n                    if '\u002Fstatic\u002F' not in request.url.path:\n                        response.headers['Cache-Control'] = 'no-cache'\n                else:\n                    # Static content - long cache\n                    response.headers['Cache-Control'] = 'public, max-age=31536000'\n                \n                message['headers'] = list(response.headers.items())\n            \n            await send(message)\n        \n        await self.app(scope, receive, send_wrapper)\n```\n\n## Cache Invalidation Patterns\n```python\n# Event-driven cache invalidation\nclass CacheInvalidator:\n    def __init__(self, cache: CacheService) -> None:\n        self.cache = cache\n        self.subscriptions = {}\n    \n    def subscribe(self, event_type: str, callback: Callable) -> None:\n        \"\"\"Subscribe to invalidation events.\"\"\"\n        if event_type not in self.subscriptions:\n            self.subscriptions[event_type] = []\n        self.subscriptions[event_type].append(callback)\n    \n    def invalidate(self, event_type: str, data: dict) -> None:\n        \"\"\"Trigger invalidation based on event.\"\"\"\n        if event_type in self.subscriptions:\n            for callback in self.subscriptions[event_type]:\n                pattern = callback(data)\n                if pattern:\n                    self.cache.invalidate_pattern(pattern)\n    \n    def on_user_update(self, user_id: str) -> None:\n        \"\"\"Invalidate user-related caches.\"\"\"\n        patterns = [\n            f\"user:{user_id}:*\",\n            f\"users:list:*\",\n            f\"stats:user:{user_id}\",\n        ]\n        for pattern in patterns:\n            self.cache.invalidate_pattern(pattern)\n```\n\n## Cache Monitoring\n```python\nclass CacheMonitor:\n    \"\"\"Monitor cache performance.\"\"\"\n    \n    def __init__(self, redis_client: redis.Redis) -> None:\n        self.redis = redis_client\n    \n    def get_stats(self) -> dict:\n        \"\"\"Get cache statistics.\"\"\"\n        info = self.redis.info('stats')\n        memory = self.redis.info('memory')\n        \n        return {\n            'hits': info.get('keyspace_hits', 0),\n            'misses': info.get('keyspace_misses', 0),\n            'hit_rate': self._calculate_hit_rate(info),\n            'used_memory': memory.get('used_memory_human'),\n            'connected_clients': self.redis.info('clients').get('connected_clients', 0),\n            'uptime_seconds': self.redis.info('server').get('uptime_in_seconds', 0),\n        }\n    \n    def _calculate_hit_rate(self, info: dict) -> float:\n        hits = info.get('keyspace_hits', 0)\n        misses = info.get('keyspace_misses', 0)\n        total = hits + misses\n        if total == 0:\n            return 0.0\n        return round(hits \u002F total * 100, 2)\n```\n","## What I do\n- Implement caching at multiple levels\n- Choose appropriate cache strategies\n- Handle cache invalidation\n- Prevent cache stampede\n- Use distributed caching effectively\n- Monitor cache performance\n- Implement cache warming\n\n## When to use me\nWhen implementing caching solutions or optimizing cache performance.\n\n## Multi-Level Caching\n```\n┌─────────────────────────────────────────────────────────────┐\n│                     Request                                │\n└────────────────────────┬────────────────────────────────────┘\n                         │\n┌────────────────────────▼────────────────────────────────────┐\n│                Browser Cache (HTTP)                         │\n│  - Cache-Control headers                                    │\n│  - ETag\u002FLast-Modified                                      │\n│  - LocalStorage\u002FSessionStorage                              │\n└────────────────────────┬────────────────────────────────────┘\n                         │\n┌────────────────────────▼────────────────────────────────────┐\n│                CDN \u002F Edge Cache                              │\n│  - CloudFront, Cloudflare                                   │\n│  - Static assets, API responses                             │\n└────────────────────────┬────────────────────────────────────┘\n                         │\n┌────────────────────────▼────────────────────────────────────┐\n│                Application Cache (Memory)                     │\n│  - In-memory caches (LRU, LFU)                              │\n│  - Per-process or shared memory                             │\n└────────────────────────┬────────────────────────────────────┘\n                         │\n┌────────────────────────▼────────────────────────────────────┐\n│                Distributed Cache (Redis\u002FMemcached)            │\n│  - Shared across instances                                  │\n│  - High availability                                        │\n└────────────────────────┬────────────────────────────────────┘\n                         │\n┌────────────────────────▼────────────────────────────────────┐\n│                Database Cache                                │\n│  - Query cache                                             │\n│  - Buffer pool                                             │\n└─────────────────────────────────────────────────────────────┘\n```\n\n## Cache Strategies\n```python\nimport redis\nimport json\nfrom typing import Optional, Callable, Any\nfrom functools import wraps\nfrom datetime import timedelta\n\n\nclass CacheService:\n    \"\"\"Multi-level cache service with TTL support.\"\"\"\n    \n    def __init__(self, redis_url: str) -> None:\n        self.redis = redis.from_url(redis_url)\n        self.local_cache = {}\n    \n    def get(self, key: str) -> Optional[Any]:\n        \"\"\"Get from cache hierarchy.\"\"\"\n        # Check local cache first\n        if key in self.local_cache:\n            value, expires = self.local_cache[key]\n            if expires > datetime.utcnow():\n                return value\n            del self.local_cache[key]\n        \n        # Check distributed cache\n        cached = self.redis.get(key)\n        if cached:\n            value = json.loads(cached)\n            # Populate local cache\n            self.local_cache[key] = (\n                value,\n                datetime.utcnow() + timedelta(seconds=60)\n            )\n            return value\n        \n        return None\n    \n    def set(\n        self,\n        key: str,\n        value: Any,\n        ttl_seconds: int = 3600,\n        local_ttl_seconds: int = 60\n    ) -> None:\n        \"\"\"Set in both cache layers.\"\"\"\n        # Set distributed cache\n        self.redis.setex(key, ttl_seconds, json.dumps(value))\n        \n        # Set local cache with shorter TTL\n        self.local_cache[key] = (\n            value,\n            datetime.utcnow() + timedelta(seconds=local_ttl_seconds)\n        )\n    \n    def delete(self, key: str) -> None:\n        \"\"\"Delete from both cache layers.\"\"\"\n        self.redis.delete(key)\n        self.local_cache.pop(key, None)\n    \n    def invalidate_pattern(self, pattern: str) -> None:\n        \"\"\"Delete keys matching pattern.\"\"\"\n        keys = self.redis.keys(pattern)\n        if keys:\n            self.redis.delete(*keys)\n        # Clear local cache\n        for key in list(self.local_cache.keys()):\n            if pattern.replace('*', '') in key:\n                del self.local_cache[key]\n\n\ndef cached(\n    ttl: int = 3600,\n    key_prefix: str = ''\n):\n    \"\"\"Decorator for caching function results.\"\"\"\n    def decorator(func: Callable) -> Callable:\n        @wraps(func)\n        def wrapper(*args, **kwargs) -> Any:\n            cache = get_cache_service()\n            key = f\"{key_prefix}:{func.__name__}:{args}:{kwargs}\"\n            \n            cached_value = cache.get(key)\n            if cached_value is not None:\n                return cached_value\n            \n            result = func(*args, **kwargs)\n            cache.set(key, result, ttl)\n            return result\n        return wrapper\n    return decorator\n```\n\n## Cache Stampede Prevention\n```python\nimport asyncio\nimport async_timeout\n\n\nclass CacheStampedePreventer:\n    \"\"\"Prevent cache stampede with distributed locking.\"\"\"\n    \n    def __init__(\n        self,\n        cache: CacheService,\n        lock_ttl: int = 30\n    ) -> None:\n        self.cache = cache\n        self.lock_ttl = lock_ttl\n    \n    async def get_or_compute(\n        self,\n        key: str,\n        compute_fn: Callable,\n        ttl: int = 3600\n    ) -> Any:\n        \"\"\"Get from cache or compute with stampede prevention.\"\"\"\n        # Try cache first\n        cached = self.cache.get(key)\n        if cached is not None:\n            return cached\n        \n        # Acquire distributed lock\n        lock_key = f\"lock:{key}\"\n        lock_acquired = self.cache.redis.set(\n            lock_key,\n            \"locked\",\n            nx=True,\n            ex=self.lock_ttl\n        )\n        \n        if not lock_acquired:\n            # Wait for other process to compute\n            return await self._wait_for_computation(key, compute_fn)\n        \n        try:\n            # Compute and cache\n            result = await compute_fn()\n            self.cache.set(key, result, ttl)\n            return result\n        finally:\n            # Release lock\n            self.cache.redis.delete(lock_key)\n    \n    async def _wait_for_computation(\n        self,\n        key: str,\n        compute_fn: Callable\n    ) -> Any:\n        \"\"\"Wait for computation to complete.\"\"\"\n        max_wait = 10  # seconds\n        \n        for _ in range(max_wait * 10):  # Poll every 100ms\n            cached = self.cache.get(key)\n            if cached is not None:\n                return cached\n            await asyncio.sleep(0.1)\n        \n        # If still not cached, compute ourselves\n        return await compute_fn()\n\n\nclass ProbabilisticEarlyRecomputation:\n    \"\"\"Prevent expired cache with early recomputation.\"\"\"\n    \n    def __init__(\n        self,\n        cache: CacheService,\n        delta_percent: int = 10\n    ) -> None:\n        self.cache = cache\n        self.delta_percent = delta_percent\n    \n    def get(self, key: str, compute_fn: Callable) -> Any:\n        \"\"\"Get with early recomputation.\"\"\"\n        cached = self.cache.get(key)\n        if cached is not None:\n            return cached\n        \n        ttl = self.cache.redis.ttl(key)\n        if ttl == -1:  # Key doesn't exist\n            return compute_fn()\n        \n        # If within delta period, recompute in background\n        threshold = ttl * (100 - self.delta_percent) \u002F 100\n        if ttl \u003C threshold:\n            # Could trigger background task here\n            pass\n        \n        return compute_fn()\n```\n\n## HTTP Caching\n```python\nfrom fastapi import Request, Response\nfrom typing import Optional\n\n\nclass CacheControlMiddleware:\n    \"\"\"Add appropriate cache control headers.\"\"\"\n    \n    def __init__(self, app):\n        self.app = app\n    \n    async def __call__(self, scope, receive, send):\n        if scope['type'] != 'http':\n            await self.app(scope, receive, send)\n            return\n        \n        async def send_wrapper(message):\n            if message['type'] == 'http.response.start':\n                request = Request(scope)\n                response = Response(\n                    content=b'',\n                    status_code=message['status'],\n                    headers=dict(message.get('headers', []))\n                )\n                \n                # Set cache headers based on route\n                if '\u002Fapi\u002F' in request.url.path:\n                    # API endpoints - no cache or short cache\n                    if '\u002Fstatic\u002F' not in request.url.path:\n                        response.headers['Cache-Control'] = 'no-cache'\n                else:\n                    # Static content - long cache\n                    response.headers['Cache-Control'] = 'public, max-age=31536000'\n                \n                message['headers'] = list(response.headers.items())\n            \n            await send(message)\n        \n        await self.app(scope, receive, send_wrapper)\n```\n\n## Cache Invalidation Patterns\n```python\n# Event-driven cache invalidation\nclass CacheInvalidator:\n    def __init__(self, cache: CacheService) -> None:\n        self.cache = cache\n        self.subscriptions = {}\n    \n    def subscribe(self, event_type: str, callback: Callable) -> None:\n        \"\"\"Subscribe to invalidation events.\"\"\"\n        if event_type not in self.subscriptions:\n            self.subscriptions[event_type] = []\n        self.subscriptions[event_type].append(callback)\n    \n    def invalidate(self, event_type: str, data: dict) -> None:\n        \"\"\"Trigger invalidation based on event.\"\"\"\n        if event_type in self.subscriptions:\n            for callback in self.subscriptions[event_type]:\n                pattern = callback(data)\n                if pattern:\n                    self.cache.invalidate_pattern(pattern)\n    \n    def on_user_update(self, user_id: str) -> None:\n        \"\"\"Invalidate user-related caches.\"\"\"\n        patterns = [\n            f\"user:{user_id}:*\",\n            f\"users:list:*\",\n            f\"stats:user:{user_id}\",\n        ]\n        for pattern in patterns:\n            self.cache.invalidate_pattern(pattern)\n```\n\n## Cache Monitoring\n```python\nclass CacheMonitor:\n    \"\"\"Monitor cache performance.\"\"\"\n    \n    def __init__(self, redis_client: redis.Redis) -> None:\n        self.redis = redis_client\n    \n    def get_stats(self) -> dict:\n        \"\"\"Get cache statistics.\"\"\"\n        info = self.redis.info('stats')\n        memory = self.redis.info('memory')\n        \n        return {\n            'hits': info.get('keyspace_hits', 0),\n            'misses': info.get('keyspace_misses', 0),\n            'hit_rate': self._calculate_hit_rate(info),\n            'used_memory': memory.get('used_memory_human'),\n            'connected_clients': self.redis.info('clients').get('connected_clients', 0),\n            'uptime_seconds': self.redis.info('server').get('uptime_in_seconds', 0),\n        }\n    \n    def _calculate_hit_rate(self, info: dict) -> float:\n        hits = info.get('keyspace_hits', 0)\n        misses = info.get('keyspace_misses', 0)\n        total = hits + misses\n        if total == 0:\n            return 0.0\n        return round(hits \u002F total * 100, 2)\n```\n",{"name":5,"license":14,"metadata":28,"description":7,"compatibility":20},{"audience":29,"category":18},"developers","main","5f7a3e453c98261f93d19a6a7de44ad8f7b72d41",2,"https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk","2026-03-01 06:55:40",{"source":8,"skillName":5,"commands":37,"prompt":47,"zipAvailable":48},[38,41,44],{"tool":39,"command":40},"npx","npx skills add ffsshhttiikk\u002Fopencode-agents-skills --skill caching",{"tool":42,"command":43},"bunx","bunx skills add ffsshhttiikk\u002Fopencode-agents-skills --skill caching",{"tool":45,"command":46},"pnpm","pnpm dlx skills add ffsshhttiikk\u002Fopencode-agents-skills --skill caching","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fcaching\u002FSKILL.md",true,[],[51,62,72,81,91,100],{"skillNo":52,"name":53,"nameZh":6,"description":54,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":55,"categories":56,"keywords":57,"publishedAt":23},"01M6CXT9TXDF79BWJTMQAPB49G","xamarin","Xamarin cross-platform development","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fxamarin\u002FSKILL.md",[],[53,58,59,60,20,61],"platform","cross-platform","mobile","development",{"skillNo":63,"name":64,"nameZh":6,"description":65,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":66,"categories":67,"keywords":68,"publishedAt":23},"01M6CXT8AD04MFYDA32VW3FKAG","wrangling","Data wrangling fundamentals","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fwrangling\u002FSKILL.md",[],[64,69,20,70,71],"data wrangling","science","data",{"skillNo":73,"name":74,"nameZh":6,"description":75,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":76,"categories":77,"keywords":78,"publishedAt":23},"01M6CXT717GCN7SRRNPBDP4508","windows","Windows operating system administration and scripting","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fwindows\u002FSKILL.md",[],[74,79,20,80],"system","scripting",{"skillNo":82,"name":83,"nameZh":6,"description":84,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":85,"categories":86,"keywords":87,"publishedAt":23},"01M6CXT54K794NMEM3XAPZZDKT","wide-column","Wide-column data model","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fwide-column\u002FSKILL.md",[],[88,89,20,90,71],"wide column","databases","model",{"skillNo":92,"name":93,"nameZh":6,"description":94,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":95,"categories":96,"keywords":97,"publishedAt":23},"01M6CXT28FMT2P4V9GZE67WA8E","wide-column-stores","Wide-column database stores","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fwide-column-stores\u002FSKILL.md",[],[98,89,20,99],"wide column stores","database",{"skillNo":101,"name":102,"nameZh":6,"description":103,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":104,"categories":105,"keywords":106,"publishedAt":23},"01M6CXT0D0M0Q4T2N7C2RX7DSN","websockets","WebSocket implementation and best practices","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fwebsockets\u002FSKILL.md",[],[102,107,108,109,20,19,110],"websocket","real-time","time","implementation"]