sdd-full 4.6.1 → 4.8.0

package/skills/flutter-skills/tool/dart_skills_lint/lib/src/rules/absolute_paths_rule.dart

@@ -0,0 +1,74 @@
+import 'dart:io';
+import 'package:path/path.dart';
+import '../fixable_rule.dart';
+import '../models/analysis_severity.dart';
+import '../models/skill_context.dart';
+import '../models/skill_rule.dart';
+import '../models/validation_error.dart';
+
+/// Enforces that links in SKILL.md do not use absolute paths.
+class AbsolutePathsRule extends SkillRule implements FixableRule {
+  AbsolutePathsRule({this.severity = defaultSeverity});
+
+  static const String ruleName = 'check-absolute-paths';
+  static const AnalysisSeverity defaultSeverity = AnalysisSeverity.warning;
+
+  @override
+  String get name => ruleName;
+
+  @override
+  final AnalysisSeverity severity;
+
+  static final _markdownLinkRegex = RegExp(r'\[.*?\]\((.*?)\)');
+  static const String _skillFileName = SkillContext.skillFileName;
+
+  @override
+  Future<List<ValidationError>> validate(SkillContext context) async {
+    final errors = <ValidationError>[];
+
+    // Extract content after YAML frontmatter
+    final skillStartRegex = RegExp(r'^---\s*\n(.*?)\n---\s*\n', dotAll: true);
+    final RegExpMatch? match = skillStartRegex.firstMatch(context.rawContent);
+    final String markdownContent = match != null
+        ? context.rawContent.substring(match.end)
+        : context.rawContent;
+
+    for (final RegExpMatch linkMatch in _markdownLinkRegex.allMatches(markdownContent)) {
+      final String path = linkMatch.group(1)!;
+      if (isAbsolute(path) || windows.isAbsolute(path)) {
+        errors.add(
+          ValidationError(
+            ruleId: name,
+            severity: severity,
+            file: _skillFileName,
+            message: 'Absolute filepath found in link: $path',
+          ),
+        );
+      }
+    }
+
+    return errors;
+  }
+
+  @override
+  Future<String> fix(String filePath, String currentContent, Directory directory) async {
+    if (filePath != SkillContext.skillFileName) {
+      return currentContent;
+    }
+
+    return currentContent.replaceAllMapped(_markdownLinkRegex, (match) {
+      final String path = match.group(1)!;
+      if (isAbsolute(path) || windows.isAbsolute(path)) {
+        final file = File(path);
+        if (file.existsSync()) {
+          final String relativePath = relative(path, from: directory.path);
+          final String posixRelativePath = relativePath.replaceAll(r'\', '/');
+          final String fullMatch = match.group(0)!;
+          final int lastParen = fullMatch.lastIndexOf('(');
+          return '${fullMatch.substring(0, lastParen + 1)}$posixRelativePath)';
+        }
+      }
+      return match.group(0)!;
+    });
+  }
+}

package/skills/flutter-skills/tool/dart_skills_lint/lib/src/rules/description_length_rule.dart

@@ -0,0 +1,49 @@
+import 'package:yaml/yaml.dart';
+import '../models/analysis_severity.dart';
+import '../models/skill_context.dart';
+import '../models/skill_rule.dart';
+import '../models/validation_error.dart';
+
+/// Enforces that the description field is not too long.
+class DescriptionLengthRule extends SkillRule {
+  DescriptionLengthRule({this.severity = defaultSeverity});
+
+  static const String ruleName = 'description-too-long';
+  static const AnalysisSeverity defaultSeverity = AnalysisSeverity.error;
+
+  @override
+  String get name => ruleName;
+
+  @override
+  final AnalysisSeverity severity;
+
+  static const maxDescriptionLength = 1024;
+  static const _skillFileName = 'SKILL.md';
+  static const _descriptionFieldUrl = 'https://agentskills.io/specification#description-field';
+
+  @override
+  Future<List<ValidationError>> validate(SkillContext context) async {
+    final errors = <ValidationError>[];
+
+    if (context.parsedYaml == null) {
+      return errors;
+    }
+
+    final YamlMap yaml = context.parsedYaml!;
+    final String description = yaml['description']?.toString() ?? '';
+
+    if (description.length > maxDescriptionLength) {
+      errors.add(
+        ValidationError(
+          ruleId: name,
+          severity: severity,
+          file: _skillFileName,
+          message:
+              'Description field is too long. Maximum $maxDescriptionLength characters (see $_descriptionFieldUrl)',
+        ),
+      );
+    }
+
+    return errors;
+  }
+}

package/skills/flutter-skills/tool/dart_skills_lint/lib/src/rules/disallowed_field_rule.dart

@@ -0,0 +1,61 @@
+import 'package:yaml/yaml.dart';
+import '../models/analysis_severity.dart';
+import '../models/skill_context.dart';
+import '../models/skill_rule.dart';
+import '../models/validation_error.dart';
+
+/// Enforces that only allowed fields are present in YAML metadata.
+class DisallowedFieldRule extends SkillRule {
+  DisallowedFieldRule({this.severity = defaultSeverity});
+
+  static const String ruleName = 'disallowed-field';
+  static const AnalysisSeverity defaultSeverity = AnalysisSeverity.disabled;
+
+  @override
+  String get name => ruleName;
+
+  @override
+  final AnalysisSeverity severity;
+
+  static const _allowedFields = {
+    'name',
+    'description',
+    'license',
+    'allowed-tools',
+    'metadata',
+    'compatibility',
+    'category',
+    'tags',
+    'version',
+    'eval_task',
+  };
+
+  static const _skillFileName = 'SKILL.md';
+  static const _metadataUrl = 'https://agentskills.io/specification#frontmatter';
+
+  @override
+  Future<List<ValidationError>> validate(SkillContext context) async {
+    final errors = <ValidationError>[];
+
+    if (context.parsedYaml == null) {
+      return errors;
+    }
+
+    final YamlMap yaml = context.parsedYaml!;
+    for (final Object? key in yaml.keys) {
+      final bool isDisallowed = key is! String || !_allowedFields.contains(key);
+      if (isDisallowed) {
+        errors.add(
+          ValidationError(
+            ruleId: name,
+            severity: severity,
+            file: _skillFileName,
+            message: 'Disallowed field: $key (see $_metadataUrl)',
+          ),
+        );
+      }
+    }
+
+    return errors;
+  }
+}

package/skills/flutter-skills/tool/dart_skills_lint/lib/src/rules/name_format_rule.dart

@@ -0,0 +1,167 @@
+import 'dart:io';
+import 'package:meta/meta.dart';
+import 'package:path/path.dart';
+import 'package:yaml/yaml.dart';
+import '../fixable_rule.dart';
+import '../models/analysis_severity.dart';
+import '../models/skill_context.dart';
+import '../models/skill_rule.dart';
+import '../models/validation_error.dart';
+
+/// Enforces constraints on the skill name field.
+class NameFormatRule extends SkillRule implements FixableRule {
+  NameFormatRule({this.severity = defaultSeverity});
+
+  static const String ruleName = 'invalid-skill-name';
+  static const AnalysisSeverity defaultSeverity = AnalysisSeverity.error;
+
+  @override
+  String get name => ruleName;
+
+  @override
+  final AnalysisSeverity severity;
+
+  static const maxNameLength = 64;
+  static final _validNameRegex = RegExp(r'^[a-z0-9\-]+$');
+  static const String _skillFileName = SkillContext.skillFileName;
+  static const _nameFieldUrl = 'https://agentskills.io/specification#name-field';
+
+  @override
+  Future<List<ValidationError>> validate(SkillContext context) async {
+    final errors = <ValidationError>[];
+
+    if (context.parsedYaml == null) {
+      return errors;
+    }
+
+    final YamlMap yaml = context.parsedYaml!;
+    final String skillName = getNameNode(yaml)?.value.toString() ?? '';
+
+    if (skillName.isEmpty) {
+      return errors; // Handled by required fields check
+    }
+
+    if (skillName != skillName.toLowerCase()) {
+      errors.add(
+        ValidationError(
+          ruleId: name,
+          severity: severity,
+          file: _skillFileName,
+          message: 'Skill name must be lowercase: $skillName (see $_nameFieldUrl)',
+        ),
+      );
+    }
+
+    if (skillName.length > maxNameLength) {
+      errors.add(
+        ValidationError(
+          ruleId: name,
+          severity: severity,
+          file: _skillFileName,
+          message: 'Skill name too long. Maximum $maxNameLength characters (see $_nameFieldUrl)',
+        ),
+      );
+    }
+
+    if (!_validNameRegex.hasMatch(skillName)) {
+      errors.add(
+        ValidationError(
+          ruleId: name,
+          severity: severity,
+          file: _skillFileName,
+          message:
+              'Skill name contains invalid characters. Only lowercase letters, digits, and hyphens allowed (see $_nameFieldUrl)',
+        ),
+      );
+    }
+
+    if (skillName.startsWith('-') || skillName.endsWith('-')) {
+      errors.add(
+        ValidationError(
+          ruleId: name,
+          severity: severity,
+          file: _skillFileName,
+          message: 'Skill name cannot have leading or trailing hyphens (see $_nameFieldUrl)',
+        ),
+      );
+    }
+
+    if (skillName.contains('--')) {
+      errors.add(
+        ValidationError(
+          ruleId: name,
+          severity: severity,
+          file: _skillFileName,
+          message: 'Skill name cannot have consecutive hyphens (see $_nameFieldUrl)',
+        ),
+      );
+    }
+
+    final String dirName = basename(context.directory.path);
+    if (skillName != dirName) {
+      errors.add(
+        ValidationError(
+          ruleId: name,
+          severity: severity,
+          file: _skillFileName,
+          message:
+              'Skill name ($skillName) must exactly match the parent directory name ($dirName) (see $_nameFieldUrl)',
+        ),
+      );
+    }
+
+    return errors;
+  }
+
+  @override
+  Future<String> fix(String filePath, String currentContent, Directory directory) async {
+    if (filePath != SkillContext.skillFileName) {
+      return currentContent;
+    }
+
+    final RegExpMatch? match = SkillContext.skillStartRegex.firstMatch(currentContent);
+    if (match == null) {
+      return currentContent;
+    }
+    final String yamlStr = match.group(1)!;
+
+    final Object? yamlObj;
+    try {
+      yamlObj = loadYaml(yamlStr);
+    } catch (e) {
+      return currentContent;
+    }
+
+    if (yamlObj is! YamlMap) {
+      return currentContent;
+    }
+
+    final YamlMap yaml = yamlObj;
+    final YamlNode? nameNode = getNameNode(yaml);
+    if (nameNode == null) {
+      return currentContent;
+    }
+
+    final String dirName = basename(directory.path);
+
+    final currentName = nameNode.value.toString();
+    if (currentName == dirName) {
+      return currentContent;
+    }
+
+    final int yamlOffset = currentContent.indexOf(yamlStr, match.start);
+
+    // ignore: specify_nonobvious_local_variable_types
+    final span = nameNode.span;
+    final String before = currentContent.substring(0, yamlOffset + span.start.offset);
+    final String after = currentContent.substring(yamlOffset + span.end.offset);
+
+    return '$before$dirName$after';
+  }
+
+  /// Returns the YAML node for the skill name.
+  @visibleForTesting
+  static YamlNode? getNameNode(YamlMap yaml) {
+    return yaml.nodes['name'];
+  }
+}

package/skills/flutter-skills/tool/dart_skills_lint/lib/src/rules/relative_paths_rule.dart

@@ -0,0 +1,72 @@
+import 'dart:io';
+import 'package:path/path.dart';
+import '../models/analysis_severity.dart';
+import '../models/skill_context.dart';
+import '../models/skill_rule.dart';
+import '../models/validation_error.dart';
+
+/// Enforces that relative links in SKILL.md point to existing files.
+class RelativePathsRule extends SkillRule {
+  RelativePathsRule({this.severity = defaultSeverity});
+
+  static const String ruleName = 'check-relative-paths';
+  static const AnalysisSeverity defaultSeverity = AnalysisSeverity.disabled;
+
+  @override
+  String get name => ruleName;
+
+  @override
+  final AnalysisSeverity severity;
+
+  static final _markdownLinkRegex = RegExp(r'\[.*?\]\((.*?)\)');
+  static const _skillFileName = 'SKILL.md';
+
+  @override
+  Future<List<ValidationError>> validate(SkillContext context) async {
+    final errors = <ValidationError>[];
+
+    // Extract content after YAML frontmatter
+    final skillStartRegex = RegExp(r'^---\s*\n(.*?)\n---\s*\n', dotAll: true);
+    final RegExpMatch? match = skillStartRegex.firstMatch(context.rawContent);
+    final String markdownContent = match != null
+        ? context.rawContent.substring(match.end)
+        : context.rawContent;
+
+    for (final RegExpMatch linkMatch in _markdownLinkRegex.allMatches(markdownContent)) {
+      final String fullPath = linkMatch.group(1)!;
+      // Markdown links can have a title after the URL, separated by spaces.
+      // e.g. [text](url "title")
+      final String path = fullPath.trim().split(RegExp(r'\s+')).first;
+
+      // Skip absolute paths (handled by AbsolutePathsRule)
+      if (isAbsolute(path) || windows.isAbsolute(path)) {
+        continue;
+      }
+
+      var effectivePath = path;
+      try {
+        final Uri uri = Uri.parse(path);
+        if (uri.hasScheme || path.startsWith('#')) {
+          continue; // Ignore web URLs, email links, anchors, etc.
+        }
+        effectivePath = uri.path;
+      } catch (_) {
+        // If Uri parsing fails, treat it as a potential filepath.
+      }
+
+      final linkedFile = File(join(context.directory.path, effectivePath));
+      if (!linkedFile.existsSync()) {
+        errors.add(
+          ValidationError(
+            ruleId: name,
+            severity: severity,
+            file: _skillFileName,
+            message: 'Linked file does not exist: $path',
+          ),
+        );
+      }
+    }
+
+    return errors;
+  }
+}

package/skills/flutter-skills/tool/dart_skills_lint/lib/src/rules/trailing_whitespace_rule.dart

@@ -0,0 +1,93 @@
+// 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:meta/meta.dart';
+
+import '../fixable_rule.dart';
+import '../models/analysis_severity.dart';
+import '../models/skill_context.dart';
+import '../models/skill_rule.dart';
+import '../models/validation_error.dart';
+
+/// Enforces that lines in SKILL.md do not have trailing whitespace,
+/// except for exactly two spaces which indicate a hard line break.
+class TrailingWhitespaceRule extends SkillRule implements FixableRule {
+  TrailingWhitespaceRule({this.severity = defaultSeverity});
+
+  static const String ruleName = 'check-trailing-whitespace';
+  static const AnalysisSeverity defaultSeverity = AnalysisSeverity.disabled;
+  static final RegExp _whitespaceRegExp = RegExp(r'([ \t]+)$');
+
+  @override
+  String get name => ruleName;
+
+  @override
+  final AnalysisSeverity severity;
+
+  @override
+  Future<List<ValidationError>> validate(SkillContext context) async {
+    final errors = <ValidationError>[];
+    final List<String> lines = context.rawContent.split('\n');
+
+    for (var i = 0; i < lines.length; i++) {
+      final String line = lines[i];
+
+      // Remove carriage return if present (Windows line endings)
+      final String trimmedLine = line.endsWith('\r') ? line.substring(0, line.length - 1) : line;
+
+      final RegExpMatch? match = _whitespaceRegExp.firstMatch(trimmedLine);
+      if (match != null) {
+        final String whitespace = match.group(1)!;
+        String? message;
+
+        if (whitespace.contains('\t')) {
+          message = 'Line ${i + 1} has trailing whitespace containing tabs.';
+        } else {
+          final int spacesCount = whitespace.length;
+          if (spacesCount == 1 || spacesCount >= 3) {
+            message =
+                'Line ${i + 1} has $spacesCount trailing space(s). Only exactly 2 spaces are allowed for line breaks.';
+          }
+        }
+
+        if (message != null) {
+          errors.add(
+            ValidationError(ruleId: name, severity: severity, file: 'SKILL.md', message: message),
+          );
+        }
+      }
+    }
+
+    return errors;
+  }
+
+  @override
+  Future<String> fix(String filePath, String currentContent, Directory directory) async {
+    if (filePath != 'SKILL.md') {
+      return currentContent;
+    }
+
+    return currentContent.split('\n').map(fixLine).join('\n');
+  }
+
+  @visibleForTesting
+  String fixLine(String line) {
+    final bool hasCR = line.endsWith('\r');
+    final String lineWithoutCR = hasCR ? line.substring(0, line.length - 1) : line;
+
+    final RegExpMatch? match = _whitespaceRegExp.firstMatch(lineWithoutCR);
+    if (match == null) {
+      return line;
+    }
+
+    final String whitespace = match.group(1)!;
+    if (whitespace == '  ') {
+      return line; // Keep the 2 space hard line break.
+    }
+
+    final String fixedLine = lineWithoutCR.replaceAll(_whitespaceRegExp, '');
+    return hasCR ? '$fixedLine\r' : fixedLine;
+  }
+}

package/skills/flutter-skills/tool/dart_skills_lint/lib/src/rules/valid_yaml_metadata_rule.dart

@@ -0,0 +1,74 @@
+import 'package:yaml/yaml.dart';
+import '../models/analysis_severity.dart';
+import '../models/skill_context.dart';
+import '../models/skill_rule.dart';
+import '../models/validation_error.dart';
+
+/// Enforces that SKILL.md has valid YAML frontmatter and required fields.
+class ValidYamlMetadataRule extends SkillRule {
+  ValidYamlMetadataRule({this.severity = defaultSeverity});
+
+  static const String ruleName = 'valid-yaml-metadata';
+  static const AnalysisSeverity defaultSeverity = AnalysisSeverity.error;
+
+  @override
+  String get name => ruleName;
+
+  @override
+  final AnalysisSeverity severity;
+
+  static const _requiredFields = {'name', 'description'};
+  static const _skillFileName = 'SKILL.md';
+  static const _metadataUrl = 'https://agentskills.io/specification#frontmatter';
+  static const maxCompatibilityLength = 500;
+  static const _compatibilityFieldUrl = 'https://agentskills.io/specification#compatibility-field';
+
+  @override
+  Future<List<ValidationError>> validate(SkillContext context) async {
+    final errors = <ValidationError>[];
+
+    if (context.parsedYaml == null) {
+      errors.add(
+        ValidationError(
+          ruleId: name,
+          severity: severity,
+          file: _skillFileName,
+          message:
+              'Invalid YAML metadata: ${context.yamlParsingError ?? 'Missing or invalid'} (see $_metadataUrl)',
+        ),
+      );
+      return errors;
+    }
+
+    final YamlMap yaml = context.parsedYaml!;
+    for (final String field in _requiredFields) {
+      if (!yaml.containsKey(field)) {
+        errors.add(
+          ValidationError(
+            ruleId: name,
+            severity: severity,
+            file: _skillFileName,
+            message: 'Missing required field: $field (see $_metadataUrl)',
+          ),
+        );
+      }
+    }
+
+    if (yaml.containsKey('compatibility')) {
+      final String compatibility = yaml['compatibility']?.toString() ?? '';
+      if (compatibility.length > maxCompatibilityLength) {
+        errors.add(
+          ValidationError(
+            ruleId: name,
+            severity: severity,
+            file: _skillFileName,
+            message:
+                'Compatibility field is too long. Maximum $maxCompatibilityLength characters (see $_compatibilityFieldUrl)',
+          ),
+        );
+      }
+    }
+
+    return errors;
+  }
+}

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

@@ -0,0 +1,36 @@
+// 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 'models/skills_ignores.dart';
+
+/// Service class for reading and writing the `SkillsIgnores` model to/from disk.
+class SkillsIgnoresStorage {
+  /// Loads `SkillsIgnores` from the specified path.
+  ///
+  /// Returns an empty `SkillsIgnores` if the file does not exist or fails to parse.
+  Future<SkillsIgnores> load(String path) async {
+    final file = File(path);
+    if (!file.existsSync()) {
+      return SkillsIgnores(skills: {});
+    }
+
+    try {
+      final String content = await file.readAsString();
+      final json = jsonDecode(content) as Map<String, dynamic>;
+      return SkillsIgnores.fromJson(json);
+    } catch (_) {
+      return SkillsIgnores(skills: {});
+    }
+  }
+
+  /// Saves `SkillsIgnores` to the specified path.
+  Future<void> save(String path, SkillsIgnores ignores) async {
+    final file = File(path);
+    final String jsonString = const JsonEncoder.withIndent('  ').convert(ignores.toJson());
+    await file.writeAsString(jsonString);
+  }
+}