@uipath/skills 1.199.0 → 1.200.0

package/skills/uipath-rpa/references/coded/coding-guidelines.md

@@ -1,255 +0,0 @@
-# Coding Guidelines Reference
-
-Detailed coding rules, best practices, anti-patterns, and troubleshooting for UiPath coded workflows.
-
-## Using Statements Rules
-
-**CRITICAL: Only include `using` statements for namespaces actually used in the file.** Adding usings for packages not in `project.json` will cause compile errors.
-
-**Minimal using statements** (always safe in any workflow/test case file):
-```csharp
-using System;
-using System.Collections.Generic;
-using UiPath.CodedWorkflows;
-```
-
-**Add based on actual usage** — only include these when the file uses the corresponding types/services AND the package is in `project.json`:
-```csharp
-// If using system.* service (UiPath.System.Activities package):
-using UiPath.Core;
-using UiPath.Core.Activities.Storage;       // only if using storage APIs
-using UiPath.Orchestrator.Client.Models;    // only if using Orchestrator models
-
-// If using testing.* service (UiPath.Testing.Activities package):
-using UiPath.Testing;
-using UiPath.Testing.Enums;                 // only if using testing enums
-using UiPath.Testing.Activities.TestData;   // only if using test data queues
-
-// If using uiAutomation.* service (UiPath.UIAutomation.Activities package):
-using UiPath.UIAutomationNext.API.Contracts;
-using UiPath.UIAutomationNext.API.Models;
-using UiPath.UIAutomationNext.Enums;
-
-// If using Object Repository descriptors (Descriptors.App.Screen.Element):
-using <ProjectNamespace>.ObjectRepository;  // e.g. using RoboticEnterpriseFramework.ObjectRepository;
-// OR if descriptors come from a UILibrary NuGet package (not the project's own OR):
-// using <PackageNamespace>.ObjectRepository;  // e.g. using MultipleApps.Descriptors.ObjectRepository;
-// CRITICAL: Without this, you get CS0103: The name 'Descriptors' does not exist in the current context
-// NOTE: When descriptors come from a UILibrary package, use the PACKAGE namespace, not the project namespace
-
-// If using excel.* service (UiPath.Excel.Activities package):
-using UiPath.Excel;
-using UiPath.Excel.Activities;
-using UiPath.Excel.Activities.API;
-using UiPath.Excel.Activities.API.Models;
-
-// If using word.* service (UiPath.Word.Activities package):
-using UiPath.Word;
-using UiPath.Word.Activities;
-using UiPath.Word.Activities.API;
-using UiPath.Word.Activities.API.Models;
-
-// If using powerpoint.* service (UiPath.Presentations.Activities package):
-using UiPath.Presentations;
-using UiPath.Presentations.Activities;
-using UiPath.Presentations.Activities.API;
-using UiPath.Presentations.Activities.API.Models;
-
-// If using mail.* service (UiPath.Mail.Activities package):
-using UiPath.Mail.Activities.Api;
-
-// If using office365.* service (UiPath.MicrosoftOffice365.Activities package):
-using UiPath.MicrosoftOffice365.Activities.Api;
-
-// If using google.* service (UiPath.GSuite.Activities package):
-using UiPath.GSuite.Activities.Api;
-
-// Standard .NET (add as needed):
-using System.Data;           // DataTable
-using System.Linq;           // LINQ
-using System.IO;             // file operations
-using System.Text.RegularExpressions;  // regex
-```
-
-**When adding a file that uses a service:**
-1. Check `project.json` to confirm the required package is listed in `dependencies` — add it if missing
-2. Add only the `using` statements needed for the types actually referenced in the file
-3. Add the entry point to `project.json` (**Process projects only** — Tests and Library projects do not use `entryPoints`). Add `fileInfoCollection` for test case files (all project types)
-
-## Platform types — do not reinvent
-
-UiPath ships first-class types for the patterns coded workflows most commonly need (exceptions, queue items, credentials, OR descriptors). **Always import the platform type instead of defining a project-local equivalent.** A project-local `BusinessRuleException`, custom queue-item record, or hand-rolled credential helper diverges from Orchestrator behaviour and breaks integration with platform features that expect the canonical types.
-
-| Platform type | Namespace / package | Use for | Do NOT do this instead |
-|---|---|---|---|
-| **`UiPath.Core.BusinessRuleException`** | `UiPath.Core` (in `UiPath.System.Activities`) | Business-rule violations that must NOT be retried by REFramework / Orchestrator (e.g., invalid input data, validation failure, missing required field). Orchestrator marks the queue item as `Failed` with no retry. | Define a project-local `class BusinessRuleException : Exception { … }`. |
-| **`UiPath.Robot.Activities.BusinessException`** | `UiPath.Robot.Activities` | Same role as `BusinessRuleException` in robot-side custom activity packages. | Same — do not define your own. |
-| **`UiPath.Core.Activities.Storage.IResource` / `ILocalResource`** | `UiPath.Core.Activities.Storage` (in `UiPath.System.Activities`) | File / folder handles passed to activities that need an `IResource`. | Pass raw `string` paths or hand-roll a `LocalResource` constructor (the constructor is internal — see § IResource / ILocalResource below). |
-| **`UiPath.Orchestrator.Client.Models.QueueItemDto`** and related | `UiPath.Orchestrator.Client.Models` (in `UiPath.System.Activities`) | Queue-item shape returned by `GetTransactionItem` / pushed via `AddQueueItem`. | Define a project-local queue-item record that diverges from Orchestrator's schema. |
-| **OR descriptors `Descriptors.<App>.<Screen>.<Element>`** | Generated into `<PROJECT_DIR>/.local/.codedworkflows/ObjectRepository.cs` | UI element targeting in coded UI automation. | Hand-roll selector strings or `TargetAppModel` instances; bypass the Object Repository. |
-| **`UiPath.CodedWorkflows.CodedWorkflow`** | `UiPath.CodedWorkflows` (built into the runtime) | Base class for `[Workflow]` and `[TestCase]` classes. | Inherit from a custom base; the Studio wrapper generation depends on this exact type. |
-
-### Throwing `BusinessRuleException` correctly
-
-```csharp
-using UiPath.Core;     // brings BusinessRuleException into scope
-
-if (!System.Text.RegularExpressions.Regex.IsMatch(hash, @"^[0-9a-f]{40}$"))
-{
-    throw new BusinessRuleException(
-        $"Computed hash '{hash}' does not match expected SHA1 format (40 lowercase hex chars).");
-}
-```
-
-`BusinessRuleException` is recognised by REFramework's `SetTransactionStatus` and by Orchestrator's queue-item lifecycle — items failed with this exception are marked **Failed** and not retried automatically. A project-local exception with the same name is just an `Exception` from REFramework's point of view and triggers the system-error retry path instead.
-
-### When you MAY define a project-local type
-
-Project-local types are appropriate for **domain DTOs** that have no platform equivalent — `InvoiceLineItem`, `CustomerRecord`, `WorkItem` — and belong in Coded Source Files. The rule above applies to platform-provided types only: do not reinvent exceptions, queue-item shapes, credential handles, file-resource handles, or OR descriptors.
-
-## Coded Workflow Analyzer Rules
-
-Four built-in Workflow Analyzer rules with scope `Coded Workflow` run as Roslyn analyzers over the project's `.cs` files. All four are **Error** severity and enabled by default — a violation fails `uip rpa analyze`, `build`, and `pack`, and Studio flags the same violations as validation errors. Author to satisfy them up front:
-
-| Rule | Trigger | Fix |
-|------|---------|-----|
-| **ST-NMG-017** — Class name matches default namespace | A class declared inside the project's default namespace has the same name as that namespace (generated from the project name) — e.g. class `Invoicing` in project `Invoicing`. Applies to every class, including Coded Source Files. | Rename the class (and its file to match) — e.g. `InvoicingWorkflow` |
-| **ST-DBP-010** — Multiple `[Workflow]`/`[TestCase]` | More than one `[Workflow]` or `[TestCase]` attribute in the same **file** (the two attribute kinds count together) | One entry-point attribute per file — move each extra entry point to its own file |
-| **ST-REL-001** — Mismatched InOut argument types | An entry-point input parameter collapses into an InOut argument (its name matches a return-tuple element, or it is literally named `Output` with a single non-void return) but the input and returned types differ | Make the input parameter type and the returned type identical |
-| **ST-USG-017** — Invalid parameter modifier | `out` or `ref` modifier on a `[Workflow]`/`[TestCase]` method parameter | Use return values or tuples for outputs instead |
-
-> Older CLI versions listed these rules in `analyzer-rules list` but did not execute them headlessly — only Studio flagged the violations. Do not treat a clean `analyze`/`build`/`pack` from an older CLI as proof these rules pass; fix violations at authoring time regardless.
-
-## Best Practices
-
-### API Discovery
-- **ALWAYS search for existing .cs files BEFORE generating new code** — Learn from existing patterns
-- Read at least 5 existing workflow files (or all if fewer) to understand project conventions
-- **When writing UI automation code** — the UIA package guide (`{PROJECT_DIR}/.local/docs/packages/UiPath.UIAutomation.Activities/ui-automation-guide.md`) MUST be read IN FULL first (SKILL.md Rule 7). Follow its **Finding Descriptors** hierarchy in strict order. Do NOT write any UI code until descriptors are resolved:
-  1. Read `ObjectRepository.cs` — use existing descriptors if present
-  2. Inspect UILibrary/descriptor NuGet packages in `project.json` (e.g. `*.Descriptors`, `*.UILibrary`) using `uip rpa packages inspect`. The tool checks the local NuGet cache automatically. If the package is still not found, read `.metadata` files manually at `~/.nuget/packages/<package-name>/<version>/contentFiles/any/any/.objects/` to discover App/Screen/Element hierarchy
-  3. If descriptors are still missing — use the `uia-configure-target` skill flow (found in the UIA activity-docs) to create targets. This handles capturing the application, discovering elements, generating selectors, improving them, and registering them in the OR. Do NOT manually call the internal `uip rpa uia` CLIs outside of the skill flow. Fallback: the indication commands (see UIA docs) when elements appear only after user interaction (e.g., a compose form that opens after clicking a button)
-  4. UITask (ScreenPlay) is ONLY for when selectors are genuinely brittle/unreliable — NEVER as a first approach
-  5. NEVER bypass Object Repository by constructing `TargetAppModel` with raw URL/BrowserType
-- Use `uip rpa packages inspect` for API discovery when documentation is unclear
-
-### IResource / ILocalResource — Converting File Paths
-
-Many activities (O365, GSuite, Mail, file operations) require `IResource` or `ILocalResource` instead of a string path. NEVER pass a raw string where `IResource` is expected — it will fail at runtime. NEVER try to construct `LocalResource(string)` directly — the constructor is internal.
-
-| Method | Signature | Use when |
-|--------|-----------|----------|
-| `GetResourceForLocalPath` | `system.GetResourceForLocalPath(string path, PathType pathType)` → `IResource` | You have a path and need an `IResource` (no existence check needed) |
-| `PathExists` (with out param) | `system.PathExists(string path, PathType pathType, out ILocalResource resource)` → `bool` | You need to verify the file exists AND get an `ILocalResource` |
-
-```csharp
-// Direct conversion — preferred when you know the file exists
-IResource file = system.GetResourceForLocalPath(@"C:\Reports\report.pdf", PathType.File);
-IResource folder = system.GetResourceForLocalPath(@"C:\Archive", PathType.Folder);
-
-// With existence check
-if (system.PathExists(@"C:\Reports\report.pdf", PathType.File, out ILocalResource localFile))
-{
-    // use localFile
-}
-```
-
-`PathType` values: `PathType.File`, `PathType.Folder`
-
-### Code Quality
-- **Start simple, iterate** — Create minimal working version first, then refine
-- **NEVER use C# `out` or `ref` keywords in `[Workflow]` methods** — The auto-generated `*+Activity.cs` wrapper does not handle them correctly. Symptoms: analyzer error ST-USG-017 at `analyze`/`build`/`pack`, compile error `CS1620`, or runtime `Using 'out' and 'ref' modifiers is not allowed for Coded Workflows executions.` Studio regenerates the wrapper on every save, so manual fixes are reverted. Use return values or tuples for outputs instead
-- **Only include using statements for packages in project.json** — Adding unused usings causes compile errors
-- **Match input parameter names exactly** — Execute method signature must match `--input` arguments (case-sensitive)
-- **Escape backslashes in paths** — Use `C:\\path\\file.txt` not `C:\path\file.txt` in input arguments
-
-### Validation Loop (Critical Rule #14)
-uip rpa validate --file-path "<FILE>" --project-dir "<PROJECT_DIR>" --output json
-@../validation-guide.md
-
-### Error Handling
-- **Fix compilation errors methodically** — Categorize: Syntax → Type → Logic. Use the validation loop above to iterate until clean.
-- **Retry on execution failures** — Attempt to fix and retry up to 2 times before asking user
-- **Analyze errors carefully** — Read error messages, identify root cause, make targeted fixes
-- **Fix one thing at a time** — When a runtime error occurs, identify the root cause, fix ONLY that, and re-run. Never bundle a speculative "improvement" (e.g., switching from TypeInto to KeyboardShortcut) with the actual fix (e.g., correcting a selector). Changing two things at once makes it impossible to verify which change resolved the issue — or whether the speculative change introduced a new one.
-- **Don't give up too early** — But stop after 2 failed retries and present the user with options:
-```
-Workflow execution failed after 2 retry attempts.
-
-**Error Details:** <specific error message and location>
-**Suggested Fix:** <analysis of what went wrong>
-**Next Steps:** Would you like me to:
-A) <recommended fix approach>
-B) <alternative approach>
-C) <user-driven approach>
-```
-
-### File Operations
-- **ALWAYS use Read tool before Edit tool** — Understand current state before making changes
-- **Prefer editing over creating new files** — Build on existing work, avoid file bloat
-- **Use Glob for file discovery** — Never guess file locations
-
-## Anti-Patterns (What NOT to Do)
-
-> Many of these reinforce SKILL.md Critical Rules. They are grouped by category for quick scanning.
-
-### Project & Code Structure
-
-- Never manually write `project.json` or `project.uiproj` when creating a new project — use `uip rpa init` (Critical Rule #1)
-- Never generate C# code without first searching for existing .cs files (API Discovery)
-- Never edit files without reading them first
-- Never skip the `[Workflow]` or `[TestCase]` attribute on the Execute method (Critical Rule #4)
-- Never put more than one `[Workflow]`/`[TestCase]` attribute in the same file — analyzer error ST-DBP-010 (see § Coded Workflow Analyzer Rules)
-- Never name a class the same as the project — analyzer error ST-NMG-017 (see § Coded Workflow Analyzer Rules)
-- Never forget to inherit from `CodedWorkflow` (except Coded Source Files) (Critical Rule #3)
-- Never add `using` statements for packages not in `project.json` — causes CS errors
-- Never guess service method names — verify with existing code or `uip rpa packages inspect`
-
-### UI Automation
-
-- Never hardcode UI selectors — use Object Repository descriptors
-- Never write UI code referencing descriptors without first reading `ObjectRepository.cs`
-- Never manually craft UI selectors by calling the internal `uip rpa uia` CLIs outside of the `uia-configure-target` skill flow — this skips selector improvement and OR registration
-- Never skip the target configuration step when a descriptor is missing — use the `uia-configure-target` skill flow (fallback: indication commands per the UIA docs)
-- Never use UITask (ScreenPlay) as the primary approach — resolve descriptors via Finding Descriptors hierarchy first (Critical Rule #15)
-- Never skip configuring targets because it "seems tedious" — configure ALL missing elements
-- Never construct `TargetAppModel` with raw URL/BrowserType to bypass Object Repository
-- Never skip checking UILibrary/descriptor NuGet packages in `project.json`
-- Never use an element descriptor on the wrong screen handle — each `UiTargetApp` is bound to its screen. Wrong handle gives `"Target name 'X' is not part of the current screen."`
-- Never use `SelectItem` on web dropdowns without a `TypeInto` fallback — web `<select>` elements often fail with `"Cannot select item"`
-- Never forget `using <ProjectNamespace>.ObjectRepository;` (or `using <PackageName>.ObjectRepository;` for UILibrary packages) when referencing `Descriptors.*`
-
-### Object Repository / Indicate Commands
-
-- Never assume `.objects/` subdirectories mean a valid App exists — verify `.metadata` files are present
-- Never cache or reuse AppVersion references across OR resets — always re-read `.objects/` metadata
-- Never run indicate commands from outside the project directory — cwd must contain `project.json`
-- Never use camelCase flags — all `uip rpa` CLI flags use kebab-case (e.g., `--foo-bar`, not `--fooBar`)
-
-### Validation & Execution
-
-- Never assume create/edit succeeded without running the validation loop (Critical Rule #14)
-- Never continue retrying indefinitely — stop after 5 validation fix attempts or 2 runtime execution retries
-- Never make unrelated changes during retry — identify the root cause, fix only that, re-run and verify. Never bundle a speculative "improvement" with the actual fix (e.g., fixing a broken selector AND switching from TypeInto to KeyboardShortcut in the same edit). One change, one re-run.
-- Never execute a workflow with parameters without providing `--input` arguments
-- Never use parameter names in `--input` that don't match the Execute method signature (case-sensitive)
-
-### Shell & Environment
-
-- Never redirect output to `nul` — use `> /dev/null 2>&1` instead (`nul` creates a literal file on Windows)
-- Never use Windows shell commands (`del`, `dir`, `copy`) in bash — use `rm`, `ls`, `cp`
-
-## Common Issues and Fixes
-
-| Issue | Cause | Fix |
-|-------|-------|-----|
-| **"Studio X.X.X does not have interop support"** | Surfaces only when running against Studio Desktop and the auto-detected install is too old (< 26.2). Headless Studio is unaffected. | Pass `--studio-dir "<STUDIO_DIR>"` pointing to a 26.2+ build, or drop the Studio Desktop override and let the command run headless |
-| **No Studio instances found** | Only relevant for `diff` / `focus-activity` — they need Studio Desktop. Every other command runs headless and doesn't need a Desktop instance. | Run `uip rpa studio start --project-dir "<PROJECT_DIR>"` if you actually need Studio Desktop; otherwise re-run the command — headless Studio relaunches automatically |
-| **Stale pipe / ENOENT** | Studio instance crashed or was closed | The tool retries automatically; if persistent, re-run the command (headless) or restart Studio Desktop |
-| **Workflow cannot be found** | Entrypoint not in project.json | Verify project.json entrypoint has the file listed (Process projects only — Tests and Library projects do not use `entryPoints`) |
-| **Service property not available** | Missing package dependency | Install the required package via `uip rpa packages install --project-dir "<PROJECT_DIR>" --packages id=<PACKAGE_ID> --output json` (no `add-dependency` command exists; do not hand-edit `project.json`) |
-| **Timeout** | Studio took too long to start. First headless call on a cold NuGet cache can take 30–90 s. | Increase timeout: `--timeout 600` |
-| **"Target name 'X' is not part of the current screen"** | Element descriptor used on wrong screen handle | Use the `UiTargetApp` handle from `Open`/`Attach` for the screen that owns the element |
-| **"Cannot select item. It was not found among existing items"** | The `Item` value doesn't match any option (wrong text/casing) — not a control-type limitation | Read the control's `items` attribute via the interact CLI (SelectItem usage guide, routed from the UIA package guide § Documentation) and pass one of those values verbatim. `SelectItem` drives any control whose `items` lists options (any UI stack); use `TypeInto` only for type-ahead combos or controls with no `items`. |
-| **`packages inspect` cannot find UILibrary package** | Package is on a private/local NuGet feed | Use `--nupkg-path` to inspect the local `.nupkg` directly, or read `.metadata` files manually from `~/.nuget/packages/<name>/<version>/contentFiles/any/any/.objects/` |
-| **Studio rejects manually created project** | Missing metadata dirs, wrong schema/version | Always use `uip rpa init` instead of writing `project.json` manually |

package/skills/uipath-rpa/references/coded/inspect-package-guide.md

@@ -1,80 +0,0 @@
-# Inspect NuGet Package Tool (On-Demand API Discovery)
-
-Use this when the static reference files (`references/<service>/examples.md`) don't cover an API, when the user has a different package version, or when you need ground-truth method signatures.
-
-## How to Run
-
-The `packages inspect` verb is built into the UiPath CLI. No separate build step is needed.
-
-### Inspect a package from a NuGet feed
-```bash
-uip rpa packages inspect --package-name <PackageName> --package-version <Version> [--feed-url <NuGetV3FeedUrl>]```
-
-When `--feed-url` is omitted, the tool downloads from the UiPath Official feed first and falls back to nuget.org.
-
-### Inspect a local .nupkg file
-```bash
-uip rpa packages inspect --nupkg-path <path/to/package.nupkg>```
-
-Use this when the package is already cached locally (e.g. from a private feed) or when you have a `.nupkg` file on disk.
-
-## Examples
-
-```bash
-# Inspect Excel activities from UiPath feed
-uip rpa packages inspect --package-name UiPath.Excel.Activities --package-version 3.3.1
-# Inspect a specific version the user has
-uip rpa packages inspect --package-name UiPath.System.Activities --package-version 25.12.2
-# Inspect from a custom feed
-uip rpa packages inspect --package-name MyPackage --package-version 1.0.0 --feed-url https://my-feed/v3/index.json
-# Inspect third-party package from nuget.org
-uip rpa packages inspect --package-name CsvHelper --package-version 33.0.1
-# Inspect a local .nupkg file directly
-uip rpa packages inspect --nupkg-path ~/.nuget/packages/csvhelper/33.0.1/csvhelper.33.0.1.nupkg```
-
-## Finding the Latest Stable Version
-
-When you don't know the version of a UiPath package, query the UiPath Official NuGet feed to find the latest stable (non-preview) version:
-
-```bash
-UIPATH_FEED="https://uipath.pkgs.visualstudio.com/5b98d55c-1b14-4a03-893f-7a59746f1246/_packaging/1c781268-d43d-45ab-9dfc-0151a1c740b7/nuget/v3/flat2" && bun -e "const p=process.argv[1];const r=await fetch(p+'/index.json');const d=await r.json();console.log(d.versions.find(v=>v.indexOf('preview')<0))" "$UIPATH_FEED/<package-name-lowercase>"
-```
-
-Replace `<package-name-lowercase>` with the package ID in lowercase (e.g. `uipath.microsoftoffice365.activities`).
-
-**Examples:**
-```bash
-# Latest stable UiPath.MicrosoftOffice365.Activities → 3.6.10
-... "$UIPATH_FEED/uipath.microsoftoffice365.activities"
-
-# Latest stable UiPath.System.Activities → 25.12.2
-... "$UIPATH_FEED/uipath.system.activities"
-```
-
-**Notes:**
-- The feed returns versions in descending order (newest first); the one-liner picks the first non-preview entry
-- Package names in the URL **must be lowercase**
-- This feed is public for version listing but requires authentication for package downloads (Studio handles this automatically when restoring dependencies)
-
----
-
-## When to Use
-
-- **First**, check for pre-generated coded API docs at `{projectRoot}/.local/docs/packages/{PackageId}/coded/coded-api.md` — these contain service API signatures and usage for coded workflows. Use `packages inspect` only when these docs are missing or insufficient.
-- You encounter an unknown activity/method not in reference files
-- The user's `project.json` has a different package version than reference docs
-- You need exact method signatures, parameter types, or enum values
-- You're unsure about the correct API and want to verify against the actual package
-- You need to find and evaluate a third-party NuGet package for use in a coded workflow
-
-## Output
-
-Structured markdown listing all public types, methods, properties, enums, delegates, and events from the package DLLs. The tool performs framework-aware DLL selection and recursive dependency resolution (up to depth 2).
-
-## Requirements & Notes
-
-- Requires `uip` to be available on PATH
-- Downloads from the UiPath Official feed first, then falls back to nuget.org — so it works with **any** NuGet package, not just UiPath ones
-- The tool automatically checks the local NuGet cache at `~/.nuget/packages/` when a package cannot be downloaded
-- For local `.nupkg` files (e.g. packages from private feeds already cached locally), use `--nupkg-path` to skip the download entirely
-- Some packages are metapackages with no DLLs (e.g. `Humanizer`). If you get "No DLLs found", try the `.Core` sub-package (e.g. `Humanizer.Core`)

package/skills/uipath-rpa/references/coded/third-party-packages-guide.md

@@ -1,67 +0,0 @@
-# Using Third-Party NuGet Packages in Coded Workflows
-
-When a user needs functionality that **no UiPath built-in activity provides** (e.g. PDF generation, barcode reading, advanced math, specific file formats), find and use a third-party NuGet package.
-
-## Decision Flow
-
-1. **Consider whether a built-in activity or plain .NET is the better fit** — prefer activities for Orchestrator integration, UI automation, and document handling; prefer .NET for data transforms, HTTP to external APIs, parsing, etc.
-2. **If no built-in activity fits** — search for a well-known .NET NuGet package that provides the capability
-3. **Inspect the package** — run the `uip rpa packages inspect` command with the appropriate flags in order to get exact API signatures before writing code
-4. **Install it** — run `uip rpa packages install --project-dir "<PROJECT_DIR>" --packages 'id=<PACKAGE_ID>,version=<VERSION>' --output json`. Omit `,version=<VERSION>` to resolve the latest compatible. Do NOT hand-edit `project.json` `dependencies`. **There is no `uip rpa add-dependency` command.**
-5. **Write C# code using the package** — use the package's API directly in the `Execute` method (no service proxy needed — just `using` + direct API calls)
-
-## How Third-Party Packages Differ from UiPath Activity Packages
-
-- UiPath packages provide services on the `CodedWorkflow` base class (e.g. `excel.ReadRange(...)`)
-- Third-party packages are used as **plain C# libraries** — instantiate classes, call methods directly
-- They do NOT get a service property on `CodedWorkflow`
-- Add them to `project.json` `dependencies` just like UiPath packages: `"PackageName": "[version]"`
-
-## Example — Using CsvHelper in a Coded Workflow
-
-```csharp
-using System;
-using System.Globalization;
-using System.IO;
-using CsvHelper;
-using UiPath.CodedWorkflows;
-
-namespace MyProject
-{
-    public class ProcessCsv : CodedWorkflow
-    {
-        [Workflow]
-        public void Execute(string inputPath)
-        {
-            using var reader = new StreamReader(inputPath);
-            using var csv = new CsvReader(reader, CultureInfo.InvariantCulture);
-            var records = csv.GetRecords<dynamic>().ToList();
-            Log($"Read {records.Count} records from CSV");
-        }
-    }
-}
-```
-
-With `project.json` dependency:
-```json
-{
-  "dependencies": {
-    "CsvHelper": "[33.0.1]"
-  }
-}
-```
-
-## How to Search for Packages
-
-- Use web search to find the best .NET NuGet package for the task
-- Look for packages with high download counts, active maintenance, and .NET 6+ support
-- Common choices:
-  - `CsvHelper` (CSV parsing)
-  - `QuestPDF` (PDF generation)
-  - `ClosedXML` (Excel without UiPath)
-  - `HtmlAgilityPack` (HTML parsing)
-  - `Dapper` (database access)
-  - `RestSharp` (REST APIs)
-  - `Polly` (retry/resilience patterns)
-  - `Newtonsoft.Json` (JSON parsing - already included in most projects)
-- After identifying a package, run the `uip rpa packages inspect` command to discover exact APIs before coding

package/skills/uipath-rpa/references/connector-capabilities.md

@@ -1,79 +0,0 @@
-# Discover Connector Capabilities (For IS/Connector Workflows)
-
-When a workflow involves an Integration Service connector (Salesforce, Jira, ServiceNow, Slack, etc.), explore the connector before writing XAML. For the full end-to-end authoring flow, see [is-connector-xaml-guide.md](is-connector-xaml-guide.md).
-
-## Prerequisite: `uip login`
-
-All `uip is *` commands require an authenticated session. They fail silently (with a generic "Not logged in" error) otherwise.
-
-```bash
-uip login                                                       # production (cloud.uipath.com)
-uip login --authority https://alpha.uipath.com/identity_        # alpha
-uip login --authority https://staging.uipath.com/identity_      # staging
-```
-
-If you need the user to authenticate, ask them to type `! uip login` so the token lands in the current session.
-
-## Discovery Commands
-
-```bash
-# List connectors available to the tenant (find the connector key):
-uip is connectors list --output json
-
-# What activities does a specific connector offer? (get activity names + method + operation)
-uip is activities list <connector-key> --output json
-
-# What data objects/resources does it expose?
-uip is resources list <connector-key> --output json
-
-# Describe an object's schema for an operation (fields, types, required flags, enum values).
-# Second positional is the object/resource name (from `resources list`); the operation goes in --operation:
-uip is resources describe <connector-key> <object-name> --operation Create --output json
-```
-
-`resources describe` is the authoritative field schema — **never guess field names**. The response includes a `metadataFile` path like `~/.uipath/cache/integrationservice/<connector>/_static/<operation>.Create.json`. Read that JSON directly for the full `parameters` / `requestFields` / `responseFields` list.
-
-Note: it's `resources describe` (not `activities describe`). The `activities` subcommand only has `list`.
-
-## Finding an Activity's Type ID (for XAML generation)
-
-For hand-authored XAML, the IS `ConnectorActivity` element needs a `UiPathActivityTypeId` GUID. Get it via `activities find`:
-
-```bash
-uip rpa activities find --query "<search terms>" --project-dir "<PROJECT_DIR>" --output json
-```
-
-In the response, each result's `activityTypeId` field is the GUID to pass to:
-
-```bash
-uip rpa activities get-default-xaml \
-    --activity-type-id "<TYPE_ID>" \
-    --connection-id "<CONN_ID>" \
-    --project-dir "<PROJECT_DIR>" --output json
-```
-
-**`--activity-type-id` is mandatory for IS dynamic activities** — without it, the default XAML comes back empty (`Configuration={x:Null}`, no fields) and isn't runnable.
-
-`get-default-xaml` also accepts repeatable `--field-values name=value` pairs: the values are pre-bound as literals in the returned `FieldObjects`, and when they cover the operation's prerequisite criteria fields (e.g. Jira's `project` + `issuetype`), the returned `Configuration` blob is re-resolved with the full expanded field schema — the same expansion Studio's designer performs when those fields are committed in the canvas. Full usage pattern: [is-connector-xaml-guide.md § Step 4](is-connector-xaml-guide.md).
-
-## Connection Management
-
-**Check if a connection exists:**
-```bash
-uip is connections list <connector-key> --output json
-```
-
-**If no connection exists**, options:
-1. **Create one** (opens an OAuth browser flow for the user): `uip is connections create <connector-key>`
-2. **Placeholder** — drop the XAML with a placeholder `ConnectionId="00000000-0000-0000-0000-000000000000"` and tell the user to configure the connection in Studio before running.
-
-**Verify a connection is active:**
-```bash
-uip is connections ping <connection-id>
-```
-
-If the ping fails, offer to re-authenticate: `uip is connections edit <connection-id>`.
-
-## Next: Generate the XAML
-
-Once you have `connector-key`, `activityTypeId`, `connection-id`, and the field schema, follow [is-connector-xaml-guide.md](is-connector-xaml-guide.md) for the complete authoring flow with a worked example.

package/skills/uipath-rpa/references/legacy/activity-docs/Testing.md

@@ -1,95 +0,0 @@
-# UiPath Testing Activities - Legacy Reference
-
-## Overview
-Test assertions, data generation, document comparison, and test data queue management. Package: `UiPath.Testing.Activities`.
-
----
-
-## Assertion Activities
-
-| Activity | Purpose | Key Arguments |
-|----------|---------|---------------|
-| `VerifyExpression` | Assert boolean is true | Expression (bool), ContinueOnFailure (default true) |
-| `VerifyExpressionWithOperator` | Compare two values | FirstExpression, SecondExpression, Operator |
-| `VerifyRange` | Value within/outside range | Expression, LowerLimit, UpperLimit, VerificationType (IsWithin/IsNotWithin) |
-| `VerifyControlAttribute` | Verify activity output | ActivityToTest, OutputArgument, Expression, Operator |
-
-### Comparison Operators
-Equality (=), Inequality (<>), GreaterThan (>), GreaterThanOrEqual (>=), LessThan (<), LessThanOrEqual (<=), Contains, RegexMatch
-
----
-
-## Document Comparison (NET5+)
-
-| Activity | Purpose | Key Arguments |
-|----------|---------|---------------|
-| `ComparePdfDocuments` | Diff two PDFs | BaselinePath, TargetPath, ComparisonType (Line/Word/Character), Rules, IncludeImages |
-| `CompareText` | Diff two strings | BaselineText, TargetText, ComparisonType, OutputFilePath (HTML) |
-| `CreateComparisonRule` | Custom ignore rules | RuleName, ComparisonRuleType (Regex/Wildcard), Pattern, UsePlaceholder |
-
-### Comparison Output
-- `Result` (bool): True if equivalent
-- `Differences` (IEnumerable\<Difference\>): Each with Operation (Inserted/Deleted/Equal) and Text
-- `SemanticDifferences`: AI analysis when InterpretDifferencesWithAutopilot=true
-
----
-
-## Test Data Queue Activities
-
-| Activity | Purpose | Key Arguments |
-|----------|---------|---------------|
-| `GetTestDataQueueItem` | Get next item | QueueName, MarkConsumed (default true) |
-| `GetTestDataQueueItems` | Batch fetch with filter | QueueName, Status (All/OnlyConsumed/OnlyNotConsumed), Top, Skip |
-| `NewAddTestDataQueueItem` | Add single item | QueueName, ItemInformation (Dict\<string, InArgument\>) |
-| `BulkAddTestDataQueue` | Add from DataTable | QueueName, QueueItemsDataTable |
-| `DeleteTestDataQueueItems` | Delete items | TestDataQueueItems (must have valid Ids) |
-| ~~`AddTestDataQueueItem`~~ | **OBSOLETE** | Use NewAddTestDataQueueItem instead |
-
----
-
-## Test Data Generation
-
-| Activity | Output | Key Arguments |
-|----------|--------|---------------|
-| `RandomString` | string | Case (Lower/Upper/Camel/Mixed), Length (default 10) |
-| `RandomNumber` | decimal | Min, Max, Decimals (default 0) |
-| `RandomDate` | DateTime | MinDate, MaxDate |
-| `RandomValue` | string | FilePath (one value per line, random selection) |
-| `GivenName` | string | (from predefined list) |
-| `LastName` | string | (from predefined list) |
-| `Address` | Dict\<string, string\> | Country, City (both hidden in designer) |
-
----
-
-## Critical Gotchas
-
-### Assertions
-1. **ContinueOnFailure=true by default in designer activities** - assertions don't stop workflow; set to false for strict testing. **Note**: Coded workflow API defaults to `false` (opts?.ContinueOnError ?? false)
-2. **Screenshot capture** available on both success and failure (separate flags, both default false)
-3. **VerifyControlAttribute cannot be nested** inside another VerifyControlAttribute
-4. **Type compatibility validated at CacheMetadata** - incompatible types cause design-time errors
-5. **RegexMatch operator** uses full .NET regex engine
-
-### Document Comparison
-6. **ComparePdfDocuments creates visual diff PDFs** - `{filename}_result.pdf` for both baseline and target
-7. **CompareText creates HTML diff report** at OutputFilePath (default "differences.html")
-8. **Rules (regex/wildcard)** allow ignoring dynamic content (dates, IDs)
-9. **Semantic analysis (Autopilot)** provides AI explanation separate from byte-level diff
-
-### Test Data Queues
-10. **Requires Orchestrator** - all queue operations go through IOrchestratorService
-11. **MarkConsumed=true** prevents item from being returned again
-12. **Batch fetch max 1000** items per internal API call
-13. **Top=0 treated as null** (no limit)
-14. **Delete requires valid Ids** - items must be previously retrieved
-15. **BulkAdd DataTable columns must be unique** - throws InvalidArgumentsException
-16. **Queue items stored as JSON** in Orchestrator
-
-### Test Data Generation
-17. **RandomValue reads from file** - file must exist with line-delimited values
-18. **Address Country/City inputs hidden in designer** but available programmatically
-19. **RandomDate validates MinDate < MaxDate** (skipped for expression arguments)
-
-### Misc
-20. **AttachDocument** uploads file to Orchestrator as test evidence
-21. **CoverageMergeActivity is internal** (Browsable=false) - for test framework infrastructure only