@uipath/skills 1.204.0 → 1.204.1

package/skills/uipath-maestro-flow/.maintenance/check-anchors.sh

@@ -0,0 +1,101 @@
+#!/bin/bash
+# Verify every markdown anchor link (`[text](file.md#anchor)`) resolves to an actual heading in the target file.
+# Usage: bash .maintenance/check-anchors.sh
+# Output: BAD ANCHOR lines per failure, then "anchors_checked=N anchors_bad=M" summary.
+#
+# Skips:
+# - links inside fenced code blocks (```...```)
+# - links inside inline code spans (`...`)
+# - links without a `#anchor` fragment
+# - http(s):// links
+# - slash-command links
+# - same-file anchor-only links (#anchor without a path)
+# - links to files that don't exist (those are caught by check-links.sh, not this checker)
+#
+# An anchor resolves if the target file supplies it either as a heading slug or as an
+# explicit `<a id="...">` / `<a name="...">` tag (GitHub honors both).
+#
+# Slug rule (matches GitHub heading-anchor generation):
+# 1. Lowercase the heading
+# 2. Strip backtick, asterisk, underscore, and any non-alphanumeric/non-space/non-dash character
+# 3. Replace each remaining space with `-`
+# 4. Separator characters do not collapse
+#
+# See .maintenance/README.md for common gotchas.
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$ROOT" || exit 1
+
+heading_anchors() {
+  /usr/bin/awk '
+    /^#{1,6} /{
+      sub(/^#+ /, "");
+      gsub(/[`*_]/, "");
+      anchor = tolower($0);
+      gsub(/[^a-z0-9 -]/, "", anchor);
+      gsub(/ /, "-", anchor);
+      print anchor;
+    }' "$1"
+}
+
+# Explicit anchor tags authored inline (e.g. `<a id="attachment-preflight"></a>`).
+# Used where the link target is a paragraph or table row rather than a heading.
+explicit_anchors() {
+  /usr/bin/grep -oE '<a[[:space:]]+(id|name)="[^"]+"' "$1" \
+    | /usr/bin/sed -E 's/.*="([^"]+)"/\1/'
+}
+
+target_anchors() {
+  heading_anchors "$1"
+  explicit_anchors "$1"
+}
+
+# Per-file: strip fenced code blocks and inline code spans, then extract links.
+extract_links() {
+  /usr/bin/awk '
+    /^```/ { fenced = !fenced; next }
+    !fenced {
+      gsub(/`[^`]*`/, "", $0)
+      while (match($0, /\]\([^)]+\)/)) {
+        link = substr($0, RSTART, RLENGTH)
+        sub(/^\]\(/, "", link)
+        sub(/\)$/, "", link)
+        print link
+        $0 = substr($0, RSTART + RLENGTH)
+      }
+    }
+  ' "$1"
+}
+
+broken=0
+checked=0
+
+while IFS= read -r srcfile; do
+  while IFS= read -r raw; do
+    case "$raw" in
+      \#*) continue ;;
+      http*|/uipath*) continue ;;
+    esac
+    [[ "$raw" != *#* ]] && continue
+    target_path="${raw%%#*}"
+    anchor="${raw#*#}"
+    [ -z "$target_path" ] && continue
+    srcdir=$(/usr/bin/dirname "$srcfile")
+    full="$srcdir/$target_path"
+    resolved=$(cd "$(/usr/bin/dirname "$full")" 2>/dev/null && /bin/pwd)/$(/usr/bin/basename "$full")
+    [ ! -f "$resolved" ] && continue
+    checked=$((checked+1))
+    if target_anchors "$resolved" | /usr/bin/grep -qx -- "$anchor"; then
+      :
+    else
+      echo "BAD ANCHOR  $srcfile -> $raw"
+      broken=$((broken+1))
+    fi
+  done < <(extract_links "$srcfile")
+done < <(/usr/bin/find . -name "*.md" -type f)
+
+echo ""
+echo "anchors_checked=$checked anchors_bad=$broken"
+
+[ "$broken" -gt 0 ] && exit 1
+exit 0

package/skills/uipath-maestro-flow/.maintenance/check-depth.sh

@@ -0,0 +1,132 @@
+#!/bin/bash
+# Verify every markdown file under references/ is reachable from SKILL.md within the configured max hops.
+# Usage: bash .maintenance/check-depth.sh [MAX_HOPS]
+# Default MAX_HOPS=2. Output per file: "DEPTH=N  path/to/file.md" + summary.
+#
+# Counts BFS hops via outbound links. Folder links count as reachability for every file in the folder
+# (per the convention documented in .maintenance/README.md — folder links satisfy practical reachability).
+#
+# Skips:
+# - Links inside fenced code blocks (```...```)
+# - Links inside inline code spans (`...`)
+# - http(s):// links
+# - Anchor-only links (#anchor)
+# - Slash-command links (/uipath:..., /uipath-feedback)
+#
+# Exits non-zero if any file exceeds MAX_HOPS or is unreachable.
+# Compatible with bash 3.2 (no associative arrays — uses tab-separated state files).
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$ROOT" || exit 1
+
+MAX_HOPS="${1:-2}"
+
+# State files: each line is "<depth>\t<absolute_path>"
+visited=$(/usr/bin/mktemp)
+frontier=$(/usr/bin/mktemp)
+next_frontier=$(/usr/bin/mktemp)
+trap 'rm -f "$visited" "$frontier" "$next_frontier"' EXIT
+
+# Per-file: strip fenced code blocks and inline code spans, then extract links.
+extract_links() {
+  /usr/bin/awk '
+    /^```/ { fenced = !fenced; next }
+    !fenced {
+      gsub(/`[^`]*`/, "", $0)
+      while (match($0, /\]\([^)]+\)/)) {
+        link = substr($0, RSTART, RLENGTH)
+        sub(/^\]\(/, "", link)
+        sub(/\)$/, "", link)
+        print link
+        $0 = substr($0, RSTART + RLENGTH)
+      }
+    }
+  ' "$1"
+}
+
+resolve_link() {
+  local from_file="$1"
+  local link="$2"
+  link="${link%%#*}"
+  [ -z "$link" ] && return 1
+  case "$link" in
+    http://*|https://*) return 1 ;;
+    /uipath:*|/uipath-feedback*) return 1 ;;
+  esac
+  local from_dir
+  from_dir=$(/usr/bin/dirname "$from_file")
+  local target="$from_dir/$link"
+  local resolved_dir
+  resolved_dir=$(cd "$(/usr/bin/dirname "$target")" 2>/dev/null && /bin/pwd)
+  [ -z "$resolved_dir" ] && return 1
+  echo "$resolved_dir/$(/usr/bin/basename "$target")"
+}
+
+is_visited() {
+  /usr/bin/grep -q "	$1$" "$visited"
+}
+
+mark_visited() {
+  printf "%s\t%s\n" "$1" "$2" >> "$visited"
+}
+
+depth_of() {
+  /usr/bin/awk -F'\t' -v p="$1" '$2 == p { print $1; exit }' "$visited"
+}
+
+# Seed with SKILL.md at depth 0
+mark_visited 0 "$ROOT/SKILL.md"
+echo "$ROOT/SKILL.md" > "$frontier"
+
+current_depth=0
+while [ -s "$frontier" ] && [ "$current_depth" -lt "$MAX_HOPS" ]; do
+  : > "$next_frontier"
+  while IFS= read -r file; do
+    [ -z "$file" ] && continue
+    while IFS= read -r raw_link; do
+      target=$(resolve_link "$file" "$raw_link") || continue
+      [ -z "$target" ] && continue
+      if [ -d "$target" ]; then
+        while IFS= read -r f; do
+          [ -z "$f" ] && continue
+          if ! is_visited "$f"; then
+            mark_visited $((current_depth + 1)) "$f"
+            echo "$f" >> "$next_frontier"
+          fi
+        done < <(/usr/bin/find "$target" -name "*.md" -type f)
+      elif [ -f "$target" ]; then
+        if ! is_visited "$target"; then
+          mark_visited $((current_depth + 1)) "$target"
+          echo "$target" >> "$next_frontier"
+        fi
+      fi
+    done < <(extract_links "$file")
+  done < "$frontier"
+  /bin/cp "$next_frontier" "$frontier"
+  current_depth=$((current_depth + 1))
+done
+
+# Report — every .md under references/ should be visited within MAX_HOPS
+total=0
+unreachable=0
+exceeded=0
+while IFS= read -r f; do
+  [ -z "$f" ] && continue
+  total=$((total + 1))
+  d=$(depth_of "$f")
+  if [ -z "$d" ]; then
+    echo "UNREACHABLE  ${f#$ROOT/}"
+    unreachable=$((unreachable + 1))
+  elif [ "$d" -gt "$MAX_HOPS" ]; then
+    echo "EXCEEDS_DEPTH ($d > $MAX_HOPS)  ${f#$ROOT/}"
+    exceeded=$((exceeded + 1))
+  fi
+done < <(/usr/bin/find "$ROOT/references" -name "*.md" -type f | /usr/bin/sort -u)
+
+echo ""
+echo "max_hops=$MAX_HOPS total_files=$total reachable_within=$((total - unreachable - exceeded)) unreachable=$unreachable exceeds_depth=$exceeded"
+
+if [ "$unreachable" -gt 0 ] || [ "$exceeded" -gt 0 ]; then
+  exit 1
+fi
+exit 0

package/skills/uipath-maestro-flow/.maintenance/check-link-text.sh

@@ -0,0 +1,123 @@
+#!/bin/bash
+# Verify markdown link text agrees with link URL when text contains a file-like token.
+# Usage: bash .maintenance/check-link-text.sh
+# Output: BROKEN lines per failure, then "checked=N broken=M" summary.
+#
+# Failure modes (all hard failures):
+# - basename-mismatch: text contains a file-like token whose basename != URL basename.
+# - prefix-mismatch: basenames match but the directory prefix in the text doesn't match
+#   the URL's directory (and isn't a suffix of it). Catches misleading text like
+#   "operate/manage.md" pointing to "references/manage.md".
+# - folder-url-but-text-is-file: URL ends with "/" but text claims a file.
+#
+# Skips:
+# - links inside fenced code blocks (```...```)
+# - links inside inline code spans (`...`)
+# - http(s):// links
+# - slash-command links (/uipath:..., /uipath-feedback)
+# - same-file anchor-only links (#anchor)
+# - image links (![alt](url))
+# - links whose text contains no file-like token
+#
+# File-like token regex: [A-Za-z0-9_./-]+\.(md|sh|json|js|ts|py|cs|xaml|flow|yaml|yml)
+#
+# Run from any directory; resolves to the skill root automatically.
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$ROOT" || exit 1
+
+broken=0
+checked=0
+
+# Per-file: strip fenced code blocks and inline code spans, then emit "lineno<TAB>text<TAB>url"
+# for every non-image link on every line.
+extract_pairs() {
+  /usr/bin/awk '
+    /^```/ { fenced = !fenced; next }
+    !fenced {
+      lineno = NR
+      line = $0
+      gsub(/`[^`]*`/, "", line)
+      while (match(line, /\[[^]]*\]\([^)]+\)/)) {
+        m = substr(line, RSTART, RLENGTH)
+        # Skip image links: ![alt](url)
+        if (RSTART > 1 && substr(line, RSTART - 1, 1) == "!") {
+          line = substr(line, RSTART + RLENGTH)
+          continue
+        }
+        ti = index(m, "](")
+        text = substr(m, 2, ti - 2)
+        url  = substr(m, ti + 2, length(m) - ti - 2)
+        printf "%d\t%s\t%s\n", lineno, text, url
+        line = substr(line, RSTART + RLENGTH)
+      }
+    }
+  ' "$1"
+}
+
+# Extract the first file-like token from a string. Empty if none found.
+first_file_token() {
+  printf '%s' "$1" | /usr/bin/grep -oE '[A-Za-z0-9_./-]+\.(md|sh|json|js|ts|py|cs|xaml|flow|yaml|yml)' | /usr/bin/head -n1
+}
+
+while IFS= read -r srcfile; do
+  while IFS=$'\t' read -r lineno text url; do
+    [ -z "$url" ] && continue
+
+    case "$url" in
+      http://*|https://*) continue ;;
+      /uipath:*|/uipath-feedback*) continue ;;
+      \#*) continue ;;
+    esac
+
+    url_nofrag="${url%%#*}"
+    [ -z "$url_nofrag" ] && continue
+
+    text_token=$(first_file_token "$text")
+    [ -z "$text_token" ] && continue
+
+    checked=$((checked+1))
+
+    case "$url_nofrag" in
+      */)
+        echo "BROKEN  $srcfile:$lineno -> text=\"$text\" url=$url reason=folder-url-but-text-is-file"
+        broken=$((broken+1))
+        continue
+        ;;
+    esac
+
+    text_base="${text_token##*/}"
+    url_base="${url_nofrag##*/}"
+
+    if [ "$text_base" != "$url_base" ]; then
+      echo "BROKEN  $srcfile:$lineno -> text=\"$text\" url=$url reason=basename-mismatch"
+      broken=$((broken+1))
+      continue
+    fi
+
+    # Basenames match. Check directory coherence.
+    text_dir="${text_token%/*}"
+    [ "$text_dir" = "$text_token" ] && text_dir=""
+    url_dir="${url_nofrag%/*}"
+    [ "$url_dir" = "$url_nofrag" ] && url_dir=""
+
+    if [ -n "$text_dir" ] && [ "$text_dir" != "$url_dir" ]; then
+      # Tolerate the case where the text directory is a suffix of the URL directory
+      # (e.g., text "author/greenfield.md" vs. url "references/author/greenfield.md").
+      mismatch=1
+      case "/$url_dir/" in
+        */"$text_dir"/*) mismatch=0 ;;
+      esac
+      if [ "$mismatch" -eq 1 ]; then
+        echo "BROKEN  $srcfile:$lineno -> text=\"$text\" url=$url reason=prefix-mismatch"
+        broken=$((broken+1))
+      fi
+    fi
+  done < <(extract_pairs "$srcfile")
+done < <(/usr/bin/find . -name "*.md" -type f)
+
+echo ""
+echo "checked=$checked broken=$broken"
+
+[ "$broken" -gt 0 ] && exit 1
+exit 0

package/skills/uipath-maestro-flow/.maintenance/check-links.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+# Verify every markdown file-path link in the skill resolves to an existing file or directory.
+# Usage: bash .maintenance/check-links.sh
+# Output: BROKEN lines per failure, then "checked=N broken=M" summary.
+#
+# Skips:
+# - links inside fenced code blocks (```...```)
+# - links inside inline code spans (`...`)
+# - http(s):// links
+# - slash-command links (/uipath:..., /uipath-feedback)
+# - same-file anchor-only links (#anchor)
+#
+# Accepts:
+# - file links resolving to a file (-f)
+# - folder links resolving to a directory (-d)
+#
+# Run from any directory; resolves to the skill root automatically.
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$ROOT" || exit 1
+
+broken=0
+checked=0
+
+# Per-file: strip fenced code blocks and inline code spans, then extract links.
+extract_links() {
+  /usr/bin/awk '
+    /^```/ { fenced = !fenced; next }
+    !fenced {
+      # Strip inline code spans: anything between two backticks
+      gsub(/`[^`]*`/, "", $0)
+      # Match all ](...) link targets on this line
+      while (match($0, /\]\([^)]+\)/)) {
+        link = substr($0, RSTART, RLENGTH)
+        sub(/^\]\(/, "", link)
+        sub(/\)$/, "", link)
+        print link
+        $0 = substr($0, RSTART + RLENGTH)
+      }
+    }
+  ' "$1"
+}
+
+while IFS= read -r srcfile; do
+  while IFS= read -r link; do
+    link="${link%%#*}"
+    [ -z "$link" ] && continue
+    case "$link" in
+      http://*|https://*) continue ;;
+      /uipath:*|/uipath-feedback*) continue ;;
+    esac
+    filedir=$(/usr/bin/dirname "$srcfile")
+    target="$filedir/$link"
+    resolved_dir=$(cd "$(/usr/bin/dirname "$target")" 2>/dev/null && /bin/pwd)
+    resolved_base=$(/usr/bin/basename "$target")
+    resolved="$resolved_dir/$resolved_base"
+    checked=$((checked+1))
+    if [ -f "$resolved" ] || [ -d "$resolved" ]; then
+      :
+    elif [ -d "$target" ]; then
+      :
+    else
+      echo "BROKEN  $srcfile -> $link"
+      broken=$((broken+1))
+    fi
+  done < <(extract_links "$srcfile")
+done < <(/usr/bin/find . -name "*.md" -type f)
+
+echo ""
+echo "checked=$checked broken=$broken"
+
+[ "$broken" -gt 0 ] && exit 1
+exit 0

package/skills/uipath-maestro-flow/.maintenance/check-orphans.sh

@@ -0,0 +1,93 @@
+#!/bin/bash
+# Find .md files under references/ that no other .md file links to.
+# Usage: bash .maintenance/check-orphans.sh
+# Output: ORPHAN lines per orphan, then "files_checked=N orphans=M" summary.
+#
+# Skips:
+# - SKILL.md (the entry point — has no inbound links by design)
+# - CAPABILITY.md files (linked from SKILL.md and peer indexes)
+# - Links inside fenced code blocks (```...```)
+# - Links inside inline code spans (`...`)
+#
+# A file is considered "linked to" if any other .md file references it via
+# `[text](path)` or via a folder link (`[text](folder/)`) that resolves to its parent dir.
+#
+# Exits non-zero if any orphans found.
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$ROOT" || exit 1
+
+# Per-file: strip fenced code blocks and inline code spans, then extract links.
+extract_links() {
+  /usr/bin/awk '
+    /^```/ { fenced = !fenced; next }
+    !fenced {
+      gsub(/`[^`]*`/, "", $0)
+      while (match($0, /\]\([^)]+\)/)) {
+        link = substr($0, RSTART, RLENGTH)
+        sub(/^\]\(/, "", link)
+        sub(/\)$/, "", link)
+        print link
+        $0 = substr($0, RSTART + RLENGTH)
+      }
+    }
+  ' "$1"
+}
+
+resolve_link() {
+  local from_file="$1"
+  local link="$2"
+  link="${link%%#*}"
+  [ -z "$link" ] && return 1
+  case "$link" in
+    http://*|https://*) return 1 ;;
+    /uipath:*|/uipath-feedback*) return 1 ;;
+  esac
+  local from_dir
+  from_dir=$(/usr/bin/dirname "$from_file")
+  local target="$from_dir/$link"
+  local resolved_dir
+  resolved_dir=$(cd "$(/usr/bin/dirname "$target")" 2>/dev/null && /bin/pwd)
+  [ -z "$resolved_dir" ] && return 1
+  echo "$resolved_dir/$(/usr/bin/basename "$target")"
+}
+
+# Build the set of every .md path that any .md file links to (file links + folder links).
+linked_set=$(/usr/bin/mktemp)
+trap 'rm -f "$linked_set"' EXIT
+
+while IFS= read -r srcfile; do
+  while IFS= read -r raw_link; do
+    target=$(resolve_link "$srcfile" "$raw_link") || continue
+    [ -z "$target" ] && continue
+    if [ -d "$target" ]; then
+      # Folder link → mark every .md inside as linked
+      /usr/bin/find "$target" -name "*.md" -type f >> "$linked_set"
+    elif [ -f "$target" ]; then
+      echo "$target" >> "$linked_set"
+    fi
+  done < <(extract_links "$srcfile")
+done < <(/usr/bin/find . -name "*.md" -type f)
+
+# Sort + dedupe linked set
+sorted_linked=$(/usr/bin/sort -u "$linked_set")
+
+# Check each .md under references/ — orphan if not in linked set, with exceptions.
+orphans=0
+checked=0
+while IFS= read -r f; do
+  [ -z "$f" ] && continue
+  basename=$(/usr/bin/basename "$f")
+  [ "$basename" = "CAPABILITY.md" ] && continue
+  checked=$((checked + 1))
+  if ! echo "$sorted_linked" | /usr/bin/grep -qx "$f"; then
+    echo "ORPHAN  ${f#$ROOT/}"
+    orphans=$((orphans + 1))
+  fi
+done < <(/usr/bin/find "$ROOT/references" -name "*.md" -type f | /usr/bin/sort)
+
+echo ""
+echo "files_checked=$checked orphans=$orphans"
+
+[ "$orphans" -gt 0 ] && exit 1
+exit 0

package/skills/uipath-maestro-flow/.maintenance/check-plugin-pairs.sh

@@ -0,0 +1,39 @@
+#!/bin/bash
+# Verify every plugin folder under references/author/plugins/ has both
+# `planning.md` and `impl.md` (the per-plugin convention from skill-structure.md).
+# Usage: bash .maintenance/check-plugin-pairs.sh
+# Output: MISSING lines per failure, then "plugins_checked=N missing_files=M" summary.
+#
+# Exits non-zero if any plugin folder is missing planning.md or impl.md.
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$ROOT" || exit 1
+
+PLUGINS_DIR="$ROOT/references/author/plugins"
+
+if [ ! -d "$PLUGINS_DIR" ]; then
+  echo "ERROR: plugins directory not found at $PLUGINS_DIR" >&2
+  exit 2
+fi
+
+REQUIRED_FILES=("planning.md" "impl.md")
+
+failures=0
+checked=0
+
+while IFS= read -r plugin_dir; do
+  [ -z "$plugin_dir" ] && continue
+  checked=$((checked + 1))
+  for required in "${REQUIRED_FILES[@]}"; do
+    if [ ! -f "$plugin_dir/$required" ]; then
+      echo "MISSING  ${plugin_dir#$ROOT/}/$required"
+      failures=$((failures + 1))
+    fi
+  done
+done < <(/usr/bin/find "$PLUGINS_DIR" -mindepth 1 -maxdepth 1 -type d | /usr/bin/sort)
+
+echo ""
+echo "plugins_checked=$checked missing_files=$failures"
+
+[ "$failures" -gt 0 ] && exit 1
+exit 0

package/skills/uipath-maestro-flow/.maintenance/check-template.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+# Verify each CAPABILITY.md follows the canonical 6-section template:
+#   1. When to use this capability
+#   2. Critical rules
+#   3. Workflow
+#   4. Common tasks
+#   5. Anti-patterns
+#   6. References
+# Usage: bash .maintenance/check-template.sh
+# Exits non-zero if any CAPABILITY.md is missing a required section.
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$ROOT" || exit 1
+
+REQUIRED_SECTIONS=(
+  "When to use this capability"
+  "Critical rules"
+  "Workflow"
+  "Common tasks"
+  "Anti-patterns"
+  "References"
+)
+
+failures=0
+checked=0
+
+while IFS= read -r capfile; do
+  [ -z "$capfile" ] && continue
+  checked=$((checked + 1))
+  for section in "${REQUIRED_SECTIONS[@]}"; do
+    if ! /usr/bin/grep -qE "^## $section\$" "$capfile"; then
+      echo "MISSING_SECTION  ${capfile#$ROOT/}  ->  ## $section"
+      failures=$((failures + 1))
+    fi
+  done
+done < <(/usr/bin/find "$ROOT/references" -name "CAPABILITY.md" -type f | /usr/bin/sort)
+
+echo ""
+echo "capabilities_checked=$checked missing_sections=$failures"
+
+[ "$failures" -gt 0 ] && exit 1
+exit 0