@ngxtm/devkit 3.3.0 → 3.4.1

package/cli/index.js

@@ -17,6 +17,7 @@ const { initProject, uninstallProject } = require('./init');
 const { updateProject, showStatus } = require('./update');
 const { detectProjectType, getRulesForTypes, printDetectionResults } = require('./detect');
 const { validatePath } = require('./utils');
+const { listRules, addRules, removeRules } = require('./rules');
 
 // Legacy imports for backwards compatibility (will be deprecated)
 let legacyInstall = null;
@@ -38,6 +39,8 @@ function parseArgs(args) {
     update: false,
     clean: false,
     help: false,
+    installed: false,
+    ruleArgs: [],
     // Legacy options (deprecated)
     tool: null,
     minimal: false,
@@ -57,6 +60,8 @@ function parseArgs(args) {
       options.update = true;
     } else if (arg === '--clean' || arg === '-c') {
       options.clean = true;
+    } else if (arg === '--installed' || arg === '-i') {
+      options.installed = true;
     } else if (arg === '--status' || arg === '-s') {
       options.command = 'status';
     } else if (arg.startsWith('--path=')) {
@@ -65,21 +70,15 @@ function parseArgs(args) {
       // Handle legacy options for backwards compatibility
       if (arg === '--minimal' || arg === '-m') options.minimal = true;
       if (arg === '--lite' || arg === '-l') options.lite = true;
-      if (arg === '--interactive' || arg === '-i') options.interactive = true;
-      if (arg === '--full') options.fullSkills = true;
       if (arg.startsWith('--category=')) {
         const cats = arg.split('=')[1].split(',').map(c => c.trim());
         options.categories.push(...cats);
       }
     } else if (!options.command) {
       options.command = arg;
-    } else if (!options.path && !options.tool) {
-      // Could be a path or a tool name (legacy)
-      if (['claude', 'cursor', 'copilot', 'gemini'].includes(arg)) {
-        options.tool = arg;
-      } else {
-        options.path = arg;
-      }
+    } else {
+      // Additional args (for add/remove commands)
+      options.ruleArgs.push(arg);
     }
   }
 
@@ -104,6 +103,15 @@ COMMANDS:
   detect        Show detected technologies for current project
                 Useful to see what devkit will install.
 
+  rules         List all available rules
+                Use --installed to show only installed rules.
+
+  add <rule>    Add rules manually (space-separated)
+                Example: devkit add golang docker
+
+  remove <rule> Remove rules from project
+                Example: devkit remove flutter
+
   status        Show installation status
 
   uninstall     Remove devkit from current project
@@ -115,10 +123,11 @@ COMMANDS:
   version       Show version
 
 OPTIONS:
-  --force, -f   Force overwrite existing installation
-  --clean, -c   Remove rules for technologies no longer detected (with update)
-  --path=DIR    Specify project directory (default: current directory)
-  --help, -h    Show this help
+  --force, -f     Force overwrite existing installation
+  --clean, -c     Remove rules for technologies no longer detected (with update)
+  --installed, -i Show only installed rules (with rules command)
+  --path=DIR      Specify project directory (default: current directory)
+  --help, -h      Show this help
 
 EXAMPLES:
   devkit init                 # Initialize in current project
@@ -126,6 +135,10 @@ EXAMPLES:
   devkit update               # Update and re-detect technologies
   devkit update --clean       # Update and remove old rules
   devkit detect               # Show what would be detected
+  devkit rules                # List all available rules
+  devkit rules --installed    # Show installed rules
+  devkit add golang docker    # Add golang and docker rules
+  devkit remove flutter       # Remove flutter rule
   devkit status               # Show current installation
   devkit uninstall            # Remove from current project
 
@@ -211,6 +224,39 @@ const commands = {
     });
   },
 
+  // List available rules
+  rules: (options) => {
+    const projectPath = validatePath(options.path) || process.cwd();
+    return listRules({
+      path: projectPath,
+      installed: options.installed
+    });
+  },
+
+  // Add rules manually
+  add: (options) => {
+    const projectPath = validatePath(options.path) || process.cwd();
+    if (options.ruleArgs.length === 0) {
+      console.log('\n  Usage: devkit add <rule> [rule2 ...]');
+      console.log('  Example: devkit add golang docker\n');
+      console.log('  Run "devkit rules" to see available rules.\n');
+      return { success: false, reason: 'no_rules' };
+    }
+    return addRules(options.ruleArgs, { path: projectPath });
+  },
+
+  // Remove rules
+  remove: (options) => {
+    const projectPath = validatePath(options.path) || process.cwd();
+    if (options.ruleArgs.length === 0) {
+      console.log('\n  Usage: devkit remove <rule> [rule2 ...]');
+      console.log('  Example: devkit remove flutter\n');
+      console.log('  Run "devkit rules --installed" to see installed rules.\n');
+      return { success: false, reason: 'no_rules' };
+    }
+    return removeRules(options.ruleArgs, { path: projectPath });
+  },
+
   // List skills (from skills-index.json)
   list: () => {
     const indexPath = path.join(__dirname, '..', 'skills-index.json');

package/cli/rules.js

@@ -0,0 +1,248 @@
+/**
+ * Rules Management
+ *
+ * Add/remove rules manually for projects where auto-detection
+ * doesn't cover all needs.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { copyDir } = require('./utils');
+
+const PACKAGE_ROOT = path.join(__dirname, '..');
+
+/**
+ * Get all available rules from the rules/ directory
+ */
+function getAvailableRules() {
+  const rulesDir = path.join(PACKAGE_ROOT, 'rules');
+
+  if (!fs.existsSync(rulesDir)) {
+    return [];
+  }
+
+  return fs.readdirSync(rulesDir).filter(item => {
+    const itemPath = path.join(rulesDir, item);
+    return fs.statSync(itemPath).isDirectory() && !item.startsWith('.');
+  });
+}
+
+/**
+ * Get installed rules from devkit.json
+ */
+function getInstalledRules(projectDir) {
+  const configPath = path.join(projectDir, '.claude', 'devkit.json');
+
+  if (!fs.existsSync(configPath)) {
+    return { rules: [], manualRules: [] };
+  }
+
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    return {
+      rules: config.installedRules || [],
+      manualRules: config.manualRules || [],
+      detectedTypes: config.detectedTypes || []
+    };
+  } catch (e) {
+    return { rules: [], manualRules: [] };
+  }
+}
+
+/**
+ * Update devkit.json with new rules
+ */
+function updateDevkitConfig(projectDir, updates) {
+  const configPath = path.join(projectDir, '.claude', 'devkit.json');
+
+  if (!fs.existsSync(configPath)) {
+    console.log('  No devkit.json found. Run "devkit init" first.');
+    return false;
+  }
+
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  Object.assign(config, updates, { updatedAt: new Date().toISOString() });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  return true;
+}
+
+/**
+ * List all available rules
+ */
+function listRules(options = {}) {
+  const projectDir = options.path || process.cwd();
+  const available = getAvailableRules();
+  const { rules: installed, manualRules } = getInstalledRules(projectDir);
+  const allInstalled = [...new Set([...installed, ...manualRules])];
+
+  console.log('\n' + '='.repeat(50));
+  console.log('  AVAILABLE RULES');
+  console.log('='.repeat(50));
+
+  if (options.installed) {
+    // Show only installed rules
+    console.log('\nInstalled in this project:');
+    if (allInstalled.length === 0) {
+      console.log('  (none)');
+    } else {
+      allInstalled.forEach(rule => {
+        const isManual = manualRules.includes(rule);
+        console.log(`  - ${rule}${isManual ? ' (manual)' : ' (auto-detected)'}`);
+      });
+    }
+  } else {
+    // Show all available rules
+    console.log(`\nTotal: ${available.length} rules\n`);
+    available.forEach(rule => {
+      const isInstalled = allInstalled.includes(rule);
+      const marker = isInstalled ? '[x]' : '[ ]';
+      console.log(`  ${marker} ${rule}`);
+    });
+
+    console.log('\n  [x] = installed in current project');
+  }
+
+  console.log('');
+  return { available, installed: allInstalled };
+}
+
+/**
+ * Add rules to project
+ */
+function addRules(ruleNames, options = {}) {
+  const projectDir = options.path || process.cwd();
+  const claudeDir = path.join(projectDir, '.claude');
+
+  if (!fs.existsSync(claudeDir)) {
+    console.log('\n  No .claude/ folder found. Run "devkit init" first.\n');
+    return { success: false, reason: 'not_initialized' };
+  }
+
+  const available = getAvailableRules();
+  const { rules: autoRules, manualRules = [] } = getInstalledRules(projectDir);
+  const allInstalled = [...new Set([...autoRules, ...manualRules])];
+
+  console.log('\n' + '='.repeat(50));
+  console.log('  ADD RULES');
+  console.log('='.repeat(50));
+
+  const added = [];
+  const skipped = [];
+  const notFound = [];
+
+  for (const ruleName of ruleNames) {
+    const rule = ruleName.toLowerCase();
+
+    if (!available.includes(rule)) {
+      notFound.push(rule);
+      console.log(`  [!] ${rule} - not found`);
+      continue;
+    }
+
+    if (allInstalled.includes(rule)) {
+      skipped.push(rule);
+      console.log(`  [-] ${rule} - already installed`);
+      continue;
+    }
+
+    // Copy rule files
+    const srcDir = path.join(PACKAGE_ROOT, 'rules', rule);
+    const destDir = path.join(claudeDir, 'rules', rule);
+
+    if (fs.existsSync(srcDir)) {
+      const count = copyDir(srcDir, destDir);
+      added.push(rule);
+      console.log(`  [+] ${rule} - added (${count} files)`);
+    }
+  }
+
+  // Update devkit.json
+  if (added.length > 0) {
+    const newManualRules = [...new Set([...manualRules, ...added])];
+    updateDevkitConfig(projectDir, { manualRules: newManualRules });
+  }
+
+  // Summary
+  console.log('\n' + '-'.repeat(50));
+  if (added.length > 0) {
+    console.log(`  Added: ${added.join(', ')}`);
+  }
+  if (skipped.length > 0) {
+    console.log(`  Skipped (already installed): ${skipped.join(', ')}`);
+  }
+  if (notFound.length > 0) {
+    console.log(`  Not found: ${notFound.join(', ')}`);
+    console.log(`  Run "devkit rules" to see available rules.`);
+  }
+  console.log('');
+
+  return { success: true, added, skipped, notFound };
+}
+
+/**
+ * Remove rules from project
+ */
+function removeRules(ruleNames, options = {}) {
+  const projectDir = options.path || process.cwd();
+  const claudeDir = path.join(projectDir, '.claude');
+
+  if (!fs.existsSync(claudeDir)) {
+    console.log('\n  No .claude/ folder found.\n');
+    return { success: false, reason: 'not_initialized' };
+  }
+
+  const { rules: autoRules, manualRules = [] } = getInstalledRules(projectDir);
+
+  console.log('\n' + '='.repeat(50));
+  console.log('  REMOVE RULES');
+  console.log('='.repeat(50));
+
+  const removed = [];
+  const notInstalled = [];
+
+  for (const ruleName of ruleNames) {
+    const rule = ruleName.toLowerCase();
+    const ruleDir = path.join(claudeDir, 'rules', rule);
+
+    if (!fs.existsSync(ruleDir)) {
+      notInstalled.push(rule);
+      console.log(`  [-] ${rule} - not installed`);
+      continue;
+    }
+
+    // Remove rule directory
+    fs.rmSync(ruleDir, { recursive: true, force: true });
+    removed.push(rule);
+    console.log(`  [x] ${rule} - removed`);
+  }
+
+  // Update devkit.json
+  if (removed.length > 0) {
+    const newAutoRules = autoRules.filter(r => !removed.includes(r));
+    const newManualRules = manualRules.filter(r => !removed.includes(r));
+    updateDevkitConfig(projectDir, {
+      installedRules: newAutoRules,
+      manualRules: newManualRules
+    });
+  }
+
+  // Summary
+  console.log('\n' + '-'.repeat(50));
+  if (removed.length > 0) {
+    console.log(`  Removed: ${removed.join(', ')}`);
+  }
+  if (notInstalled.length > 0) {
+    console.log(`  Not installed: ${notInstalled.join(', ')}`);
+  }
+  console.log('');
+
+  return { success: true, removed, notInstalled };
+}
+
+module.exports = {
+  getAvailableRules,
+  getInstalledRules,
+  listRules,
+  addRules,
+  removeRules
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngxtm/devkit",
-  "version": "3.3.0",
+  "version": "3.4.1",
   "description": "Per-project AI skills with smart tech detection - lightweight and context-optimized",
   "main": "cli/index.js",
   "bin": {
@@ -20,6 +20,7 @@
     "merged-commands/",
     "templates/",
     "skills/",
+    "rules/",
     "scripts/merge-commands.js",
     "scripts/organize-rules.js",
     "scripts/generate-index.js",

package/rules/README.md

@@ -0,0 +1,141 @@
+# Agent Skills Registry
+
+This directory contains the source of truth for all AI agent skills. Skills are organized by **Category** (Language or Framework) and then by **Domain**.
+
+## 📂 Structure
+
+Each skill must follow the standard directory structure:
+`skills/{category}/{skill-name}/SKILL.md`
+
+## 🛠 Active Categories
+
+### 🎯 Flutter (Framework)
+
+High-density standards for modern Flutter development.
+
+- [**Layer-based Clean Architecture**](flutter/layer-based-clean-architecture/SKILL.md) (P0) - Dependency flow & modularity.
+- [**BLoC State Management**](flutter/bloc-state-management/SKILL.md) (P0) - Predictable state flows.
+- [**Security**](flutter/security/SKILL.md) (P0) - OWASP & data safety.
+- [**Feature-based Clean Architecture**](flutter/feature-based-clean-architecture/SKILL.md) (P1) - Scalable directory structures.
+- [**Idiomatic Flutter**](flutter/idiomatic-flutter/SKILL.md) (P1) - Modern layout & composition.
+- [**Performance**](flutter/performance/SKILL.md) (P1) - 60fps & memory optimization.
+- [**Widgets**](flutter/widgets/SKILL.md) (P1) - Reusable components.
+- [**Error Handling**](flutter/error-handling/SKILL.md) (P1) - Functional error handling.
+- [**Retrofit Networking**](flutter/retrofit-networking/SKILL.md) (P1) - API client standards.
+- [**Dependency Injection**](flutter/dependency-injection/SKILL.md) (P1) - GetIt & Provider patterns.
+- [**CI/CD**](flutter/cicd/SKILL.md) (P1) - GitHub Actions, Fastlane, Automation.
+- [**Testing**](flutter/testing/SKILL.md) (P1) - Unit, Widget & Integration Strategies.
+- [**AutoRoute Navigation**](flutter/auto-route-navigation/SKILL.md) (P2) - Type-safe routing.
+- [**GoRouter Navigation**](flutter/go-router-navigation/SKILL.md) (P2) - URI-based routing.
+
+### 🔷 Dart (Language)
+
+Core language idioms and patterns.
+
+- [**Language Patterns**](dart/language/SKILL.md) (P0) - Records, Patterns, Sealed classes.
+- [**Best Practices**](dart/best-practices/SKILL.md) (P1) - Scoping, Imports, Config.
+- [**Tooling**](dart/tooling/SKILL.md) (P1) - Linting, Formatting, Analysis.
+
+### 🔷 TypeScript (Language)
+
+Modern TypeScript standards for type-safe development.
+
+- [**Language Patterns**](typescript/language/SKILL.md) (P0) - Types, Generics, Type Guards.
+- [**Security**](typescript/security/SKILL.md) (P0) - Input Validation, Auth, Secrets.
+- [**Best Practices**](typescript/best-practices/SKILL.md) (P1) - Naming, Modules, Conventions.
+- [**Tooling**](typescript/tooling/SKILL.md) (P1) - ESLint, Testing, Build Tools.
+
+### 🟨 JavaScript (Language)
+
+Modern JavaScript (ES2022+) patterns.
+
+- [**Language Patterns**](javascript/language/SKILL.md) (P0) - Modern Syntax, Async/Await.
+- [**Best Practices**](javascript/best-practices/SKILL.md) (P1) - Conventions, Error Handling.
+- [**Tooling**](javascript/tooling/SKILL.md) (P1) - ESLint, Jest, Build Tools.
+
+### ⚛️ React (Framework)
+
+Modern React development patterns.
+
+- [**Component Patterns**](react/component-patterns/SKILL.md) (P0) - Function Components, Composition.
+- [**State Management**](react/state-management/SKILL.md) (P0) - useState, Context, Zustand.
+- [**TypeScript**](react/typescript/SKILL.md) (P0) - React-specific Types.
+- [**Security**](react/security/SKILL.md) (P0) - XSS Prevention, Auth Patterns.
+- [**Hooks**](react/hooks/SKILL.md) (P1) - Custom Hooks, Best Practices.
+- [**Performance**](react/performance/SKILL.md) (P1) - Memoization, Code Splitting.
+- [**Tooling**](react/tooling/SKILL.md) (P1) - Debugging & Profiling.
+- [**Testing**](react/testing/SKILL.md) (P2) - React Testing Library, Jest.
+
+### 🦁 NestJS (Framework)
+
+Enterprise-grade Node.js backend development.
+
+- [**Architecture**](nestjs/architecture/SKILL.md) (P0) - Modules, DI, Scalability.
+- [**Controllers & Services**](nestjs/controllers-services/SKILL.md) (P0) - Layer separation standards.
+- [**Database**](nestjs/database/SKILL.md) (P0) - TypeORM, Prisma, Mongoose patterns.
+- [**Security**](nestjs/security/SKILL.md) (P0) - Auth, Guards, Headers.
+- [**Configuration**](nestjs/configuration/SKILL.md) (P1) - Environment management.
+- [**Error Handling**](nestjs/error-handling/SKILL.md) (P1) - Global filters.
+- [**Performance**](nestjs/performance/SKILL.md) (P1) - Fastify, Caching.
+- [**Testing**](nestjs/testing/SKILL.md) (P2) - Unit & E2E strategies.
+
+### ▲ Next.js (Framework)
+
+Modern fullstack React framework standards (App Router).
+
+- [**App Router**](nextjs/app-router/SKILL.md) (P0) - Routing conventions, Layouts, Loading.
+- [**Server Components**](nextjs/server-components/SKILL.md) (P0) - RSC patterns, "use client" boundaries.
+- [**Rendering**](nextjs/rendering/SKILL.md) (P0) - SSG, SSR, PPR, Streaming.
+- [**Data Fetching**](nextjs/data-fetching/SKILL.md) (P0) - Extended fetch, Caching control.
+- [**Authentication**](nextjs/authentication/SKILL.md) (P0) - Auth.js / Middleware patterns.
+- [**Data Access Layer**](nextjs/data-access-layer/SKILL.md) (P1) - DAL patterns & DTOs.
+- [**Caching**](nextjs/caching/SKILL.md) (P1) - Request & Data caching layers.
+- [**Styling**](nextjs/styling/SKILL.md) (P1) - Tailwind, Fonts, CSS-in-JS constraints.
+- [**Optimization**](nextjs/optimization/SKILL.md) (P1) - Images, Scripts, Core Web Vitals.
+- [**Server Actions**](nextjs/server-actions/SKILL.md) (P1) - Mutations & Forms.
+- [**Internationalization**](nextjs/internationalization/SKILL.md) (P2) - i18n routing.
+- [**Architecture**](nextjs/architecture/SKILL.md) (P2) - Feature-Sliced Design (FSD).
+- [**State Management**](nextjs/state-management/SKILL.md) (P2) - URL-state, avoiding global stores.
+
+### ☕ Java (Language & Frameworks)
+
+Modern Java development with Spring Boot, Quarkus, and Micronaut.
+
+- [**Core Language**](java/java-core-language/SKILL.md) (P0) - Records, Sealed Classes, Pattern Matching.
+- [**Collections & Streams**](java/java-collections-streams/SKILL.md) (P0) - Stream API, Collectors, Optional.
+- [**Concurrency**](java/java-concurrency/SKILL.md) (P0) - Executors, CompletableFuture, Virtual Threads.
+- [**Project Structure**](java/java-project-structure/SKILL.md) (P0) - Maven/Gradle layout, Modules.
+- [**Spring Boot Architecture**](java/spring-boot-architecture/SKILL.md) (P0) - Auto-configuration, Profiles.
+- [**Spring Boot Web**](java/spring-boot-web/SKILL.md) (P0) - REST Controllers, Validation.
+- [**Spring Security**](java/spring-security/SKILL.md) (P0) - JWT, OAuth2, Method Security.
+- [**Spring Data JPA**](java/spring-data-jpa/SKILL.md) (P0) - Entities, Repositories, Transactions.
+- [**Spring Batch**](java/spring-batch/SKILL.md) (P1) - Job Configuration, Chunk Processing.
+- [**Spring Cloud**](java/spring-cloud/SKILL.md) (P1) - Service Discovery, Circuit Breakers.
+- [**Quarkus Core**](java/quarkus-core/SKILL.md) (P1) - CDI, Configuration, Dev Mode.
+- [**Quarkus Reactive**](java/quarkus-reactive/SKILL.md) (P1) - Mutiny, Reactive Routes.
+- [**Micronaut Core**](java/micronaut-core/SKILL.md) (P1) - Compile-time DI, Configuration.
+- [**Micronaut Reactive**](java/micronaut-reactive/SKILL.md) (P1) - Reactive Types, HTTP Clients.
+- [**GraalVM Native**](java/graalvm-native/SKILL.md) (P1) - Native Image, Reflection Config.
+- [**Maven Build**](java/build-maven/SKILL.md) (P2) - POM, Dependency Management.
+- [**Gradle Build**](java/build-gradle/SKILL.md) (P2) - Kotlin DSL, Tasks.
+- [**Testing (JUnit & Mockito)**](java/testing-junit-mockito/SKILL.md) (P2) - JUnit 5, Test Slices.
+
+### 🚀 Coming Soon
+
+- **Angular** (Framework)
+- **Kotlin** (Language)
+
+---
+
+## ✍️ Contribution Guide
+
+To add or update a skill:
+
+1. **Format**: Ensure the `SKILL.md` uses the high-density format (YAML frontmatter + concise Markdown).
+2. **Progressive Disclosure**: Move large code samples or templates to `references/REFERENCE.md` inside the skill folder. This keeps the primary context small and token-efficient.
+3. **Naming**: Category folders must be lowercase. Skill folders use `kebab-case`.
+4. **Discovery**: Ensure the `triggers` in the YAML frontmatter are accurate for the AI agent to pick it up.
+5. **Priority**:
+   - **P0**: Foundational (Architecture, Types, Security).
+   - **P1**: Operational (Performance, Idioms, UI).
+   - **P2**: Maintenance (Testing, Tooling, Docs).

package/rules/dart/best-practices/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: Dart Best Practices
+description: General purity standards for Dart development.
+metadata:
+  labels: [dart, clean-code]
+  triggers:
+    files: ['**/*.dart']
+    keywords: [import, final, const, var, global]
+---
+
+# Dart Best Practices (P1)
+
+- **Scoping**:
+  - No global variables.
+  - Private globals (if required) must start with `_`.
+- **Immutability**: Use `const` > `final` > `var`.
+- **Config**: Use `--dart-define` for secrets. Never hardcode API keys.
+- **Naming**: Follow [effective-dart](https://dart.dev/guides/language/effective-dart) (PascalCase classes, camelCase members).
+
+```dart
+import 'models/user.dart'; // Good
+import 'package:app/models/user.dart'; // Avoid local absolute
+```

package/rules/dart/language/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: Dart Language Patterns
+description: Modern Dart standards (3.x+) including null safety and patterns.
+metadata:
+  labels: [dart, language, idioms]
+  triggers:
+    files: ['**/*.dart']
+    keywords: [sealed, record, switch, pattern, extension, final, late, async, await]
+---
+
+# Dart Language Patterns
+
+## **Priority: P0 (CRITICAL)**
+
+Modern Dart standards for safety, performance, and readability.
+
+## Implementation Guidelines
+
+- **Null Safety**: Avoid `!`. Use `?.`, `??`, or short-circuiting. Use `late` only if necessary.
+- **Immutability**: Use `final` for all variables. Use `@freezed` for data classes.
+- **Pattern Matching (3.x)**: Use `switch (value)` with patterns and destructuring.
+- **Records**: Use Records (e.g., `(String, int)`) for returning multiple values.
+- **Sealed Classes**: Use `sealed class` for exhaustive state handling in domain logic.
+- **Extensions**: Use `extension` to add utility methods to third-party types.
+- **Wildcards (3.7+)**: Use `_` for unused variables in declarations and patterns.
+- **Tear-offs**: Prefer using tear-offs (e.g., `list.forEach(print)`) over anonymous lambdas (e.g., `list.forEach((e) => print(e))`).
+- **Asynchrony**: Prefer `async/await` over raw `Future.then`. Use `unawaited` for fire-and-forget logic if necessary.
+- **Collections**: Use `collection-if`, `collection-for`, and spread operators `...`.
+
+## Anti-Patterns
+
+- **No ! Operator**: Do not use the bang operator `!` unless you can prove the value is non-null via `if` or `assert`.
+- **No var for members**: Do not use `var` for class members; use `final` or explicit types.
+- **No logic in constructors**: Do not perform complex calculations or async work inside constructors.
+
+## Code
+
+```dart
+// Sealed class and Switch expression
+sealed class Result {}
+class Success extends Result { final String data; Success(this.data); }
+class Failure extends Result {}
+
+String message(Result r) => switch (r) {
+  Success(data: var d) => "Got $d",
+  Failure() => "Error",
+};
+```
+
+## Related Topics
+
+feature-based-clean-architecture | tooling

package/rules/dart/tooling/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: Dart Tooling & CI
+description: Standards for analysis, linting, formatting, and automation.
+metadata:
+  labels: [tooling, linting, automation]
+  triggers:
+    files: ['analysis_options.yaml', 'pubspec.yaml', 'build.yaml']
+    keywords: [analysis_options, lints, format, build_runner, cider, husky]
+---
+
+# Tooling & CI
+
+## **Priority: P1 (HIGH)**
+
+Standards for code quality, formatting, and generation.
+
+## Implementation Guidelines
+
+- **Linter**: Use `analysis_options.yaml`. Enforce `always_use_package_imports` and `require_trailing_commas`.
+- **Formatting**: Use `dart format . --line-length 80`. Run on every commit.
+- **DCM**: Use `dart_code_metrics` for complexity checks (Max cyclomatic complexity: 15).
+- **Build Runner**: Always use `--delete-conflicting-outputs` with code generation.
+- **CI Pipeline**: All PRs MUST pass `analyze`, `format`, and `test` steps.
+- **Imports**: Group imports: `dart:`, `package:`, then relative.
+- **Documentation**: Use `///` for public APIs. Link symbols using `[Class]`.
+
+## Code
+
+```yaml
+# analysis_options.yaml
+analyzer:
+  errors:
+    todo: ignore
+    missing_required_param: error
+linter:
+  rules:
+    - prefer_single_quotes
+    - unawaited_futures
+```
+
+## Related Topics
+
+language | testing