sdd-full 4.6.1 → 4.8.0

package/skills/flutter-skills/tool/dart_skills_lint/lib/src/entry_point.dart

@@ -0,0 +1,354 @@
+// Copyright (c) 2026, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:io';
+
+import 'package:args/args.dart';
+import 'package:logging/logging.dart';
+import 'package:meta/meta.dart';
+
+import 'config_parser.dart';
+import 'models/analysis_severity.dart';
+import 'models/check_type.dart';
+import 'models/skill_rule.dart';
+import 'rule_registry.dart';
+import 'validation_session.dart';
+
+export 'validation_session.dart';
+
+final _log = Logger('dart_skills_lint');
+
+const _printWarningsFlag = 'print-warnings';
+const _fastFailFlag = 'fast-fail';
+const _quietFlag = 'quiet';
+const _skillsDirectoryFlag = 'skills-directory';
+const _skillOption = 'skill';
+const _ignoreFileOption = 'ignore-file';
+const _ignoreConfigFlag = 'ignore-config';
+const _generateBaselineFlag = 'generate-baseline';
+const _fixFlag = 'fix';
+const _fixApplyFlag = 'fix-apply';
+const _allowMisconfiguredKeysFlag = 'allow-misconfigured-keys';
+
+/// Main entrypoint execution logic for the CLI tool.
+///
+/// Parses arguments and runs validation on the specified directory.
+Future<void> runApp(List<String> args) async {
+  // Setup logger to print to stdout/stderr
+  Logger.root.level = Level.ALL;
+  Logger.root.onRecord.listen((record) {
+    if (record.level >= Level.SEVERE) {
+      stderr.writeln(record.message);
+    } else {
+      stdout.writeln(record.message);
+    }
+  });
+
+  const helpFlag = 'help';
+
+  final ArgParser parser = _createArgParser(helpFlag);
+
+  final ArgResults results;
+  try {
+    results = parser.parse(args);
+    if (results[helpFlag] as bool) {
+      _printUsage(parser);
+      return;
+    }
+  } catch (e) {
+    _printUsage(parser, e.toString());
+    exitCode = 64; // Bad usage
+    return;
+  }
+
+  final Configuration? config = await _loadConfig(results);
+  if (config == null) {
+    exitCode = 1;
+    return;
+  }
+
+  var skillDirPaths = results[_skillsDirectoryFlag] as List<String>;
+  final individualSkillPaths = results[_skillOption] as List<String>;
+
+  if (skillDirPaths.isEmpty && individualSkillPaths.isEmpty) {
+    if (config.directoryConfigs.isNotEmpty) {
+      skillDirPaths = config.directoryConfigs.map((e) => e.path).toList();
+    } else {
+      final defaults = ['.claude/skills', '.agents/skills'];
+      final existingDefaults = <String>[];
+      for (final path in defaults) {
+        if (Directory(path).existsSync()) {
+          existingDefaults.add(path);
+        }
+      }
+      if (existingDefaults.isEmpty) {
+        _printUsage(parser, 'Missing skills directory. Checked defaults: ${defaults.join(', ')}');
+        exitCode = 64;
+        return;
+      }
+      skillDirPaths = existingDefaults;
+    }
+  }
+
+  final Map<String, AnalysisSeverity> resolvedRules = resolveRules(results, config);
+
+  final printWarnings = results[_printWarningsFlag] as bool;
+  final fastFail = results[_fastFailFlag] as bool;
+  final quiet = results[_quietFlag] as bool;
+  final generateBaseline = results[_generateBaselineFlag] as bool;
+  final fix = results[_fixFlag] as bool;
+  final fixApply = results[_fixApplyFlag] as bool;
+
+  String? ignoreFileOverride;
+  if (results.wasParsed(_ignoreFileOption)) {
+    ignoreFileOverride = results[_ignoreFileOption] as String?;
+  }
+
+  final bool success = await validateSkillsInternal(
+    skillDirPaths: skillDirPaths,
+    individualSkillPaths: individualSkillPaths,
+    resolvedRules: resolvedRules,
+    printWarnings: printWarnings,
+    fastFail: fastFail,
+    quiet: quiet,
+    generateBaseline: generateBaseline,
+    fix: fix,
+    fixApply: fixApply,
+    ignoreFileOverride: ignoreFileOverride,
+    config: config,
+  );
+
+  exitCode = success ? 0 : 1;
+}
+
+/// Creates the [ArgParser] for the CLI, adding all supported flags and options.
+///
+/// Dynamically adds flags for all registered rules in [RuleRegistry].
+ArgParser _createArgParser(String helpFlag) {
+  final parser = ArgParser()
+    ..addFlag(helpFlag, abbr: 'h', negatable: false, help: 'Show usage information.')
+    ..addFlag(_printWarningsFlag, abbr: 'w', defaultsTo: true, help: 'Print validation warnings.');
+
+  // Dynamically add flags for all registered rules.
+  for (final CheckType check in RuleRegistry.allChecks) {
+    parser.addFlag(
+      check.name,
+      defaultsTo: check.defaultSeverity != AnalysisSeverity.disabled,
+      help: check.help,
+    );
+  }
+
+  parser
+    ..addFlag(
+      _fastFailFlag,
+      negatable: false,
+      help: 'Fail immediately on the first skill validation error.',
+    )
+    ..addFlag(
+      _quietFlag,
+      abbr: 'q',
+      negatable: false,
+      help: 'Quiet mode (only print errors and warnings).',
+    )
+    ..addMultiOption(
+      _skillsDirectoryFlag,
+      abbr: 'd',
+      help: 'Path to a skills directory to validate. Can be specified multiple times.',
+    )
+    ..addMultiOption(
+      _skillOption,
+      abbr: 's',
+      help: 'Path to an individual skill directory to validate. Can be specified multiple times.',
+    )
+    ..addOption(_ignoreFileOption, help: 'Path to a JSON file listing lints to ignore for the run.')
+    ..addFlag(
+      _generateBaselineFlag,
+      negatable: false,
+      help: 'Write all current errors into $defaultIgnoreFileName to ignore on future runs.',
+    )
+    ..addFlag(
+      _ignoreConfigFlag,
+      negatable: false,
+      help: 'Ignore the YAML configuration file entirely.',
+    )
+    ..addFlag(_fixFlag, negatable: false, help: 'Preview fixes for failing lints (dry run).')
+    ..addFlag(_fixApplyFlag, negatable: false, help: 'Apply fixes for failing lints.')
+    ..addFlag(
+      _allowMisconfiguredKeysFlag,
+      negatable: false,
+      hide: true,
+      help: 'Allow misconfigured keys in dart_skills_lint.yaml.',
+    );
+
+  return parser;
+}
+
+Future<Configuration?> _loadConfig(ArgResults results) async {
+  final ignoreConfig = results[_ignoreConfigFlag] as bool;
+  final Configuration config = ignoreConfig ? Configuration() : await ConfigParser.loadConfig();
+  if (ignoreConfig && !(results[_quietFlag] as bool)) {
+    _log.info('Ignoring configuration file due to $_ignoreConfigFlag flag');
+  }
+
+  if (config.parsingErrors.isNotEmpty) {
+    final allowMisconfiguredKeys = results[_allowMisconfiguredKeysFlag] as bool;
+    if (allowMisconfiguredKeys) {
+      for (final String error in config.parsingErrors) {
+        _log.warning('Configuration warning: $error');
+      }
+    } else {
+      for (final String error in config.parsingErrors) {
+        _log.severe('Configuration error: $error');
+      }
+      _log.severe('Use --$_allowMisconfiguredKeysFlag to ignore these errors.');
+      return null;
+    }
+  }
+  return config;
+}
+
+/// Validates skills based on the provided configuration.
+///
+/// This is the public API for validating skills. It does not support fixing
+/// lints as that feature is currently considered internal to the CLI.
+///
+/// [skillDirPaths] is a list of directories containing multiple skills.
+/// [individualSkillPaths] is a list of paths to individual skill directories.
+/// [resolvedRules] is a map of rule names to their severity overrides.
+/// [printWarnings] controls whether to print validation warnings.
+/// [fastFail] causes validation to stop on the first error.
+/// [quiet] suppresses non-error/warning output.
+/// [generateBaseline] writes current errors to a baseline file instead of reporting them.
+/// [ignoreFileOverride] is an optional path to a baseline file to use.
+/// [config] is the loaded configuration.
+///
+/// Returns `true` if all validations passed (or if generating a baseline), `false` otherwise.
+Future<bool> validateSkills({
+  List<String> skillDirPaths = const [],
+  List<String> individualSkillPaths = const [],
+  Map<String, AnalysisSeverity> resolvedRules = const {},
+  bool printWarnings = true,
+  bool fastFail = false,
+  bool quiet = false,
+  bool generateBaseline = false,
+  String? ignoreFileOverride,
+  Configuration? config,
+  List<SkillRule> customRules = const [],
+}) {
+  return validateSkillsInternal(
+    skillDirPaths: skillDirPaths,
+    individualSkillPaths: individualSkillPaths,
+    resolvedRules: resolvedRules,
+    printWarnings: printWarnings,
+    fastFail: fastFail,
+    quiet: quiet,
+    generateBaseline: generateBaseline,
+    ignoreFileOverride: ignoreFileOverride,
+    config: config,
+    customRules: customRules,
+  );
+}
+
+/// Internal implementation of skill validation that supports fixing.
+///
+/// Kept internal to avoid exposing experimental fix parameters in the public API.
+@visibleForTesting
+Future<bool> validateSkillsInternal({
+  List<String> skillDirPaths = const [],
+  List<String> individualSkillPaths = const [],
+  Map<String, AnalysisSeverity> resolvedRules = const {},
+  bool printWarnings = true,
+  bool fastFail = false,
+  bool quiet = false,
+  bool generateBaseline = false,
+  bool fix = false,
+  bool fixApply = false,
+  String? ignoreFileOverride,
+  Configuration? config,
+  List<SkillRule> customRules = const [],
+}) async {
+  final session = ValidationSession(
+    config: config ?? Configuration(),
+    resolvedRules: resolvedRules,
+    ignoreFileOverride: ignoreFileOverride,
+    customRules: customRules,
+    printWarnings: printWarnings,
+    fastFail: fastFail,
+    quiet: quiet,
+    generateBaseline: generateBaseline,
+    fix: fix,
+    fixApply: fixApply,
+  );
+
+  for (final skillPath in individualSkillPaths) {
+    final bool keepGoing = await session.processIndividualSkill(skillPath);
+    if (!keepGoing) {
+      break;
+    }
+  }
+  if (session.anyFailed && fastFail) {
+    return false;
+  }
+
+  for (final rootPath in skillDirPaths) {
+    final bool keepGoing = await session.processSkillRoot(rootPath);
+    if (!keepGoing) {
+      break;
+    }
+  }
+
+  session.reportNoSkillsValidated(skillDirPaths);
+
+  if (generateBaseline) {
+    return true;
+  }
+  return !session.anyFailed;
+}
+
+@visibleForTesting
+Map<String, AnalysisSeverity> resolveRules(ArgResults results, Configuration config) {
+  final resolved = <String, AnalysisSeverity>{};
+
+  // 1. Initialize with default severities from the registry.
+  for (final CheckType check in RuleRegistry.allChecks) {
+    resolved[check.name] = check.defaultSeverity;
+  }
+
+  // 2. Override with configurations from the YAML file.
+  resolved.addAll(config.configuredRules);
+
+  // 3. Override with CLI flags. CLI flags take highest precedence.
+  for (final CheckType check in RuleRegistry.allChecks) {
+    final String name = check.name;
+
+    // Skip if the flag was not passed on the command line.
+    if (!results.wasParsed(name)) {
+      continue;
+    }
+
+    // TODO(reidbaker): Handle options in addition to flags.
+    final Object? value = results[name];
+    if (value is! bool) {
+      continue;
+    }
+
+    if (value) {
+      // If the user explicitly enabled the rule via flag (e.g., --rule), set to error.
+      resolved[name] = AnalysisSeverity.error;
+    } else {
+      // If the user explicitly disabled the rule via flag (e.g., --no-rule).
+      resolved[name] = AnalysisSeverity.disabled;
+    }
+  }
+
+  return resolved;
+}
+
+void _printUsage(ArgParser parser, [String? error]) {
+  if (error != null) {
+    _log.severe('Error: $error');
+  }
+  _log.info('Usage: dart_skills_lint [options] --$_skillsDirectoryFlag <$_skillsDirectoryFlag>');
+  _log.info(parser.usage);
+}

package/skills/flutter-skills/tool/dart_skills_lint/lib/src/fixable_rule.dart

@@ -0,0 +1,20 @@
+// Copyright (c) 2026, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:io';
+import 'models/skill_rule.dart';
+
+/// Interface for rules that support fixes.
+/// Kept internal to the package for now.
+abstract class FixableRule extends SkillRule {
+  /// Returns the updated content of the file at [filePath].
+  /// [currentContent] is the content after previous fixes have been applied.
+  /// If the rule does not support fixing the file at [filePath], it should return [currentContent].
+  ///
+  /// Rules should rely on [currentContent] for the current state of the file.
+  /// If a rule needs structured access (like parsed YAML), it should parse
+  /// [currentContent] itself, as structured data in [SkillContext] may be stale
+  /// if previous rules applied fixes.
+  Future<String> fix(String filePath, String currentContent, Directory directory);
+}

package/skills/flutter-skills/tool/dart_skills_lint/lib/src/models/analysis_severity.dart

@@ -0,0 +1,15 @@
+// Copyright (c) 2026, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// Severity level for a specific analysis rule.
+enum AnalysisSeverity {
+  /// Check is completely disabled.
+  disabled,
+
+  /// Failures are reported as warnings and do not fail the overall validation.
+  warning,
+
+  /// Failures are reported as errors and fail the overall validation.
+  error,
+}

package/skills/flutter-skills/tool/dart_skills_lint/lib/src/models/check_type.dart

@@ -0,0 +1,17 @@
+// Copyright (c) 2026, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'analysis_severity.dart';
+
+/// Encapsulates metadata and severity state for a specific validation rule.
+class CheckType {
+  const CheckType({required this.name, required this.defaultSeverity, required this.help});
+  final String name;
+
+  /// The default severity if not overridden by config or flags.
+  final AnalysisSeverity defaultSeverity;
+
+  /// The help message displayed by the CLI.
+  final String help;
+}

package/skills/flutter-skills/tool/dart_skills_lint/lib/src/models/ignore_entry.dart

@@ -0,0 +1,34 @@
+// Copyright (c) 2026, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:json_annotation/json_annotation.dart';
+
+part 'ignore_entry.g.dart';
+
+/// Represents a single ignored rule entry for a specific file.
+@JsonSerializable()
+class IgnoreEntry {
+  IgnoreEntry({required this.ruleId, required this.fileName, this.used = false});
+
+  /// Creates an IgnoreEntry from a JSON map.
+  factory IgnoreEntry.fromJson(Map<String, dynamic> json) => _$IgnoreEntryFromJson(json);
+
+  static const String ruleIdKey = 'rule_id';
+  static const String fileNameKey = 'file_name';
+
+  /// The rule ID that should be suppressed (e.g., 'description_too_long').
+  @JsonKey(name: ruleIdKey)
+  final String ruleId;
+
+  /// The file name to apply this suppression to.
+  @JsonKey(name: fileNameKey)
+  final String fileName;
+
+  /// Whether this entry has been used during the run.
+  @JsonKey(includeFromJson: false, includeToJson: false)
+  bool used;
+
+  /// Converts an IgnoreEntry to a JSON map.
+  Map<String, dynamic> toJson() => _$IgnoreEntryToJson(this);
+}

package/skills/flutter-skills/tool/dart_skills_lint/lib/src/models/ignore_entry.g.dart

@@ -0,0 +1,19 @@
+// Copyright (c) 2026, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'ignore_entry.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+IgnoreEntry _$IgnoreEntryFromJson(Map<String, dynamic> json) =>
+    IgnoreEntry(ruleId: json['rule_id'] as String, fileName: json['file_name'] as String);
+
+Map<String, dynamic> _$IgnoreEntryToJson(IgnoreEntry instance) => <String, dynamic>{
+  'rule_id': instance.ruleId,
+  'file_name': instance.fileName,
+};

package/skills/flutter-skills/tool/dart_skills_lint/lib/src/models/skill_context.dart

@@ -0,0 +1,27 @@
+import 'dart:io';
+import 'package:yaml/yaml.dart';
+
+/// Context provided to [SkillRule]s during validation.
+class SkillContext {
+  SkillContext({
+    required this.directory,
+    required this.rawContent,
+    this.parsedYaml,
+    this.yamlParsingError,
+  });
+
+  /// The required filename for skill documentation.
+  static const String skillFileName = 'SKILL.md';
+
+  /// Regex to match the YAML frontmatter in SKILL.md.
+  static final RegExp skillStartRegex = RegExp(r'^---\s*\n(.*?)\n---\s*\n', dotAll: true);
+
+  final Directory directory;
+
+  /// Guaranteed to be non-null because we only run rules if SKILL.md exists.
+  final String rawContent;
+
+  final YamlMap? parsedYaml;
+
+  final String? yamlParsingError;
+}

package/skills/flutter-skills/tool/dart_skills_lint/lib/src/models/skill_rule.dart

@@ -0,0 +1,27 @@
+import 'analysis_severity.dart';
+import 'skill_context.dart';
+import 'validation_error.dart';
+
+/// Abstract base class for all skill validation rules.
+///
+/// Custom rules should follow these guidelines to play nice with others:
+/// 1. **Unique Name**: The [name] must be unique to allow for overrides in
+///    configuration.
+/// 2. **Statelessness**: Rules should not maintain state between [validate] calls.
+/// 3. **Use Context**: Prefer using data in [SkillContext] (like [context.parsedYaml])
+///    rather than reading files manually to avoid duplicate I/O.
+/// 4. **Handle Parsing Errors**: If [context.parsedYaml] is null, check
+///    [context.yamlParsingError]. Rules that require valid YAML should return
+///    quickly if parsing failed.
+/// 5. **Respect Severity**: The rule should use its [severity] when creating
+///    [ValidationError]s unless there is a good reason not to.
+abstract class SkillRule {
+  /// The unique name of the rule (e.g., 'check-relative-paths').
+  /// Used in configuration and flags.
+  String get name;
+
+  AnalysisSeverity get severity;
+
+  /// Validates the skill provided in [context].
+  Future<List<ValidationError>> validate(SkillContext context);
+}

package/skills/flutter-skills/tool/dart_skills_lint/lib/src/models/skills_ignores.dart

@@ -0,0 +1,26 @@
+// Copyright (c) 2026, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:json_annotation/json_annotation.dart';
+import 'ignore_entry.dart';
+
+part 'skills_ignores.g.dart';
+
+/// Represents the top-level structure of the skills ignore JSON file.
+@JsonSerializable(explicitToJson: true)
+class SkillsIgnores {
+  SkillsIgnores({required this.skills});
+
+  /// Creates a SkillsIgnores from a JSON map.
+  factory SkillsIgnores.fromJson(Map<String, dynamic> json) => _$SkillsIgnoresFromJson(json);
+
+  static const String skillsKey = 'skills';
+
+  /// Map of skill names to their list of ignore entries.
+  @JsonKey(name: skillsKey)
+  final Map<String, List<IgnoreEntry>> skills;
+
+  /// Converts a SkillsIgnores to a JSON map.
+  Map<String, dynamic> toJson() => _$SkillsIgnoresToJson(this);
+}

package/skills/flutter-skills/tool/dart_skills_lint/lib/src/models/skills_ignores.g.dart

@@ -0,0 +1,24 @@
+// Copyright (c) 2026, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'skills_ignores.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+SkillsIgnores _$SkillsIgnoresFromJson(Map<String, dynamic> json) => SkillsIgnores(
+  skills: (json['skills'] as Map<String, dynamic>).map(
+    (k, e) => MapEntry(
+      k,
+      (e as List<dynamic>).map((e) => IgnoreEntry.fromJson(e as Map<String, dynamic>)).toList(),
+    ),
+  ),
+);
+
+Map<String, dynamic> _$SkillsIgnoresToJson(SkillsIgnores instance) => <String, dynamic>{
+  'skills': instance.skills.map((k, e) => MapEntry(k, e.map((e) => e.toJson()).toList())),
+};

package/skills/flutter-skills/tool/dart_skills_lint/lib/src/models/validation_error.dart

@@ -0,0 +1,31 @@
+// Copyright (c) 2026, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'analysis_severity.dart';
+
+/// Represents a single validation error found during analysis.
+class ValidationError {
+  ValidationError({
+    required this.ruleId,
+    required this.file,
+    required this.message,
+    required this.severity,
+    this.isIgnored = false,
+  });
+
+  /// The unique rule ID (e.g., 'description_too_long').
+  final String ruleId;
+
+  /// The file name context (e.g., 'SKILL.md' or relative path).
+  final String file;
+
+  /// The human-readable error message.
+  final String message;
+
+  /// The severity of the error.
+  final AnalysisSeverity severity;
+
+  /// Whether this error has been ignored via configuration.
+  bool isIgnored;
+}

package/skills/flutter-skills/tool/dart_skills_lint/lib/src/rule_registry.dart

@@ -0,0 +1,79 @@
+// Copyright (c) 2026, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'models/analysis_severity.dart';
+import 'models/check_type.dart';
+import 'models/skill_rule.dart';
+import 'rules/absolute_paths_rule.dart';
+import 'rules/description_length_rule.dart';
+import 'rules/disallowed_field_rule.dart';
+import 'rules/name_format_rule.dart';
+import 'rules/relative_paths_rule.dart';
+import 'rules/trailing_whitespace_rule.dart';
+import 'rules/valid_yaml_metadata_rule.dart';
+
+/// Registry of all built-in rules.
+class RuleRegistry {
+  /// All registered rules and their default configurations.
+  // TODO(reidbaker): Break out flags vs options here so entry_point can generate appropriate CLI arguments.
+  static final List<CheckType> allChecks = [
+    const CheckType(
+      name: AbsolutePathsRule.ruleName,
+      defaultSeverity: AbsolutePathsRule.defaultSeverity,
+      help: 'Check if absolute paths exist.',
+    ),
+    const CheckType(
+      name: DescriptionLengthRule.ruleName,
+      defaultSeverity: DescriptionLengthRule.defaultSeverity,
+      help: 'Check if description is too long.',
+    ),
+    const CheckType(
+      name: DisallowedFieldRule.ruleName,
+      defaultSeverity: DisallowedFieldRule.defaultSeverity,
+      help: 'Check for disallowed fields in YAML metadata.',
+    ),
+    const CheckType(
+      name: NameFormatRule.ruleName,
+      defaultSeverity: NameFormatRule.defaultSeverity,
+      help: 'Check if skill name is invalid.',
+    ),
+    const CheckType(
+      name: RelativePathsRule.ruleName,
+      defaultSeverity: RelativePathsRule.defaultSeverity,
+      help: 'Check if relative paths exist.',
+    ),
+    const CheckType(
+      name: TrailingWhitespaceRule.ruleName,
+      defaultSeverity: TrailingWhitespaceRule.defaultSeverity,
+      help: 'Check for trailing whitespace (allows exactly 2 spaces for line breaks).',
+    ),
+    const CheckType(
+      name: ValidYamlMetadataRule.ruleName,
+      defaultSeverity: ValidYamlMetadataRule.defaultSeverity,
+      help: 'Check if YAML metadata is valid.',
+    ),
+  ];
+
+  /// Creates a rule instance by name, or returns null if not a class-based rule.
+  static SkillRule? createRule(String name, AnalysisSeverity severity) {
+    switch (name) {
+      case AbsolutePathsRule.ruleName:
+        return AbsolutePathsRule(severity: severity);
+      case DescriptionLengthRule.ruleName:
+        return DescriptionLengthRule(severity: severity);
+      case DisallowedFieldRule.ruleName:
+        return DisallowedFieldRule(severity: severity);
+      case NameFormatRule.ruleName:
+        return NameFormatRule(severity: severity);
+      case RelativePathsRule.ruleName:
+        return RelativePathsRule(severity: severity);
+      case TrailingWhitespaceRule.ruleName:
+        return TrailingWhitespaceRule(severity: severity);
+      case ValidYamlMetadataRule.ruleName:
+        return ValidYamlMetadataRule(severity: severity);
+      default:
+        return null;
+    }
+  }
+}