Skip to content
Back to search

uipath-ai-skills

AI skills that turns coding agents into UiPath experts.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/marcelocruzrpa--uipath-ai-skills/badge.svg)](/listings/marcelocruzrpa--uipath-ai-skills)

HTML

<a href="/listings/marcelocruzrpa--uipath-ai-skills"><img src="/api/listings/marcelocruzrpa--uipath-ai-skills/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

> [!IMPORTANT] > **Plugin Layout:** Plugins (like `uipath-tasks`) must be installed as sibling directories to `uipath-core`. The runtime loader scans sibling folders for extensions; moving them to a different nested structure will break discovery.

> [!NOTE] > **PowerShell:** While the core generators are cross-platform, desktop selector generation via `inspect-ui-tree.ps1` requires PowerShell on a Windows environment.

Adding the skills to your environment is super simple:

<details open> <summary><strong>Claude Code</strong></summary>

/plugin marketplace add marcelocruzrpa/uipath-ai-skills
/plugin install uipath-core@uipath-ai-skills
/plugin install uipath-tasks@uipath-ai-skills

Verify by asking Claude *"List my available skills"* — you should see both `uipath-core` and `uipath-tasks`.

</details>

<details> <summary><strong>Codex CLI</strong></summary>

git clone https://github.com/marcelocruzrpa/uipath-ai-skills.git
mkdir -p .codex/skills
cp -r uipath-ai-skills/uipath-core  .codex/skills/uipath-core
cp -r uipath-ai-skills/uipath-tasks .codex/skills/uipath-tasks
codex

Or install globally:

cp -r uipath-ai-skills/uipath-core  ~/.codex/skills/uipath-core
cp -r uipath-ai-skills/uipath-tasks ~/.codex/skills/uipath-tasks

If Codex truncates the skill, raise the instruction limit in `~/.codex/config.toml`:

project_doc_max_bytes = 131072  # 128 KB

</details>

<details> <summary><strong>Manual install</strong></summary>

If you're using a different agent or vendoring the plugins into an existing project, clone and copy:

git clone https://github.com/marcelocruzrpa/uipath-ai-skills.git

# Optional: install openpyxl for Config.xlsx management
pip install "openpyxl>=3.1.0"

No other dependencies required — all core scripts use Python stdlib.

Copy into a Claude Code project:

mkdir -p <your-project>/.claude/skills
cp -r uipath-ai-skills/uipath-core  <your-project>/.claude/skills/
cp -r uipath-ai-skills/uipath-tasks <your-project>/.claude/skills/

Copy into a Codex CLI project:

mkdir -p <your-project>/.codex/skills
cp -r uipath-ai-skills/uipath-core  <your-project>/.codex/skills/
cp -r uipath-ai-skills/uipath-tasks <your-project>/.codex/skills/

</details>

Using the skill

1. **Start in plan mode when your agent supports it.** In Claude Code, toggle plan mode with Shift+Tab before sending your prompt — the agent reads your **PDD (Process Definition Document)**, drafts a plan, and waits for your approval before touching files. Review the plan, tweak it if needed, then approve and let it execute. 2. **Name the skill in your prompt** to be sure it loads — e.g. *"Use `uipath-core` to scaffold a REFramework dispatcher for this PDD..."*. The skill also auto-loads when your prompt mentions UiPath, but naming it explicitly is the surest path. For human-in-the-loop or Tasks workflows, name `uipath-tasks`. 3. **Three ways to use it:** - **Build a project from a PDD** — point the agent at a PDD file and (optionally) tell it the architecture (sequence, dispatcher, or performer). It scaffolds the project, generates the workflows, inspects target apps for selectors, and validates the output. - **Update an existing project** — point it at an existing UiPath project and ask for a bug fix, a new workflow, or a small change. It reads the project structure, generates only the deltas, and re-validates. - **Refactor a legacy project into REFramework** — point it at an existing project built with flat structure or bad practices and ask for a wholesale rewrite. It reads the workflows, proposes a proper decomposition (launch / init / process / action files, Config.xlsx, Object Repository), and migrates the logic into the new shape. *Not battle-tested as the other two modes*

Version-band targeting (v1.2.1+)

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 24 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "uipath-ai-skills",
  3. "owner": { "name": "marcelocruzrpa" },
  4. "metadata": {
  5. "description": "AI skills for generating production-quality UiPath Studio projects from natural language.",
  6. "version": "1.0.0"
  7. },
  8. "plugins": [
  9. {
  10. "name": "uipath-core",
  11. "description": "Build UiPath Studio projects, REFramework scaffolds, XAML workflows, and VB/C# expressions via 104 deterministic Python generators. Trigger keywords: UiPath, REFramework, XAML, RPA, Orchestrator, dispatcher, performer, queue items, project.json, Config.xlsx.",
  12. "source": "./",
  13. "strict": false,
  14. "skills": ["./uipath-core"]
  15. },
  16. {
  17. "name": "uipath-tasks",
  18. "description": "Generates UiPath Tasks workflows — Form Tasks, External Tasks, and Task Management activities for human-in-the-loop, system-in-the-loop, and recovery patterns. Plugs into uipath-core via plugin_loader.",
  19. "source": "./",
  20. "strict": false,
  21. "skills": ["./uipath-tasks"]
  22. }
  23. ]
  24. }
README.md · README · 561 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p align="center">
  2. <img src="assets/banner.png" alt="uipath-ai-skills" width="100%">
  3. </p>
  4. AI skills that turn natural language into production-quality UiPath Studio projects — powered by deterministic Python generators, real Studio-exported templates, and a validation layer tuned to catch LLM hallucination patterns. No hallucinated XAML. No guessed selectors. Every `.xaml` file opens cleanly in UiPath Studio.
  5. ## The problem
  6. LLMs are bad at generating UiPath code. The XAML they produce is typically invalid — wrong namespaces, hallucinated activity names, broken selectors, missing ViewState blocks, incompatible NuGet versions. Most of it won't even open in Studio.
  7. **uipath-ai-skills** closes that gap. The agent writes JSON specs; the toolchain emits valid XAML, catches hallucination patterns before they reach your project, and wires the framework for you — so what usually takes days of Studio cleanup becomes minutes of review.
  8. ---
  9. ## Complete walkthrough
  10. [![uipath-ai-skills walkthrough](https://img.youtube.com/vi/0JjiM8sGP08/hqdefault.jpg)](https://youtu.be/0JjiM8sGP08)
  11. End-to-end walkthrough — setup, how to use the skills, and what production output looks like in UiPath Studio.
  12. ---
  13. ## What you can build
  14. | Automation type | Description | Recommended project |
  15. |---|---|---|
  16. | **Web form filling** | Browser-based data entry with real selectors from Playwright inspection | Sequence or REFramework |
  17. | **Queue dispatching** | Read data sources (Excel, DB, API) and populate Orchestrator queues | REFramework Dispatcher |
  18. | **Queue processing** | Process queue items with retry logic, exception handling, and status tracking | REFramework Performer |
  19. | **API integrations** | HTTP requests with OAuth, retry policies, JSON parsing, credential management | Sequence |
  20. | **Excel processing** | Read, filter, transform, and write Excel data with LINQ expressions | Sequence |
  21. | **PDF extraction** | Extract text from PDFs using native parsing or OCR | Sequence |
  22. | **Email automation** | IMAP retrieval, attachment processing, and sending via Integration Service | Sequence |
  23. | **Desktop automation** | Win32/WPF/WinForms app automation with PowerShell-inspected selectors | Sequence or REFramework |
  24. | **Multi-app orchestration** | Processes spanning multiple web and desktop applications | REFramework Performer |
  25. | **Human-in-the-loop tasks** | Form approvals, external system handoff, recovery workflows | Any (uipath-tasks plugin) |
  26. ---
  27. ## Quick start
  28. > [!IMPORTANT]
  29. > **Plugin Layout:** Plugins (like `uipath-tasks`) must be installed as sibling directories to `uipath-core`. The runtime loader scans sibling folders for extensions; moving them to a different nested structure will break discovery.
  30. > [!NOTE]
  31. > **PowerShell:** While the core generators are cross-platform, desktop selector generation via `inspect-ui-tree.ps1` requires PowerShell on a Windows environment.
  32. Adding the skills to your environment is super simple:
  33. <details open>
  34. <summary><strong>Claude Code</strong></summary>
  35. ```
  36. /plugin marketplace add marcelocruzrpa/uipath-ai-skills
  37. /plugin install uipath-core@uipath-ai-skills
  38. /plugin install uipath-tasks@uipath-ai-skills
  39. ```
  40. Verify by asking Claude *"List my available skills"* — you should see both `uipath-core` and `uipath-tasks`.
  41. </details>
  42. <details>
  43. <summary><strong>Codex CLI</strong></summary>
  44. ```bash
  45. git clone https://github.com/marcelocruzrpa/uipath-ai-skills.git
  46. mkdir -p .codex/skills
  47. cp -r uipath-ai-skills/uipath-core .codex/skills/uipath-core
  48. cp -r uipath-ai-skills/uipath-tasks .codex/skills/uipath-tasks
  49. codex
  50. ```
  51. Or install globally:
  52. ```bash
  53. cp -r uipath-ai-skills/uipath-core ~/.codex/skills/uipath-core
  54. cp -r uipath-ai-skills/uipath-tasks ~/.codex/skills/uipath-tasks
  55. ```
  56. If Codex truncates the skill, raise the instruction limit in `~/.codex/config.toml`:
  57. ```toml
  58. project_doc_max_bytes = 131072 # 128 KB
  59. ```
  60. </details>
  61. <details>
  62. <summary><strong>Manual install</strong></summary>
  63. If you're using a different agent or vendoring the plugins into an existing project, clone and copy:
  64. ```bash
  65. git clone https://github.com/marcelocruzrpa/uipath-ai-skills.git
  66. # Optional: install openpyxl for Config.xlsx management
  67. pip install "openpyxl>=3.1.0"
  68. ```
  69. No other dependencies required — all core scripts use Python stdlib.
  70. Copy into a Claude Code project:
  71. ```bash
  72. mkdir -p <your-project>/.claude/skills
  73. cp -r uipath-ai-skills/uipath-core <your-project>/.claude/skills/
  74. cp -r uipath-ai-skills/uipath-tasks <your-project>/.claude/skills/
  75. ```
  76. Copy into a Codex CLI project:
  77. ```bash
  78. mkdir -p <your-project>/.codex/skills
  79. cp -r uipath-ai-skills/uipath-core <your-project>/.codex/skills/
  80. cp -r uipath-ai-skills/uipath-tasks <your-project>/.codex/skills/
  81. ```
  82. </details>
  83. ### Using the skill
  84. 1. **Start in plan mode when your agent supports it.** In Claude Code, toggle plan mode with Shift+Tab before sending your prompt — the agent reads your **PDD (Process Definition Document)**, drafts a plan, and waits for your approval before touching files. Review the plan, tweak it if needed, then approve and let it execute.
  85. 2. **Name the skill in your prompt** to be sure it loads — e.g. *"Use `uipath-core` to scaffold a REFramework dispatcher for this PDD..."*. The skill also auto-loads when your prompt mentions UiPath, but naming it explicitly is the surest path. For human-in-the-loop or Tasks workflows, name `uipath-tasks`.
  86. 3. **Three ways to use it:**
  87. - **Build a project from a PDD** — point the agent at a PDD file and (optionally) tell it the architecture (sequence, dispatcher, or performer). It scaffolds the project, generates the workflows, inspects target apps for selectors, and validates the output.
  88. - **Update an existing project** — point it at an existing UiPath project and ask for a bug fix, a new workflow, or a small change. It reads the project structure, generates only the deltas, and re-validates.
  89. - **Refactor a legacy project into REFramework** — point it at an existing project built with flat structure or bad practices and ask for a wholesale rewrite. It reads the workflows, proposes a proper decomposition (launch / init / process / action files, Config.xlsx, Object Repository), and migrates the logic into the new shape. *Not battle-tested as the other two modes*
  90. ### Version-band targeting (v1.2.1+)
  91. UiPath activity packages evolve their attribute set across Studio releases — `Version="V5"`, `HealingAgentBehavior`, and `ClipboardMode` exist in band 25.10+ but not in earlier bands. Generating XAML against the wrong band produces "Could not find member" errors when Studio opens the project.
  92. To target a specific Studio band, pass `--band` when scaffolding:
  93. ```bash
  94. python uipath-core/scripts/scaffold_project.py --template reframework --band 25 ...
  95. ```
  96. This stamps `versionBand` into `project.json` and activates lints **120/121/122**, which fire when an emitted XAML contains attributes incompatible with the target band. The scaffold also auto-stamps the band when year-based dependencies are supplied via `--deps`. Always target the most recent **stable** band — version profiles are never authored against prerelease packages.
  97. See `CHANGELOG.md` (1.2.1) for the full list of additions: data-driven generator, Studio harvest tooling, plugin API v2 (`register_version_profile` / `register_band_profile_mapping`), and the auto-generated `references/routing-index.md` index across 463 activities.
  98. ---
  99. ## How it works
  100. ```mermaid
  101. flowchart LR
  102. A["Describe automation<br/>in plain English"] --> B["Skill reads<br/>routing table"]
  103. B --> C{"Project<br/>exists?"}
  104. C -->|No| D["Scaffold project<br/>(sequence / dispatcher / performer)"]
  105. C -->|Yes| U{"UI<br/>automation?"}
  106. D --> U
  107. U -->|Yes| E["Inspect target app(s) UI"]
  108. E --> F["Write JSON spec<br/>to disk"]
  109. U -->|No| F
  110. F --> G["Deterministic<br/>generator"]
  111. G --> H["XAML<br/>output"]
  112. H --> V["Lint validation<br/>+ auto-fix"]
  113. V -->|Errors| G
  114. V -->|Pass| K["Framework wiring<br/>+ Object Repository<br/>+ NuGet resolution"]
  115. K --> J["Complete UiPath<br/>project"]
  116. ```
  117. The skill uses four layers to ensure valid output:
  118. 1. **Deterministic generators** — Python functions that produce structurally correct XAML for each activity type. The LLM writes a JSON spec (which LLMs handle well); generators handle the complex XML structure (which LLMs handle poorly). Every enum value, child element, namespace, and attribute is locked down.
  119. 2. **Studio-exported templates** — every generator is anchored to real XAML exported from UiPath Studio 24.10. Not documentation examples — actual working files.
  120. 3. **Lint validation** — rules that specifically target the hallucination patterns LLMs produce when generating UiPath XAML. Catches issues before you open Studio. Auto-fix is available for common issues.
  121. 4. **Framework wiring** — `modify_framework.py` wires `InvokeWorkflowFile` calls into framework files, injects variables, replaces scaffold markers, and chains UiElement arguments. `generate_object_repository.py` builds the `.objects/` tree from captured selectors. Both ensure the generated project is structurally complete.
  122. ---
  123. ## Available skills
  124. | Skill | Status | Description |
  125. |---|---|---|
  126. | **[uipath-core](./uipath-core/)** | **Released** | XAML generation, REFramework scaffolding, selector generation, lint validation, plugin loader |
  127. | **[uipath-tasks](./uipath-tasks/)** | **Released** | Form Tasks, External Tasks, and Task Management activities for human-in-the-loop, system-in-the-loop, and recovery workflows |
  128. | uipath-sap-wingui | Planned | SAP GUI for Windows automation |
  129. | uipath-du | Planned | Document Understanding — taxonomy, extraction, classification, and validation pipelines |
  130. `uipath-core` is the required base. Additional skills are plugins that extend the core through `plugin_loader.py` — they register their own generators, lint rules, scaffold hooks, namespaces, and known activities, and the core engine auto-discovers them at runtime.
  131. ---
  132. ## Plugin architecture
  133. uipath-ai-skills has two distinct extension surfaces — keep them straight when you're authoring or installing plugins.
  134. **Marketplace manifest** — `.claude-plugin/marketplace.json`. Declares each plugin's name and skill path for Claude Code's `/plugin install` command. This is the install/discovery surface only.
  135. **Runtime loader** — `uipath-core/scripts/plugin_loader.py`. At import time, scans every sibling directory of `uipath-core/` for an `extensions/__init__.py` package. Each plugin's `__init__.py` registers its contributions through the loader's API. Core scripts (`generate_workflow.py`, `validate_xaml`, `scaffold_project.py`, `resolve_nuget.py`, etc.) query the registries when they run.
  136. A plugin can register:
  137. - **Generators** — XAML emitters for new activity types
  138. - **Lint rules** — validators that run as part of `validate_xaml`
  139. - **Scaffold hooks** — `project.json` mutators that run after `scaffold_project.py` creates a project
  140. - **Namespaces** — XML namespace bindings for plugin activities
  141. - **Known / key activities** — IdRef and DisplayName requirements
  142. - **Hallucination patterns** — common LLM error → corrected form mappings
  143. - **Common packages** — NuGet packages picked up by `resolve_nuget.py --all`
  144. - **Type mappings** — short type aliases for plugin types
  145. - **Variable prefixes** — naming-convention hints for variables of plugin types
  146. - **Battle-test graders** — automated grading functions for plugin-specific suites
  147. - **Generator test specs** and **lint test fixtures** — regression coverage that the core test runner picks up automatically
  148. ### Writing your own plugin
  149. The reference implementation is `uipath-tasks/extensions/__init__.py`. The minimal layout:
  150. ```
  151. your-plugin/ # sibling directory of uipath-core/
  152. ├── SKILL.md # skill routing table for the LLM
  153. ├── extensions/
  154. │ ├── __init__.py # registers your contributions
  155. │ ├── generators.py
  156. │ └── lint_rules.py
  157. ├── references/ # docs the LLM reads as context
  158. └── assets/
  159. ├── generator-snapshots/ # golden XAML for your generators
  160. └── lint-test-cases/ # bad/good XAML for your lint rules
  161. ```
  162. A typical `extensions/__init__.py`:
  163. ```python
  164. from plugin_loader import (
  165. register_generator, register_lint, register_namespace,
  166. register_known_activities,
  167. )
  168. from .generators import gen_my_activity
  169. from .lint_rules import lint_my_rules
  170. register_namespace("mypfx", "clr-namespace:My.Namespace;assembly=My.Assembly")
  171. register_generator("my_activity", gen_my_activity, display_name="MyActivity")
  172. register_lint(lint_my_rules, "lint_my_plugin")
  173. register_known_activities("MyActivity")
  174. ```
  175. To make it installable through Claude Code, add an entry to `.claude-plugin/marketplace.json`.
  176. ---
  177. ## Built-in best practices
  178. The skill doesn't just generate valid XAML — it enforces the patterns that experienced UiPath developers apply manually:
  179. - **Modular decomposition** — one workflow per action, organized in `Workflows/<AppName>/` subfolders. Main.xaml orchestrates via `InvokeWorkflowFile` and never contains business logic directly.
  180. - **Config-driven everything** — URLs, credential asset names, queue names, and application settings live in Config.xlsx. Nothing is hardcoded in workflows.
  181. - **Credential security** — passwords are always `SecureString`, never `String`. `GetRobotCredential` is called inside the Launch workflow at minimal scope — never in InitAllApplications, never passed as arguments between workflows.
  182. - **REFramework architectural discipline** — InitAllApplications opens all apps and gets them to a ready state. Process.xaml and action workflows are attach-only (`OpenMode="Never"`). SetTransactionStatus is never modified. Login stays inside `AppName_Launch.xaml`.
  183. - **Browser discipline** — incognito mode by default, one browser instance per web app, no logout actions (close the browser instead). Navigates by URL (`NGoToUrl` with Config-driven URLs) instead of fragile UI click-paths whenever the target page has a direct URL.
  184. - **Selector standards** — strict selectors over fuzzy, single-quoted attributes, dynamic selectors via Config for environment-dependent values.
  185. - **Naming conventions** — type-prefixed variables (`strName`, `dt_Report`), direction-prefixed arguments (`in_strUrl`, `out_boolSuccess`), PascalCase workflows with app prefixes (`ACME_Login.xaml`).
  186. These are highlights — the skill encodes additional rules covering API retry patterns, extraction/filtering separation, queue dispatch patterns, and error handling hierarchy. See `uipath-core/references/rules.md` for the full set.
  187. ---
  188. ## Activity coverage
  189. Generators cover the core categories you reach for on real projects.
  190. <details>
  191. <summary><strong>View activity categories</strong></summary>
  192. | Category | Activities |
  193. |---|---|
  194. | **UI Automation** | NClick, NTypeInto, NSelectItem, NGetText, NCheckState, NCheck, NHover, NDoubleClick, NRightClick, NKeyboardShortcuts, NMouseScroll |
  195. | **Application Card** | Open, Attach, Close, Desktop Open |
  196. | **Navigation** | NGoToUrl, NGetUrl, NExtractData, Pick (login validation) |
  197. | **Control Flow** | If, If/ElseIf, ForEach, ForEach Row, ForEach File, While, DoWhile, Switch, Flowchart, StateMachine, Parallel, ParallelForEach |
  198. | **Data Operations** | Assign, MultipleAssign, BuildDataTable, Add Row/Column, Filter, Sort, Join, Lookup, Merge, Output, Remove Column / Duplicates, Generate, Variables Block |
  199. | **Dialogs** | InputDialog, MessageBox |
  200. | **Error Handling** | TryCatch, Throw, Rethrow, RetryScope |
  201. | **File System** | Copy, Move, Delete, Create Directory, Path Exists, Read/Write Text, Read/Write CSV |
  202. | **HTTP / JSON** | NetHttpRequest, DeserializeJson |
  203. | **Integrations** | Excel (Read/Write/Append/Cell), Email (IMAP, SMTP, attachments), PDF (text + OCR), Database (Connect/Query/NonQuery) |
  204. | **Invoke** | InvokeWorkflowFile, InvokeCode, InvokeMethod |
  205. | **Logging & Misc** | LogMessage, Comment, CommentOut, Break, Continue, KillProcess, Add/Remove Log Fields, ShouldStop, TakeScreenshot, TerminateWorkflow |
  206. | **Orchestrator** | AddQueueItem, BulkAddQueueItems, GetQueueItem, GetRobotAsset, GetRobotCredential |
  207. | **Tasks plugin** | CreateFormTask, WaitForFormTaskAndResume, GetFormTasks, CreateExternalTask, WaitForExternalTaskAndResume, CompleteTask, AssignTasks |
  208. </details>
  209. ---
  210. ## Validation pipeline
  211. Lint rules are organized by severity and target the patterns where LLMs most often generate incorrect XAML. Plugins extend the rule set at runtime.
  212. | Severity | What it catches | Examples |
  213. |---|---|---|
  214. | **ERROR** | Studio crashes and compile failures | Hallucinated enum values, missing `xmlns` declarations, wrong child elements, non-existent properties |
  215. | **WARN** | Runtime failures and silent data loss | Wrong enum namespace, empty Out argument bindings, type mismatches, C# syntax in VB.NET Throw expressions |
  216. | **INFO** | Best practices and architecture | Missing log bookends, hardcoded URLs, credentials passed as arguments, missing RetryScope on API calls |
  217. ```bash
  218. python3 uipath-core/scripts/validate_xaml <project_or_file> --lint # check
  219. python3 uipath-core/scripts/validate_xaml <project_or_file> --lint --fix # auto-fix common issues
  220. ```
  221. <details>
  222. <summary><strong>What the lint rules catch</strong></summary>
  223. **Hallucination prevention:**
  224. - Non-existent properties (`NApplicationCard.Url`, `NCheckState.Appears`, `NTypeInto.EmptyField`)
  225. - Invalid enum values that crash Studio (`Version="V3"`, `ElementType="InputBoxText"`)
  226. - Placeholder file paths (`C:\path\to\app.exe`)
  227. - Hallucinated activity names and namespace prefixes
  228. **Activity-specific validation:**
  229. - NTypeInto, NClick, NCheckState, NSelectItem, NGetText property correctness
  230. - DataTable operation type consistency and FilterOperator enum validation
  231. - REFramework structure rules (GetQueueItem/SetTransactionStatus patterns)
  232. - Selector syntax validation and app/screen/element hierarchy checks
  233. **Production safety:**
  234. - Credentials must use `GetRobotCredential` (never passed as arguments)
  235. - API/network calls wrapped in RetryScope
  236. - URLs sourced from Config.xlsx (never hardcoded)
  237. - Browser defaults enforced (IsIncognito, InteractionMode)
  238. **Plugin-contributed (uipath-tasks):**
  239. - AC-10 / AC-11 / AC-12 — Form/External Task Create-Wait pairing and FormData key validation
  240. - AC-26 — Persistence activities must stay in Main.xaml
  241. </details>
  242. ---
  243. ## Verification
  244. ```bash
  245. # Lint validation
  246. python3 uipath-core/scripts/validate_xaml <project_folder> --lint
  247. # Run all test suites
  248. python3 uipath-core/scripts/test_all.py
  249. # Individual suites
  250. python3 uipath-core/scripts/run_lint_tests.py # lint rule fixtures
  251. python3 uipath-core/scripts/regression_test.py # regression suite
  252. python3 uipath-core/scripts/test_generator_snapshots.py # generator snapshots
  253. python3 uipath-core/scripts/test_cross_plugin.py # plugin loading + registration
  254. python3 uipath-core/scripts/test_generator_lint_integration.py # generator + lint integration
  255. python3 uipath-core/scripts/test_auto_fix.py # auto-fix validation
  256. python3 uipath-core/scripts/test_dependency_graph.py # workflow dependency analysis
  257. # Scaffold a test project
  258. python3 uipath-core/scripts/scaffold_project.py --name "test-project" --variant performer --output <output-dir>
  259. # Resolve latest NuGet package versions
  260. python3 uipath-core/scripts/resolve_nuget.py --all
  261. # Validate Config.xlsx keys against XAML references
  262. python3 uipath-core/scripts/config_xlsx_manager.py validate <project_folder>
  263. # Battle-test grading (semi-automated)
  264. python3 uipath-core/scripts/grade_battle_test.py <project_dir> --suite core --scenario 1 # uipath-core
  265. python3 uipath-core/scripts/grade_battle_test.py <project_dir> --suite ac --scenario 1 # uipath-tasks
  266. ```
  267. Battle-test scenarios live in `uipath-core/evals/core-battle-tests.md` and `uipath-tasks/evals/tasks-battle-tests.md`. The grader auto-checks the deterministic checkpoints; the rest are manual Studio verification.
  268. ---
  269. ## Platform support
  270. | Capability | Environment |
  271. |---|---|
  272. | Generate / scaffold projects | Python 3.10+ — cross-platform |
  273. | Open generated projects | UiPath Studio 2024.10+ on Windows (older versions may work) |
  274. | Web selector generation | Playwright MCP — cross-platform |
  275. | Desktop selector generation | Windows + PowerShell |
  276. | Config.xlsx management | Python + `openpyxl` — cross-platform |
  277. ### Prerequisites
  278. | Dependency | Notes |
  279. |---|---|
  280. | **Python 3.10+** | Core scripts use stdlib only |
  281. | **`openpyxl`** *(optional)* | `pip install openpyxl` — for Config.xlsx operations |
  282. | **Claude Opus or Claude Sonnet** *(recommended)* | Opus delivers best results for new projects. Sonnet is great for updates to existing projects. Smaller models hallucinate more on complex projects. Works with other LLMs such as OpenAI GPT |
  283. | **Node.js 18+** *(optional)* | For running Playwright MCP server |
  284. | **Playwright MCP** *(optional)* | For live web app inspection and selector generation |
  285. ### Setting up selector generation (optional)
  286. Selector generation connects your agent to live applications. Without it, the skill still generates full projects — you'll just need to fill in selectors manually in Studio.
  287. <details>
  288. <summary><strong>Web selectors (Playwright MCP)</strong></summary>
  289. 1. Add Playwright MCP to your agent's config — the server command is `npx @playwright/mcp@latest`. See [Playwright MCP docs](https://github.com/microsoft/playwright-mcp) for the exact JSON snippet per agent.
  290. 2. The skill opens a browser automatically and navigates to the target URL
  291. 3. Inspection is **read-only** — the agent never types credentials or submits forms
  292. </details>
  293. <details>
  294. <summary><strong>Desktop selectors (inspect-ui-tree.ps1)</strong></summary>
  295. 1. The agent opens the target desktop app (or asks permission to open it)
  296. 2. The agent runs the script directly via PowerShell to capture the UIA element tree
  297. 3. Works with WPF, Win32, WinForms, DirectUI, UWP. Inspection is **read-only**
  298. No setup needed — `inspect-ui-tree.ps1` ships with `uipath-core/scripts/`.
  299. </details>
  300. ---
  301. ## Key design decisions
  302. **XAML is never hand-written.** All XAML is produced by deterministic Python generators. This eliminates the #1 source of errors: LLM hallucination of XML structures, enum values, and namespace declarations.
  303. **JSON specs as intermediate format.** LLMs are good at JSON. LLMs are bad at XML. The JSON spec format lets the agent describe *what* it wants while generators handle the complex XAML structure.
  304. **Real templates, not invented ones.** Every template in `uipath-core/assets/` is a genuine UiPath Studio 24.10+ export. Nothing was constructed from documentation or memory.
  305. **Lint rules target LLM hallucination patterns.** The lint rules aren't generic XML validators — they specifically catch the mistakes LLMs make when generating UiPath XAML.
  306. **Plugin architecture for extensibility.** Domain-specific capabilities (Tasks, and future plugins) are added as sibling directories that register their own generators, lint rules, and scaffold hooks via `plugin_loader.py` — without modifying core code.
  307. ---
  308. ## Limitations
  309. - Tested against **UiPath Studio 2024.10+ Windows** with **Modern UI Automation** activities
  310. - Output quality depends on PDD clarity and scope — the agent will ask clarifying questions when instructions are vague, but more detailed PDDs produce better workflows
  311. - Live web selector generation requires Playwright MCP setup; desktop inspection requires PowerShell on Windows. Without these, selectors need manual completion in Studio
  312. - Desktop inspection is **Windows-only** (UIA is a Windows API)
  313. - Browser inspection is **read-only** and stops at login gates — it cannot type credentials or navigate past authentication
  314. - Not every arbitrary PDD converts perfectly without iteration and refinement
  315. - The tool does not invent real credentials, API keys, or perform login on the user's behalf
  316. ---
  317. ## Troubleshooting
  318. **`ModuleNotFoundError: No module named 'openpyxl'`** — Run `pip install openpyxl`. Needed for Config.xlsx operations.
  319. **NuGet resolution fails / times out** — Needs outbound HTTPS to `pkgs.dev.azure.com`. Falls back to cached versions if blocked.
  320. **MCP server not found** — Check your agent's MCP config. For web apps, Playwright MCP is used for live selector inspection. Without it, the skill still generates projects — selectors will need manual completion in Studio.
  321. **Inspection stops at login page** — Browser inspection is read-only and cannot type credentials. Log in manually first, then have the skill inspect the authenticated page.
  322. **Generated project won't open in Studio** — Ensure your Studio version supports Modern activities. Run `python3 uipath-core/scripts/validate_xaml <project> --lint` to identify specific issues.
  323. **Plugin not loading / generator missing** — `uipath-tasks` (and any plugin) must live as a **sibling directory** to `uipath-core`. The loader scans for `extensions/__init__.py` in sibling directories; if you copy plugins to a different layout, runtime discovery breaks. Run `python3 uipath-core/scripts/test_cross_plugin.py` to verify the loader sees your plugin.
  324. ---
  325. ## Project structure
  326. <details>
  327. <summary><strong>View directory tree</strong></summary>
  328. ```
  329. uipath-ai-skills/
  330. ├── README.md
  331. ├── CONTRIBUTING.md
  332. ├── CHANGELOG.md
  333. ├── LICENSE
  334. ├── assets/ # README banner and shared imagery
  335. ├── .claude-plugin/
  336. │ └── marketplace.json # plugin marketplace manifest
  337. │
  338. ├── uipath-core/ # required base plugin
  339. │ ├── SKILL.md # skill routing table
  340. │ ├── requirements.txt
  341. │ ├── evals/
  342. │ │ └── core-battle-tests.md
  343. │ ├── references/ # XAML, expressions, selectors, lint, etc.
  344. │ ├── scripts/
  345. │ │ ├── generate_workflow.py # JSON spec → validated XAML (entry point)
  346. │ │ ├── generate_activities/ # deterministic generators by category
  347. │ │ ├── validate_xaml/ # lint suite + auto-fix
  348. │ │ ├── scaffold_project.py # project scaffolding (sequence/dispatcher/performer)
  349. │ │ ├── modify_framework.py # framework wiring + variable injection
  350. │ │ ├── resolve_nuget.py # live NuGet version resolution
  351. │ │ ├── generate_object_repository.py
  352. │ │ ├── config_xlsx_manager.py
  353. │ │ ├── plugin_loader.py # plugin discovery + registration API
  354. │ │ ├── dependency_graph.py # workflow dependency analysis
  355. │ │ ├── grade_battle_test.py # semi-automated battle test grader
  356. │ │ ├── inspect-ui-tree.ps1 # desktop UIA inspector
  357. │ │ ├── test_all.py # runs every test suite
  358. │ │ ├── run_lint_tests.py
  359. │ │ ├── regression_test.py
  360. │ │ ├── test_generator_snapshots.py
  361. │ │ ├── test_cross_plugin.py
  362. │ │ ├── test_generator_lint_integration.py
  363. │ │ ├── test_auto_fix.py
  364. │ │ └── test_dependency_graph.py
  365. │ └── assets/
  366. │ ├── reframework/ # clean REFramework template (Studio 24.10)
  367. │ ├── simple-sequence-template/ # sequence scaffold template
  368. │ ├── simple-sequence/ # sequence golden samples
  369. │ ├── samples/ # common workflow patterns
  370. │ ├── stripped/ # minimal XAML templates for generators
  371. │ ├── generator-snapshots/ # generator regression fixtures
  372. │ └── lint-test-cases/ # bad/good XAML lint fixtures
  373. │
  374. └── uipath-tasks/ # released plugin — Tasks (HITL / external / management)
  375. ├── SKILL.md
  376. ├── references/
  377. │ ├── form-tasks.md
  378. │ ├── external-tasks.md
  379. │ └── task-management.md
  380. ├── evals/
  381. │ └── tasks-battle-tests.md
  382. ├── extensions/ # auto-discovered by plugin_loader at import time
  383. │ ├── __init__.py # registers generators, lints, hooks, namespaces
  384. │ ├── generators.py
  385. │ ├── lint_rules.py
  386. │ ├── scaffold_hooks.py
  387. │ └── battle_test_grading.py
  388. └── assets/
  389. ├── generator-snapshots/
  390. └── lint-test-cases/
  391. ```
  392. </details>
  393. ---
  394. ## Contributing
  395. See [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines. Contributions welcome — especially bug reports with Studio error messages, golden XAML samples from real exports, and new lint rules for hallucination patterns. See [CHANGELOG.md](./CHANGELOG.md) for release history.
  396. ---
  397. ## License
  398. [MIT License](./LICENSE)
  399. ---
  400. ## Contributors
  401. Thanks to all contributors:
  402. <a href="https://github.com/marcelocruzrpa/uipath-ai-skills/graphs/contributors">
  403. <img src="https://contrib.rocks/image?repo=marcelocruzrpa/uipath-ai-skills" />
  404. </a>
  405. ---
  406. ## Author
  407. Built by [Marcelo Cruz](https://www.linkedin.com/in/marcelo-cruz-rpa/) — UiPath MVP.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.