ai-qakit 1.0.0

package/templates/.claude/scripts/scan_commands.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""
+Scan .claude/commands directory and extract command metadata.
+"""
+
+import re
+from pathlib import Path
+from typing import Dict, List
+import yaml
+
+def extract_frontmatter(content: str) -> Dict:
+    """Extract YAML frontmatter from markdown content."""
+    match = re.match(r'^---\s*\n(.*?)\n---\s*\n', content, re.DOTALL)
+    if match:
+        try:
+            return yaml.safe_load(match.group(1))
+        except:
+            return {}
+    return {}
+
+def scan_commands(base_path: Path) -> List[Dict]:
+    """Scan all command files and extract metadata."""
+    commands = []
+
+    for cmd_file in sorted(base_path.rglob('*.md')):
+        # Get relative path from commands directory
+        rel_path = cmd_file.relative_to(base_path)
+
+        # Build command name from path
+        parts = list(rel_path.parts[:-1]) + [rel_path.stem]
+        command_name = ':'.join(parts)
+
+        # Read file and extract frontmatter
+        try:
+            content = cmd_file.read_text()
+            frontmatter = extract_frontmatter(content)
+
+            description = frontmatter.get('description', '')
+            arg_hint = frontmatter.get('argument-hint', '')
+
+            # Extract power level (⚡ count)
+            power_level = description.count('⚡')
+            clean_desc = description.replace('⚡', '').strip()
+
+            commands.append({
+                'name': command_name,
+                'path': str(rel_path),
+                'description': clean_desc,
+                'argument_hint': arg_hint,
+                'power_level': power_level,
+                'category': parts[0] if len(parts) > 1 else 'core'
+            })
+        except Exception as e:
+            print(f"Error processing {cmd_file}: {e}")
+
+    return commands
+
+def group_by_category(commands: List[Dict]) -> Dict[str, List[Dict]]:
+    """Group commands by category."""
+    categories = {}
+
+    for cmd in commands:
+        category = cmd['category']
+        if category not in categories:
+            categories[category] = []
+        categories[category].append(cmd)
+
+    return categories
+
+def main():
+    """Main execution."""
+    # Resolve relative to script location (templates/.claude/scripts/ -> templates/.claude/commands/)
+    base_path = Path(__file__).parent.parent / 'commands'
+    
+    if not base_path.exists():
+        print(f"Error: {base_path} not found")
+        return
+
+    print("Scanning commands...")
+    commands = scan_commands(base_path)
+
+    print(f"\nFound {len(commands)} commands\n")
+
+    # Group by category
+    categories = group_by_category(commands)
+
+    for category, cmds in sorted(categories.items()):
+        print(f"\n{category.upper()}:")
+        for cmd in cmds:
+            power = '⚡' * cmd['power_level'] if cmd['power_level'] > 0 else ''
+            print(f"  {cmd['name']:40} {power:10} {cmd['description'][:80]}")
+
+    # Output JSON for processing
+    import json
+    output_path = Path(__file__).parent / 'commands_data.yaml'
+    # output_path.write_text(json.dumps(commands, indent=2))
+    output_path.write_text(yaml.dump(commands, allow_unicode=True, default_flow_style=False))
+    print(f"\n✓ Saved metadata to {output_path}")
+
+if __name__ == '__main__':
+    main()

package/templates/.claude/scripts/scan_skills.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""
+Scan .claude/skills directory and extract skill metadata.
+"""
+
+import re
+from pathlib import Path
+from typing import Dict, List
+import yaml
+
+def extract_frontmatter(content: str) -> Dict:
+    """Extract YAML frontmatter from markdown content."""
+    match = re.match(r'^---\s*\n(.*?)\n---\s*\n', content, re.DOTALL)
+    if match:
+        try:
+            return yaml.safe_load(match.group(1))
+        except:
+            return {}
+    return {}
+
+def extract_first_paragraph(content: str) -> str:
+    """Extract first meaningful paragraph after frontmatter."""
+    # Remove frontmatter
+    content = re.sub(r'^---\s*\n.*?\n---\s*\n', '', content, flags=re.DOTALL)
+
+    # Find first paragraph (after headings)
+    lines = content.split('\n')
+    paragraph = []
+
+    for line in lines:
+        line = line.strip()
+        # Skip headings and empty lines
+        if line.startswith('#') or not line:
+            if paragraph:  # If we've started collecting, stop
+                break
+            continue
+
+        paragraph.append(line)
+
+        # Stop after first paragraph
+        if line.endswith('.') and len(' '.join(paragraph)) > 50:
+            break
+
+    return ' '.join(paragraph)[:200]
+
+def scan_skills(base_path: Path) -> List[Dict]:
+    """Scan all skill files and extract metadata."""
+    skills = []
+
+    for skill_file in sorted(base_path.rglob('SKILL.md')):
+        # Get skill directory name
+        skill_dir = skill_file.parent
+        skill_name = skill_dir.name
+
+        # Skip template
+        if skill_name == 'template-skill':
+            continue
+
+        # Handle nested skills (like document-skills/*)
+        if skill_dir.parent.name != 'skills':
+            parent_name = skill_dir.parent.name
+            skill_name = f"{parent_name}/{skill_name}"
+
+        try:
+            content = skill_file.read_text()
+            frontmatter = extract_frontmatter(content)
+
+            description = frontmatter.get('description', '')
+            if not description:
+                description = extract_first_paragraph(content)
+
+            # Categorize based on content/name
+            category = categorize_skill(skill_name, description, content)
+
+            skills.append({
+                'name': skill_name,
+                'path': str(skill_file.relative_to(base_path)),
+                'description': description,
+                'category': category,
+                'has_scripts': (skill_dir / 'scripts').exists(),
+                'has_references': (skill_dir / 'references').exists()
+            })
+        except Exception as e:
+            print(f"Error processing {skill_file}: {e}")
+
+    return skills
+
+def categorize_skill(name: str, description: str, content: str) -> str:
+    """Categorize skill based on name and content."""
+    lower_name = name.lower()
+    lower_desc = description.lower()
+    lower_content = content[:500].lower()
+
+    # AI/ML
+    if any(x in lower_name for x in ['ai-', 'gemini', 'multimodal', 'adk']):
+        return 'ai-ml'
+
+    # Frontend
+    if any(x in lower_name for x in ['frontend', 'ui', 'design', 'aesthetic', 'threejs']):
+        return 'frontend'
+
+    # Backend
+    if any(x in lower_name for x in ['backend', 'auth', 'payment']):
+        return 'backend'
+
+    # Infrastructure
+    if any(x in lower_name for x in ['devops', 'docker', 'cloudflare', 'gcloud']):
+        return 'infrastructure'
+
+    # Database
+    if any(x in lower_name for x in ['database', 'mongodb', 'postgresql', 'sql']):
+        return 'database'
+
+    # Development Tools
+    if any(x in lower_name for x in ['mcp', 'skill-creator', 'claude-code', 'repomix', 'docs-seeker']):
+        return 'dev-tools'
+
+    # Multimedia
+    if any(x in lower_name for x in ['media', 'chrome-devtools', 'document-skills']):
+        return 'multimedia'
+
+    # Frameworks
+    if any(x in lower_name for x in ['web-frameworks', 'mobile', 'shopify']):
+        return 'frameworks'
+
+    # Utilities
+    if any(x in lower_name for x in ['debug', 'problem', 'code-review', 'planning', 'research', 'sequential']):
+        return 'utilities'
+
+    return 'other'
+
+def group_by_category(skills: List[Dict]) -> Dict[str, List[Dict]]:
+    """Group skills by category."""
+    categories = {}
+
+    for skill in skills:
+        category = skill['category']
+        if category not in categories:
+            categories[category] = []
+        categories[category].append(skill)
+
+    return categories
+
+def main():
+    """Main execution."""
+    # Resolve relative to script location (templates/.claude/scripts/ -> templates/.claude/skills/)
+    base_path = Path(__file__).parent.parent / 'skills'
+
+    if not base_path.exists():
+        print(f"Error: {base_path} not found")
+        return
+
+    print("Scanning skills...")
+    skills = scan_skills(base_path)
+
+    print(f"\nFound {len(skills)} skills\n")
+
+    # Group by category
+    categories = group_by_category(skills)
+
+    category_names = {
+        'ai-ml': 'AI & Machine Learning',
+        'frontend': 'Frontend & Design',
+        'backend': 'Backend Development',
+        'infrastructure': 'Infrastructure & DevOps',
+        'database': 'Database & Storage',
+        'dev-tools': 'Development Tools',
+        'multimedia': 'Multimedia & Processing',
+        'frameworks': 'Frameworks & Platforms',
+        'utilities': 'Utilities & Helpers',
+        'other': 'Other'
+    }
+
+    for category, skills_list in sorted(categories.items()):
+        print(f"\n{category_names.get(category, category.upper())}:")
+        for skill in skills_list:
+            scripts = '📦' if skill['has_scripts'] else '  '
+            refs = '📚' if skill['has_references'] else '  '
+            print(f"  {scripts}{refs} {skill['name']:30} {skill['description'][:80]}")
+
+    # Output YAML for processing (generate_catalogs.py reads YAML)
+    output_path = Path(__file__).parent / 'skills_data.yaml'
+    output_path.write_text(yaml.dump(skills, allow_unicode=True, default_flow_style=False))
+    print(f"\n✓ Saved metadata to {output_path}")
+
+if __name__ == '__main__':
+    main()

package/templates/.claude/scripts/skills_data.yaml

@@ -0,0 +1,348 @@
+- category: frontend
+  description: Create aesthetically beautiful interfaces following proven design principles.
+    Use when building UI/UX, analyzing designs from inspiration sites, generating
+    design images with ai-multimodal, implementing visual hierarchy and color theory,
+    adding micro-interactions, or creating design documentation. Includes workflows
+    for capturing and analyzing inspiration screenshots with chrome-devtools and ai-multimodal,
+    iterative design image generation until aesthetic standards are met, and comprehensive
+    design system guidance covering BEAUTIFUL (aesthetic principles), RIGHT (functionality/accessibility),
+    SATISFYING (micro-interactions), and PEAK (storytelling) stages. Integrates with
+    chrome-devtools, ai-multimodal, media-processing, ui-styling, and web-frameworks
+    skills.
+  has_references: true
+  has_scripts: false
+  name: aesthetic
+  path: aesthetic/SKILL.md
+- category: frontend
+  description: Guide for creating effective skills, adding skill references, skill
+    scripts or optimizing existing skills. This skill should be used when users want
+    to create a new skill (or update an existing skill) that extends Claude's capabilities
+    with specialized knowledge, workflows, frameworks, libraries or plugins usage,
+    or API and tool integrations.
+  has_references: false
+  has_scripts: true
+  name: aesthetic/skill-creator
+  path: aesthetic/skill-creator/SKILL.md
+- category: ai-ml
+  description: Process and generate multimedia content using Google Gemini API for
+    better vision capabilities. Capabilities include analyze audio files (transcription
+    with timestamps, summarization, speech understanding, music/sound analysis up
+    to 9.5 hours), understand images (better image analysis than Claude models, captioning,
+    reasoning, object detection, design extraction, OCR, visual Q&A, segmentation,
+    handle multiple images), process videos (scene detection, Q&A, temporal analysis,
+    YouTube URLs, up to 6 hours), extract from documents (PDF tables, forms, charts,
+    diagrams, multi-page), generate images (text-to-image with Imagen 4, editing,
+    composition, refinement), generate videos (text-to-video with Veo 3, 8-second
+    clips with native audio). Use when working with audio/video files, analyzing images
+    or screenshots (instead of default vision capabilities of Claude, only fallback
+    to Claude's vision capabilities if needed), processing PDF documents, extracting
+    structured data from media, creating images/videos from text prompts, or implementing
+    multimodal AI features. Supports Gemini 3/2.5, Imagen 4, and Veo 3 models with
+    context windows up to 2M tokens.
+  has_references: true
+  has_scripts: true
+  name: ai-multimodal
+  path: ai-multimodal/SKILL.md
+- category: frontend
+  description: Master REST and GraphQL API design principles to build intuitive, scalable,
+    and maintainable APIs that delight developers. Use when designing new APIs, reviewing
+    API specifications, or establishing API design standards.
+  has_references: true
+  has_scripts: false
+  name: api-design-principles
+  path: api-design-principles/SKILL.md
+- category: backend
+  description: Build robust backend systems with modern technologies (Node.js, Python,
+    Go, Rust), frameworks (NestJS, FastAPI, Django), databases (PostgreSQL, MongoDB,
+    Redis), APIs (REST, GraphQL, gRPC), authentication (OAuth 2.1, JWT), testing strategies,
+    security best practices (OWASP Top 10), performance optimization, scalability
+    patterns (microservices, caching, sharding), DevOps practices (Docker, Kubernetes,
+    CI/CD), and monitoring. Use when designing APIs, implementing authentication,
+    optimizing database queries, setting up CI/CD pipelines, handling security vulnerabilities,
+    building microservices, or developing production-ready backend systems.
+  has_references: true
+  has_scripts: false
+  name: backend-development
+  path: backend-development/SKILL.md
+- category: multimedia
+  description: Browser automation, debugging, and performance analysis using Puppeteer
+    CLI scripts. Use for automating browsers, taking screenshots, analyzing performance,
+    monitoring network traffic, web scraping, form automation, and JavaScript debugging.
+  has_references: true
+  has_scripts: true
+  name: chrome-devtools
+  path: chrome-devtools/SKILL.md
+- category: dev-tools
+  description: Analyzes Claude Code usage patterns and provides comprehensive recommendations.
+    Runs usage analysis, discovers GitHub community resources, suggests CLAUDE.md
+    improvements, and fetches latest docs on-demand. Use when user wants to optimize
+    their Claude Code workflow, create configurations (agents/skills/commands), or
+    set up project documentation.
+  has_references: true
+  has_scripts: true
+  name: claude-code-analyzer
+  path: claude-code-analyzer/SKILL.md
+- category: utilities
+  description: Use when receiving code review feedback (especially if unclear or technically
+    questionable), when completing tasks or major features requiring review before
+    proceeding, before making any completion/success claims, or when providing constructive
+    code review to human developers. Covers receiving feedback with technical rigor,
+    requesting reviews via code-reviewer subagent, verification gates requiring evidence
+    before claims, and human code review best practices. Essential for subagent-driven
+    development, pull requests, preventing false completion claims, and mentoring
+    developers.
+  has_references: true
+  has_scripts: false
+  name: code-review
+  path: code-review/SKILL.md
+- category: other
+  description: This skill should be used when the user asks to "create a slash command",
+    "add a command", "write a custom command", "define command arguments", "use command
+    frontmatter", "organize commands", "create command with file references", "interactive
+    command", "use AskUserQuestion in command", or needs guidance on slash command
+    structure, YAML frontmatter fields, dynamic arguments, bash execution in commands,
+    user interaction patterns, or command development best practices for Claude Code.
+  has_references: true
+  has_scripts: false
+  name: command-development
+  path: command-development/SKILL.md
+- category: database
+  description: 'MongoDB and PostgreSQL database administration. Databases: MongoDB
+    (document store, aggregation, Atlas), PostgreSQL (relational, SQL, psql). Capabilities:
+    schema design, query optimization, indexing, migrations, replication, sharding,
+    backup/restore, user management, performance analysis. Actions: design, query,
+    optimize, migrate, backup, restore, index, shard databases. Keywords: MongoDB,
+    PostgreSQL, SQL, NoSQL, BSON, aggregation pipeline, Atlas, psql, pgAdmin, schema
+    design, index, query optimization, EXPLAIN, replication, sharding, backup, restore,
+    migration, ORM, Prisma, Mongoose, connection pooling, transactions, ACID. Use
+    when: designing database schemas, writing complex queries, optimizing query performance,
+    creating indexes, performing migrations, setting up replication, implementing
+    backup strategies, managing database permissions, troubleshooting slow queries.'
+  has_references: true
+  has_scripts: true
+  name: databases
+  path: databases/SKILL.md
+- category: utilities
+  description: Systematic debugging framework ensuring root cause investigation before
+    fixes. Includes four-phase debugging process, backward call stack tracing, multi-layer
+    validation, and verification protocols. Use when encountering bugs, test failures,
+    unexpected behavior, performance issues, or before claiming work complete. Prevents
+    random fixes, masks over symptoms, and false completion claims.
+  has_references: true
+  has_scripts: true
+  name: debugging
+  path: debugging/SKILL.md
+- category: other
+  description: 'Technical documentation discovery via context7 and web search. Capabilities:
+    library/framework docs lookup, topic-specific search. Keywords: llms.txt, context7,
+    documentation, library docs, API docs. Use when: searching library documentation,
+    finding framework guides, looking up API references.'
+  has_references: false
+  has_scripts: false
+  name: docs-discovery
+  path: docs-discovery/SKILL.md
+- category: dev-tools
+  description: 'Search technical documentation using executable scripts to detect
+    query type, fetch from llms.txt sources (context7.com), and analyze results. Use
+    when user needs: (1) Topic-specific documentation (features/components/concepts),
+    (2) Library/framework documentation, (3) GitHub repository analysis, (4) Documentation
+    discovery with automated agent distribution strategy'
+  has_references: true
+  has_scripts: true
+  name: docs-seeker
+  path: docs-seeker/SKILL.md
+- category: multimedia
+  description: 'Comprehensive document creation, editing, and analysis with support
+    for tracked changes, comments, formatting preservation, and text extraction. When
+    Claude needs to work with professional documents (.docx files) for: (1) Creating
+    new documents, (2) Modifying or editing content, (3) Working with tracked changes,
+    (4) Adding comments, or any other document tasks'
+  has_references: false
+  has_scripts: true
+  name: document-skills/docx
+  path: document-skills/docx/SKILL.md
+- category: multimedia
+  description: Comprehensive PDF manipulation toolkit for extracting text and tables,
+    creating new PDFs, merging/splitting documents, and handling forms. When Claude
+    needs to fill in a PDF form or programmatically process, generate, or analyze
+    PDF documents at scale.
+  has_references: false
+  has_scripts: true
+  name: document-skills/pdf
+  path: document-skills/pdf/SKILL.md
+- category: multimedia
+  description: 'Presentation creation, editing, and analysis. When Claude needs to
+    work with presentations (.pptx files) for: (1) Creating new presentations, (2)
+    Modifying or editing content, (3) Working with layouts, (4) Adding comments or
+    speaker notes, or any other presentation tasks'
+  has_references: false
+  has_scripts: true
+  name: document-skills/pptx
+  path: document-skills/pptx/SKILL.md
+- category: multimedia
+  description: 'Comprehensive spreadsheet creation, editing, and analysis with support
+    for formulas, formatting, data analysis, and visualization. When Claude needs
+    to work with spreadsheets (.xlsx, .xlsm, .csv, .tsv, etc) for: (1) Creating new
+    spreadsheets with formulas and formatting, (2) Reading or analyzing data, (3)
+    Modify existing spreadsheets while preserving formulas, (4) Data analysis and
+    visualization in spreadsheets, or (5) Recalculating formulas'
+  has_references: false
+  has_scripts: false
+  name: document-skills/xlsx
+  path: document-skills/xlsx/SKILL.md
+- category: frontend
+  description: 'Build modern frontend applications with React 18+. Architecture: Feature
+    Sliced Design (FSD). Styling: Tailwind CSS with cn() utility. UI Libraries: shadcn/ui
+    and Ant Design. Data: TanStack Query (REST) or Apollo Client (GraphQL). Routing:
+    TanStack Router or React Router DOM v6. State: Zustand (global), React Context
+    (shared). Forms: React Hook Form + Zod. Testing: Vitest + React Testing Library
+    + MSW. TypeScript strict mode, accessibility (a11y), performance optimization.
+    Use when creating components, building pages, fetching data, implementing routing,
+    managing state, or developing production-ready React applications.'
+  has_references: true
+  has_scripts: false
+  name: frontend-development
+  path: frontend-development/SKILL.md
+- category: other
+  description: 'Comprehensive infrastructure engineering covering DevOps, cloud platforms,
+    FinOps, and DevSecOps. Platforms: AWS (EC2, Lambda, S3, ECS, EKS, RDS, CloudFormation),
+    Azure basics, Cloudflare (Workers, R2, D1, Pages), GCP (GKE, Cloud Run, Cloud
+    Storage), Docker, Kubernetes. Capabilities: CI/CD pipelines (GitHub Actions, GitLab
+    CI, Jenkins), GitOps, infrastructure as code (Terraform, CloudFormation), container
+    orchestration, cost optimization, security scanning, vulnerability management,
+    secrets management, compliance (SOC2, HIPAA). Actions: deploy, configure, manage,
+    scale, monitor, secure, optimize cloud infrastructure. Keywords: AWS, EC2, Lambda,
+    S3, ECS, EKS, RDS, CloudFormation, Azure, Kubernetes, k8s, Docker, Terraform,
+    CI/CD, GitHub Actions, GitLab CI, Jenkins, ArgoCD, Flux, cost optimization, FinOps,
+    reserved instances, spot instances, security scanning, SAST, DAST, vulnerability
+    management, secrets management, Vault, compliance, monitoring, observability.
+    Use when: deploying to AWS/Azure/GCP/Cloudflare, setting up CI/CD pipelines, implementing
+    GitOps workflows, managing Kubernetes clusters, optimizing cloud costs, implementing
+    security best practices, managing infrastructure as code, container orchestration,
+    compliance requirements, cost analysis and optimization.'
+  has_references: true
+  has_scripts: true
+  name: infra-engineer
+  path: infra-engineer/SKILL.md
+- category: other
+  description: Write idiomatic modern JavaScript with ES2015+ features, async patterns,
+    functional programming, and performance optimization. Use when implementing JavaScript
+    applications, refactoring legacy code, handling async operations, applying design
+    patterns, or optimizing performance. Triggers on "destructuring", "spread operator",
+    "async/await", "Promise", "closure", "higher-order function", "event loop".
+  has_references: true
+  has_scripts: false
+  name: javascript-pro
+  path: javascript-pro/SKILL.md
+- category: frameworks
+  description: 'Cross-platform and native mobile development. Frameworks: React Native,
+    Flutter, Swift/SwiftUI, Kotlin/Jetpack Compose. Capabilities: mobile UI, offline-first
+    architecture, push notifications, deep linking, biometrics, app store deployment.
+    Actions: build, create, implement, optimize, test, deploy mobile apps. Keywords:
+    iOS, Android, React Native, Flutter, Swift, Kotlin, mobile app, offline sync,
+    push notification, deep link, biometric auth, App Store, Play Store, iOS HIG,
+    Material Design, battery optimization, memory management, mobile performance.
+    Use when: building mobile apps, implementing mobile-first UX, choosing native
+    vs cross-platform, optimizing battery/memory/network, deploying to app stores,
+    handling mobile-specific features.'
+  has_references: true
+  has_scripts: false
+  name: mobile-development
+  path: mobile-development/SKILL.md
+- category: utilities
+  description: Use when you need to plan technical solutions that are scalable, secure,
+    and maintainable.
+  has_references: true
+  has_scripts: false
+  name: planning
+  path: planning/SKILL.md
+- category: utilities
+  description: Apply systematic problem-solving techniques for complexity spirals
+    (simplification cascades), innovation blocks (collision-zone thinking), recurring
+    patterns (meta-pattern recognition), assumption constraints (inversion exercise),
+    scale uncertainty (scale game), and dispatch when stuck. Techniques derived from
+    Microsoft Amplifier project patterns adapted for immediate application.
+  has_references: true
+  has_scripts: false
+  name: problem-solving
+  path: problem-solving/SKILL.md
+- category: other
+  description: 'Prompt engineering and optimization for AI/LLMs. Capabilities: transform
+    unclear prompts, reduce token usage, improve structure, add constraints, optimize
+    for specific models, backward-compatible rewrites. Actions: improve, enhance,
+    optimize, refactor, compress prompts. Keywords: prompt engineering, prompt optimization,
+    token efficiency, LLM prompt, AI prompt, clarity, structure, system prompt, user
+    prompt, few-shot, chain-of-thought, instruction tuning, prompt compression, token
+    reduction, prompt rewrite, semantic preservation. Use when: improving unclear
+    prompts, reducing token consumption, optimizing LLM outputs, restructuring verbose
+    requests, creating system prompts, enhancing prompt clarity.'
+  has_references: false
+  has_scripts: false
+  name: prompt-enhancer
+  path: prompt-enhancer/SKILL.md
+- category: other
+  description: Write idiomatic Python code with advanced features like decorators,
+    generators, and async/await. Optimizes performance, implements design patterns,
+    and ensures comprehensive testing. Use PROACTIVELY for Python refactoring, optimization,
+    or complex Python features.
+  has_references: true
+  has_scripts: false
+  name: python-pro
+  path: python-pro/SKILL.md
+- category: dev-tools
+  description: Package entire code repositories into single AI-friendly files using
+    Repomix. Capabilities include pack codebases with customizable include/exclude
+    patterns, generate multiple output formats (XML, Markdown, plain text), preserve
+    file structure and context, optimize for AI consumption with token counting, filter
+    by file types and directories, add custom headers and summaries. Use when packaging
+    codebases for AI analysis, creating repository snapshots for LLM context, analyzing
+    third-party libraries, preparing for security audits, generating documentation
+    context, or evaluating unfamiliar codebases.
+  has_references: true
+  has_scripts: true
+  name: repomix
+  path: repomix/SKILL.md
+- category: utilities
+  description: Use when you need to research, analyze, and plan technical solutions
+    that are scalable, secure, and maintainable.
+  has_references: false
+  has_scripts: false
+  name: research
+  path: research/SKILL.md
+- category: utilities
+  description: Apply structured, reflective problem-solving for complex tasks requiring
+    multi-step analysis, revision capability, and hypothesis verification. Use for
+    complex problem decomposition, adaptive planning, analysis needing course correction,
+    problems with unclear scope, multi-step solutions, and hypothesis-driven work.
+  has_references: true
+  has_scripts: true
+  name: sequential-thinking
+  path: sequential-thinking/SKILL.md
+- category: other
+  description: Master TypeScript's advanced type system including generics, conditional
+    types, mapped types, template literals, and utility types for building type-safe
+    applications. Use when implementing complex type logic, creating reusable type
+    utilities, designing type-safe API clients, building form validation systems,
+    or ensuring compile-time type safety. Triggers on "type inference", "generic constraints",
+    "conditional type", "mapped type", "template literal type", "utility type".
+  has_references: true
+  has_scripts: false
+  name: typescript-pro
+  path: typescript-pro/SKILL.md
+- category: frontend
+  description: 'Frontend UI/UX design intelligence - activate FIRST when user requests
+    beautiful, stunning, gorgeous, or aesthetic interfaces. The primary skill for
+    design decisions before implementation. 50 styles, 21 palettes, 50 font pairings,
+    20 charts, 8 stacks (React, Next.js, Vue, Svelte, SwiftUI, React Native, Flutter,
+    Tailwind). Actions: plan, build, create, design, implement, review, fix, improve,
+    optimize, enhance, refactor, check frontend UI/UX code. Projects: website, landing
+    page, dashboard, admin panel, e-commerce, SaaS, portfolio, blog, mobile app, .html,
+    .tsx, .vue, .svelte. Elements: button, modal, navbar, sidebar, card, table, form,
+    chart. Styles: glassmorphism, claymorphism, minimalism, brutalism, neumorphism,
+    bento grid, dark mode, responsive, skeuomorphism, flat design. Topics: color palette,
+    accessibility, animation, layout, typography, font pairing, spacing, hover, shadow,
+    gradient.'
+  has_references: false
+  has_scripts: true
+  name: ui-ux-pro-max
+  path: ui-ux-pro-max/SKILL.md