sdd-full 4.6.2 → 4.8.0

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

@@ -0,0 +1,292 @@
+// 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:path/path.dart' as p;
+import 'package:test/test.dart';
+import 'package:test_process/test_process.dart';
+
+void main() {
+  group('Configuration File Integration', () {
+    late Directory tempDir;
+
+    setUp(() async {
+      tempDir = await Directory.systemTemp.createTemp('config_test.');
+    });
+
+    tearDown(() async {
+      if (tempDir.existsSync()) {
+        await tempDir.delete(recursive: true);
+      }
+    });
+
+    test('obeys disabled relative paths in config', () async {
+      final Directory skillDir = await Directory('${tempDir.path}/test-skill').create();
+      await File('${skillDir.path}/SKILL.md').writeAsString('''
+---
+name: test-skill
+description: A test skill
+---
+[broken](missing.md)''');
+
+      await File('${tempDir.path}/dart_skills_lint.yaml').writeAsString('''
+dart_skills_lint:
+  rules:
+    check-relative-paths: disabled
+''');
+
+      final TestProcess process = await TestProcess.start('dart', [
+        p.normalize(p.absolute('bin/cli.dart')),
+        '-s',
+        'test-skill',
+      ], workingDirectory: tempDir.path);
+
+      final List<String> stdout = await process.stdout.rest.toList();
+      expect(stdout.join('\n'), contains('Skill is valid.'));
+      await process.shouldExit(0);
+    });
+
+    test('obeys warning absolute paths in config', () async {
+      final Directory skillDir = await Directory('${tempDir.path}/test-skill').create();
+      await File('${skillDir.path}/SKILL.md').writeAsString('''
+---
+name: test-skill
+description: A test skill
+---
+[absolute](/absolute/path.md)''');
+
+      await File('${tempDir.path}/dart_skills_lint.yaml').writeAsString('''
+dart_skills_lint:
+  rules:
+    check-absolute-paths: warning
+''');
+
+      final TestProcess process = await TestProcess.start('dart', [
+        p.normalize(p.absolute('bin/cli.dart')),
+        '-s',
+        'test-skill',
+      ], workingDirectory: tempDir.path);
+
+      final List<String> stdout = await process.stdout.rest.toList();
+      expect(stdout.join('\n'), contains('Warnings:'));
+      await process.shouldExit(0);
+    });
+
+    test('CLI flags override config', () async {
+      final Directory skillDir = await Directory('${tempDir.path}/test-skill').create();
+      await File('${skillDir.path}/SKILL.md').writeAsString('''
+---
+name: test-skill
+description: A test skill
+---
+[broken](missing.md)''');
+
+      await File('${tempDir.path}/dart_skills_lint.yaml').writeAsString('''
+dart_skills_lint:
+  rules:
+    check-relative-paths: disabled
+''');
+
+      final TestProcess process = await TestProcess.start('dart', [
+        p.normalize(p.absolute('bin/cli.dart')),
+        '-s',
+        'test-skill',
+        '--check-relative-paths',
+      ], workingDirectory: tempDir.path);
+
+      final List<String> stderr = await process.stderr.rest.toList();
+      expect(stderr.join('\n'), contains('Skill is invalid:'));
+      await process.shouldExit(1);
+    });
+
+    test('writes empty ignore-file if missing and specified in config', () async {
+      await Directory('${tempDir.path}/test-skill').create();
+      await File('${tempDir.path}/test-skill/SKILL.md').writeAsString('''
+---
+name: test-skill
+description: A test skill
+---
+Body''');
+
+      const ignorePath = 'custom_ignore.json';
+      await File('${tempDir.path}/dart_skills_lint.yaml').writeAsString('''
+dart_skills_lint:
+  directories:
+    - path: "test-skill"
+      ignore_file: "$ignorePath"
+''');
+
+      final TestProcess process = await TestProcess.start('dart', [
+        p.normalize(p.absolute('bin/cli.dart')),
+        '-s',
+        'test-skill',
+      ], workingDirectory: tempDir.path);
+
+      final List<String> stdout = await process.stdout.rest.toList();
+      expect(stdout.join('\n'), contains('File not found generating-baseline'));
+      await process.shouldExit(0);
+
+      final writtenFile = File('${tempDir.path}/$ignorePath');
+      expect(writtenFile.existsSync(), isTrue);
+      final String fileContent = await writtenFile.readAsString();
+      expect(fileContent, contains('"skills":'));
+    });
+
+    test('ignores config when --ignore-config is passed', () async {
+      final Directory skillDir = await Directory('${tempDir.path}/TEST-SKILL').create();
+      await File('${skillDir.path}/SKILL.md').writeAsString('''
+---
+name: TEST-SKILL
+description: A test skill
+license: MIT
+---
+Body''');
+
+      await File('${tempDir.path}/dart_skills_lint.yaml').writeAsString('''
+dart_skills_lint:
+  rules:
+    invalid-skill-name: disabled
+''');
+
+      // 1. Run without --ignore-config. Should pass because config disables the check.
+      final TestProcess passProcess = await TestProcess.start('dart', [
+        p.normalize(p.absolute('bin/cli.dart')),
+        '-s',
+        'TEST-SKILL',
+      ], workingDirectory: tempDir.path);
+      await passProcess.shouldExit(0);
+
+      // 2. Run with --ignore-config. Should fail because config is ignored and default is used.
+      final TestProcess failProcess = await TestProcess.start('dart', [
+        p.normalize(p.absolute('bin/cli.dart')),
+        '-s',
+        'TEST-SKILL',
+        '--ignore-config',
+      ], workingDirectory: tempDir.path);
+      await failProcess.shouldExit(1);
+    });
+
+    test('ignores config when generating baseline with --ignore-config', () async {
+      final Directory skillDir = await Directory('${tempDir.path}/TEST-SKILL').create();
+      await File('${skillDir.path}/SKILL.md').writeAsString('''
+---
+name: TEST-SKILL
+description: A test skill
+license: MIT
+---
+Body''');
+
+      await File('${tempDir.path}/dart_skills_lint.yaml').writeAsString('''
+dart_skills_lint:
+  rules:
+    invalid-skill-name: disabled
+''');
+
+      // 1. Generate baseline with --ignore-config. It should ignore config (so the rule is enabled) and find violations to generate baseline for!
+      final TestProcess genProcess = await TestProcess.start('dart', [
+        p.normalize(p.absolute('bin/cli.dart')),
+        '-s',
+        'TEST-SKILL',
+        '--generate-baseline',
+        '--ignore-config',
+      ], workingDirectory: tempDir.path);
+      await genProcess.shouldExit(0); // Exits 0 if --generate-baseline passed
+
+      final ignoreFile = File('${skillDir.parent.path}/$defaultIgnoreFileName');
+      expect(ignoreFile.existsSync(), isTrue);
+
+      final String content = await ignoreFile.readAsString();
+      expect(content, contains('invalid-skill-name')); // It should generate baseline for it!
+    });
+
+    test('fails on invalid top-level key in config by default', () async {
+      await Directory('${tempDir.path}/test-skill').create();
+      await File('${tempDir.path}/test-skill/SKILL.md').writeAsString('''
+---
+name: test-skill
+description: A test skill
+---
+Body''');
+
+      await File('${tempDir.path}/dart_skills_lint.yaml').writeAsString('''
+dart_skills_lint:
+  invalid-key: value
+''');
+
+      final TestProcess process = await TestProcess.start('dart', [
+        p.normalize(p.absolute('bin/cli.dart')),
+        '-s',
+        'test-skill',
+      ], workingDirectory: tempDir.path);
+
+      final List<String> stderr = await process.stderr.rest.toList();
+      expect(
+        stderr.join('\n'),
+        contains('Configuration error: Unrecognized top-level key "invalid-key"'),
+      );
+      await process.shouldExit(1);
+    });
+
+    test('fails on invalid directory key in config by default', () async {
+      await Directory('${tempDir.path}/test-skill').create();
+      await File('${tempDir.path}/test-skill/SKILL.md').writeAsString('''
+---
+name: test-skill
+description: A test skill
+---
+Body''');
+
+      await File('${tempDir.path}/dart_skills_lint.yaml').writeAsString('''
+dart_skills_lint:
+  directories:
+    - path: "test-skill"
+      invalid-dir-key: value
+''');
+
+      final TestProcess process = await TestProcess.start('dart', [
+        p.normalize(p.absolute('bin/cli.dart')),
+        '-s',
+        'test-skill',
+      ], workingDirectory: tempDir.path);
+
+      final List<String> stderr = await process.stderr.rest.toList();
+      expect(
+        stderr.join('\n'),
+        contains('Configuration error: Unrecognized key "invalid-dir-key"'),
+      );
+      await process.shouldExit(1);
+    });
+
+    test('succeeds with warning on invalid key when --allow-misconfigured-keys passed', () async {
+      await Directory('${tempDir.path}/test-skill').create();
+      await File('${tempDir.path}/test-skill/SKILL.md').writeAsString('''
+---
+name: test-skill
+description: A test skill
+---
+Body''');
+
+      await File('${tempDir.path}/dart_skills_lint.yaml').writeAsString('''
+dart_skills_lint:
+  invalid-key: value
+''');
+
+      final TestProcess process = await TestProcess.start('dart', [
+        p.normalize(p.absolute('bin/cli.dart')),
+        '-s',
+        'test-skill',
+        '--allow-misconfigured-keys',
+      ], workingDirectory: tempDir.path);
+
+      final List<String> stdout = await process.stdout.rest.toList();
+      expect(
+        stdout.join('\n'),
+        contains('Configuration warning: Unrecognized top-level key "invalid-key"'),
+      );
+      await process.shouldExit(0);
+    });
+  });
+}

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

@@ -0,0 +1,122 @@
+import 'dart:async';
+import 'dart:io';
+import 'package:dart_skills_lint/dart_skills_lint.dart';
+import 'package:logging/logging.dart';
+import 'package:test/test.dart';
+
+class CustomRule extends SkillRule {
+  @override
+  final String name = 'custom-rule';
+
+  @override
+  final AnalysisSeverity severity = AnalysisSeverity.error;
+
+  @override
+  Future<List<ValidationError>> validate(SkillContext context) async {
+    final errors = <ValidationError>[];
+    if (context.rawContent.contains('TRIGGER_ERROR')) {
+      errors.add(
+        ValidationError(
+          ruleId: name,
+          severity: severity,
+          file: 'SKILL.md',
+          message: 'Custom rule triggered',
+        ),
+      );
+    }
+    return errors;
+  }
+}
+
+class MismatchRule extends SkillRule {
+  @override
+  final String name = 'mismatch-rule';
+
+  @override
+  final AnalysisSeverity severity = AnalysisSeverity.warning;
+
+  @override
+  Future<List<ValidationError>> validate(SkillContext context) async {
+    return [
+      ValidationError(
+        ruleId: name,
+        severity: AnalysisSeverity.error, // Mismatch!
+        file: 'SKILL.md',
+        message: 'Triggered',
+      ),
+    ];
+  }
+}
+
+void main() {
+  group('Custom Rules', () {
+    late Directory tempDir;
+
+    setUp(() async {
+      tempDir = await Directory.systemTemp.createTemp('custom_rule_test.');
+    });
+
+    tearDown(() async {
+      if (tempDir.existsSync()) {
+        await tempDir.delete(recursive: true);
+      }
+    });
+
+    test('Validator runs custom rule', () async {
+      final Directory skillDir = await Directory('${tempDir.path}/skill-name').create();
+      await File('${skillDir.path}/SKILL.md').writeAsString('''
+---
+name: skill-name
+description: A test skill
+---
+TRIGGER_ERROR''');
+
+      final validator = Validator(customRules: [CustomRule()]);
+      final ValidationResult result = await validator.validate(skillDir);
+
+      expect(result.isValid, isFalse);
+      expect(result.errors, contains(contains('Custom rule triggered')));
+    });
+
+    test('Validator logs warning on severity mismatch', () async {
+      final Directory skillDir = await Directory('${tempDir.path}/skill-name-3').create();
+      await File('${skillDir.path}/SKILL.md').writeAsString('''
+---
+name: skill-name-3
+description: A test skill
+---
+Body''');
+
+      final validator = Validator(customRules: [MismatchRule()]);
+
+      final logs = <String>[];
+      final StreamSubscription<LogRecord> subscription = Logger('dart_skills_lint').onRecord.listen(
+        (record) {
+          logs.add(record.message);
+        },
+      );
+
+      try {
+        await validator.validate(skillDir);
+      } finally {
+        await subscription.cancel();
+      }
+
+      expect(
+        logs,
+        contains(
+          contains(
+            'Rule "mismatch-rule" used severity AnalysisSeverity.error instead of defined AnalysisSeverity.warning',
+          ),
+        ),
+      );
+    });
+
+    test('Validator throws ArgumentError on duplicate rule names', () {
+      final rule1 = CustomRule();
+      final rule2 = CustomRule(); // Same name 'custom-rule'
+
+      expect(() => Validator(customRules: [rule1, rule2]), throwsArgumentError);
+    });
+  });
+}

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

@@ -0,0 +1,163 @@
+// 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:convert';
+import 'dart:io';
+
+import 'package:dart_skills_lint/src/models/analysis_severity.dart';
+import 'package:dart_skills_lint/src/validator.dart';
+import 'package:path/path.dart' as p;
+import 'package:test/test.dart';
+
+class MockInaccessibleFile implements File {
+  MockInaccessibleFile(this._path);
+  final String _path;
+
+  @override
+  String get path => _path;
+
+  @override
+  bool existsSync() => true;
+
+  @override
+  Future<String> readAsString({Encoding encoding = utf8}) async {
+    throw FileSystemException('File is inaccessible', _path);
+  }
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+base class TestIOOverrides extends IOOverrides {
+  TestIOOverrides(this.targetPath);
+  final String targetPath;
+
+  @override
+  File createFile(String path) {
+    if (path == targetPath) {
+      return MockInaccessibleFile(path);
+    }
+    return super.createFile(path);
+  }
+}
+
+void main() {
+  group('Directory Structure Validation', () {
+    late Directory tempDir;
+
+    setUp(() async {
+      tempDir = await Directory.systemTemp.createTemp('skill_test.');
+    });
+
+    tearDown(() async {
+      if (tempDir.existsSync()) {
+        await tempDir.delete(recursive: true);
+      }
+    });
+
+    test('fails if directory does not exist', () async {
+      final nonExistentDir = Directory('path/to/nothing');
+      final validator = Validator();
+      final ValidationResult result = await validator.validate(nonExistentDir);
+
+      expect(result.isValid, isFalse);
+      expect(result.errors, contains(contains('Directory does not exist')));
+    });
+
+    test('fails if path is a file', () async {
+      final file = File('${tempDir.path}/some_file');
+      await file.create();
+      final validator = Validator();
+      final ValidationResult result = await validator.validate(Directory(file.path));
+
+      expect(result.isValid, isFalse);
+      expect(result.errors, contains(contains('is not a directory')));
+    });
+
+    test('fails if SKILL.md is missing', () async {
+      final validator = Validator();
+      final ValidationResult result = await validator.validate(tempDir);
+
+      expect(result.isValid, isFalse);
+      expect(result.errors, contains(contains('SKILL.md is missing')));
+    });
+
+    test('fails if SKILL.md cannot be read', () async {
+      final skillDir = Directory(p.join(tempDir.path, 'test-skill-inaccessible'));
+      await skillDir.create();
+      final String filePath = p.join(skillDir.path, 'SKILL.md');
+
+      final overrides = TestIOOverrides(filePath);
+      await IOOverrides.runWithIOOverrides(() async {
+        try {
+          final validator = Validator();
+          final ValidationResult validationResult = await validator.validate(skillDir);
+
+          // ignore: avoid_print
+          print(
+            'DEBUG errors: ${validationResult.validationErrors.map((e) => "${e.ruleId}: ${e.message}").toList()}',
+          );
+          expect(validationResult.isValid, isFalse);
+          expect(
+            validationResult.validationErrors.any(
+              (e) => e.ruleId == Validator.skillFileInaccessible,
+            ),
+            isTrue,
+          );
+        } catch (e, s) {
+          fail('Unexpected exception during validation: $e\n$s');
+        }
+      }, overrides);
+    });
+
+    test('obeys skill-file-inaccessible severity override', () async {
+      final skillDir = Directory(p.join(tempDir.path, 'test-skill-override'));
+      await skillDir.create();
+      final String filePath = p.join(skillDir.path, 'SKILL.md');
+
+      final overrides = TestIOOverrides(filePath);
+      await IOOverrides.runWithIOOverrides(() async {
+        try {
+          final validator = Validator(
+            ruleOverrides: {Validator.skillFileInaccessible: AnalysisSeverity.warning},
+          );
+          final ValidationResult validationResult = await validator.validate(skillDir);
+
+          // ignore: avoid_print
+          print(
+            'DEBUG errors (override): ${validationResult.validationErrors.map((e) => "${e.ruleId}: ${e.message}").toList()}',
+          );
+          expect(validationResult.isValid, isTrue);
+          expect(
+            validationResult.validationErrors.any(
+              (e) =>
+                  e.ruleId == Validator.skillFileInaccessible &&
+                  e.severity == AnalysisSeverity.warning,
+            ),
+            isTrue,
+          );
+        } catch (e, s) {
+          fail('Unexpected exception during validation: $e\n$s');
+        }
+      }, overrides);
+    });
+
+    test('passes if directory exists and contains SKILL.md', () async {
+      final skillDir = Directory(p.join(tempDir.path, 'test-skill'));
+      await skillDir.create();
+      await File(p.join(skillDir.path, 'SKILL.md')).writeAsString('''
+---
+name: test-skill
+description: A test skill
+---
+Body''');
+
+      final validator = Validator();
+      final ValidationResult result = await validator.validate(skillDir);
+
+      expect(result.isValid, isTrue, reason: result.errors.isEmpty ? '' : result.errors.first);
+      expect(result.errors, isEmpty);
+    });
+  });
+}