oh-my-customcode 0.36.2 → 0.37.0

package/templates/.claude/skills/flutter-best-practices/SKILL.md

@@ -46,15 +46,7 @@ state_choice:
 
 build_context:
   rule: "Never store BuildContext across async gaps"
-  pattern: |
-    // BAD
-    final ctx = context;
-    await Future.delayed(Duration(seconds: 1));
-    Navigator.of(ctx).push(...); // context may be invalid
-
-    // GOOD
-    if (!mounted) return;
-    Navigator.of(context).push(...);
+  pattern: "Check mounted before using context after await"
 
 keys:
   ValueKey: "When items have unique business identity"
@@ -83,6 +75,8 @@ slivers:
   avoid: "Nested ListView in ListView"
 ```
 
+Reference: guides/flutter/fundamentals.md
+
 ### 2. State Management
 
 ```yaml
@@ -99,51 +93,26 @@ riverpod_patterns:
   async_state: "AsyncNotifier + AsyncValue (loading/data/error)"
   family: "family modifier for parameterized providers"
   keep_alive: "Only when justified (expensive computations)"
-  invalidate_vs_refresh: |
-    ref.invalidate(provider)  // reset to loading, lazy re-fetch
-    ref.refresh(provider)     // immediate re-fetch, return new value
+  invalidate_vs_refresh: "ref.invalidate() resets to loading (lazy); ref.refresh() immediate re-fetch"
 
 bloc_patterns:
   one_event_per_action: "One UI action = one event class"
-  cubit_vs_bloc: |
-    Cubit: direct emit(state) — for simple state changes
-    Bloc: event → state mapping — when audit trail needed
+  cubit_vs_bloc: "Cubit for simple state changes; Bloc when audit trail needed"
   never: "Emit state in constructor body"
-  listener_vs_consumer: |
-    BlocListener: side effects (navigation, snackbar)
-    BlocConsumer: rebuild UI + side effects
-    BlocBuilder: rebuild UI only (most common)
+  listener_vs_consumer: "BlocListener for side effects; BlocConsumer for UI + effects; BlocBuilder for UI only"
   stream_management: "Cancel subscriptions in close()"
 
 state_immutability:
   rule: "All state objects must be immutable"
   tool: "freezed package for copyWith/==/hashCode generation"
-  pattern: |
-    @freezed
-    class UserState with _$UserState {
-      const factory UserState({
-        required String name,
-        required int age,
-        @Default(false) bool isLoading,
-      }) = _UserState;
-    }
 
 result_type:
   rule: "Return Result<T> from repositories, never throw"
-  pattern: |
-    sealed class Result<T> {
-      const Result();
-    }
-    final class Ok<T> extends Result<T> {
-      const Ok(this.value);
-      final T value;
-    }
-    final class Error<T> extends Result<T> {
-      const Error(this.error);
-      final Exception error;
-    }
+  pattern: "sealed class Result<T> with Ok<T> and Error<T> subclasses"
 ```
 
+Reference: guides/flutter/state-management.md
+
 ### 3. Performance
 
 ```yaml
@@ -151,16 +120,7 @@ build_optimization:
   const_widgets: "Mark immutable widgets const — zero rebuild"
   localize_setState: "Call setState on smallest possible subtree"
   extract_widgets: "StatelessWidget class > helper method"
-  child_parameter: |
-    // GOOD: static child passed through
-    AnimatedBuilder(
-      animation: controller,
-      builder: (context, child) => Transform.rotate(
-        angle: controller.value,
-        child: child, // not rebuilt
-      ),
-      child: const ExpensiveWidget(), // built once
-    )
+  child_parameter: "Pass static child through AnimatedBuilder to avoid rebuild"
 
 rebuild_avoidance:
   consumer_placement: "Place Consumer/ListenableBuilder as deep as possible"
@@ -183,6 +143,8 @@ frame_budget:
   tool: "DevTools Performance view for jank detection"
 ```
 
+Reference: guides/flutter/performance.md
+
 ### 4. Testing
 
 ```yaml
@@ -192,36 +154,16 @@ test_pyramid:
   integration: "Full app on device — slow, high confidence"
   golden: "Visual regression via matchesGoldenFile()"
 
-widget_test_pattern: |
-  testWidgets('shows loading then content', (tester) async {
-    await tester.pumpWidget(
-      ProviderScope(
-        overrides: [productsProvider.overrideWith((_) => fakeProducts)],
-        child: const MaterialApp(home: ProductListScreen()),
-      ),
-    );
-    expect(find.byType(CircularProgressIndicator), findsOneWidget);
-    await tester.pumpAndSettle();
-    expect(find.byType(ProductCard), findsNWidgets(3));
-  });
+widget_test_pattern:
+  rule: "Use pumpWidget with ProviderScope overrides, then pump/pumpAndSettle for async"
 
 mocking:
   prefer: "mocktail (null-safe, no codegen)"
   avoid: "Legacy mockito with build_runner"
   fakes: "Use Fake implementations for deterministic tests"
-  pattern: |
-    class FakeProductRepository extends Fake implements ProductRepository {
-      @override
-      Future<Result<List<Product>>> getAll() async => Ok(testProducts);
-    }
-
-bloc_testing: |
-  blocTest<AuthBloc, AuthState>(
-    'emits [loading, success] when login succeeds',
-    build: () => AuthBloc(FakeAuthRepository()),
-    act: (bloc) => bloc.add(LoginRequested('user', 'pass')),
-    expect: () => [AuthLoading(), isA<AuthSuccess>()],
-  );
+
+bloc_testing:
+  rule: "Use blocTest<Bloc, State> with build/act/expect pattern"
 
 coverage_target:
   widget_tests: "80%+ for UI logic"
@@ -229,6 +171,8 @@ coverage_target:
   integration: "Critical user flows only"
 ```
 
+Reference: guides/flutter/testing.md
+
 ### 5. Security
 
 ```yaml
@@ -236,14 +180,14 @@ secrets:
   never: "Hardcode API keys, tokens, or credentials in source"
   best: "Backend proxy for all sensitive API calls"
   use: "--dart-define-from-file=.env for NON-SECRET build config only (feature flags, environment URLs)"
-  warning: "dart-define values are embedded in compiled binary and extractable via static analysis. Use only for non-secret build configuration (feature flags, environment URLs)."
+  warning: "dart-define values are embedded in compiled binary and extractable via static analysis"
 
 storage:
   sensitive_data: "flutter_secure_storage v10+ (Keychain/Keystore)"
   never: "SharedPreferences for tokens, PII, or credentials"
   ios: "AppleOptions(useSecureEnclave: true) for high-value"
   android: "AndroidOptions(encryptedSharedPreferences: true)"
-  web_warning: "flutter_secure_storage on Web uses localStorage by default, which is accessible to any JavaScript on the page (XSS vulnerable). For Web targets, use HttpOnly cookies managed by backend or in-memory-only storage for sensitive data."
+  web_warning: "flutter_secure_storage on Web uses localStorage by default (XSS vulnerable). Use HttpOnly cookies or in-memory-only for sensitive data."
 
 network:
   tls: "Certificate pinning (SPKI) for financial/health apps"
@@ -267,54 +211,35 @@ logging:
   never: "Log PII, tokens, or credentials"
 ```
 
+Reference: guides/flutter/security.md
+
 ### 6. Dart Language Patterns
 
 ```yaml
 naming:
-  types: "UpperCamelCase for classes, enums, typedefs, extensions, mixins (e.g., HttpClient, JsonParser)"
-  variables: "lowerCamelCase for variables, parameters, named constants (e.g., itemCount, defaultTimeout)"
-  libraries: "lowercase_with_underscores for libraries, packages, directories, source files (e.g., my_package, slider_menu.dart)"
-  constants: "lowerCamelCase for const (e.g., const defaultTimeout = 30), NOT SCREAMING_CAPS"
-  private: "Prefix with underscore for library-private (e.g., _internalCache, _helper())"
-  boolean: "Prefix with is/has/can/should for booleans (e.g., isEnabled, hasData, canScroll)"
-  avoid: "Hungarian notation, type prefixes (strName, lstItems), abbreviations unless universally known (e.g., ok: http, url, id; avoid: mgr, ctx, btn)"
+  types: "UpperCamelCase for classes, enums, typedefs, extensions, mixins"
+  variables: "lowerCamelCase for variables, parameters, named constants"
+  libraries: "lowercase_with_underscores for libraries, packages, directories, source files"
+  constants: "lowerCamelCase for const (NOT SCREAMING_CAPS)"
+  private: "Prefix with underscore for library-private"
+  boolean: "Prefix with is/has/can/should"
+  avoid: "Hungarian notation, type prefixes, abbreviations unless universally known"
 
 null_safety:
   default: "Non-nullable types — use ? only when null is meaningful"
   avoid_bang: "Minimize ! operator — use only when null is logically impossible"
   late: "Only when initialization is guaranteed before use"
-  pattern: |
-    // GOOD
-    final name = user?.name ?? 'Anonymous';
-
-    // AVOID
-    final name = user!.name; // crashes if null
 
 sealed_classes:
   use_for: "Exhaustive pattern matching on state/result types"
-  pattern: |
-    sealed class AuthState {}
-    class AuthInitial extends AuthState {}
-    class AuthLoading extends AuthState {}
-    class AuthSuccess extends AuthState { final User user; AuthSuccess(this.user); }
-    class AuthError extends AuthState { final String message; AuthError(this.message); }
-
-    // Exhaustive switch — compiler enforces all cases
-    return switch (state) {
-      AuthInitial() => LoginScreen(),
-      AuthLoading() => CircularProgressIndicator(),
-      AuthSuccess(:final user) => HomeScreen(user: user),
-      AuthError(:final message) => ErrorWidget(message),
-    };
+  pattern: "sealed class with subclass per state, exhaustive switch expression"
 
 records:
   use_for: "Lightweight multi-value returns without class boilerplate"
-  pattern: "(String name, int age) getUserInfo() => ('Alice', 30);"
   avoid: "Records for complex data — use freezed classes instead"
 
 extension_types:
   use_for: "Zero-cost type wrappers for primitive IDs"
-  pattern: "extension type UserId(int id) implements int {}"
 
 immutability:
   prefer: "final variables, const constructors"
@@ -331,48 +256,19 @@ dynamic:
   reason: "No compile-time type checking, reduces IDE support"
 ```
 
+Reference: guides/flutter/fundamentals.md
+
 ### 7. Architecture & Project Structure
 
 ```yaml
 default_structure:
-  small_app: |
-    lib/
-      models/
-      services/
-      screens/
-      widgets/
-  medium_app: |
-    lib/
-      ui/
-        core/themes/, core/widgets/
-        <feature>/<feature>_screen.dart
-        <feature>/<feature>_viewmodel.dart
-      data/
-        repositories/<entity>_repository.dart
-        services/<source>_service.dart
-      domain/ (optional)
-        use_cases/
-  large_app: |
-    lib/
-      core/ (shared)
-      features/<feature>/
-        data/datasources/, data/repositories/
-        domain/entities/, domain/usecases/
-        presentation/bloc/, presentation/pages/
+  small_app: "lib/{models,services,screens,widgets}/"
+  medium_app: "lib/{ui/{core/,<feature>/},data/{repositories/,services/},domain/}"
+  large_app: "lib/{core/,features/<feature>/{data/,domain/,presentation/}}"
 
 navigation:
   default: "go_router (official recommendation)"
-  pattern: |
-    GoRoute(
-      path: '/product/:id',
-      builder: (context, state) {
-        final id = state.pathParameters['id']!;
-        return ProductDetailScreen(id: id);
-      },
-    )
-  go_vs_push: |
-    context.go('/path')   // replaces stack (navigation reset)
-    context.push('/path') // adds to stack (back button works)
+  go_vs_push: "context.go() replaces stack; context.push() adds to stack"
 
 dependency_injection:
   riverpod: "Built-in — providers as DI (default)"
@@ -381,13 +277,12 @@ dependency_injection:
 
 environments:
   pattern: "Flavors + --dart-define for multi-environment builds"
-  command: "flutter run --flavor development --target lib/main/main_development.dart"
   rule: "Separate bundle IDs, API URLs, and Firebase config per flavor"
 ```
 
-## Default Stack
+Reference: guides/flutter/architecture.md
 
-When starting a new Flutter project, recommend this stack:
+## Default Stack
 
 ```yaml
 state_management: Riverpod 3.0
@@ -402,8 +297,6 @@ structure: Official MVVM (lib/{ui,data}/)
 
 ## Enterprise Stack
 
-For regulated or large-team projects:
-
 ```yaml
 state_management: BLoC 9.0 + Cubit
 navigation: go_router or auto_route

package/templates/.claude/skills/go-backend-best-practices/SKILL.md

@@ -14,25 +14,7 @@ Apply Go backend patterns for building production-ready services.
 ### 1. Project Structure (Standard Layout)
 
 ```yaml
-layout: |
-  project/
-  ├── cmd/
-  │   └── server/
-  │       └── main.go
-  ├── internal/
-  │   ├── handler/
-  │   ├── service/
-  │   ├── repository/
-  │   └── model/
-  ├── pkg/
-  │   └── shared/
-  ├── api/
-  │   └── openapi.yaml
-  ├── configs/
-  ├── scripts/
-  ├── Dockerfile
-  ├── Makefile
-  └── go.mod
+layout: "cmd/{server/main.go} + internal/{handler/,service/,repository/,model/} + pkg/{shared/} + api/{openapi.yaml} + configs/ + scripts/"
 
 directories:
   cmd: Main applications (one per binary)
@@ -43,6 +25,8 @@ directories:
   scripts: Build and CI scripts
 ```
 
+Reference: guides/go-backend/project-layout.md
+
 ### 2. Error Handling (Uber Style)
 
 ```yaml
@@ -52,28 +36,14 @@ principles:
   - Use sentinel errors for specific conditions
   - Name error variables with Err prefix
 
-patterns: |
-  // Sentinel errors
-  var (
-      ErrNotFound = errors.New("not found")
-      ErrInvalidInput = errors.New("invalid input")
-  )
-
-  // Wrap with context
-  func getUser(id string) (*User, error) {
-      user, err := db.FindUser(id)
-      if err != nil {
-          return nil, fmt.Errorf("getUser %s: %w", id, err)
-      }
-      return user, nil
-  }
-
-  // Check specific errors
-  if errors.Is(err, ErrNotFound) {
-      return http.StatusNotFound
-  }
+patterns:
+  sentinel: "var ErrNotFound = errors.New(\"not found\")"
+  wrapping: "fmt.Errorf(\"getUser %s: %w\", id, err)"
+  checking: "errors.Is(err, ErrNotFound)"
 ```
 
+Reference: guides/go-backend/uber-style.md
+
 ### 3. Concurrency (Uber Style)
 
 ```yaml
@@ -84,44 +54,11 @@ channels:
 goroutines:
   never: fire-and-forget
   always: wait for completion or manage lifecycle
-
-patterns: |
-  // Wait group for goroutines
-  func process(items []Item) error {
-      var wg sync.WaitGroup
-      errCh := make(chan error, 1)
-
-      for _, item := range items {
-          wg.Add(1)
-          go func(item Item) {
-              defer wg.Done()
-              if err := processItem(item); err != nil {
-                  select {
-                  case errCh <- err:
-                  default:
-                  }
-              }
-          }(item)
-      }
-
-      wg.Wait()
-      close(errCh)
-      return <-errCh
-  }
-
-  // Context for cancellation
-  func longRunningTask(ctx context.Context) error {
-      for {
-          select {
-          case <-ctx.Done():
-              return ctx.Err()
-          default:
-              // do work
-          }
-      }
-  }
+  patterns: "sync.WaitGroup + error channel for parallel work; context.Context for cancellation"
 ```
 
+Reference: guides/go-backend/uber-style.md
+
 ### 4. HTTP Server
 
 ```yaml
@@ -130,88 +67,24 @@ structure:
   service: Business logic
   repository: Data access
 
-patterns: |
-  // Handler with dependency injection
-  type UserHandler struct {
-      service UserService
-  }
-
-  func NewUserHandler(s UserService) *UserHandler {
-      return &UserHandler{service: s}
-  }
-
-  func (h *UserHandler) GetUser(w http.ResponseWriter, r *http.Request) {
-      id := chi.URLParam(r, "id")
-
-      user, err := h.service.GetUser(r.Context(), id)
-      if err != nil {
-          if errors.Is(err, ErrNotFound) {
-              http.Error(w, "user not found", http.StatusNotFound)
-              return
-          }
-          http.Error(w, "internal error", http.StatusInternalServerError)
-          return
-      }
-
-      json.NewEncoder(w).Encode(user)
-  }
-
-  // Router setup
-  func NewRouter(h *UserHandler) *chi.Mux {
-      r := chi.NewRouter()
-      r.Use(middleware.Logger)
-      r.Use(middleware.Recoverer)
-
-      r.Route("/api/v1", func(r chi.Router) {
-          r.Get("/users/{id}", h.GetUser)
-          r.Post("/users", h.CreateUser)
-      })
-
-      return r
-  }
+patterns:
+  dependency_injection: "Handler struct with service field, constructor NewXxxHandler()"
+  router: "chi.NewRouter() with middleware (Logger, Recoverer) and versioned routes"
+  error_mapping: "errors.Is() to map domain errors to HTTP status codes"
 ```
 
+Reference: guides/go-backend/uber-style.md
+
 ### 5. Dependency Injection
 
 ```yaml
 approach: constructor injection
 avoid: global variables
-
-patterns: |
-  // Service with dependencies
-  type UserService struct {
-      repo   UserRepository
-      cache  Cache
-      logger *slog.Logger
-  }
-
-  func NewUserService(
-      repo UserRepository,
-      cache Cache,
-      logger *slog.Logger,
-  ) *UserService {
-      return &UserService{
-          repo:   repo,
-          cache:  cache,
-          logger: logger,
-      }
-  }
-
-  // Wire up in main
-  func main() {
-      logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
-      db := database.New(cfg.DatabaseURL)
-      cache := redis.New(cfg.RedisURL)
-
-      repo := repository.NewUserRepository(db)
-      service := service.NewUserService(repo, cache, logger)
-      handler := handler.NewUserHandler(service)
-
-      router := handler.NewRouter(handler)
-      http.ListenAndServe(":8080", router)
-  }
+pattern: "Struct with dependencies as fields, New* constructor functions, wire up in main()"
 ```
 
+Reference: guides/go-backend/uber-style.md
+
 ### 6. Configuration
 
 ```yaml
@@ -219,30 +92,11 @@ approach:
   - Use environment variables
   - Validate at startup
   - Group related settings
-
-patterns: |
-  type Config struct {
-      Server   ServerConfig
-      Database DatabaseConfig
-      Redis    RedisConfig
-  }
-
-  type ServerConfig struct {
-      Host         string        `env:"SERVER_HOST" envDefault:"0.0.0.0"`
-      Port         int           `env:"SERVER_PORT" envDefault:"8080"`
-      ReadTimeout  time.Duration `env:"SERVER_READ_TIMEOUT" envDefault:"5s"`
-      WriteTimeout time.Duration `env:"SERVER_WRITE_TIMEOUT" envDefault:"10s"`
-  }
-
-  func LoadConfig() (*Config, error) {
-      var cfg Config
-      if err := env.Parse(&cfg); err != nil {
-          return nil, fmt.Errorf("parse config: %w", err)
-      }
-      return &cfg, nil
-  }
+pattern: "Config struct with nested typed configs, env struct tags, Parse at startup"
 ```
 
+Reference: guides/go-backend/uber-style.md
+
 ### 7. Testing
 
 ```yaml
@@ -250,55 +104,11 @@ patterns:
   table_driven: for comprehensive coverage
   interfaces: for mocking
   parallel: for speed
-
-example: |
-  func TestUserService_GetUser(t *testing.T) {
-      tests := []struct {
-          name    string
-          userID  string
-          mock    func(*MockRepository)
-          want    *User
-          wantErr error
-      }{
-          {
-              name:   "success",
-              userID: "123",
-              mock: func(m *MockRepository) {
-                  m.EXPECT().FindByID("123").Return(&User{ID: "123"}, nil)
-              },
-              want: &User{ID: "123"},
-          },
-          {
-              name:   "not found",
-              userID: "999",
-              mock: func(m *MockRepository) {
-                  m.EXPECT().FindByID("999").Return(nil, ErrNotFound)
-              },
-              wantErr: ErrNotFound,
-          },
-      }
-
-      for _, tt := range tests {
-          t.Run(tt.name, func(t *testing.T) {
-              t.Parallel()
-              ctrl := gomock.NewController(t)
-              repo := NewMockRepository(ctrl)
-              tt.mock(repo)
-
-              svc := NewUserService(repo, nil, slog.Default())
-              got, err := svc.GetUser(context.Background(), tt.userID)
-
-              if !errors.Is(err, tt.wantErr) {
-                  t.Errorf("got error %v, want %v", err, tt.wantErr)
-              }
-              if diff := cmp.Diff(tt.want, got); diff != "" {
-                  t.Errorf("mismatch (-want +got):\n%s", diff)
-              }
-          })
-      }
-  }
+  tools: "gomock for mocks, cmp.Diff for assertions"
 ```
 
+Reference: guides/go-backend/uber-style.md
+
 ### 8. Performance (Uber Style)
 
 ```yaml
@@ -307,24 +117,10 @@ guidelines:
   - Pre-allocate slices with known capacity
   - Avoid repeated string-to-byte conversions
   - Copy slices/maps at boundaries
-
-patterns: |
-  // Pre-allocate
-  items := make([]Item, 0, len(input))
-
-  // strconv for conversions
-  s := strconv.Itoa(n) // not fmt.Sprintf("%d", n)
-
-  // Copy at boundaries
-  func (s *Store) GetItems() []Item {
-      s.mu.RLock()
-      defer s.mu.RUnlock()
-      items := make([]Item, len(s.items))
-      copy(items, s.items)
-      return items
-  }
 ```
 
+Reference: guides/go-backend/uber-style.md
+
 ## Application
 
 When writing Go backend code: