docs: add SETUP.MD

Adds a top-level SETUP.MD documenting how to provision a clean
development environment, run the build, execute the tests, and
validate a sample code change end-to-end through a coded agent.

PRODEV-622

Author: giuliastf

SETUP.MD

@@ -0,0 +1,135 @@
+# SETUP.MD
+
+This file documents how to provision a clean development environment for `uipath-mcp`, run the build, execute the tests, and validate a sample code change end-to-end. It is intended both as a quick reference for human contributors and as a structured guide for automated environment-setup tooling.
+
+## Prerequisites
+
+- Python 3.11+
+- [uv](https://docs.astral.sh/uv/) 0.5+
+
+### Supported platforms
+
+`uv` is shell- and OS-agnostic, so the commands below run unchanged on every supported platform:
+
+- [x] Linux
+- [x] Windows
+- [x] macOS
+
+## Environment Variables
+
+### Standard
+
+None of the common shared environment variables (e.g. `AZURE_DEVOPS_PAT`, `GH_NPM_REGISTRY_TOKEN`) are required for environment setup, build, or unit tests.
+
+### Project-specific
+
+None. The unit-test suite under the `Test` section below runs fully offline and requires no external authentication.
+
+## Setup
+
+```bash
+# Install uv if not already on PATH
+python3 -m pip install --upgrade uv
+
+# Sync the package with dev dependencies
+uv sync --all-extras
+```
+
+## Verify Setup
+
+```bash
+python3 --version
+uv --version
+uv run python -c "import uipath_mcp; print('uipath_mcp ok')"
+```
+
+## Build
+
+```bash
+# Compile every Python module to bytecode — fast syntax/import validation,
+# no publish artifacts produced.
+uv run python -m compileall src/
+```
+
+## Test
+
+```bash
+uv run pytest
+```
+
+## Sample Code Change
+
+### The change
+
+Add a new `server_count` property to `McpConfig` in `src/uipath_mcp/_cli/_utils/_config.py`, immediately after the existing `get_server_names` method:
+
+```python
+@property
+def server_count(self) -> int:
+    """Number of MCP servers currently loaded from configuration."""
+    return len(self._servers)
+```
+
+Then create `tests/test_config_server_count.py` with two pytest tests:
+
+```python
+"""Tests for McpConfig.server_count."""
+
+import json
+from pathlib import Path
+
+from uipath_mcp._cli._utils._config import McpConfig
+
+
+def test_server_count_empty(tmp_path: Path) -> None:
+    config_path = tmp_path / "mcp.json"
+    config_path.write_text(json.dumps({"servers": {}}))
+    cfg = McpConfig(str(config_path))
+    assert cfg.server_count == 0
+
+
+def test_server_count_multiple(tmp_path: Path) -> None:
+    config_path = tmp_path / "mcp.json"
+    config_path.write_text(
+        json.dumps(
+            {
+                "servers": {
+                    "alpha": {"command": "node", "args": ["alpha.js"]},
+                    "beta": {"command": "node", "args": ["beta.js"]},
+                }
+            }
+        )
+    )
+    cfg = McpConfig(str(config_path))
+    assert cfg.server_count == 2
+```
+
+### Verification
+
+```bash
+uv run pytest tests/test_config_server_count.py -v
+```
+
+## Test with an agent (coded MCP for this example)
+
+The unit tests above are necessary but not sufficient — they don't exercise the package end-to-end through a real agent. The flow below validates changes against a live MCP/agent runtime:
+
+1. Apply the code changes locally.
+2. Run the unit tests (see the `Sample Code Change` section above).
+3. Scaffold a coded agent (or coded MCP) that exercises the changed code path.
+4. In the downstream project's `pyproject.toml`, add this local library as an editable dependency:
+
+   ```toml
+   [tool.uv.sources]
+   uipath-mcp = { path = "../path/to/uipath-mcp-python", editable = true }
+   ```
+
+5. Exercise the new behavior end-to-end:
+
+   ```bash
+   uv run uipath run <agent-name> --input '{...}'
+   ```
+
+6. (Optional) Open a PR and apply the `build:dev` label — this publishes the development version to Test PyPI.
+7. The PR description is updated automatically with instructions for pointing the downstream agent at the Test PyPI dev version.
+8. Deploy the agent (or coded MCP) to Orchestrator / Studio Web and run it in cloud to confirm the changes behave correctly against the real platform.