claude-code-templates 1.21.12 → 1.21.14

package/cli-tool/components/commands/svelte/svelte-test-coverage.md

@@ -0,0 +1,77 @@
+# /svelte:test-coverage
+
+Analyze test coverage, identify testing gaps, and provide recommendations for improving test coverage in Svelte/SvelteKit projects.
+
+## Instructions
+
+You are acting as the Svelte Testing Specialist Agent focused on test coverage analysis. When analyzing coverage:
+
+1. **Coverage Analysis**:
+   - Run coverage reports
+   - Identify untested files and functions
+   - Analyze coverage metrics (statements, branches, functions, lines)
+   - Find critical paths without tests
+
+2. **Gap Identification**:
+   
+   **Component Coverage**:
+   - Props not tested
+   - Event handlers without tests
+   - Conditional rendering paths
+   - Error states
+   - Edge cases
+   
+   **Route Coverage**:
+   - Untested load functions
+   - Form actions without tests
+   - Error boundaries
+   - Authentication flows
+   
+   **Business Logic**:
+   - Stores without tests
+   - Utility functions
+   - Data transformations
+   - API integrations
+
+3. **Priority Matrix**:
+   ```
+   High Priority:
+   - Core user flows
+   - Payment/checkout processes
+   - Authentication/authorization
+   - Data mutations
+   
+   Medium Priority:
+   - UI component variations
+   - Form validations
+   - Navigation flows
+   
+   Low Priority:
+   - Static content
+   - Simple presentational components
+   ```
+
+4. **Coverage Report Actions**:
+   - Generate visual coverage reports
+   - Create coverage badges
+   - Set up coverage thresholds
+   - Integrate with CI/CD
+
+5. **Recommendations**:
+   - Suggest specific tests to write
+   - Identify high-risk untested code
+   - Propose testing strategies
+   - Estimate effort for coverage improvement
+
+## Example Usage
+
+User: "Analyze test coverage for my e-commerce site"
+
+Assistant will:
+- Run coverage analysis
+- Identify critical untested paths (checkout, payment)
+- Find components with low coverage
+- Analyze store and API coverage
+- Create prioritized test writing plan
+- Suggest coverage threshold targets
+- Provide specific test examples for gaps

package/cli-tool/components/commands/svelte/svelte-test-fix.md

@@ -0,0 +1,74 @@
+# /svelte:test-fix
+
+Troubleshoot and fix failing tests in Svelte/SvelteKit projects, including debugging test issues and resolving common testing problems.
+
+## Instructions
+
+You are acting as the Svelte Testing Specialist Agent focused on fixing test issues. When troubleshooting tests:
+
+1. **Diagnose Test Failures**:
+   - Analyze error messages and stack traces
+   - Identify failure patterns (flaky, consistent, environment-specific)
+   - Check test logs and debug output
+   - Review recent code changes
+
+2. **Common Test Issues**:
+   
+   **Component Tests**:
+   - Async timing issues → Use `await tick()` or `flushSync()`
+   - Component not cleaning up → Ensure proper unmounting
+   - State not updating → Check reactivity and bindings
+   - DOM queries failing → Use proper Testing Library queries
+   
+   **E2E Tests**:
+   - Timing issues → Add proper waits and assertions
+   - Selector problems → Use data-testid attributes
+   - Navigation failures → Check route configurations
+   - API mocking issues → Verify mock setup
+   
+   **Environment Issues**:
+   - Module resolution → Check import paths
+   - TypeScript errors → Verify test tsconfig
+   - Missing globals → Configure test environment
+   - Build conflicts → Separate test builds
+
+3. **Debugging Techniques**:
+   ```javascript
+   // Add debug helpers
+   const { debug } = render(Component);
+   debug(); // Print DOM
+   
+   // Component state inspection
+   console.log('Props:', component.$$.props);
+   console.log('Context:', component.$$.context);
+   
+   // Playwright debugging
+   await page.pause(); // Interactive debugging
+   await page.screenshot({ path: 'debug.png' });
+   ```
+
+4. **Fix Strategies**:
+   - Isolate failing tests
+   - Add detailed logging
+   - Simplify test cases
+   - Mock external dependencies
+   - Fix timing/race conditions
+
+5. **Prevention**:
+   - Add retry logic for flaky tests
+   - Improve test stability
+   - Set up better error reporting
+   - Create test utilities
+
+## Example Usage
+
+User: "My component tests are failing with 'Cannot access before initialization' errors"
+
+Assistant will:
+- Analyze the test setup
+- Check component lifecycle
+- Identify initialization issues
+- Fix async/timing problems
+- Add proper test utilities
+- Ensure cleanup procedures
+- Provide debugging tips

package/cli-tool/components/commands/svelte/svelte-test-setup.md

@@ -0,0 +1,85 @@
+# /svelte:test-setup
+
+Set up comprehensive testing infrastructure for Svelte/SvelteKit projects, including unit testing, component testing, and E2E testing frameworks.
+
+## Instructions
+
+You are acting as the Svelte Testing Specialist Agent focused on testing infrastructure. When setting up testing:
+
+1. **Assess Current State**:
+   - Check existing test setup
+   - Identify missing testing tools
+   - Review package.json for test scripts
+   - Analyze project structure
+
+2. **Testing Stack Setup**:
+   
+   **Unit/Component Testing (Vitest)**:
+   - Install dependencies: `vitest`, `@testing-library/svelte`, `jsdom`
+   - Configure vitest.config.js
+   - Set up test helpers and utilities
+   - Create setup files
+   
+   **E2E Testing (Playwright)**:
+   - Install Playwright
+   - Configure playwright.config.js
+   - Set up test fixtures
+   - Create page object models
+   
+   **Additional Tools**:
+   - Coverage reporting (c8/istanbul)
+   - Test utilities (@testing-library/user-event)
+   - Mock service worker for API mocking
+   - Visual regression testing tools
+
+3. **Configuration Files**:
+   ```javascript
+   // vitest.config.js
+   import { sveltekit } from '@sveltejs/kit/vite';
+   import { defineConfig } from 'vitest/config';
+   
+   export default defineConfig({
+     plugins: [sveltekit()],
+     test: {
+       environment: 'jsdom',
+       setupFiles: ['./src/tests/setup.ts'],
+       coverage: {
+         reporter: ['text', 'html', 'lcov']
+       }
+     }
+   });
+   ```
+
+4. **Test Structure**:
+   ```
+   src/
+   ├── tests/
+   │   ├── setup.ts
+   │   ├── helpers/
+   │   └── fixtures/
+   ├── routes/
+   │   └── +page.test.ts
+   └── lib/
+       └── Component.test.ts
+   ```
+
+5. **NPM Scripts**:
+   - `test`: Run all tests
+   - `test:unit`: Run unit tests
+   - `test:e2e`: Run E2E tests
+   - `test:coverage`: Generate coverage report
+   - `test:watch`: Run tests in watch mode
+
+## Example Usage
+
+User: "Set up testing for my new SvelteKit project"
+
+Assistant will:
+- Analyze current project setup
+- Install and configure Vitest
+- Install and configure Playwright
+- Create test configuration files
+- Set up test utilities and helpers
+- Add comprehensive npm scripts
+- Create example tests
+- Set up CI/CD test workflows

package/cli-tool/components/commands/svelte/svelte-test.md

@@ -0,0 +1,60 @@
+# /svelte:test
+
+Create comprehensive tests for Svelte components and SvelteKit routes, including unit tests, component tests, and E2E tests.
+
+## Instructions
+
+You are acting as the Svelte Testing Specialist Agent. When creating tests:
+
+1. **Analyze the Target**:
+   - Identify what needs testing (component, route, store, utility)
+   - Determine appropriate test types (unit, integration, E2E)
+   - Review existing test patterns in the codebase
+
+2. **Test Creation Strategy**:
+   - **Component Tests**: User interactions, prop variations, slots, events
+   - **Route Tests**: Load functions, form actions, error handling
+   - **Store Tests**: State changes, derived values, subscriptions
+   - **E2E Tests**: User flows, navigation, form submissions
+
+3. **Test Structure**:
+   ```javascript
+   // Component Test Example
+   import { render, fireEvent } from '@testing-library/svelte';
+   import { expect, test, describe } from 'vitest';
+   
+   describe('Component', () => {
+     test('user interaction', async () => {
+       // Arrange
+       // Act
+       // Assert
+     });
+   });
+   ```
+
+4. **Coverage Areas**:
+   - Happy path scenarios
+   - Edge cases and error states
+   - Accessibility requirements
+   - Performance constraints
+   - Security considerations
+
+5. **Test Types to Generate**:
+   - Vitest unit/component tests
+   - Playwright E2E tests
+   - Accessibility tests
+   - Performance tests
+   - Visual regression tests
+
+## Example Usage
+
+User: "Create tests for my UserProfile component that has edit mode"
+
+Assistant will:
+- Analyze UserProfile component structure
+- Create comprehensive component tests
+- Test view/edit mode transitions
+- Test form validation in edit mode
+- Add accessibility tests
+- Create E2E test for full user flow
+- Suggest additional test scenarios

package/cli-tool/components/commands/sync/bidirectional-sync.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [sync-mode] | --full | --incremental | --dry-run | --conflict-strategy
+description: Enable comprehensive bidirectional GitHub-Linear synchronization with conflict resolution
+model: sonnet
+---
+
+# Bidirectional Sync
+
+Enable comprehensive bidirectional GitHub-Linear synchronization: **$ARGUMENTS**
+
+## Current Sync Environment
+
+- GitHub status: !`gh api user 2>/dev/null && echo "✓ Authenticated" || echo "⚠ Not authenticated"`
+- Linear MCP: Check if Linear MCP server is available and configured
+- Sync state: @.sync-state.json or @sync/ (if exists)
+- Webhooks: !`gh api repos/{owner}/{repo}/hooks 2>/dev/null | grep -c linear || echo "0"`
+
+## Task
+
+Implement robust bidirectional synchronization between GitHub Issues and Linear tasks:
+
+**Sync Mode**: Use $ARGUMENTS to specify full sync, incremental sync, dry-run preview, or conflict resolution strategy
+
+**Synchronization Framework**:
+1. **Sync State Management** - Initialize sync database, track entity relationships, maintain sync history
+2. **Conflict Detection** - Identify simultaneous changes, field-level conflicts, timing issues
+3. **Resolution Strategies** - NEWER_WINS, GITHUB_WINS, LINEAR_WINS, or intelligent field-level merge
+4. **Transaction Management** - Atomic operations, rollback capability, distributed locking
+5. **Webhook Integration** - Real-time event handling, sync loop prevention, automated triggers
+6. **Data Integrity** - Bidirectional validation, cross-reference maintenance, audit trails
+
+**Advanced Features**: Field-level merge rules, sync loop prevention, webhook automation, performance optimization, comprehensive monitoring.
+
+**Production Ready**: Transaction safety, conflict resolution, error recovery, performance monitoring, comprehensive logging.
+
+**Output**: Complete bidirectional sync system with conflict resolution, webhook integration, performance metrics, and comprehensive sync reporting.

package/cli-tool/components/commands/sync/bulk-import-issues.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [import-scope] | --state | --label | --milestone | --batch-size
+description: Bulk import GitHub issues to Linear with comprehensive progress tracking and error handling
+model: sonnet
+---
+
+# Bulk Import Issues
+
+Bulk import GitHub issues to Linear with advanced processing capabilities: **$ARGUMENTS**
+
+## Current Import Context
+
+- Repository: !`gh repo view --json nameWithOwner -q .nameWithOwner 2>/dev/null || echo "No repo context"`
+- Issue count: !`gh api repos/{owner}/{repo}/issues?state=all --paginate | jq length 2>/dev/null || echo "Check manually"`
+- Linear teams: Check available Linear teams and projects for import mapping
+- Rate limits: !`gh api rate_limit -q '.rate | "GitHub: \(.remaining)/\(.limit)"' 2>/dev/null || echo "Check GitHub rate limit"`
+
+## Task
+
+Execute efficient bulk import of GitHub issues to Linear with comprehensive management:
+
+**Import Scope**: Use $ARGUMENTS to filter by state, labels, milestones, or configure batch processing parameters
+
+**Import Pipeline**:
+1. **Pre-Import Analysis** - Issue discovery, duplicate detection, import estimation, resource planning
+2. **Batch Configuration** - Dynamic batch sizing, rate limit management, progress tracking, error handling
+3. **Data Transformation** - Field mapping, priority inference, user mapping, content enhancement
+4. **Import Execution** - Parallel processing, retry logic, transaction management, progress reporting
+5. **Error Recovery** - Failed item handling, retry mechanisms, partial import recovery, validation
+6. **Post-Import Actions** - Cross-reference creation, GitHub updates, mapping files, notifications
+
+**Advanced Features**: Dynamic batch adjustment, intelligent rate limiting, duplicate detection, comprehensive error recovery, progress visualization.
+
+**Quality Assurance**: Pre-import validation, post-import verification, data integrity checks, comprehensive audit trails.
+
+**Output**: Complete import results with success metrics, failed item reports, mapping documentation, and performance analytics for large-scale issue migration.

package/cli-tool/components/commands/sync/cross-reference-manager.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [action] | audit | repair | map | validate | export
+description: Manage cross-platform reference links between GitHub and Linear with integrity checking
+model: sonnet
+---
+
+# Cross-Reference Manager
+
+Manage comprehensive cross-platform reference links with integrity validation: **$ARGUMENTS**
+
+## Current Reference State
+
+- GitHub CLI: !`gh --version 2>/dev/null && echo "✓ Available" || echo "⚠ Not available"`
+- Linear MCP: Check Linear MCP server connectivity and authentication
+- Reference database: @.reference-mappings.json or reference state files
+- Link integrity: !`find . -name "*sync*" -o -name "*reference*" | wc -l` mapping files found
+
+## Task
+
+Implement comprehensive cross-reference management for GitHub-Linear integration:
+
+**Management Action**: Use $ARGUMENTS to specify audit, repair, mapping, validation, or export operations
+
+**Reference Management Framework**:
+1. **Reference Database** - Initialize mapping storage, track bidirectional links, maintain sync history
+2. **Integrity Auditing** - Scan cross-references, identify orphaned links, detect mismatches, validate consistency
+3. **Smart Repair** - Fix broken references, update outdated links, consolidate duplicates, remove invalid entries
+4. **Mapping Visualization** - Display reference networks, show connection health, highlight problems, provide statistics
+5. **Deep Validation** - Verify link functionality, test bidirectional navigation, check field consistency, ensure data integrity
+6. **Export & Documentation** - Generate mapping reports, create backup files, provide import instructions, maintain audit trails
+
+**Advanced Features**: Automated orphan detection, intelligent reference reconstruction, duplicate consolidation, comprehensive validation.
+
+**Data Protection**: Backup before modifications, transaction-based operations, rollback capabilities, comprehensive logging.
+
+**Output**: Complete reference management system with integrity reports, repair summaries, mapping visualizations, and comprehensive cross-platform link maintenance.

package/cli-tool/components/commands/sync/issue-to-linear-task.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [issue-number] | --team | --project | --close-github | --skip-comments
+description: Convert individual GitHub issues to Linear tasks with comprehensive data preservation
+model: sonnet
+---
+
+# Issue to Linear Task
+
+Convert GitHub issues to Linear tasks with comprehensive field mapping: **$ARGUMENTS**
+
+## Current Conversion Context
+
+- Repository: !`gh repo view --json nameWithOwner -q .nameWithOwner 2>/dev/null || echo "No repo context"`
+- Issue details: Based on $ARGUMENTS issue number or selection criteria
+- Linear teams: Available Linear teams and project assignments
+- User mappings: @user-mappings.json or GitHub-Linear user correspondence
+
+## Task
+
+Execute precise conversion of individual GitHub issues to Linear tasks:
+
+**Issue Target**: Use $ARGUMENTS to specify issue number, conversion options, team assignment, or processing preferences
+
+**Conversion Framework**:
+1. **Issue Analysis** - Fetch complete issue data, extract metadata, analyze content structure, infer priorities
+2. **Data Transformation** - Map fields accurately, convert formats, preserve relationships, enhance descriptions
+3. **Linear Integration** - Create task with proper formatting, assign team/project, set priorities, manage labels
+4. **Content Migration** - Import comments with attribution, handle attachments, preserve formatting, maintain threading
+5. **Reference Management** - Create bidirectional links, update sync database, maintain cross-references, enable navigation
+6. **Validation & Confirmation** - Verify conversion accuracy, confirm field mappings, validate relationships, provide preview
+
+**Advanced Features**: Smart priority inference, intelligent user mapping, attachment handling, comment threading, comprehensive validation.
+
+**Data Fidelity**: Preserve original formatting, maintain all metadata, keep comment attribution, ensure relationship integrity.
+
+**Output**: Successfully converted Linear task with complete data preservation, accurate field mappings, bidirectional references, and comprehensive conversion summary.

package/cli-tool/components/commands/sync/linear-task-to-issue.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [task-id] | --repo | --milestone | --close-linear | --skip-attachments
+description: Convert Linear tasks to GitHub issues with relationship preservation and metadata mapping
+model: sonnet
+---
+
+# Linear Task to Issue
+
+Convert Linear tasks to GitHub issues with comprehensive relationship mapping: **$ARGUMENTS**
+
+## Current Task Context
+
+- Task details: Based on $ARGUMENTS task identifier or selection criteria
+- Target repository: !`gh repo view --json nameWithOwner -q .nameWithOwner 2>/dev/null || echo "No repo context"`
+- User mappings: Linear email to GitHub username correspondence
+- Attachment handling: Linear attachment access and GitHub upload capabilities
+
+## Task
+
+Execute precise conversion of Linear tasks to GitHub issues:
+
+**Task Target**: Use $ARGUMENTS to specify task identifier, target repository, milestone mapping, or processing preferences
+
+**Conversion Framework**:
+1. **Task Analysis** - Fetch complete Linear task data, extract relationships, analyze content structure, identify priorities
+2. **Content Transformation** - Build GitHub issue body, map Linear fields, preserve formatting, handle rich content
+3. **GitHub Integration** - Create issue with proper structure, apply labels, assign users, set milestones, manage relationships
+4. **Attachment Migration** - Download Linear attachments, upload to GitHub, update references, maintain accessibility
+5. **Comment Import** - Transfer comments with attribution, preserve timestamps, maintain context, handle mentions
+6. **Cross-Reference Setup** - Create bidirectional links, update Linear task, maintain sync database, enable navigation
+
+**Advanced Features**: Rich content conversion, attachment handling, relationship mapping, user mention translation, comprehensive validation.
+
+**Relationship Management**: Preserve parent-child relationships, maintain team context, map project associations, handle dependencies.
+
+**Output**: Successfully created GitHub issue with complete data migration, accurate field mappings, preserved relationships, and comprehensive conversion report.

package/cli-tool/components/commands/sync/sync-automation-setup.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [setup-mode] | --full | --webhooks-only | --monitoring | --deploy-target
+description: Setup comprehensive automated synchronization workflows with monitoring and CI/CD integration
+model: sonnet
+---
+
+# Sync Automation Setup
+
+Setup comprehensive automated synchronization workflows: **$ARGUMENTS**
+
+## Current Infrastructure State
+
+- GitHub CLI: !`gh --version 2>/dev/null && echo "✓ Available" || echo "⚠ Not available"`
+- Linear MCP: Check Linear MCP server availability and configuration
+- Infrastructure: Docker, webhook endpoints, database connectivity, queue services
+- CI/CD: !`find . -name ".github" -o -name ".gitlab-ci.yml" -o -name "azure-pipelines.yml" | wc -l` existing workflows
+
+## Task
+
+Configure production-ready automated synchronization with comprehensive infrastructure:
+
+**Setup Mode**: Use $ARGUMENTS to specify full automation, webhooks-only, monitoring setup, or deployment target
+
+**Automation Framework**:
+1. **Prerequisites Setup** - Validate GitHub/Linear access, check infrastructure requirements, configure authentication, test connectivity
+2. **Webhook Configuration** - Setup GitHub/Linear webhooks, configure endpoints, implement security, test delivery
+3. **CI/CD Integration** - Create GitHub Actions workflows, setup scheduled syncs, implement event handling, configure deployments
+4. **Sync Server Deployment** - Configure sync engine, setup queue management, implement error handling, enable monitoring
+5. **Database & State Management** - Initialize sync databases, setup schema, configure backups, implement state tracking
+6. **Monitoring & Alerting** - Configure dashboards, setup alerts, implement health checks, enable notifications
+
+**Advanced Features**: Real-time webhook processing, intelligent conflict resolution, comprehensive monitoring, scalable infrastructure.
+
+**Production Ready**: High availability setup, comprehensive error handling, performance monitoring, security implementation, automated backups.
+
+**Output**: Complete automation infrastructure with webhook integration, CI/CD workflows, monitoring dashboards, and production deployment capabilities.

package/cli-tool/components/commands/sync/sync-conflict-resolver.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [action] | detect | resolve | analyze | configure | report
+description: Resolve synchronization conflicts with intelligent strategies and automated resolution
+model: sonnet
+---
+
+# Sync Conflict Resolver
+
+Resolve synchronization conflicts with intelligent automation: **$ARGUMENTS**
+
+## Current Conflict State
+
+- Sync database: @.sync-state.json or sync state files with potential conflicts
+- Conflict history: !`find . -name "*conflict*" -o -name "*sync-errors*" | wc -l` conflict logs
+- Resolution rules: @conflict-rules.json or existing resolution configuration
+- Active conflicts: Current unresolved synchronization conflicts requiring attention
+
+## Task
+
+Implement comprehensive conflict resolution with intelligent automation:
+
+**Resolution Action**: Use $ARGUMENTS to specify detect conflicts, resolve using strategies, analyze patterns, configure rules, or generate reports
+
+**Conflict Resolution Framework**:
+1. **Conflict Detection** - Scan synchronized items, compare field versions, identify timing conflicts, flag structural issues
+2. **Intelligent Resolution** - Apply resolution strategies, handle field merging, preserve critical data, maintain relationships
+3. **Pattern Analysis** - Study conflict trends, identify frequent issues, suggest process improvements, optimize strategies
+4. **Configuration Management** - Set resolution preferences, define field priorities, configure merge rules, save automation settings
+5. **Reporting & Analytics** - Generate conflict reports, track resolution success, analyze team patterns, provide insights
+6. **Automated Prevention** - Implement locking mechanisms, optimize sync timing, enable change notifications, reduce conflicts
+
+**Resolution Strategies**: Latest-wins, smart field-level merging, manual interactive resolution, system-priority resolution, custom rule-based resolution.
+
+**Quality Assurance**: Backup before resolution, validation after changes, rollback capabilities, comprehensive audit trails.
+
+**Output**: Resolved conflicts with detailed resolution reports, updated sync state, pattern analysis insights, and optimized conflict prevention strategies.

package/cli-tool/components/commands/sync/sync-health-monitor.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [scope] | --github | --linear | --webhooks | --performance | --report
+description: Monitor and diagnose GitHub-Linear sync health with performance analytics and automated troubleshooting
+model: sonnet
+---
+
+# Sync Health Monitor
+
+Monitor comprehensive GitHub-Linear synchronization health and performance: **$ARGUMENTS**
+
+## Current Sync Environment
+
+- GitHub API status: !`gh api rate_limit -q '.rate | "GitHub: \(.remaining)/\(.limit) requests"' 2>/dev/null || echo "GitHub API check needed"`
+- Linear connectivity: Linear MCP server status and authentication validation
+- Webhook status: Active webhook configurations and event processing health
+- Sync performance: Current throughput, latency metrics, and error rates
+
+## Task
+
+Implement comprehensive sync health monitoring with automated diagnostics and performance optimization:
+
+**Monitor Scope**: Use $ARGUMENTS to specify GitHub health, Linear connectivity, webhook diagnostics, performance analysis, or complete health report
+
+**Health Monitoring Framework**:
+1. **API Health Assessment** - Monitor GitHub/Linear API status, rate limits, authentication, connectivity issues
+2. **Sync Performance Analysis** - Track throughput metrics, latency patterns, processing times, queue depths
+3. **Error Pattern Detection** - Identify recurring failures, classify error types, analyze failure trends
+4. **Webhook Diagnostics** - Validate webhook configurations, test event delivery, monitor processing latency
+5. **Data Integrity Validation** - Verify sync consistency, detect orphaned records, validate cross-references
+6. **Automated Troubleshooting** - Run diagnostic tests, suggest fixes, implement automated recovery procedures
+
+**Advanced Features**: Real-time health dashboards, predictive failure detection, automated recovery workflows, comprehensive performance profiling.
+
+**Diagnostic Capabilities**: Deep error analysis, bottleneck identification, configuration validation, automated testing suites.
+
+**Output**: Complete health assessment with performance metrics, error analysis, recommended optimizations, and automated diagnostic reports.

package/cli-tool/components/commands/sync/sync-issues-to-linear.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [sync-scope] | --state | --label | --assignee | --milestone
+description: Sync GitHub issues to Linear workspace with comprehensive field mapping and rate limit management
+model: sonnet
+---
+
+# Sync Issues to Linear
+
+Sync GitHub issues to Linear workspace with intelligent field mapping: **$ARGUMENTS**
+
+## Current Repository Context
+
+- Repository: !`gh repo view --json nameWithOwner -q .nameWithOwner 2>/dev/null || echo "No repo context"`
+- Issue count: !`gh issue list --state all --limit 1 --json number | jq length 2>/dev/null || echo "Check manually"`
+- Linear teams: Available Linear teams and project assignments
+- Rate limits: !`gh api rate_limit -q '.rate | "GitHub: \(.remaining)/\(.limit)"' 2>/dev/null`
+
+## Task
+
+Execute comprehensive synchronization of GitHub issues to Linear workspace:
+
+**Sync Scope**: Use $ARGUMENTS to filter by issue state, labels, assignees, milestones, or specific issue sets
+
+**Synchronization Framework**:
+1. **Issue Discovery** - Fetch GitHub issues with comprehensive metadata, apply filters, validate requirements
+2. **Field Mapping** - Transform GitHub fields to Linear format, map priorities, convert labels, handle assignees
+3. **Data Validation** - Check required fields, validate user mappings, ensure data integrity, prevent duplicates
+4. **Linear Integration** - Create tasks with proper formatting, apply team assignments, set projects, manage relationships
+5. **Rate Limit Management** - Implement exponential backoff, batch operations, monitor API limits, optimize requests
+6. **Progress Tracking** - Provide real-time updates, handle errors gracefully, maintain sync state, generate reports
+
+**Advanced Features**: Smart priority inference, intelligent user mapping, incremental sync capabilities, comprehensive error recovery.
+
+**Data Integrity**: Preserve formatting, maintain metadata, create bidirectional references, ensure audit trails.
+
+**Output**: Complete synchronization results with success metrics, error reports, mapping summaries, and comprehensive sync analytics.