@uipath/skills 1.196.0 → 1.197.0

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

@@ -1,70 +0,0 @@
-#!/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"

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

@@ -1,93 +0,0 @@
-#!/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-bpmn/.maintenance/check-plugin-pairs.sh

@@ -1,39 +0,0 @@
-#!/bin/bash
-# Verify every plugin folder under references/author/references/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/references/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-bpmn/.maintenance/check-real-pack.sh

@@ -1,79 +0,0 @@
-#!/bin/bash
-# Package validation fixtures through the installed uip CLI.
-# Usage: bash .maintenance/check-real-pack.sh
-#
-# Runs local `uip maestro bpmn pack` for every validation fixture. Also runs
-# `uip solution pack` for fixtures that are expected to be full solution-pack
-# contracts. Solution pack reads the current tenant context, so that leg is
-# skipped when the CLI is not logged in.
-
-set -u
-
-ROOT="$(cd "$(dirname "$0")/.." && pwd)"
-cd "$ROOT" || exit 1
-
-if ! command -v uip >/dev/null 2>&1; then
-  echo "uip not found on PATH; skipping real pack checks"
-  echo "real_pack_fixtures=0 solution_pack_fixtures=0 errors=0"
-  exit 0
-fi
-
-TMPDIR="$(mktemp -d)"
-trap 'rm -rf "$TMPDIR"' EXIT
-
-errors=0
-bpmn_count=0
-solution_count=0
-
-run_json_command() {
-  local label="$1"
-  shift
-  local log="$TMPDIR/${label//[^A-Za-z0-9_.-]/_}.log"
-  if "$@" >"$log" 2>&1; then
-    return 0
-  fi
-  echo "ERROR: $label failed"
-  tail -80 "$log"
-  return 1
-}
-
-for project in fixtures/validation/*; do
-  [ -d "$project" ] || continue
-  name="$(basename "$project")"
-  bpmn_count=$((bpmn_count + 1))
-  mkdir -p "$TMPDIR/bpmn-pack/$name"
-  if ! run_json_command "bpmn-pack-$name" \
-    uip maestro bpmn pack "$project" "$TMPDIR/bpmn-pack/$name" --output json; then
-    errors=1
-  fi
-done
-
-if uip login status --output json >"$TMPDIR/login-status.json" 2>&1 \
-  && grep -q '"Status": "Logged in"' "$TMPDIR/login-status.json"; then
-  for name in agent-invocation; do
-    project="fixtures/validation/$name"
-    solution_dir="$TMPDIR/solution-$name"
-    solution_file="$solution_dir/solution-$name.uipx"
-    solution_count=$((solution_count + 1))
-
-    if ! run_json_command "solution-init-$name" \
-      uip solution init "$solution_dir" --output json; then
-      errors=1
-      continue
-    fi
-    if ! run_json_command "solution-import-$name" \
-      uip solution project import --source "$project" --solutionFile "$solution_file" --output json; then
-      errors=1
-      continue
-    fi
-    if ! run_json_command "solution-pack-$name" \
-      uip solution pack "$solution_dir" "$TMPDIR/solution-pack/$name" --output json; then
-      errors=1
-    fi
-  done
-else
-  echo "uip is not logged in; skipping solution pack fixtures"
-fi
-
-echo "real_pack_fixtures=$bpmn_count solution_pack_fixtures=$solution_count errors=$errors"
-exit "$errors"

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

@@ -1,42 +0,0 @@
-#!/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

package/skills/uipath-maestro-bpmn/.maintenance/check-uip-commands.sh

@@ -1,266 +0,0 @@
-#!/bin/bash
-# Verify every `uip` command referenced in this skill's markdown actually exists.
-# Usage: bash .maintenance/check-uip-commands.sh [--strict] [file1.md ...]
-# Output: BAD lines per unknown command, then "commands_checked=N unknown=M" summary.
-#
-# Scans fenced code blocks (```bash, ```sh, ```shell, ```zsh, ```console, or
-# unlabelled ```) under this skill for lines that begin with `uip `, extracts
-# the command path (tokens before the first flag, placeholder, or shell
-# metachar), and verifies it against `uip <path> --help`. Help output only —
-# no command is ever executed for real.
-#
-# How verification works: `uip <bogus> --help` silently falls back to the
-# parent's help, so exit code is not a reliable signal. Instead, we walk the
-# path level by level and confirm each next segment appears in the parent's
-# `Subcommands[].Name` list. Help responses are cached per prefix.
-#
-# Skips:
-# - Inline backtick references like `uip ...` (only fenced blocks are scanned)
-# - Files matching --skip-glob
-#
-# --strict: exit 2 if `uip` is not on PATH (CI mode). Default: warn and exit 0.
-#
-# Exits non-zero if any unknown command is referenced.
-
-set -e
-
-ROOT="$(cd "$(dirname "$0")/.." && pwd)"
-cd "$ROOT" || exit 1
-
-STRICT=0
-FILES=()
-for arg in "$@"; do
-  case "$arg" in
-    --strict) STRICT=1 ;;
-    *) FILES+=("$arg") ;;
-  esac
-done
-
-if ! command -v uip >/dev/null 2>&1; then
-  if [ "$STRICT" -eq 1 ]; then
-    echo "uip not found on PATH (--strict)" >&2
-    exit 2
-  fi
-  echo "uip not found on PATH; skipping (use --strict to fail)" >&2
-  echo ""
-  echo "commands_checked=0 unknown=0"
-  exit 0
-fi
-
-if ! command -v python3 >/dev/null 2>&1; then
-  echo "python3 not found on PATH" >&2
-  exit 2
-fi
-
-if [ "${#FILES[@]}" -eq 0 ]; then
-  # Scan the skill's published surface only: SKILL.md + references/.
-  # Skips .maintenance/, scratch files at the skill root (PLAN.md, PR_BODY.md),
-  # and anything else that isn't part of what agents load.
-  while IFS= read -r f; do
-    FILES+=("$f")
-  done < <({ [ -f SKILL.md ] && echo "./SKILL.md"; /usr/bin/find ./references -type f -name '*.md' 2>/dev/null; } | /usr/bin/sort)
-fi
-
-if [ "${#FILES[@]}" -eq 0 ]; then
-  echo ""
-  echo "commands_checked=0 unknown=0"
-  exit 0
-fi
-
-export UIP_BIN="$(command -v uip)"
-export SKILL_ROOT="$ROOT"
-
-python3 - "${FILES[@]}" <<'PYEOF'
-import json
-import os
-import re
-import subprocess
-import sys
-from pathlib import Path
-
-UIP = os.environ["UIP_BIN"]
-SKILL_ROOT = Path(os.environ["SKILL_ROOT"])
-files = [Path(p) for p in sys.argv[1:]]
-
-# Cache value: (subcommands_set, takes_positional_args) or None for invalid prefix
-_help_cache: dict[tuple, tuple[set, bool] | None] = {}
-
-
-def get_help(prefix):
-    if prefix in _help_cache:
-        return _help_cache[prefix]
-    # `--output json` is required: top-level `uip --help` defaults to plain
-    # text; other levels default to JSON but accept the flag too. Forcing it
-    # makes parsing deterministic.
-    cmd = [UIP, *prefix, "--help", "--output", "json"]
-    try:
-        proc = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
-    except Exception:
-        _help_cache[prefix] = None
-        return None
-    # uip prints non-JSON noise around the help payload — sometimes a banner
-    # before (e.g. `Tool factory already registered ...`), sometimes a human
-    # usage block after. Use raw_decode to grab the first complete JSON object.
-    out = proc.stdout
-    brace = out.find("{")
-    if brace < 0:
-        _help_cache[prefix] = None
-        return None
-    try:
-        data, _ = json.JSONDecoder().raw_decode(out[brace:])
-    except json.JSONDecodeError:
-        _help_cache[prefix] = None
-        return None
-    inner = data.get("Data", {})
-    resolved = inner.get("Command", "")
-    expected = prefix[-1] if prefix else "uip"
-    if resolved != expected:
-        _help_cache[prefix] = None
-        return None
-    subs = set()
-    for entry in inner.get("Subcommands", []) or []:
-        name = entry.get("Name", "")
-        leaf = name.split(None, 1)[0]
-        if leaf:
-            subs.add(leaf)
-    takes_args = bool(inner.get("Arguments"))
-    _help_cache[prefix] = (subs, takes_args)
-    return _help_cache[prefix]
-
-
-def verify_path(path):
-    prefix = ()
-    for seg in path:
-        info = get_help(prefix)
-        if info is None:
-            return False, prefix[-1] if prefix else seg, []
-        subs, takes_args = info
-        if seg not in subs:
-            # If the parent is a leaf (no subcommands) and accepts positional
-            # args, this token is an arg — path is valid up to here.
-            if not subs and takes_args:
-                return True, "", []
-            import difflib
-            return False, seg, difflib.get_close_matches(seg, sorted(subs), n=3, cutoff=0.5)
-        prefix = prefix + (seg,)
-    return True, "", []
-
-
-FENCE_RE = re.compile(r"^```([a-zA-Z0-9_+-]*)\s*$")
-ACCEPTED_LANGS = {"", "bash", "sh", "shell", "zsh", "console"}
-# Inline single-backtick spans. Greedy is fine: ` cannot appear inside a
-# single-backtick span by definition (use double-backtick spans for that, which
-# we deliberately don't scan — they're rare and usually contain code samples).
-INLINE_RE = re.compile(r"`([^`\n]+)`")
-# Per-line opt-out marker: `<!-- uip-check-skip -->` anywhere on the line
-# suppresses checking for that line. Used for intentional historical references
-# (e.g. CLI version-comparison tables that document a removed prefix). For
-# table rows, place the marker inside a cell (e.g. `| ... | ... <!-- uip-check-skip --> |`)
-# so it doesn't break table structure — HTML comments render as nothing.
-SKIP_MARKER = "<!-- uip-check-skip -->"
-
-
-SUBCOMMAND_RE = re.compile(r"^[a-z][a-z0-9-]*$")
-
-
-def is_terminator(tok):
-    # A real uip subcommand is a lowercase kebab-case identifier. Anything else
-    # (flags, placeholders, paths, comments, quoted strings, shell metachars,
-    # positional args) ends the path.
-    if not tok:
-        return True
-    if tok.startswith("#"):
-        return True
-    if tok in {"|", ">", ">>", "<", "&&", "||", ";", "&", "$(", "`"}:
-        return True
-    return not SUBCOMMAND_RE.match(tok)
-
-
-def extract_path_from_uip_line(content):
-    """Tokenize a uip line and walk to extract the command path.
-
-    Returns the path list (possibly empty for bare `uip`).
-    Returns None if the line doesn't start with `uip`.
-    """
-    if content.startswith("$ "):
-        content = content[2:]
-    if not (content.startswith("uip ") or content.rstrip() == "uip"):
-        return None
-    tokens = content.split()
-    path = []
-    for tok in tokens[1:]:
-        if is_terminator(tok):
-            break
-        path.append(tok)
-    return path
-
-
-def extract_uip_commands(md_path):
-    try:
-        text = md_path.read_text(encoding="utf-8")
-    except Exception:
-        return
-    lines = text.splitlines()
-    in_fence = False
-    fence_lang = ""
-    i = 0
-    while i < len(lines):
-        line = lines[i]
-        m = FENCE_RE.match(line.strip())
-        if m:
-            if not in_fence:
-                in_fence = True
-                fence_lang = m.group(1).lower()
-            else:
-                in_fence = False
-                fence_lang = ""
-            i += 1
-            continue
-        if SKIP_MARKER in line:
-            i += 1
-            continue
-        if in_fence:
-            if fence_lang in ACCEPTED_LANGS:
-                start = i
-                joined = line
-                while joined.rstrip().endswith("\\") and i + 1 < len(lines):
-                    joined = joined.rstrip()[:-1] + " " + lines[i + 1]
-                    i += 1
-                path = extract_path_from_uip_line(joined.lstrip())
-                if path:
-                    yield (start + 1, path)
-        else:
-            # Inline backtick spans outside fenced blocks.
-            for match in INLINE_RE.finditer(line):
-                path = extract_path_from_uip_line(match.group(1).strip())
-                if path:
-                    yield (i + 1, path)
-        i += 1
-
-
-references = {}
-for md in files:
-    for line_no, path in extract_uip_commands(md):
-        references.setdefault(tuple(path), []).append((md, line_no))
-
-unknown = 0
-for path_tuple, locs in sorted(references.items()):
-    ok, bad, suggestions = verify_path(list(path_tuple))
-    if ok:
-        continue
-    idx = list(path_tuple).index(bad) if bad in path_tuple else 0
-    parent = "uip" + ("" if idx == 0 else " " + " ".join(path_tuple[:idx]))
-    cmd_str = "uip " + " ".join(path_tuple)
-    sug = f" (did you mean: {', '.join(suggestions)}?)" if suggestions else ""
-    for f, ln in locs:
-        try:
-            rel = f.relative_to(SKILL_ROOT).as_posix()
-        except ValueError:
-            rel = str(f)
-        print(f'BAD  {rel}:{ln}  {cmd_str} — "{bad}" not a subcommand of "{parent}"{sug}')
-        unknown += 1
-
-print()
-print(f"commands_checked={len(references)} unknown={unknown}")
-sys.exit(1 if unknown else 0)
-PYEOF