Notes Q&A idea - rpapub/WatchfulAnvil GitHub Wiki

Perfect — now we’re fully aligned. We’re in pure discovery mode, focused solely on collecting the technical questions required to prepare for development of custom Workflow Analyzer rules in UiPath.

Let’s keep building that zero-assumption question set, based on the real constraints and mechanisms you just posted.

🔍 Planning Custom Workflow Analyzer Rules — Full Technical Question Inventory

📦 SDK & Dependencies

  • Where do we get the UiPath.Activities.Api SDK?
  • What is the correct version of the SDK to use?
  • Are SDK interfaces version-stable across UiPath Studio releases?
  • Which exact DLLs are required from the UiPath Studio installation?
  • Are all required APIs available via the NuGet package or do some require referencing local binaries?

🔧 Development Environment

  • Which .NET Framework version must be targeted? (e.g., net461 — confirmed)
  • Which project type is suitable? (Class Library? SDK-style .csproj?)
  • Can development be done using cross-platform .NET SDKs, or is Windows + Visual Studio required?
  • Can the codebase be structured for multi-targeting (e.g., net461/net6/net8)?
  • How do we configure Visual Studio or build tooling to include development-only dependencies?

🔌 Rule Registration

  • What interface(s) must be implemented to register rules?
  • What are the differences between IRegisterAnalyzerConfiguration and IRegisterMetadata?
  • Which Studio versions support each method?
  • How are rules grouped or categorized once registered?
  • Is rule ordering deterministic?
  • Can rules be conditionally registered (e.g., by project type)?

🧠 Rule Logic Scope

  • What types can rules be based on?
    • IActivityModel?
    • IWorkflowModel?
    • IProjectModel?
  • What’s the difference between a Rule and a Counter?
  • What other inspection types exist?
  • Can rules inspect multiple levels (e.g., project > workflows > activities)?
  • How are arguments, variables, annotations accessed from the model types?
  • Is there a way to resolve activity type or source (e.g., determine if an activity is Invoke Code or Assign)?

⚠️ Rule Output

  • What severity levels are supported? (Error, Warning, Info, Verbose?)
  • Can rules produce multiple messages per file or activity?
  • Can messages include positional info or references (e.g., activity name, location)?
  • Are messages localized or plain text?
  • Can output be parameterized (e.g., include configured values)?

⚙️ Rule Parameters

  • How do rules expose configurable parameters?
  • What types of parameters are supported? (string, int, regex, bool?)
  • How are defaults specified?
  • Can parameters be validated?
  • Are rule parameters editable via Studio UI?

🧪 Debugging & Testing

  • How can rules be tested without running inside Studio?
  • Is there a mock or simulation framework for IActivityModel etc.?
  • Can unit tests be written for rules?
  • Is any tracing or logging available during Studio execution?
  • What happens if a rule throws an exception?

🗃️ Distribution

  • What are the exact steps to package a rule into a .dll or NuGet?
  • What are the required folder structures for deployment?
  • Can the same package contain both rules and other activities?
  • How are dependencies handled in project-level installation?
  • Is signing or strong-naming required for Studio to trust the rule assembly?

🖥️ Integration with Studio

  • How are global vs. project-level rules resolved if both exist?
  • Is Studio restart required after rule installation?
  • Can rule changes be hot-reloaded?
  • How are rule failures shown in Studio UI?
  • Can rules influence build/publish processes?

Would you like this formatted into a Markdown doc template next? Or keep going raw and keep collecting?