sdd-full 4.6.2 → 4.8.0

package/skills/flutter-skills/tool/dart_skills_lint/test/field_constraints_test.dart

@@ -0,0 +1,178 @@
+// 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:dart_skills_lint/src/models/skill_context.dart';
+import 'package:dart_skills_lint/src/rules/description_length_rule.dart';
+import 'package:dart_skills_lint/src/rules/name_format_rule.dart';
+import 'package:dart_skills_lint/src/rules/valid_yaml_metadata_rule.dart';
+import 'package:dart_skills_lint/src/validator.dart';
+import 'package:test/test.dart';
+import 'package:yaml/yaml.dart';
+
+import 'test_utils.dart';
+
+void main() {
+  group('Field Specific Constraints Validation', () {
+    late Directory tempDir;
+
+    setUp(() async {
+      tempDir = await Directory.systemTemp.createTemp('fields_test.');
+    });
+
+    tearDown(() async {
+      if (tempDir.existsSync()) {
+        await tempDir.delete(recursive: true);
+      }
+    });
+
+    group('Skill Name', () {
+      test('fails if not lowercase', () async {
+        final Directory skillDir = await Directory('${tempDir.path}/Skill-Name').create();
+        await File('${skillDir.path}/SKILL.md').writeAsString('${buildFrontmatter()}Body');
+        final validator = Validator();
+        final ValidationResult result = await validator.validate(skillDir);
+        expect(result.isValid, isFalse);
+        expect(result.errors, contains(contains('lowercase')));
+      });
+
+      test('fails if too long (> ${NameFormatRule.maxNameLength} chars)', () async {
+        final String longName = 'a' * (NameFormatRule.maxNameLength + 1);
+        final Directory skillDir = await Directory('${tempDir.path}/$longName').create();
+        await File(
+          '${skillDir.path}/SKILL.md',
+        ).writeAsString('${buildFrontmatter(name: longName)}Body');
+        final validator = Validator();
+        final ValidationResult result = await validator.validate(skillDir);
+        expect(result.isValid, isFalse);
+        expect(
+          result.errors,
+          contains(contains('Maximum ${NameFormatRule.maxNameLength} characters')),
+        );
+      });
+
+      test('fails if contains invalid characters', () async {
+        final Directory skillDir = await Directory('${tempDir.path}/skill_name').create();
+        await File(
+          '${skillDir.path}/SKILL.md',
+        ).writeAsString('${buildFrontmatter(name: 'skill_name')}Body');
+        final validator = Validator();
+        final ValidationResult result = await validator.validate(skillDir);
+        expect(result.isValid, isFalse);
+        expect(result.errors, contains(contains('lowercase letters, digits, and hyphens')));
+      });
+
+      test('fails if has leading hyphen', () async {
+        final Directory skillDir = await Directory('${tempDir.path}/-skill-name').create();
+        await File(
+          '${skillDir.path}/SKILL.md',
+        ).writeAsString('${buildFrontmatter(name: '-skill-name')}Body');
+        final validator = Validator();
+        final ValidationResult result = await validator.validate(skillDir);
+        expect(result.isValid, isFalse);
+        expect(result.errors, contains(contains('leading or trailing hyphens')));
+      });
+
+      test('fails if has trailing hyphen', () async {
+        final Directory skillDir = await Directory('${tempDir.path}/skill-name-').create();
+        await File(
+          '${skillDir.path}/SKILL.md',
+        ).writeAsString('${buildFrontmatter(name: 'skill-name-')}Body');
+        final validator = Validator();
+        final ValidationResult result = await validator.validate(skillDir);
+        expect(result.isValid, isFalse);
+        expect(result.errors, contains(contains('leading or trailing hyphens')));
+      });
+
+      test('fails if has consecutive hyphens', () async {
+        final Directory skillDir = await Directory('${tempDir.path}/skill--name').create();
+        await File(
+          '${skillDir.path}/SKILL.md',
+        ).writeAsString('${buildFrontmatter(name: 'skill--name')}Body');
+        final validator = Validator();
+        final ValidationResult result = await validator.validate(skillDir);
+        expect(result.isValid, isFalse);
+        expect(result.errors, contains(contains('consecutive hyphens')));
+      });
+
+      test('fails if name does not match directory name', () async {
+        final Directory skillDir = await Directory('${tempDir.path}/wrong-name').create();
+        await File(
+          '${skillDir.path}/SKILL.md',
+        ).writeAsString('${buildFrontmatter(name: 'right-name')}Body');
+        final validator = Validator();
+        final ValidationResult result = await validator.validate(skillDir);
+        expect(result.isValid, isFalse);
+        expect(result.errors, contains(contains('must exactly match the parent directory name')));
+      });
+
+      test('fixes name to match directory name (not replacing underscores)', () async {
+        final Directory skillDir = await Directory('${tempDir.path}/my_skill').create();
+        final file = File('${skillDir.path}/SKILL.md');
+        await file.writeAsString('''
+---
+name: wrong-name
+description: A test skill
+---
+Body''');
+
+        final rule = NameFormatRule();
+        final String content = await file.readAsString();
+        final RegExpMatch? match = RegExp(
+          r'^---\s*\n(.*?)\n---\s*\n',
+          dotAll: true,
+        ).firstMatch(content);
+        final parsedYaml = loadYaml(match!.group(1)!) as YamlMap?;
+        final context = SkillContext(
+          directory: skillDir,
+          rawContent: content,
+          parsedYaml: parsedYaml,
+        );
+
+        final String fixedContent = await rule.fix('SKILL.md', content, context.directory);
+
+        expect(fixedContent, contains('name: my_skill'));
+      });
+    });
+
+    group('Description', () {
+      test('fails if too long (> ${DescriptionLengthRule.maxDescriptionLength} chars)', () async {
+        final String longDesc = 'a' * (DescriptionLengthRule.maxDescriptionLength + 1);
+        final Directory skillDir = await Directory('${tempDir.path}/skill-name').create();
+        await File(
+          '${skillDir.path}/SKILL.md',
+        ).writeAsString('${buildFrontmatter(name: 'skill-name', description: longDesc)}Body');
+        final validator = Validator();
+        final ValidationResult result = await validator.validate(skillDir);
+        expect(result.isValid, isFalse);
+        expect(
+          result.errors,
+          contains(contains('Maximum ${DescriptionLengthRule.maxDescriptionLength} characters')),
+        );
+      });
+    });
+
+    group('Compatibility', () {
+      test('fails if too long (> ${ValidYamlMetadataRule.maxCompatibilityLength} chars)', () async {
+        final String longComp = 'a' * (ValidYamlMetadataRule.maxCompatibilityLength + 1);
+        final Directory skillDir = await Directory('${tempDir.path}/skill-name').create();
+        await File('${skillDir.path}/SKILL.md').writeAsString('''
+---
+name: skill-name
+description: A test skill
+compatibility: $longComp
+---
+Body''');
+        final validator = Validator();
+        final ValidationResult result = await validator.validate(skillDir);
+        expect(result.isValid, isFalse);
+        expect(
+          result.errors,
+          contains(contains('Maximum ${ValidYamlMetadataRule.maxCompatibilityLength} characters')),
+        );
+      });
+    });
+  });
+}

package/skills/flutter-skills/tool/dart_skills_lint/test/fixer_test.dart

@@ -0,0 +1,172 @@
+// 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:dart_skills_lint/src/entry_point.dart';
+import 'package:dart_skills_lint/src/fixable_rule.dart';
+import 'package:dart_skills_lint/src/models/analysis_severity.dart';
+import 'package:dart_skills_lint/src/models/skill_context.dart';
+import 'package:dart_skills_lint/src/models/skill_rule.dart';
+import 'package:dart_skills_lint/src/models/validation_error.dart';
+import 'package:path/path.dart' as p;
+import 'package:test/test.dart';
+
+class RuleA extends SkillRule implements FixableRule {
+  @override
+  String get name => 'rule-a';
+
+  @override
+  AnalysisSeverity get severity => AnalysisSeverity.warning;
+
+  @override
+  Future<List<ValidationError>> validate(SkillContext context) async {
+    return [
+      ValidationError(
+        ruleId: name,
+        message: 'Error A',
+        severity: AnalysisSeverity.warning,
+        file: 'SKILL.md',
+      ),
+    ];
+  }
+
+  @override
+  Future<String> fix(String filePath, String currentContent, Directory directory) async {
+    return '$currentContent A';
+  }
+}
+
+class RuleB extends SkillRule implements FixableRule {
+  @override
+  String get name => 'rule-b';
+
+  @override
+  AnalysisSeverity get severity => AnalysisSeverity.warning;
+
+  @override
+  Future<List<ValidationError>> validate(SkillContext context) async {
+    return [
+      ValidationError(
+        ruleId: name,
+        message: 'Error B',
+        severity: AnalysisSeverity.warning,
+        file: 'SKILL.md',
+      ),
+    ];
+  }
+
+  @override
+  Future<String> fix(String filePath, String currentContent, Directory directory) async {
+    return '$currentContent B';
+  }
+}
+
+class RuleThrows extends SkillRule implements FixableRule {
+  @override
+  String get name => 'rule-throws';
+
+  @override
+  AnalysisSeverity get severity => AnalysisSeverity.warning;
+
+  @override
+  Future<List<ValidationError>> validate(SkillContext context) async {
+    return [
+      ValidationError(
+        ruleId: name,
+        message: 'Error Throws',
+        severity: AnalysisSeverity.warning,
+        file: 'SKILL.md',
+      ),
+    ];
+  }
+
+  @override
+  Future<String> fix(String filePath, String currentContent, Directory directory) async {
+    throw Exception('Fix failed');
+  }
+}
+
+void main() {
+  group('Fixer Sequential Execution', () {
+    late Directory tempDir;
+
+    setUp(() async {
+      tempDir = await Directory.systemTemp.createTemp('fixer_test.');
+    });
+
+    tearDown(() async {
+      await tempDir.delete(recursive: true);
+    });
+
+    test('applies fixes in order', () async {
+      final skillDir = Directory(p.join(tempDir.path, 'test-skill'));
+      await skillDir.create();
+      final skillFile = File(p.join(skillDir.path, 'SKILL.md'));
+      await skillFile.writeAsString('Original');
+
+      final bool success = await validateSkillsInternal(
+        individualSkillPaths: [skillDir.path],
+        fixApply: true,
+        quiet: true,
+        customRules: [RuleA(), RuleB()],
+      );
+
+      expect(success, isFalse);
+
+      final String content = await skillFile.readAsString();
+      expect(content, 'Original A B');
+    });
+
+    test(
+      '--fast-fail stops processing subsequent skills but completes current skill fixes',
+      () async {
+        final skillDir1 = Directory(p.join(tempDir.path, 'test-skill-1'));
+        await skillDir1.create();
+        final skillFile1 = File(p.join(skillDir1.path, 'SKILL.md'));
+        await skillFile1.writeAsString('Original1');
+
+        final skillDir2 = Directory(p.join(tempDir.path, 'test-skill-2'));
+        await skillDir2.create();
+        final skillFile2 = File(p.join(skillDir2.path, 'SKILL.md'));
+        await skillFile2.writeAsString('Original2');
+
+        final bool success = await validateSkillsInternal(
+          individualSkillPaths: [skillDir1.path, skillDir2.path],
+          fixApply: true,
+          fastFail: true,
+          quiet: true,
+          customRules: [RuleA()],
+        );
+
+        expect(success, isFalse);
+
+        final String content1 = await skillFile1.readAsString();
+        expect(content1, 'Original1 A');
+
+        final String content2 = await skillFile2.readAsString();
+        expect(content2, 'Original2');
+      },
+    );
+
+    test('handles exceptions in fix method gracefully', () async {
+      final skillDir = Directory(p.join(tempDir.path, 'test-skill'));
+      await skillDir.create();
+      final skillFile = File(p.join(skillDir.path, 'SKILL.md'));
+      await skillFile.writeAsString('Original');
+
+      final bool success = await validateSkillsInternal(
+        individualSkillPaths: [skillDir.path],
+        fixApply: true,
+        quiet: true,
+        customRules: [RuleThrows()],
+      );
+
+      expect(success, isFalse);
+
+      final String content = await skillFile.readAsString();
+      expect(content, 'Original');
+    });
+  });
+}

package/skills/flutter-skills/tool/dart_skills_lint/test/ignore_models_test.dart

@@ -0,0 +1,63 @@
+// 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:dart_skills_lint/src/models/ignore_entry.dart';
+import 'package:dart_skills_lint/src/models/skills_ignores.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('IgnoreEntry Serialization', () {
+    test('fromJson parses rule_id and file_name', () {
+      final Map<String, dynamic> json = {
+        IgnoreEntry.ruleIdKey: 'description_too_long',
+        IgnoreEntry.fileNameKey: 'SKILL.md',
+      };
+      final entry = IgnoreEntry.fromJson(json);
+      expect(entry.ruleId, equals('description_too_long'));
+      expect(entry.fileName, equals('SKILL.md'));
+      expect(entry.used, isFalse); // Default
+    });
+
+    test('toJson serializes rule_id and file_name', () {
+      final entry = IgnoreEntry(ruleId: 'description_too_long', fileName: 'SKILL.md');
+      final Map<String, dynamic> json = entry.toJson();
+      expect(json[IgnoreEntry.ruleIdKey], equals('description_too_long'));
+      expect(json[IgnoreEntry.fileNameKey], equals('SKILL.md'));
+      expect(json.containsKey('used'), isFalse); // Suppressed
+    });
+  });
+
+  group('SkillsIgnores Serialization', () {
+    test('fromJson parses nested skills map', () {
+      final Map<String, dynamic> json = {
+        SkillsIgnores.skillsKey: {
+          'skill-a': [
+            {IgnoreEntry.ruleIdKey: 'rule1', IgnoreEntry.fileNameKey: 'file1.md'},
+          ],
+        },
+      };
+      final ignores = SkillsIgnores.fromJson(json);
+      expect(ignores.skills.containsKey('skill-a'), isTrue);
+      expect(ignores.skills['skill-a']!.length, equals(1));
+      expect(ignores.skills['skill-a']![0].ruleId, equals('rule1'));
+    });
+
+    test('toJson serializes nested skills map', () {
+      final entry = IgnoreEntry(ruleId: 'rule1', fileName: 'file1.md');
+      final ignores = SkillsIgnores(
+        skills: {
+          'skill-a': [entry],
+        },
+      );
+      final Map<String, dynamic> json = ignores.toJson();
+
+      expect(json.containsKey(SkillsIgnores.skillsKey), isTrue);
+      final skillsJson = json[SkillsIgnores.skillsKey] as Map<String, dynamic>;
+      expect(skillsJson.containsKey('skill-a'), isTrue);
+      final skillAList = skillsJson['skill-a'] as List<dynamic>;
+      final firstItem = skillAList[0] as Map<String, dynamic>;
+      expect(firstItem[IgnoreEntry.ruleIdKey], equals('rule1'));
+    });
+  });
+}

package/skills/flutter-skills/tool/dart_skills_lint/test/metadata_validation_test.dart

@@ -0,0 +1,116 @@
+// 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:dart_skills_lint/src/models/validation_error.dart';
+import 'package:dart_skills_lint/src/rules/disallowed_field_rule.dart';
+import 'package:dart_skills_lint/src/validator.dart';
+import 'package:test/test.dart';
+
+import 'test_utils.dart';
+
+void main() {
+  group('Metadata (YAML) Validation', () {
+    late Directory tempDir;
+
+    setUp(() async {
+      tempDir = await Directory.systemTemp.createTemp('metadata_test.');
+    });
+
+    tearDown(() async {
+      if (tempDir.existsSync()) {
+        await tempDir.delete(recursive: true);
+      }
+    });
+
+    test('fails if YAML metadata is invalid', () async {
+      await File('${tempDir.path}/SKILL.md').writeAsString('''
+---
+invalid: yaml: frontmatter
+---
+Body''');
+      final validator = Validator();
+      final ValidationResult result = await validator.validate(tempDir);
+
+      expect(result.isValid, isFalse);
+      expect(result.errors, contains(contains('Invalid YAML metadata')));
+    });
+
+    test('fails if required field "name" is missing', () async {
+      await File('${tempDir.path}/SKILL.md').writeAsString('''
+---
+description: A test skill
+---
+Body''');
+      final validator = Validator();
+      final ValidationResult result = await validator.validate(tempDir);
+
+      expect(result.isValid, isFalse);
+      expect(result.errors, contains(contains('Missing required field: name')));
+    });
+
+    test('fails if required field "description" is missing', () async {
+      await File('${tempDir.path}/SKILL.md').writeAsString('''
+---
+name: metadata-test
+---
+Body''');
+      final validator = Validator();
+      final ValidationResult result = await validator.validate(tempDir);
+
+      expect(result.isValid, isFalse);
+      expect(result.errors, contains(contains('Missing required field: description')));
+    });
+
+    test('passes without warning if disallowed fields are present', () async {
+      final skillDir = Directory('${tempDir.path}/metadata-test');
+      await skillDir.create();
+      await File('${skillDir.path}/SKILL.md').writeAsString('''
+---
+name: metadata-test
+description: A test skill
+extra-field: not allowed
+---
+Body''');
+
+      final validator = Validator();
+      final ValidationResult result = await validator.validate(skillDir);
+
+      expect(result.isValid, isTrue);
+      expect(result.warnings, isEmpty);
+
+      final Iterable<ValidationError> disallowedErrors = result.validationErrors.where(
+        (e) => e.ruleId == DisallowedFieldRule.ruleName,
+      );
+      expect(disallowedErrors, isEmpty);
+    });
+
+    test('passes with all allowed fields and valid YAML', () async {
+      await File('${tempDir.path}/SKILL.md').writeAsString('''
+---
+name: metadata-test
+description: A test skill
+license: MIT
+compatibility: Python 3.10
+metadata:
+  version: 1.0.0
+allowed-tools: git
+---
+Body''');
+      final validator = Validator();
+      // We need to make sure directory name matches name in metadata
+      final skillDir = Directory('${tempDir.path}/metadata-test');
+      await skillDir.create();
+      await File(
+        '${skillDir.path}/SKILL.md',
+      ).writeAsString('${buildFrontmatter(name: 'metadata-test')}Body');
+
+      final ValidationResult result = await validator.validate(skillDir);
+
+      expect(result.isValid, isTrue, reason: result.errors.isEmpty ? '' : result.errors.first);
+      expect(result.errors, isEmpty);
+    });
+  });
+}

package/skills/flutter-skills/tool/dart_skills_lint/test/relative_path_flag_test.dart

@@ -0,0 +1,70 @@
+// 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:dart_skills_lint/src/models/analysis_severity.dart';
+import 'package:dart_skills_lint/src/rules/absolute_paths_rule.dart';
+import 'package:dart_skills_lint/src/rules/relative_paths_rule.dart';
+import 'package:dart_skills_lint/src/validator.dart';
+import 'package:test/test.dart';
+
+import 'test_utils.dart';
+
+void main() {
+  group('Relative Path Flag Validation', () {
+    late Directory tempDir;
+
+    setUp(() async {
+      tempDir = await Directory.systemTemp.createTemp('relative_path_test.');
+    });
+
+    tearDown(() async {
+      if (tempDir.existsSync()) {
+        await tempDir.delete(recursive: true);
+      }
+    });
+
+    test('validates links when relativePathsSeverity = warning', () async {
+      final skillDir = Directory('${tempDir.path}/test-skill');
+      await skillDir.create();
+      await File('${skillDir.path}/SKILL.md').writeAsString(
+        '${buildFrontmatter(name: 'test-skill')}Body with [broken link](missing.md) and [absolute link](/absolute/path.md)',
+      );
+
+      final validator = Validator(
+        ruleOverrides: {
+          RelativePathsRule.ruleName: AnalysisSeverity.warning,
+          AbsolutePathsRule.ruleName: AnalysisSeverity.error,
+        },
+      );
+      final ValidationResult result = await validator.validate(skillDir);
+
+      expect(result.isValid, isFalse);
+      expect(
+        result.errors,
+        contains(contains('Absolute filepath found in link: /absolute/path.md')),
+      );
+      expect(result.warnings, contains(contains('Linked file does not exist: missing.md')));
+    });
+
+    test('passes when relativePathsSeverity = warning and links are valid', () async {
+      final skillDir = Directory('${tempDir.path}/test-skill');
+      await skillDir.create();
+      await File('${skillDir.path}/SKILL.md').writeAsString(
+        '${buildFrontmatter(name: 'test-skill')}Body with [valid relative link](valid.md)',
+      );
+      await File('${skillDir.path}/valid.md').writeAsString('Valid file content');
+
+      final validator = Validator(
+        ruleOverrides: {RelativePathsRule.ruleName: AnalysisSeverity.warning},
+      );
+      final ValidationResult result = await validator.validate(skillDir);
+
+      expect(result.isValid, isTrue);
+      expect(result.errors, isEmpty);
+      expect(result.warnings, isEmpty);
+    });
+  });
+}